diff options
author | Christian Grothoff <christian@grothoff.org> | 2019-05-04 22:16:24 +0200 |
---|---|---|
committer | Christian Grothoff <christian@grothoff.org> | 2019-05-04 22:16:24 +0200 |
commit | 80f480c752fd8dfa1be51d78fce314d9f0650b50 (patch) | |
tree | 459c21a3fde3b5f66194ac9960632de53586c5f0 | |
parent | 3d2a951fa12546c09809f0a4d7e789ef8e971b03 (diff) | |
download | gnunet-80f480c752fd8dfa1be51d78fce314d9f0650b50.tar.gz gnunet-80f480c752fd8dfa1be51d78fce314d9f0650b50.zip |
simplify MQ logic to always carry the same kinds of flags, and extend transport API to pass them to (TNG) service
-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 | ||||
-rw-r--r-- | src/hostlist/gnunet-daemon-hostlist_server.c | 268 | ||||
-rw-r--r-- | src/include/gnunet_core_service.h | 90 | ||||
-rw-r--r-- | src/include/gnunet_mq_lib.h | 288 | ||||
-rw-r--r-- | src/nse/gnunet-service-nse.c | 627 | ||||
-rw-r--r-- | src/topology/gnunet-daemon-topology.c | 377 | ||||
-rw-r--r-- | src/transport/gnunet-service-tng.c | 3 | ||||
-rw-r--r-- | src/transport/transport.h | 4 | ||||
-rw-r--r-- | src/transport/transport_api2_core.c | 7 | ||||
-rw-r--r-- | src/transport/transport_api_core.c | 7 | ||||
-rw-r--r-- | src/util/mq.c | 277 |
17 files changed, 1413 insertions, 1881 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"); |
diff --git a/src/hostlist/gnunet-daemon-hostlist_server.c b/src/hostlist/gnunet-daemon-hostlist_server.c index 529fe4e62..8764586d6 100644 --- a/src/hostlist/gnunet-daemon-hostlist_server.c +++ b/src/hostlist/gnunet-daemon-hostlist_server.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 | ||
@@ -38,7 +38,8 @@ | |||
38 | * How long until our hostlist advertisment transmission via CORE should | 38 | * How long until our hostlist advertisment transmission via CORE should |
39 | * time out? | 39 | * time out? |
40 | */ | 40 | */ |
41 | #define GNUNET_ADV_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5) | 41 | #define GNUNET_ADV_TIMEOUT \ |
42 | GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5) | ||
42 | 43 | ||
43 | 44 | ||
44 | /** | 45 | /** |
@@ -121,7 +122,6 @@ struct HostSet | |||
121 | * Number of bytes in @e data. | 122 | * Number of bytes in @e data. |
122 | */ | 123 | */ |
123 | unsigned int size; | 124 | unsigned int size; |
124 | |||
125 | }; | 125 | }; |
126 | 126 | ||
127 | 127 | ||
@@ -140,15 +140,11 @@ static struct HostSet *builder; | |||
140 | static void | 140 | static void |
141 | add_cors_headers (struct MHD_Response *response) | 141 | add_cors_headers (struct MHD_Response *response) |
142 | { | 142 | { |
143 | MHD_add_response_header (response, | 143 | MHD_add_response_header (response, "Access-Control-Allow-Origin", "*"); |
144 | "Access-Control-Allow-Origin", | ||
145 | "*"); | ||
146 | MHD_add_response_header (response, | 144 | MHD_add_response_header (response, |
147 | "Access-Control-Allow-Methods", | 145 | "Access-Control-Allow-Methods", |
148 | "GET, OPTIONS"); | 146 | "GET, OPTIONS"); |
149 | MHD_add_response_header (response, | 147 | MHD_add_response_header (response, "Access-Control-Max-Age", "86400"); |
150 | "Access-Control-Max-Age", | ||
151 | "86400"); | ||
152 | } | 148 | } |
153 | 149 | ||
154 | 150 | ||
@@ -163,18 +159,19 @@ finish_response () | |||
163 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 159 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
164 | "Creating hostlist response with %u bytes\n", | 160 | "Creating hostlist response with %u bytes\n", |
165 | (unsigned int) builder->size); | 161 | (unsigned int) builder->size); |
166 | response = | 162 | response = MHD_create_response_from_buffer (builder->size, |
167 | MHD_create_response_from_buffer (builder->size, | 163 | builder->data, |
168 | builder->data, | 164 | MHD_RESPMEM_MUST_FREE); |
169 | MHD_RESPMEM_MUST_FREE); | ||
170 | add_cors_headers (response); | 165 | add_cors_headers (response); |
171 | if ((NULL == daemon_handle_v4) && (NULL == daemon_handle_v6)) | 166 | if ((NULL == daemon_handle_v4) && (NULL == daemon_handle_v6)) |
172 | { | 167 | { |
173 | MHD_destroy_response (response); | 168 | MHD_destroy_response (response); |
174 | response = NULL; | 169 | response = NULL; |
175 | } | 170 | } |
176 | GNUNET_STATISTICS_set (stats, gettext_noop ("bytes in hostlist"), | 171 | GNUNET_STATISTICS_set (stats, |
177 | builder->size, GNUNET_YES); | 172 | gettext_noop ("bytes in hostlist"), |
173 | builder->size, | ||
174 | GNUNET_YES); | ||
178 | GNUNET_free (builder); | 175 | GNUNET_free (builder); |
179 | builder = NULL; | 176 | builder = NULL; |
180 | } | 177 | } |
@@ -198,9 +195,10 @@ check_has_addr (void *cls, | |||
198 | if (0 == GNUNET_TIME_absolute_get_remaining (expiration).rel_value_us) | 195 | if (0 == GNUNET_TIME_absolute_get_remaining (expiration).rel_value_us) |
199 | { | 196 | { |
200 | GNUNET_STATISTICS_update (stats, | 197 | GNUNET_STATISTICS_update (stats, |
201 | gettext_noop ("expired addresses encountered"), 1, | 198 | gettext_noop ("expired addresses encountered"), |
199 | 1, | ||
202 | GNUNET_YES); | 200 | GNUNET_YES); |
203 | return GNUNET_YES; /* ignore this address */ | 201 | return GNUNET_YES; /* ignore this address */ |
204 | } | 202 | } |
205 | *arg = GNUNET_YES; | 203 | *arg = GNUNET_YES; |
206 | return GNUNET_SYSERR; | 204 | return GNUNET_SYSERR; |
@@ -234,7 +232,7 @@ host_processor (void *cls, | |||
234 | GNUNET_free (builder); | 232 | GNUNET_free (builder); |
235 | builder = NULL; | 233 | builder = NULL; |
236 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 234 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
237 | _("Error in communication with PEERINFO service: %s\n"), | 235 | _ ("Error in communication with PEERINFO service: %s\n"), |
238 | err_msg); | 236 | err_msg); |
239 | return; | 237 | return; |
240 | } | 238 | } |
@@ -247,19 +245,17 @@ host_processor (void *cls, | |||
247 | if (NULL == hello) | 245 | if (NULL == hello) |
248 | return; | 246 | return; |
249 | has_addr = GNUNET_NO; | 247 | has_addr = GNUNET_NO; |
250 | GNUNET_HELLO_iterate_addresses (hello, | 248 | GNUNET_HELLO_iterate_addresses (hello, GNUNET_NO, &check_has_addr, &has_addr); |
251 | GNUNET_NO, | ||
252 | &check_has_addr, | ||
253 | &has_addr); | ||
254 | if (GNUNET_NO == has_addr) | 249 | if (GNUNET_NO == has_addr) |
255 | { | 250 | { |
256 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 251 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
257 | "HELLO for peer `%4s' has no address, not suitable for hostlist!\n", | 252 | "HELLO for peer `%4s' has no address, not suitable for hostlist!\n", |
258 | GNUNET_i2s (peer)); | 253 | GNUNET_i2s (peer)); |
259 | GNUNET_STATISTICS_update (stats, | 254 | GNUNET_STATISTICS_update (stats, |
260 | gettext_noop | 255 | gettext_noop ( |
261 | ("HELLOs without addresses encountered (ignored)"), | 256 | "HELLOs without addresses encountered (ignored)"), |
262 | 1, GNUNET_NO); | 257 | 1, |
258 | GNUNET_NO); | ||
263 | return; | 259 | return; |
264 | } | 260 | } |
265 | old = builder->size; | 261 | old = builder->size; |
@@ -269,26 +265,23 @@ host_processor (void *cls, | |||
269 | (unsigned int) s, | 265 | (unsigned int) s, |
270 | "HELLO", | 266 | "HELLO", |
271 | GNUNET_i2s (peer)); | 267 | GNUNET_i2s (peer)); |
272 | if ( (old + s >= GNUNET_MAX_MALLOC_CHECKED) || | 268 | if ((old + s >= GNUNET_MAX_MALLOC_CHECKED) || |
273 | (old + s >= MAX_BYTES_PER_HOSTLISTS) ) | 269 | (old + s >= MAX_BYTES_PER_HOSTLISTS)) |
274 | { | 270 | { |
275 | /* too large, skip! */ | 271 | /* too large, skip! */ |
276 | GNUNET_STATISTICS_update (stats, | 272 | GNUNET_STATISTICS_update (stats, |
277 | gettext_noop | 273 | gettext_noop ( |
278 | ("bytes not included in hostlist (size limit)"), | 274 | "bytes not included in hostlist (size limit)"), |
279 | s, GNUNET_NO); | 275 | s, |
276 | GNUNET_NO); | ||
280 | return; | 277 | return; |
281 | } | 278 | } |
282 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 279 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
283 | "Adding peer `%s' to hostlist (%u bytes)\n", | 280 | "Adding peer `%s' to hostlist (%u bytes)\n", |
284 | GNUNET_i2s (peer), | 281 | GNUNET_i2s (peer), |
285 | (unsigned int) s); | 282 | (unsigned int) s); |
286 | GNUNET_array_grow (builder->data, | 283 | GNUNET_array_grow (builder->data, builder->size, old + s); |
287 | builder->size, | 284 | GNUNET_memcpy (&builder->data[old], hello, s); |
288 | old + s); | ||
289 | GNUNET_memcpy (&builder->data[old], | ||
290 | hello, | ||
291 | s); | ||
292 | } | 285 | } |
293 | 286 | ||
294 | 287 | ||
@@ -308,11 +301,12 @@ accept_policy_callback (void *cls, | |||
308 | { | 301 | { |
309 | if (NULL == response) | 302 | if (NULL == response) |
310 | { | 303 | { |
311 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 304 | GNUNET_log ( |
312 | "Received request for hostlist, but I am not yet ready; rejecting!\n"); | 305 | GNUNET_ERROR_TYPE_DEBUG, |
306 | "Received request for hostlist, but I am not yet ready; rejecting!\n"); | ||
313 | return MHD_NO; | 307 | return MHD_NO; |
314 | } | 308 | } |
315 | return MHD_YES; /* accept all */ | 309 | return MHD_YES; /* accept all */ |
316 | } | 310 | } |
317 | 311 | ||
318 | 312 | ||
@@ -369,9 +363,9 @@ access_handler_callback (void *cls, | |||
369 | struct MHD_Response *options_response; | 363 | struct MHD_Response *options_response; |
370 | int rc; | 364 | int rc; |
371 | 365 | ||
372 | options_response = MHD_create_response_from_buffer (0, NULL, | 366 | options_response = |
373 | MHD_RESPMEM_PERSISTENT); | 367 | MHD_create_response_from_buffer (0, NULL, MHD_RESPMEM_PERSISTENT); |
374 | add_cors_headers(options_response); | 368 | add_cors_headers (options_response); |
375 | rc = MHD_queue_response (connection, MHD_HTTP_OK, options_response); | 369 | rc = MHD_queue_response (connection, MHD_HTTP_OK, options_response); |
376 | MHD_destroy_response (options_response); | 370 | MHD_destroy_response (options_response); |
377 | return rc; | 371 | return rc; |
@@ -379,10 +373,12 @@ access_handler_callback (void *cls, | |||
379 | if (0 != strcmp (method, MHD_HTTP_METHOD_GET)) | 373 | if (0 != strcmp (method, MHD_HTTP_METHOD_GET)) |
380 | { | 374 | { |
381 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | 375 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
382 | _("Refusing `%s' request to hostlist server\n"), method); | 376 | _ ("Refusing `%s' request to hostlist server\n"), |
377 | method); | ||
383 | GNUNET_STATISTICS_update (stats, | 378 | GNUNET_STATISTICS_update (stats, |
384 | gettext_noop | 379 | gettext_noop ( |
385 | ("hostlist requests refused (not HTTP GET)"), 1, | 380 | "hostlist requests refused (not HTTP GET)"), |
381 | 1, | ||
386 | GNUNET_YES); | 382 | GNUNET_YES); |
387 | return MHD_NO; | 383 | return MHD_NO; |
388 | } | 384 | } |
@@ -394,29 +390,35 @@ access_handler_callback (void *cls, | |||
394 | if (0 != *upload_data_size) | 390 | if (0 != *upload_data_size) |
395 | { | 391 | { |
396 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | 392 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
397 | _("Refusing `%s' request with %llu bytes of upload data\n"), | 393 | _ ("Refusing `%s' request with %llu bytes of upload data\n"), |
398 | method, (unsigned long long) *upload_data_size); | 394 | method, |
395 | (unsigned long long) *upload_data_size); | ||
399 | GNUNET_STATISTICS_update (stats, | 396 | GNUNET_STATISTICS_update (stats, |
400 | gettext_noop | 397 | gettext_noop ( |
401 | ("hostlist requests refused (upload data)"), 1, | 398 | "hostlist requests refused (upload data)"), |
399 | 1, | ||
402 | GNUNET_YES); | 400 | GNUNET_YES); |
403 | return MHD_NO; /* do not support upload data */ | 401 | return MHD_NO; /* do not support upload data */ |
404 | } | 402 | } |
405 | if (NULL == response) | 403 | if (NULL == response) |
406 | { | 404 | { |
407 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | 405 | GNUNET_log ( |
408 | _("Could not handle hostlist request since I do not have a response yet\n")); | 406 | GNUNET_ERROR_TYPE_WARNING, |
407 | _ ( | ||
408 | "Could not handle hostlist request since I do not have a response yet\n")); | ||
409 | GNUNET_STATISTICS_update (stats, | 409 | GNUNET_STATISTICS_update (stats, |
410 | gettext_noop | 410 | gettext_noop ( |
411 | ("hostlist requests refused (not ready)"), 1, | 411 | "hostlist requests refused (not ready)"), |
412 | 1, | ||
412 | GNUNET_YES); | 413 | GNUNET_YES); |
413 | return MHD_NO; /* internal error, no response yet */ | 414 | return MHD_NO; /* internal error, no response yet */ |
414 | } | 415 | } |
415 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 416 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
416 | _("Received request for our hostlist\n")); | 417 | _ ("Received request for our hostlist\n")); |
417 | GNUNET_STATISTICS_update (stats, | 418 | GNUNET_STATISTICS_update (stats, |
418 | gettext_noop ("hostlist requests processed"), | 419 | gettext_noop ("hostlist requests processed"), |
419 | 1, GNUNET_YES); | 420 | 1, |
421 | GNUNET_YES); | ||
420 | return MHD_queue_response (connection, MHD_HTTP_OK, response); | 422 | return MHD_queue_response (connection, MHD_HTTP_OK, response); |
421 | } | 423 | } |
422 | 424 | ||
@@ -434,27 +436,19 @@ static void | |||
434 | adv_transmit (struct GNUNET_MQ_Handle *mq) | 436 | adv_transmit (struct GNUNET_MQ_Handle *mq) |
435 | { | 437 | { |
436 | static uint64_t hostlist_adv_count; | 438 | static uint64_t hostlist_adv_count; |
437 | const void *extra; | 439 | size_t uri_size; /* Including \0 termination! */ |
438 | uint64_t flags; | ||
439 | size_t uri_size; /* Including \0 termination! */ | ||
440 | struct GNUNET_MessageHeader *header; | 440 | struct GNUNET_MessageHeader *header; |
441 | struct GNUNET_MQ_Envelope *env; | 441 | struct GNUNET_MQ_Envelope *env; |
442 | 442 | ||
443 | extra = GNUNET_CORE_get_mq_options (GNUNET_YES, | ||
444 | GNUNET_CORE_PRIO_BEST_EFFORT, | ||
445 | &flags); | ||
446 | uri_size = strlen (hostlist_uri) + 1; | 443 | uri_size = strlen (hostlist_uri) + 1; |
447 | env = GNUNET_MQ_msg_extra (header, | 444 | env = GNUNET_MQ_msg_extra (header, |
448 | uri_size, | 445 | uri_size, |
449 | GNUNET_MESSAGE_TYPE_HOSTLIST_ADVERTISEMENT); | 446 | GNUNET_MESSAGE_TYPE_HOSTLIST_ADVERTISEMENT); |
450 | GNUNET_memcpy (&header[1], | 447 | GNUNET_memcpy (&header[1], hostlist_uri, uri_size); |
451 | hostlist_uri, | ||
452 | uri_size); | ||
453 | GNUNET_MQ_env_set_options (env, | 448 | GNUNET_MQ_env_set_options (env, |
454 | flags, | 449 | GNUNET_MQ_PREF_CORK_ALLOWED | |
455 | extra); | 450 | GNUNET_MQ_PREF_UNRELIABLE); |
456 | GNUNET_MQ_send (mq, | 451 | GNUNET_MQ_send (mq, env); |
457 | env); | ||
458 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 452 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
459 | "Sent advertisement message: Copied %u bytes into buffer!\n", | 453 | "Sent advertisement message: Copied %u bytes into buffer!\n", |
460 | (unsigned int) uri_size); | 454 | (unsigned int) uri_size); |
@@ -463,7 +457,8 @@ adv_transmit (struct GNUNET_MQ_Handle *mq) | |||
463 | " # Sent advertisement message: %llu\n", | 457 | " # Sent advertisement message: %llu\n", |
464 | (unsigned long long) hostlist_adv_count); | 458 | (unsigned long long) hostlist_adv_count); |
465 | GNUNET_STATISTICS_update (stats, | 459 | GNUNET_STATISTICS_update (stats, |
466 | gettext_noop ("# hostlist advertisements send"), 1, | 460 | gettext_noop ("# hostlist advertisements send"), |
461 | 1, | ||
467 | GNUNET_NO); | 462 | GNUNET_NO); |
468 | } | 463 | } |
469 | 464 | ||
@@ -479,7 +474,7 @@ adv_transmit (struct GNUNET_MQ_Handle *mq) | |||
479 | static void * | 474 | static void * |
480 | connect_handler (void *cls, | 475 | connect_handler (void *cls, |
481 | const struct GNUNET_PeerIdentity *peer, | 476 | const struct GNUNET_PeerIdentity *peer, |
482 | struct GNUNET_MQ_Handle *mq) | 477 | struct GNUNET_MQ_Handle *mq) |
483 | { | 478 | { |
484 | size_t size; | 479 | size_t size; |
485 | 480 | ||
@@ -488,8 +483,7 @@ connect_handler (void *cls, | |||
488 | if (NULL == hostlist_uri) | 483 | if (NULL == hostlist_uri) |
489 | return NULL; | 484 | return NULL; |
490 | size = strlen (hostlist_uri) + 1; | 485 | size = strlen (hostlist_uri) + 1; |
491 | if (size + sizeof (struct GNUNET_MessageHeader) >= | 486 | if (size + sizeof (struct GNUNET_MessageHeader) >= GNUNET_MAX_MESSAGE_SIZE) |
492 | GNUNET_MAX_MESSAGE_SIZE) | ||
493 | { | 487 | { |
494 | GNUNET_break (0); | 488 | GNUNET_break (0); |
495 | return NULL; | 489 | return NULL; |
@@ -500,10 +494,11 @@ connect_handler (void *cls, | |||
500 | GNUNET_break (0); | 494 | GNUNET_break (0); |
501 | return NULL; | 495 | return NULL; |
502 | } | 496 | } |
503 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 497 | GNUNET_log ( |
504 | "Asked CORE to transmit advertisement message with a size of %u bytes to peer `%s'\n", | 498 | GNUNET_ERROR_TYPE_DEBUG, |
505 | (unsigned int) size, | 499 | "Asked CORE to transmit advertisement message with a size of %u bytes to peer `%s'\n", |
506 | GNUNET_i2s (peer)); | 500 | (unsigned int) size, |
501 | GNUNET_i2s (peer)); | ||
507 | adv_transmit (mq); | 502 | adv_transmit (mq); |
508 | return NULL; | 503 | return NULL; |
509 | } | 504 | } |
@@ -528,8 +523,8 @@ process_notify (void *cls, | |||
528 | "Peerinfo is notifying us to rebuild our hostlist\n"); | 523 | "Peerinfo is notifying us to rebuild our hostlist\n"); |
529 | if (NULL != err_msg) | 524 | if (NULL != err_msg) |
530 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 525 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
531 | _("Error in communication with PEERINFO service: %s\n"), | 526 | _ ("Error in communication with PEERINFO service: %s\n"), |
532 | err_msg); | 527 | err_msg); |
533 | if (NULL != builder) | 528 | if (NULL != builder) |
534 | { | 529 | { |
535 | /* restart re-build already in progress ... */ | 530 | /* restart re-build already in progress ... */ |
@@ -547,10 +542,8 @@ process_notify (void *cls, | |||
547 | builder = GNUNET_new (struct HostSet); | 542 | builder = GNUNET_new (struct HostSet); |
548 | } | 543 | } |
549 | GNUNET_assert (NULL != peerinfo); | 544 | GNUNET_assert (NULL != peerinfo); |
550 | builder->pitr | 545 | builder->pitr = |
551 | = GNUNET_PEERINFO_iterate (peerinfo, | 546 | GNUNET_PEERINFO_iterate (peerinfo, GNUNET_NO, NULL, &host_processor, NULL); |
552 | GNUNET_NO, NULL, | ||
553 | &host_processor, NULL); | ||
554 | } | 547 | } |
555 | 548 | ||
556 | 549 | ||
@@ -594,7 +587,7 @@ run_daemon (void *cls) | |||
594 | static struct GNUNET_SCHEDULER_Task * | 587 | static struct GNUNET_SCHEDULER_Task * |
595 | prepare_daemon (struct MHD_Daemon *daemon_handle) | 588 | prepare_daemon (struct MHD_Daemon *daemon_handle) |
596 | { | 589 | { |
597 | struct GNUNET_SCHEDULER_Task * ret; | 590 | struct GNUNET_SCHEDULER_Task *ret; |
598 | fd_set rs; | 591 | fd_set rs; |
599 | fd_set ws; | 592 | fd_set ws; |
600 | fd_set es; | 593 | fd_set es; |
@@ -611,9 +604,7 @@ prepare_daemon (struct MHD_Daemon *daemon_handle) | |||
611 | wrs = GNUNET_NETWORK_fdset_create (); | 604 | wrs = GNUNET_NETWORK_fdset_create (); |
612 | wws = GNUNET_NETWORK_fdset_create (); | 605 | wws = GNUNET_NETWORK_fdset_create (); |
613 | max = -1; | 606 | max = -1; |
614 | GNUNET_assert (MHD_YES == | 607 | GNUNET_assert (MHD_YES == MHD_get_fdset (daemon_handle, &rs, &ws, &es, &max)); |
615 | MHD_get_fdset (daemon_handle, | ||
616 | &rs, &ws, &es, &max)); | ||
617 | haveto = MHD_get_timeout (daemon_handle, &timeout); | 608 | haveto = MHD_get_timeout (daemon_handle, &timeout); |
618 | if (haveto == MHD_YES) | 609 | if (haveto == MHD_YES) |
619 | tv.rel_value_us = (uint64_t) timeout * 1000LL; | 610 | tv.rel_value_us = (uint64_t) timeout * 1000LL; |
@@ -622,8 +613,11 @@ prepare_daemon (struct MHD_Daemon *daemon_handle) | |||
622 | GNUNET_NETWORK_fdset_copy_native (wrs, &rs, max + 1); | 613 | GNUNET_NETWORK_fdset_copy_native (wrs, &rs, max + 1); |
623 | GNUNET_NETWORK_fdset_copy_native (wws, &ws, max + 1); | 614 | GNUNET_NETWORK_fdset_copy_native (wws, &ws, max + 1); |
624 | ret = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_HIGH, | 615 | ret = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_HIGH, |
625 | tv, wrs, wws, | 616 | tv, |
626 | &run_daemon, daemon_handle); | 617 | wrs, |
618 | wws, | ||
619 | &run_daemon, | ||
620 | daemon_handle); | ||
627 | GNUNET_NETWORK_fdset_destroy (wrs); | 621 | GNUNET_NETWORK_fdset_destroy (wrs); |
628 | GNUNET_NETWORK_fdset_destroy (wws); | 622 | GNUNET_NETWORK_fdset_destroy (wws); |
629 | return ret; | 623 | return ret; |
@@ -676,19 +670,18 @@ GNUNET_HOSTLIST_server_start (const struct GNUNET_CONFIGURATION_Handle *c, | |||
676 | if (NULL == peerinfo) | 670 | if (NULL == peerinfo) |
677 | { | 671 | { |
678 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 672 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
679 | _("Could not access PEERINFO service. Exiting.\n")); | 673 | _ ("Could not access PEERINFO service. Exiting.\n")); |
680 | return GNUNET_SYSERR; | 674 | return GNUNET_SYSERR; |
681 | } | 675 | } |
682 | if (GNUNET_OK != | 676 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (cfg, |
683 | GNUNET_CONFIGURATION_get_value_number (cfg, | 677 | "HOSTLIST", |
684 | "HOSTLIST", | 678 | "HTTPPORT", |
685 | "HTTPPORT", | 679 | &port)) |
686 | &port)) | ||
687 | return GNUNET_SYSERR; | 680 | return GNUNET_SYSERR; |
688 | if ((0 == port) || (port > UINT16_MAX)) | 681 | if ((0 == port) || (port > UINT16_MAX)) |
689 | { | 682 | { |
690 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 683 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
691 | _("Invalid port number %llu. Exiting.\n"), | 684 | _ ("Invalid port number %llu. Exiting.\n"), |
692 | port); | 685 | port); |
693 | return GNUNET_SYSERR; | 686 | return GNUNET_SYSERR; |
694 | } | 687 | } |
@@ -700,8 +693,9 @@ GNUNET_HOSTLIST_server_start (const struct GNUNET_CONFIGURATION_Handle *c, | |||
700 | &hostname)) | 693 | &hostname)) |
701 | hostname = GNUNET_RESOLVER_local_fqdn_get (); | 694 | hostname = GNUNET_RESOLVER_local_fqdn_get (); |
702 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 695 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
703 | _("Hostlist service starts on %s:%llu\n"), | 696 | _ ("Hostlist service starts on %s:%llu\n"), |
704 | hostname, port); | 697 | hostname, |
698 | port); | ||
705 | if (NULL != hostname) | 699 | if (NULL != hostname) |
706 | { | 700 | { |
707 | size = strlen (hostname); | 701 | size = strlen (hostname); |
@@ -712,10 +706,11 @@ GNUNET_HOSTLIST_server_start (const struct GNUNET_CONFIGURATION_Handle *c, | |||
712 | else | 706 | else |
713 | { | 707 | { |
714 | GNUNET_asprintf (&hostlist_uri, | 708 | GNUNET_asprintf (&hostlist_uri, |
715 | "http://%s:%u/", hostname, | 709 | "http://%s:%u/", |
710 | hostname, | ||
716 | (unsigned int) port); | 711 | (unsigned int) port); |
717 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 712 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
718 | _("Address to obtain hostlist: `%s'\n"), | 713 | _ ("Address to obtain hostlist: `%s'\n"), |
719 | hostlist_uri); | 714 | hostlist_uri); |
720 | } | 715 | } |
721 | GNUNET_free (hostname); | 716 | GNUNET_free (hostname); |
@@ -723,29 +718,28 @@ GNUNET_HOSTLIST_server_start (const struct GNUNET_CONFIGURATION_Handle *c, | |||
723 | 718 | ||
724 | if (GNUNET_CONFIGURATION_have_value (cfg, "HOSTLIST", "BINDTOIPV4")) | 719 | if (GNUNET_CONFIGURATION_have_value (cfg, "HOSTLIST", "BINDTOIPV4")) |
725 | { | 720 | { |
726 | if (GNUNET_OK != | 721 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg, |
727 | GNUNET_CONFIGURATION_get_value_string (cfg, "HOSTLIST", | 722 | "HOSTLIST", |
728 | "BINDTOIP", &ipv4)) | 723 | "BINDTOIP", |
724 | &ipv4)) | ||
729 | { | 725 | { |
730 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | 726 | GNUNET_log ( |
731 | _("BINDTOIP does not a valid IPv4 address! Ignoring BINDTOIPV4.\n")); | 727 | GNUNET_ERROR_TYPE_WARNING, |
728 | _ ("BINDTOIP does not a valid IPv4 address! Ignoring BINDTOIPV4.\n")); | ||
732 | } | 729 | } |
733 | |||
734 | } | 730 | } |
735 | else | 731 | else |
736 | ipv4 = NULL; | 732 | ipv4 = NULL; |
737 | if (GNUNET_CONFIGURATION_have_value (cfg, | 733 | if (GNUNET_CONFIGURATION_have_value (cfg, "HOSTLIST", "BINDTOIPV6")) |
738 | "HOSTLIST", | 734 | { |
739 | "BINDTOIPV6")) | 735 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg, |
740 | { | 736 | "HOSTLIST", |
741 | if (GNUNET_OK != | 737 | "BINDTOIP", |
742 | GNUNET_CONFIGURATION_get_value_string (cfg, | 738 | &ipv6)) |
743 | "HOSTLIST", | 739 | { |
744 | "BINDTOIP", | 740 | GNUNET_log ( |
745 | &ipv6)) | 741 | GNUNET_ERROR_TYPE_WARNING, |
746 | { | 742 | _ ("BINDTOIP does not a valid IPv4 address! Ignoring BINDTOIPV6.\n")); |
747 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | ||
748 | _("BINDTOIP does not a valid IPv4 address! Ignoring BINDTOIPV6.\n")); | ||
749 | } | 743 | } |
750 | } | 744 | } |
751 | else | 745 | else |
@@ -766,7 +760,8 @@ GNUNET_HOSTLIST_server_start (const struct GNUNET_CONFIGURATION_Handle *c, | |||
766 | } | 760 | } |
767 | else | 761 | else |
768 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | 762 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
769 | _("`%s' is not a valid IPv4 address! Ignoring BINDTOIPV4.\n"), | 763 | _ ( |
764 | "`%s' is not a valid IPv4 address! Ignoring BINDTOIPV4.\n"), | ||
770 | ipv4); | 765 | ipv4); |
771 | GNUNET_free (ipv4); | 766 | GNUNET_free (ipv4); |
772 | } | 767 | } |
@@ -786,15 +781,18 @@ GNUNET_HOSTLIST_server_start (const struct GNUNET_CONFIGURATION_Handle *c, | |||
786 | } | 781 | } |
787 | else | 782 | else |
788 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | 783 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
789 | _("`%s' is not a valid IPv6 address! Ignoring BINDTOIPV6.\n"), | 784 | _ ( |
785 | "`%s' is not a valid IPv6 address! Ignoring BINDTOIPV6.\n"), | ||
790 | ipv6); | 786 | ipv6); |
791 | GNUNET_free (ipv6); | 787 | GNUNET_free (ipv6); |
792 | } | 788 | } |
793 | 789 | ||
794 | daemon_handle_v6 = MHD_start_daemon (MHD_USE_IPv6 | MHD_USE_DEBUG, | 790 | daemon_handle_v6 = MHD_start_daemon (MHD_USE_IPv6 | MHD_USE_DEBUG, |
795 | (uint16_t) port, | 791 | (uint16_t) port, |
796 | &accept_policy_callback, NULL, | 792 | &accept_policy_callback, |
797 | &access_handler_callback, NULL, | 793 | NULL, |
794 | &access_handler_callback, | ||
795 | NULL, | ||
798 | MHD_OPTION_CONNECTION_LIMIT, | 796 | MHD_OPTION_CONNECTION_LIMIT, |
799 | (unsigned int) 128, | 797 | (unsigned int) 128, |
800 | MHD_OPTION_PER_IP_CONNECTION_LIMIT, | 798 | MHD_OPTION_PER_IP_CONNECTION_LIMIT, |
@@ -807,9 +805,11 @@ GNUNET_HOSTLIST_server_start (const struct GNUNET_CONFIGURATION_Handle *c, | |||
807 | sa6, | 805 | sa6, |
808 | MHD_OPTION_END); | 806 | MHD_OPTION_END); |
809 | daemon_handle_v4 = MHD_start_daemon (MHD_NO_FLAG | MHD_USE_DEBUG, | 807 | daemon_handle_v4 = MHD_start_daemon (MHD_NO_FLAG | MHD_USE_DEBUG, |
810 | (uint16_t) port, | 808 | (uint16_t) port, |
811 | &accept_policy_callback, NULL, | 809 | &accept_policy_callback, |
812 | &access_handler_callback, NULL, | 810 | NULL, |
811 | &access_handler_callback, | ||
812 | NULL, | ||
813 | MHD_OPTION_CONNECTION_LIMIT, | 813 | MHD_OPTION_CONNECTION_LIMIT, |
814 | (unsigned int) 128, | 814 | (unsigned int) 128, |
815 | MHD_OPTION_PER_IP_CONNECTION_LIMIT, | 815 | MHD_OPTION_PER_IP_CONNECTION_LIMIT, |
@@ -822,11 +822,10 @@ GNUNET_HOSTLIST_server_start (const struct GNUNET_CONFIGURATION_Handle *c, | |||
822 | sa4, | 822 | sa4, |
823 | MHD_OPTION_END); | 823 | MHD_OPTION_END); |
824 | 824 | ||
825 | if ( (NULL == daemon_handle_v6) && | 825 | if ((NULL == daemon_handle_v6) && (NULL == daemon_handle_v4)) |
826 | (NULL == daemon_handle_v4) ) | ||
827 | { | 826 | { |
828 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 827 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
829 | _("Could not start hostlist HTTP server on port %u\n"), | 828 | _ ("Could not start hostlist HTTP server on port %u\n"), |
830 | (unsigned short) port); | 829 | (unsigned short) port); |
831 | return GNUNET_SYSERR; | 830 | return GNUNET_SYSERR; |
832 | } | 831 | } |
@@ -837,9 +836,7 @@ GNUNET_HOSTLIST_server_start (const struct GNUNET_CONFIGURATION_Handle *c, | |||
837 | hostlist_task_v4 = prepare_daemon (daemon_handle_v4); | 836 | hostlist_task_v4 = prepare_daemon (daemon_handle_v4); |
838 | if (NULL != daemon_handle_v6) | 837 | if (NULL != daemon_handle_v6) |
839 | hostlist_task_v6 = prepare_daemon (daemon_handle_v6); | 838 | hostlist_task_v6 = prepare_daemon (daemon_handle_v6); |
840 | notify = GNUNET_PEERINFO_notify (cfg, | 839 | notify = GNUNET_PEERINFO_notify (cfg, GNUNET_NO, &process_notify, NULL); |
841 | GNUNET_NO, | ||
842 | &process_notify, NULL); | ||
843 | return GNUNET_OK; | 840 | return GNUNET_OK; |
844 | } | 841 | } |
845 | 842 | ||
@@ -850,8 +847,7 @@ GNUNET_HOSTLIST_server_start (const struct GNUNET_CONFIGURATION_Handle *c, | |||
850 | void | 847 | void |
851 | GNUNET_HOSTLIST_server_stop () | 848 | GNUNET_HOSTLIST_server_stop () |
852 | { | 849 | { |
853 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 850 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Hostlist server shutdown\n"); |
854 | "Hostlist server shutdown\n"); | ||
855 | if (NULL != hostlist_task_v6) | 851 | if (NULL != hostlist_task_v6) |
856 | { | 852 | { |
857 | GNUNET_SCHEDULER_cancel (hostlist_task_v6); | 853 | GNUNET_SCHEDULER_cancel (hostlist_task_v6); |
diff --git a/src/include/gnunet_core_service.h b/src/include/gnunet_core_service.h index f10ddee75..111eb529d 100644 --- a/src/include/gnunet_core_service.h +++ b/src/include/gnunet_core_service.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 | ||
@@ -34,9 +34,8 @@ | |||
34 | #define GNUNET_CORE_SERVICE_H | 34 | #define GNUNET_CORE_SERVICE_H |
35 | 35 | ||
36 | #ifdef __cplusplus | 36 | #ifdef __cplusplus |
37 | extern "C" | 37 | extern "C" { |
38 | { | 38 | #if 0 /* keep Emacsens' auto-indent happy */ |
39 | #if 0 /* keep Emacsens' auto-indent happy */ | ||
40 | } | 39 | } |
41 | #endif | 40 | #endif |
42 | #endif | 41 | #endif |
@@ -49,35 +48,6 @@ extern "C" | |||
49 | */ | 48 | */ |
50 | #define GNUNET_CORE_VERSION 0x00000001 | 49 | #define GNUNET_CORE_VERSION 0x00000001 |
51 | 50 | ||
52 | /** | ||
53 | * Traffic priorities. | ||
54 | */ | ||
55 | enum GNUNET_CORE_Priority | ||
56 | { | ||
57 | |||
58 | /** | ||
59 | * Lowest priority, i.e. background traffic (i.e. fs) | ||
60 | */ | ||
61 | GNUNET_CORE_PRIO_BACKGROUND = 0, | ||
62 | |||
63 | /** | ||
64 | * Normal traffic (i.e. cadet/dv relay, DHT) | ||
65 | */ | ||
66 | GNUNET_CORE_PRIO_BEST_EFFORT = 1, | ||
67 | |||
68 | /** | ||
69 | * Urgent traffic (local peer, i.e. conversation). | ||
70 | */ | ||
71 | GNUNET_CORE_PRIO_URGENT = 2, | ||
72 | |||
73 | /** | ||
74 | * Highest priority, control traffic (i.e. NSE, Core/Cadet KX). | ||
75 | */ | ||
76 | GNUNET_CORE_PRIO_CRITICAL_CONTROL = 3 | ||
77 | |||
78 | |||
79 | }; | ||
80 | |||
81 | 51 | ||
82 | /** | 52 | /** |
83 | * Opaque handle to the service. | 53 | * Opaque handle to the service. |
@@ -93,10 +63,10 @@ struct GNUNET_CORE_Handle; | |||
93 | * @return closure associated with @a peer. given to mq callbacks and | 63 | * @return closure associated with @a peer. given to mq callbacks and |
94 | * #GNUNET_CORE_DisconnectEventHandler | 64 | * #GNUNET_CORE_DisconnectEventHandler |
95 | */ | 65 | */ |
96 | typedef void * | 66 | typedef void *(*GNUNET_CORE_ConnectEventHandler) ( |
97 | (*GNUNET_CORE_ConnectEventHandler) (void *cls, | 67 | void *cls, |
98 | const struct GNUNET_PeerIdentity *peer, | 68 | const struct GNUNET_PeerIdentity *peer, |
99 | struct GNUNET_MQ_Handle *mq); | 69 | struct GNUNET_MQ_Handle *mq); |
100 | 70 | ||
101 | 71 | ||
102 | /** | 72 | /** |
@@ -107,10 +77,10 @@ typedef void * | |||
107 | * @param peer_cls closure associated with peer. given in | 77 | * @param peer_cls closure associated with peer. given in |
108 | * #GNUNET_CORE_ConnectEventHandler | 78 | * #GNUNET_CORE_ConnectEventHandler |
109 | */ | 79 | */ |
110 | typedef void | 80 | typedef void (*GNUNET_CORE_DisconnectEventHandler) ( |
111 | (*GNUNET_CORE_DisconnectEventHandler) (void *cls, | 81 | void *cls, |
112 | const struct GNUNET_PeerIdentity *peer, | 82 | const struct GNUNET_PeerIdentity *peer, |
113 | void *peer_cls); | 83 | void *peer_cls); |
114 | 84 | ||
115 | 85 | ||
116 | /** | 86 | /** |
@@ -125,9 +95,9 @@ typedef void | |||
125 | * @param cls closure | 95 | * @param cls closure |
126 | * @param my_identity ID of this peer, NULL if we failed | 96 | * @param my_identity ID of this peer, NULL if we failed |
127 | */ | 97 | */ |
128 | typedef void | 98 | typedef void (*GNUNET_CORE_StartupCallback) ( |
129 | (*GNUNET_CORE_StartupCallback) (void *cls, | 99 | void *cls, |
130 | const struct GNUNET_PeerIdentity *my_identity); | 100 | const struct GNUNET_PeerIdentity *my_identity); |
131 | 101 | ||
132 | 102 | ||
133 | /** | 103 | /** |
@@ -173,22 +143,6 @@ GNUNET_CORE_disconnect (struct GNUNET_CORE_Handle *handle); | |||
173 | 143 | ||
174 | 144 | ||
175 | /** | 145 | /** |
176 | * Inquire with CORE what options should be set for a message | ||
177 | * so that it is transmitted with the given @a priority and | ||
178 | * the given @a cork value. | ||
179 | * | ||
180 | * @param cork desired corking | ||
181 | * @param priority desired message priority | ||
182 | * @param[out] flags set to `flags` value for #GNUNET_MQ_set_options() | ||
183 | * @return `extra` argument to give to #GNUNET_MQ_set_options() | ||
184 | */ | ||
185 | const void * | ||
186 | GNUNET_CORE_get_mq_options (int cork, | ||
187 | enum GNUNET_CORE_Priority priority, | ||
188 | uint64_t *flags); | ||
189 | |||
190 | |||
191 | /** | ||
192 | * Obtain the message queue for a connected peer. | 146 | * Obtain the message queue for a connected peer. |
193 | * | 147 | * |
194 | * @param h the core handle | 148 | * @param h the core handle |
@@ -197,7 +151,7 @@ GNUNET_CORE_get_mq_options (int cork, | |||
197 | */ | 151 | */ |
198 | struct GNUNET_MQ_Handle * | 152 | struct GNUNET_MQ_Handle * |
199 | GNUNET_CORE_get_mq (const struct GNUNET_CORE_Handle *h, | 153 | GNUNET_CORE_get_mq (const struct GNUNET_CORE_Handle *h, |
200 | const struct GNUNET_PeerIdentity *pid); | 154 | const struct GNUNET_PeerIdentity *pid); |
201 | 155 | ||
202 | 156 | ||
203 | /** | 157 | /** |
@@ -287,11 +241,11 @@ enum GNUNET_CORE_KxState | |||
287 | * @param state current key exchange state of the peer | 241 | * @param state current key exchange state of the peer |
288 | * @param timeout when does the current state expire | 242 | * @param timeout when does the current state expire |
289 | */ | 243 | */ |
290 | typedef void | 244 | typedef void (*GNUNET_CORE_MonitorCallback) ( |
291 | (*GNUNET_CORE_MonitorCallback)(void *cls, | 245 | void *cls, |
292 | const struct GNUNET_PeerIdentity *pid, | 246 | const struct GNUNET_PeerIdentity *pid, |
293 | enum GNUNET_CORE_KxState state, | 247 | enum GNUNET_CORE_KxState state, |
294 | struct GNUNET_TIME_Absolute timeout); | 248 | struct GNUNET_TIME_Absolute timeout); |
295 | 249 | ||
296 | 250 | ||
297 | /** | 251 | /** |
@@ -360,7 +314,7 @@ GNUNET_CORE_mq_create (struct GNUNET_CORE_Handle *h, | |||
360 | const struct GNUNET_PeerIdentity *target); | 314 | const struct GNUNET_PeerIdentity *target); |
361 | 315 | ||
362 | 316 | ||
363 | #if 0 /* keep Emacsens' auto-indent happy */ | 317 | #if 0 /* keep Emacsens' auto-indent happy */ |
364 | { | 318 | { |
365 | #endif | 319 | #endif |
366 | #ifdef __cplusplus | 320 | #ifdef __cplusplus |
@@ -370,6 +324,6 @@ GNUNET_CORE_mq_create (struct GNUNET_CORE_Handle *h, | |||
370 | /* ifndef GNUNET_CORE_SERVICE_H */ | 324 | /* ifndef GNUNET_CORE_SERVICE_H */ |
371 | #endif | 325 | #endif |
372 | 326 | ||
373 | /** @} */ /* end of group core */ | 327 | /** @} */ /* end of group core */ |
374 | 328 | ||
375 | /* end of gnunet_core_service.h */ | 329 | /* end of gnunet_core_service.h */ |
diff --git a/src/include/gnunet_mq_lib.h b/src/include/gnunet_mq_lib.h index 2a459636a..498567ec2 100644 --- a/src/include/gnunet_mq_lib.h +++ b/src/include/gnunet_mq_lib.h | |||
@@ -49,7 +49,10 @@ | |||
49 | * @param type type of the message | 49 | * @param type type of the message |
50 | * @return the MQ message | 50 | * @return the MQ message |
51 | */ | 51 | */ |
52 | #define GNUNET_MQ_msg_extra(mvar, esize, type) GNUNET_MQ_msg_(((struct GNUNET_MessageHeader**) &(mvar)), (esize) + sizeof *(mvar), (type)) | 52 | #define GNUNET_MQ_msg_extra(mvar, esize, type) \ |
53 | GNUNET_MQ_msg_ (((struct GNUNET_MessageHeader **) &(mvar)), \ | ||
54 | (esize) + sizeof *(mvar), \ | ||
55 | (type)) | ||
53 | 56 | ||
54 | /** | 57 | /** |
55 | * Allocate a GNUNET_MQ_Envelope. | 58 | * Allocate a GNUNET_MQ_Envelope. |
@@ -61,7 +64,7 @@ | |||
61 | * @param type type of the message | 64 | * @param type type of the message |
62 | * @return the allocated envelope | 65 | * @return the allocated envelope |
63 | */ | 66 | */ |
64 | #define GNUNET_MQ_msg(mvar, type) GNUNET_MQ_msg_extra(mvar, 0, type) | 67 | #define GNUNET_MQ_msg(mvar, type) GNUNET_MQ_msg_extra (mvar, 0, type) |
65 | 68 | ||
66 | 69 | ||
67 | /** | 70 | /** |
@@ -70,7 +73,8 @@ | |||
70 | * | 73 | * |
71 | * @param type type of the message | 74 | * @param type type of the message |
72 | */ | 75 | */ |
73 | #define GNUNET_MQ_msg_header(type) GNUNET_MQ_msg_ (NULL, sizeof (struct GNUNET_MessageHeader), type) | 76 | #define GNUNET_MQ_msg_header(type) \ |
77 | GNUNET_MQ_msg_ (NULL, sizeof (struct GNUNET_MessageHeader), type) | ||
74 | 78 | ||
75 | 79 | ||
76 | /** | 80 | /** |
@@ -81,7 +85,8 @@ | |||
81 | * @param esize extra space to allocate after the message header | 85 | * @param esize extra space to allocate after the message header |
82 | * @param type type of the message | 86 | * @param type type of the message |
83 | */ | 87 | */ |
84 | #define GNUNET_MQ_msg_header_extra(mh, esize, type) GNUNET_MQ_msg_ (&mh, (esize) + sizeof (struct GNUNET_MessageHeader), type) | 88 | #define GNUNET_MQ_msg_header_extra(mh, esize, type) \ |
89 | GNUNET_MQ_msg_ (&mh, (esize) + sizeof (struct GNUNET_MessageHeader), type) | ||
85 | 90 | ||
86 | 91 | ||
87 | /** | 92 | /** |
@@ -94,14 +99,16 @@ | |||
94 | * @param mh message to nest | 99 | * @param mh message to nest |
95 | * @return a newly allocated 'struct GNUNET_MQ_Envelope *' | 100 | * @return a newly allocated 'struct GNUNET_MQ_Envelope *' |
96 | */ | 101 | */ |
97 | #define GNUNET_MQ_msg_nested_mh(mvar, type, mh) \ | 102 | #define GNUNET_MQ_msg_nested_mh(mvar, type, mh) \ |
98 | ({struct GNUNET_MQ_Envelope *_ev;\ | 103 | ({ \ |
99 | _ev = GNUNET_MQ_msg_nested_mh_((struct GNUNET_MessageHeader**) &(mvar),\ | 104 | struct GNUNET_MQ_Envelope *_ev; \ |
100 | sizeof (*(mvar)),\ | 105 | _ev = GNUNET_MQ_msg_nested_mh_ ((struct GNUNET_MessageHeader **) &(mvar), \ |
101 | (type),\ | 106 | sizeof (*(mvar)), \ |
102 | (mh));\ | 107 | (type), \ |
103 | (void)(mvar)->header; /* type check */\ | 108 | (mh)); \ |
104 | _ev;}) | 109 | (void) (mvar)->header; /* type check */ \ |
110 | _ev; \ | ||
111 | }) | ||
105 | 112 | ||
106 | 113 | ||
107 | /** | 114 | /** |
@@ -112,7 +119,9 @@ | |||
112 | * @return a 'struct GNUNET_MessageHeader *' that points at the nested message of the given message, | 119 | * @return a 'struct GNUNET_MessageHeader *' that points at the nested message of the given message, |
113 | * or NULL if the given message in @a var does not have any space after the message struct | 120 | * or NULL if the given message in @a var does not have any space after the message struct |
114 | */ | 121 | */ |
115 | #define GNUNET_MQ_extract_nested_mh(var) GNUNET_MQ_extract_nested_mh_ ((struct GNUNET_MessageHeader *) (var), sizeof (*(var))) | 122 | #define GNUNET_MQ_extract_nested_mh(var) \ |
123 | GNUNET_MQ_extract_nested_mh_ ((struct GNUNET_MessageHeader *) (var), \ | ||
124 | sizeof (*(var))) | ||
116 | 125 | ||
117 | 126 | ||
118 | /** | 127 | /** |
@@ -213,14 +222,89 @@ enum GNUNET_MQ_Error | |||
213 | 222 | ||
214 | 223 | ||
215 | /** | 224 | /** |
225 | * Per envelope preferences and priorities. | ||
226 | */ | ||
227 | enum GNUNET_MQ_PriorityPreferences | ||
228 | { | ||
229 | |||
230 | /** | ||
231 | * Lowest priority, i.e. background traffic (i.e. NSE, FS). | ||
232 | * This is the default! | ||
233 | */ | ||
234 | GNUNET_MQ_PRIO_BACKGROUND = 0, | ||
235 | |||
236 | /** | ||
237 | * Best-effort traffic (i.e. CADET relay, DHT) | ||
238 | */ | ||
239 | GNUNET_MQ_PRIO_BEST_EFFORT = 1, | ||
240 | |||
241 | /** | ||
242 | * Urgent traffic (local peer, i.e. Conversation). | ||
243 | */ | ||
244 | GNUNET_MQ_PRIO_URGENT = 2, | ||
245 | |||
246 | /** | ||
247 | * Highest priority, control traffic (i.e. CORE/CADET KX). | ||
248 | */ | ||
249 | GNUNET_MQ_PRIO_CRITICAL_CONTROL = 3, | ||
250 | |||
251 | /** | ||
252 | * Bit mask to apply to extract the priority bits. | ||
253 | */ | ||
254 | GNUNET_MQ_PRIORITY_MASK = 3, | ||
255 | |||
256 | /** | ||
257 | * Flag to indicate that unreliable delivery is acceptable. This | ||
258 | * means TRANSPORT will not attempt to receive an | ||
259 | * acknowledgment. CORE will just pass this flag through. CADET | ||
260 | * will use unreliable delivery if this flag is set. | ||
261 | * | ||
262 | * Note that even without this flag, messages may be lost by | ||
263 | * TRANSPORT and CORE. | ||
264 | * | ||
265 | * Thus, how "strong" the semantics of reliable delivery are depends | ||
266 | * on the layer! | ||
267 | */ | ||
268 | GNUNET_MQ_PREF_UNRELIABLE = 16, | ||
269 | |||
270 | /** | ||
271 | * Flag to indicate that low latency is important. This flag must | ||
272 | * generally not be used in combination with | ||
273 | * #GNUNET_MQ_PREF_CORKING_ALLOWED as it would be a contradiction. | ||
274 | * When this flags is set, the envelope may skip forward in the | ||
275 | * queue (depending on priority) and also TRANSPORT should attempt | ||
276 | * to pick a communicator with particularly low latency. | ||
277 | */ | ||
278 | GNUNET_MQ_PREF_LOW_LATENCY = 32, | ||
279 | |||
280 | /** | ||
281 | * Flag to indicate that CORKing is acceptable. This allows the | ||
282 | * receiver to delay transmission in hope of combining this message | ||
283 | * with other messages into a larger transmission with less | ||
284 | * per-message overhead. | ||
285 | */ | ||
286 | GNUNET_MQ_PREF_CORK_ALLOWED = 64, | ||
287 | |||
288 | /** | ||
289 | * Flag to indicate that high bandwidth is desired. This flag | ||
290 | * indicates that the method chosen for transmission should focus on | ||
291 | * overall goodput. It rarely makes sense to combine this flag with | ||
292 | * #GNUNET_MQ_PREF_LOW_LATENCY. | ||
293 | */ | ||
294 | GNUNET_MQ_PREF_GOODPUT = 128 | ||
295 | |||
296 | }; | ||
297 | |||
298 | |||
299 | /** | ||
216 | * Called when a message has been received. | 300 | * Called when a message has been received. |
217 | * | 301 | * |
218 | * @param cls closure | 302 | * @param cls closure |
219 | * @param msg the received message | 303 | * @param msg the received message |
220 | */ | 304 | */ |
221 | typedef void | 305 | typedef void (*GNUNET_MQ_MessageCallback) ( |
222 | (*GNUNET_MQ_MessageCallback) (void *cls, | 306 | void *cls, |
223 | const struct GNUNET_MessageHeader *msg); | 307 | const struct GNUNET_MessageHeader *msg); |
224 | 308 | ||
225 | 309 | ||
226 | /** | 310 | /** |
@@ -231,9 +315,9 @@ typedef void | |||
231 | * @return #GNUNET_OK if the message is well-formed, | 315 | * @return #GNUNET_OK if the message is well-formed, |
232 | * #GNUNET_SYSERR if not | 316 | * #GNUNET_SYSERR if not |
233 | */ | 317 | */ |
234 | typedef int | 318 | typedef int (*GNUNET_MQ_MessageValidationCallback) ( |
235 | (*GNUNET_MQ_MessageValidationCallback) (void *cls, | 319 | void *cls, |
236 | const struct GNUNET_MessageHeader *msg); | 320 | const struct GNUNET_MessageHeader *msg); |
237 | 321 | ||
238 | 322 | ||
239 | /** | 323 | /** |
@@ -244,10 +328,9 @@ typedef int | |||
244 | * @param msg the message to send | 328 | * @param msg the message to send |
245 | * @param impl_state state of the implementation | 329 | * @param impl_state state of the implementation |
246 | */ | 330 | */ |
247 | typedef void | 331 | typedef void (*GNUNET_MQ_SendImpl) (struct GNUNET_MQ_Handle *mq, |
248 | (*GNUNET_MQ_SendImpl) (struct GNUNET_MQ_Handle *mq, | 332 | const struct GNUNET_MessageHeader *msg, |
249 | const struct GNUNET_MessageHeader *msg, | 333 | void *impl_state); |
250 | void *impl_state); | ||
251 | 334 | ||
252 | 335 | ||
253 | /** | 336 | /** |
@@ -259,9 +342,8 @@ typedef void | |||
259 | * @param mq the message queue to destroy | 342 | * @param mq the message queue to destroy |
260 | * @param impl_state state of the implementation | 343 | * @param impl_state state of the implementation |
261 | */ | 344 | */ |
262 | typedef void | 345 | typedef void (*GNUNET_MQ_DestroyImpl) (struct GNUNET_MQ_Handle *mq, |
263 | (*GNUNET_MQ_DestroyImpl) (struct GNUNET_MQ_Handle *mq, | 346 | void *impl_state); |
264 | void *impl_state); | ||
265 | 347 | ||
266 | 348 | ||
267 | /** | 349 | /** |
@@ -270,9 +352,8 @@ typedef void | |||
270 | * @param mq message queue | 352 | * @param mq message queue |
271 | * @param impl_state state specific to the implementation | 353 | * @param impl_state state specific to the implementation |
272 | */ | 354 | */ |
273 | typedef void | 355 | typedef void (*GNUNET_MQ_CancelImpl) (struct GNUNET_MQ_Handle *mq, |
274 | (*GNUNET_MQ_CancelImpl) (struct GNUNET_MQ_Handle *mq, | 356 | void *impl_state); |
275 | void *impl_state); | ||
276 | 357 | ||
277 | 358 | ||
278 | /** | 359 | /** |
@@ -284,9 +365,7 @@ typedef void | |||
284 | * @param cls closure | 365 | * @param cls closure |
285 | * @param error error code | 366 | * @param error error code |
286 | */ | 367 | */ |
287 | typedef void | 368 | typedef void (*GNUNET_MQ_ErrorHandler) (void *cls, enum GNUNET_MQ_Error error); |
288 | (*GNUNET_MQ_ErrorHandler) (void *cls, | ||
289 | enum GNUNET_MQ_Error error); | ||
290 | 369 | ||
291 | 370 | ||
292 | /** | 371 | /** |
@@ -411,7 +490,10 @@ struct GNUNET_MQ_MessageHandler | |||
411 | /** | 490 | /** |
412 | * End-marker for the handlers array | 491 | * End-marker for the handlers array |
413 | */ | 492 | */ |
414 | #define GNUNET_MQ_handler_end() { NULL, NULL, NULL, 0, 0 } | 493 | #define GNUNET_MQ_handler_end() \ |
494 | { \ | ||
495 | NULL, NULL, NULL, 0, 0 \ | ||
496 | } | ||
415 | 497 | ||
416 | 498 | ||
417 | /** | 499 | /** |
@@ -442,12 +524,14 @@ struct GNUNET_MQ_MessageHandler | |||
442 | * @param str type of the message (a struct) | 524 | * @param str type of the message (a struct) |
443 | * @param ctx context for the callbacks | 525 | * @param ctx context for the callbacks |
444 | */ | 526 | */ |
445 | #define GNUNET_MQ_hd_fixed_size(name,code,str,ctx) \ | 527 | #define GNUNET_MQ_hd_fixed_size(name, code, str, ctx) \ |
446 | ({ \ | 528 | ({ \ |
447 | void (*_cb)(void *cls, const str *msg) = &handle_##name; \ | 529 | void (*_cb) (void *cls, const str *msg) = &handle_##name; \ |
448 | ((struct GNUNET_MQ_MessageHandler) { \ | 530 | ((struct GNUNET_MQ_MessageHandler){NULL, \ |
449 | NULL, (GNUNET_MQ_MessageCallback) _cb, \ | 531 | (GNUNET_MQ_MessageCallback) _cb, \ |
450 | (ctx), (code), sizeof (str) }); \ | 532 | (ctx), \ |
533 | (code), \ | ||
534 | sizeof (str)}); \ | ||
451 | }) | 535 | }) |
452 | 536 | ||
453 | 537 | ||
@@ -491,14 +575,16 @@ struct GNUNET_MQ_MessageHandler | |||
491 | * @param str type of the message (a struct) | 575 | * @param str type of the message (a struct) |
492 | * @param ctx context for the callbacks | 576 | * @param ctx context for the callbacks |
493 | */ | 577 | */ |
494 | #define GNUNET_MQ_hd_var_size(name,code,str,ctx) \ | 578 | #define GNUNET_MQ_hd_var_size(name, code, str, ctx) \ |
495 | __extension__ ({ \ | 579 | __extension__({ \ |
496 | int (*_mv)(void *cls, const str *msg) = &check_##name; \ | 580 | int (*_mv) (void *cls, const str *msg) = &check_##name; \ |
497 | void (*_cb)(void *cls, const str *msg) = &handle_##name; \ | 581 | void (*_cb) (void *cls, const str *msg) = &handle_##name; \ |
498 | ((struct GNUNET_MQ_MessageHandler) \ | 582 | ((struct GNUNET_MQ_MessageHandler){(GNUNET_MQ_MessageValidationCallback) \ |
499 | { (GNUNET_MQ_MessageValidationCallback) _mv, \ | 583 | _mv, \ |
500 | (GNUNET_MQ_MessageCallback) _cb, \ | 584 | (GNUNET_MQ_MessageCallback) _cb, \ |
501 | (ctx), (code), sizeof (str) }); \ | 585 | (ctx), \ |
586 | (code), \ | ||
587 | sizeof (str)}); \ | ||
502 | }) | 588 | }) |
503 | 589 | ||
504 | 590 | ||
@@ -512,18 +598,17 @@ struct GNUNET_MQ_MessageHandler | |||
512 | * @param an IPC message with proper type to determine | 598 | * @param an IPC message with proper type to determine |
513 | * the size, starting with a `struct GNUNET_MessageHeader` | 599 | * the size, starting with a `struct GNUNET_MessageHeader` |
514 | */ | 600 | */ |
515 | #define GNUNET_MQ_check_zero_termination(m) \ | 601 | #define GNUNET_MQ_check_zero_termination(m) \ |
516 | { \ | 602 | { \ |
517 | const char *str = (const char *) &m[1]; \ | 603 | const char *str = (const char *) &m[1]; \ |
518 | const struct GNUNET_MessageHeader *hdr = \ | 604 | const struct GNUNET_MessageHeader *hdr = \ |
519 | (const struct GNUNET_MessageHeader *) m; \ | 605 | (const struct GNUNET_MessageHeader *) m; \ |
520 | uint16_t slen = ntohs (hdr->size) - sizeof (*m); \ | 606 | uint16_t slen = ntohs (hdr->size) - sizeof (*m); \ |
521 | if ( (0 == slen) || \ | 607 | if ((0 == slen) || (memchr (str, 0, slen) != &str[slen - 1])) \ |
522 | (memchr (str, 0, slen) != &str[slen - 1]) ) \ | 608 | { \ |
523 | { \ | 609 | GNUNET_break (0); \ |
524 | GNUNET_break (0); \ | 610 | return GNUNET_NO; \ |
525 | return GNUNET_NO; \ | 611 | } \ |
526 | } \ | ||
527 | } | 612 | } |
528 | 613 | ||
529 | 614 | ||
@@ -539,19 +624,19 @@ struct GNUNET_MQ_MessageHandler | |||
539 | * @param an IPC message with proper type to determine | 624 | * @param an IPC message with proper type to determine |
540 | * the size, starting with a `struct GNUNET_MessageHeader` | 625 | * the size, starting with a `struct GNUNET_MessageHeader` |
541 | */ | 626 | */ |
542 | #define GNUNET_MQ_check_boxed_message(m) \ | 627 | #define GNUNET_MQ_check_boxed_message(m) \ |
543 | { \ | 628 | { \ |
544 | const struct GNUNET_MessageHeader *inbox = \ | 629 | const struct GNUNET_MessageHeader *inbox = \ |
545 | (const struct GNUNET_MessageHeader *) &m[1]; \ | 630 | (const struct GNUNET_MessageHeader *) &m[1]; \ |
546 | const struct GNUNET_MessageHeader *hdr = \ | 631 | const struct GNUNET_MessageHeader *hdr = \ |
547 | (const struct GNUNET_MessageHeader *) m; \ | 632 | (const struct GNUNET_MessageHeader *) m; \ |
548 | uint16_t slen = ntohs (hdr->size) - sizeof (*m); \ | 633 | uint16_t slen = ntohs (hdr->size) - sizeof (*m); \ |
549 | if ( (slen < sizeof (struct GNUNET_MessageHeader))||\ | 634 | if ((slen < sizeof (struct GNUNET_MessageHeader)) || \ |
550 | (slen != ntohs (inbox->size)) ) \ | 635 | (slen != ntohs (inbox->size))) \ |
551 | { \ | 636 | { \ |
552 | GNUNET_break (0); \ | 637 | GNUNET_break (0); \ |
553 | return GNUNET_NO; \ | 638 | return GNUNET_NO; \ |
554 | } \ | 639 | } \ |
555 | } | 640 | } |
556 | 641 | ||
557 | 642 | ||
@@ -645,25 +730,34 @@ GNUNET_MQ_get_last_envelope (struct GNUNET_MQ_Handle *mq); | |||
645 | * #GNUNET_MQ_set_options() for this message only. | 730 | * #GNUNET_MQ_set_options() for this message only. |
646 | * | 731 | * |
647 | * @param env message to set options for | 732 | * @param env message to set options for |
648 | * @param flags flags to use (meaning is queue-specific) | 733 | * @param pp priority and preferences to set for @a env |
649 | * @param extra additional buffer for further data (also queue-specific) | ||
650 | */ | 734 | */ |
651 | void | 735 | void |
652 | GNUNET_MQ_env_set_options (struct GNUNET_MQ_Envelope *env, | 736 | GNUNET_MQ_env_set_options (struct GNUNET_MQ_Envelope *env, |
653 | uint64_t flags, | 737 | enum GNUNET_MQ_PriorityPreferences pp); |
654 | const void *extra); | ||
655 | 738 | ||
656 | 739 | ||
657 | /** | 740 | /** |
658 | * Get application-specific options for this envelope. | 741 | * Get performance preferences set for this envelope. |
659 | * | 742 | * |
660 | * @param env message to set options for | 743 | * @param env message to set options for |
661 | * @param[out] flags set to flags to use (meaning is queue-specific) | 744 | * @return priority and preferences to use |
662 | * @return extra additional buffer for further data (also queue-specific) | 745 | */ |
746 | enum GNUNET_MQ_PriorityPreferences | ||
747 | GNUNET_MQ_env_get_options (struct GNUNET_MQ_Envelope *env); | ||
748 | |||
749 | |||
750 | /** | ||
751 | * Combine performance preferences set for different | ||
752 | * envelopes that are being combined into one larger envelope. | ||
753 | * | ||
754 | * @param p1 one set of preferences | ||
755 | * @param p2 second set of preferences | ||
756 | * @return combined priority and preferences to use | ||
663 | */ | 757 | */ |
664 | const void * | 758 | enum GNUNET_MQ_PriorityPreferences |
665 | GNUNET_MQ_env_get_options (struct GNUNET_MQ_Envelope *env, | 759 | GNUNET_MQ_env_combine_options (enum GNUNET_MQ_PriorityPreferences p1, |
666 | uint64_t *flags); | 760 | enum GNUNET_MQ_PriorityPreferences p2); |
667 | 761 | ||
668 | 762 | ||
669 | /** | 763 | /** |
@@ -681,13 +775,11 @@ GNUNET_MQ_unsent_head (struct GNUNET_MQ_Handle *mq); | |||
681 | * Set application-specific options for this queue. | 775 | * Set application-specific options for this queue. |
682 | * | 776 | * |
683 | * @param mq message queue to set options for | 777 | * @param mq message queue to set options for |
684 | * @param flags flags to use (meaning is queue-specific) | 778 | * @param pp priority and preferences to use by default |
685 | * @param extra additional buffer for further data (also queue-specific) | ||
686 | */ | 779 | */ |
687 | void | 780 | void |
688 | GNUNET_MQ_set_options (struct GNUNET_MQ_Handle *mq, | 781 | GNUNET_MQ_set_options (struct GNUNET_MQ_Handle *mq, |
689 | uint64_t flags, | 782 | enum GNUNET_MQ_PriorityPreferences pp); |
690 | const void *extra); | ||
691 | 783 | ||
692 | 784 | ||
693 | /** | 785 | /** |
@@ -708,8 +800,7 @@ GNUNET_MQ_get_length (struct GNUNET_MQ_Handle *mq); | |||
708 | * @param ev the envelope with the message to send. | 800 | * @param ev the envelope with the message to send. |
709 | */ | 801 | */ |
710 | void | 802 | void |
711 | GNUNET_MQ_send (struct GNUNET_MQ_Handle *mq, | 803 | GNUNET_MQ_send (struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev); |
712 | struct GNUNET_MQ_Envelope *ev); | ||
713 | 804 | ||
714 | 805 | ||
715 | /** | 806 | /** |
@@ -742,8 +833,7 @@ GNUNET_MQ_send_cancel (struct GNUNET_MQ_Envelope *ev); | |||
742 | * @param assoc_data to associate | 833 | * @param assoc_data to associate |
743 | */ | 834 | */ |
744 | uint32_t | 835 | uint32_t |
745 | GNUNET_MQ_assoc_add (struct GNUNET_MQ_Handle *mq, | 836 | GNUNET_MQ_assoc_add (struct GNUNET_MQ_Handle *mq, void *assoc_data); |
746 | void *assoc_data); | ||
747 | 837 | ||
748 | 838 | ||
749 | /** | 839 | /** |
@@ -754,8 +844,7 @@ GNUNET_MQ_assoc_add (struct GNUNET_MQ_Handle *mq, | |||
754 | * @return the associated data | 844 | * @return the associated data |
755 | */ | 845 | */ |
756 | void * | 846 | void * |
757 | GNUNET_MQ_assoc_get (struct GNUNET_MQ_Handle *mq, | 847 | GNUNET_MQ_assoc_get (struct GNUNET_MQ_Handle *mq, uint32_t request_id); |
758 | uint32_t request_id); | ||
759 | 848 | ||
760 | 849 | ||
761 | /** | 850 | /** |
@@ -766,8 +855,7 @@ GNUNET_MQ_assoc_get (struct GNUNET_MQ_Handle *mq, | |||
766 | * @return the associated data | 855 | * @return the associated data |
767 | */ | 856 | */ |
768 | void * | 857 | void * |
769 | GNUNET_MQ_assoc_remove (struct GNUNET_MQ_Handle *mq, | 858 | GNUNET_MQ_assoc_remove (struct GNUNET_MQ_Handle *mq, uint32_t request_id); |
770 | uint32_t request_id); | ||
771 | 859 | ||
772 | 860 | ||
773 | /** | 861 | /** |
@@ -846,8 +934,8 @@ struct GNUNET_MQ_DestroyNotificationHandle; | |||
846 | */ | 934 | */ |
847 | struct GNUNET_MQ_DestroyNotificationHandle * | 935 | struct GNUNET_MQ_DestroyNotificationHandle * |
848 | GNUNET_MQ_destroy_notify (struct GNUNET_MQ_Handle *mq, | 936 | GNUNET_MQ_destroy_notify (struct GNUNET_MQ_Handle *mq, |
849 | GNUNET_SCHEDULER_TaskCallback cb, | 937 | GNUNET_SCHEDULER_TaskCallback cb, |
850 | void *cb_cls); | 938 | void *cb_cls); |
851 | 939 | ||
852 | /** | 940 | /** |
853 | * Cancel registration from #GNUNET_MQ_destroy_notify(). | 941 | * Cancel registration from #GNUNET_MQ_destroy_notify(). |
@@ -855,7 +943,8 @@ GNUNET_MQ_destroy_notify (struct GNUNET_MQ_Handle *mq, | |||
855 | * @param dnh handle for registration to cancel | 943 | * @param dnh handle for registration to cancel |
856 | */ | 944 | */ |
857 | void | 945 | void |
858 | GNUNET_MQ_destroy_notify_cancel (struct GNUNET_MQ_DestroyNotificationHandle *dnh); | 946 | GNUNET_MQ_destroy_notify_cancel ( |
947 | struct GNUNET_MQ_DestroyNotificationHandle *dnh); | ||
859 | 948 | ||
860 | 949 | ||
861 | /** | 950 | /** |
@@ -947,7 +1036,6 @@ const struct GNUNET_MessageHeader * | |||
947 | GNUNET_MQ_impl_current (struct GNUNET_MQ_Handle *mq); | 1036 | GNUNET_MQ_impl_current (struct GNUNET_MQ_Handle *mq); |
948 | 1037 | ||
949 | 1038 | ||
950 | |||
951 | /** | 1039 | /** |
952 | * Enum defining all known preference categories. | 1040 | * Enum defining all known preference categories. |
953 | */ | 1041 | */ |
@@ -977,7 +1065,7 @@ enum GNUNET_MQ_PreferenceKind | |||
977 | */ | 1065 | */ |
978 | GNUNET_MQ_PREFERENCE_RELIABILITY = 3 | 1066 | GNUNET_MQ_PREFERENCE_RELIABILITY = 3 |
979 | 1067 | ||
980 | /** | 1068 | /** |
981 | * Number of preference values allowed. | 1069 | * Number of preference values allowed. |
982 | */ | 1070 | */ |
983 | #define GNUNET_MQ_PREFERENCE_COUNT 4 | 1071 | #define GNUNET_MQ_PREFERENCE_COUNT 4 |
@@ -995,8 +1083,6 @@ const char * | |||
995 | GNUNET_MQ_preference_to_string (enum GNUNET_MQ_PreferenceKind type); | 1083 | GNUNET_MQ_preference_to_string (enum GNUNET_MQ_PreferenceKind type); |
996 | 1084 | ||
997 | 1085 | ||
998 | |||
999 | |||
1000 | #endif | 1086 | #endif |
1001 | 1087 | ||
1002 | /** @} */ /* end of group mq */ | 1088 | /** @} */ /* end of group mq */ |
diff --git a/src/nse/gnunet-service-nse.c b/src/nse/gnunet-service-nse.c index 5b12c4b98..09316dbcf 100644 --- a/src/nse/gnunet-service-nse.c +++ b/src/nse/gnunet-service-nse.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 | ||
@@ -51,7 +51,6 @@ | |||
51 | #include <gcrypt.h> | 51 | #include <gcrypt.h> |
52 | 52 | ||
53 | 53 | ||
54 | |||
55 | /** | 54 | /** |
56 | * Should messages be delayed randomly? This option should be set to | 55 | * Should messages be delayed randomly? This option should be set to |
57 | * #GNUNET_NO only for experiments, not in production. | 56 | * #GNUNET_NO only for experiments, not in production. |
@@ -69,12 +68,15 @@ | |||
69 | #define HISTORY_SIZE 64 | 68 | #define HISTORY_SIZE 64 |
70 | 69 | ||
71 | /** | 70 | /** |
72 | * Message priority to use. | 71 | * Message priority to use. No real rush, reliability not |
72 | * required. Corking OK. | ||
73 | */ | 73 | */ |
74 | #define NSE_PRIORITY GNUNET_CORE_PRIO_CRITICAL_CONTROL | 74 | #define NSE_PRIORITY \ |
75 | (GNUNET_MQ_PRIO_BACKGROUND | GNUNET_MQ_PREF_UNRELIABLE | \ | ||
76 | GNUNET_MQ_PREF_CORK_ALLOWED) | ||
75 | 77 | ||
76 | #if FREEBSD | 78 | #if FREEBSD |
77 | #define log2(a) (log(a)/log(2)) | 79 | #define log2(a) (log (a) / log (2)) |
78 | #endif | 80 | #endif |
79 | 81 | ||
80 | /** | 82 | /** |
@@ -158,7 +160,6 @@ struct NSEPeerEntry | |||
158 | unsigned int last_transmitted_size; | 160 | unsigned int last_transmitted_size; |
159 | 161 | ||
160 | #endif | 162 | #endif |
161 | |||
162 | }; | 163 | }; |
163 | 164 | ||
164 | 165 | ||
@@ -380,13 +381,14 @@ setup_estimate_message (struct GNUNET_NSE_ClientMessage *em) | |||
380 | if (0 != estimate_count) | 381 | if (0 != estimate_count) |
381 | { | 382 | { |
382 | mean = sum / estimate_count; | 383 | mean = sum / estimate_count; |
383 | variance = (vsq - mean * sum) / (estimate_count - 1.0); // terrible for numerical stability... | 384 | variance = (vsq - mean * sum) / |
385 | (estimate_count - 1.0); // terrible for numerical stability... | ||
384 | } | 386 | } |
385 | #endif | 387 | #endif |
386 | if (variance >= 0) | 388 | if (variance >= 0) |
387 | std_dev = sqrt (variance); | 389 | std_dev = sqrt (variance); |
388 | else | 390 | else |
389 | std_dev = variance; /* must be infinity due to estimate_count == 0 */ | 391 | std_dev = variance; /* must be infinity due to estimate_count == 0 */ |
390 | current_std_dev = std_dev; | 392 | current_std_dev = std_dev; |
391 | current_size_estimate = mean; | 393 | current_size_estimate = mean; |
392 | 394 | ||
@@ -401,14 +403,12 @@ setup_estimate_message (struct GNUNET_NSE_ClientMessage *em) | |||
401 | j = 1; /* Avoid log2(0); can only happen if CORE didn't report | 403 | j = 1; /* Avoid log2(0); can only happen if CORE didn't report |
402 | connection to self yet */ | 404 | connection to self yet */ |
403 | nsize = log2 (j); | 405 | nsize = log2 (j); |
404 | em->size_estimate = GNUNET_hton_double (GNUNET_MAX (se, | 406 | em->size_estimate = GNUNET_hton_double (GNUNET_MAX (se, nsize)); |
405 | nsize)); | ||
406 | em->std_deviation = GNUNET_hton_double (std_dev); | 407 | em->std_deviation = GNUNET_hton_double (std_dev); |
407 | GNUNET_STATISTICS_set (stats, | 408 | GNUNET_STATISTICS_set (stats, |
408 | "# nodes in the network (estimate)", | 409 | "# nodes in the network (estimate)", |
409 | (uint64_t) pow (2, GNUNET_MAX (se, | 410 | (uint64_t) pow (2, GNUNET_MAX (se, nsize)), |
410 | nsize)), | 411 | GNUNET_NO); |
411 | GNUNET_NO); | ||
412 | } | 412 | } |
413 | } | 413 | } |
414 | 414 | ||
@@ -423,23 +423,19 @@ setup_estimate_message (struct GNUNET_NSE_ClientMessage *em) | |||
423 | * @param message the message received | 423 | * @param message the message received |
424 | */ | 424 | */ |
425 | static void | 425 | static void |
426 | handle_start (void *cls, | 426 | handle_start (void *cls, const struct GNUNET_MessageHeader *message) |
427 | const struct GNUNET_MessageHeader *message) | ||
428 | { | 427 | { |
429 | struct GNUNET_SERVICE_Client *client = cls; | 428 | struct GNUNET_SERVICE_Client *client = cls; |
430 | struct GNUNET_MQ_Handle *mq; | 429 | struct GNUNET_MQ_Handle *mq; |
431 | struct GNUNET_NSE_ClientMessage em; | 430 | struct GNUNET_NSE_ClientMessage em; |
432 | struct GNUNET_MQ_Envelope *env; | 431 | struct GNUNET_MQ_Envelope *env; |
433 | 432 | ||
434 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 433 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received START message from client\n"); |
435 | "Received START message from client\n"); | ||
436 | mq = GNUNET_SERVICE_client_get_mq (client); | 434 | mq = GNUNET_SERVICE_client_get_mq (client); |
437 | GNUNET_notification_context_add (nc, | 435 | GNUNET_notification_context_add (nc, mq); |
438 | mq); | ||
439 | setup_estimate_message (&em); | 436 | setup_estimate_message (&em); |
440 | env = GNUNET_MQ_msg_copy (&em.header); | 437 | env = GNUNET_MQ_msg_copy (&em.header); |
441 | GNUNET_MQ_send (mq, | 438 | GNUNET_MQ_send (mq, env); |
442 | env); | ||
443 | GNUNET_SERVICE_client_continue (client); | 439 | GNUNET_SERVICE_client_continue (client); |
444 | } | 440 | } |
445 | 441 | ||
@@ -459,8 +455,8 @@ get_matching_bits_delay (uint32_t matching_bits) | |||
459 | // x is matching_bits | 455 | // x is matching_bits |
460 | // p' is current_size_estimate | 456 | // p' is current_size_estimate |
461 | return ((double) gnunet_nse_interval.rel_value_us / (double) 2.0) - | 457 | return ((double) gnunet_nse_interval.rel_value_us / (double) 2.0) - |
462 | ((gnunet_nse_interval.rel_value_us / M_PI) * | 458 | ((gnunet_nse_interval.rel_value_us / M_PI) * |
463 | atan (matching_bits - current_size_estimate)); | 459 | atan (matching_bits - current_size_estimate)); |
464 | } | 460 | } |
465 | 461 | ||
466 | 462 | ||
@@ -482,10 +478,10 @@ get_delay_randomization (uint32_t matching_bits) | |||
482 | i = (uint32_t) (d / (double) (hop_count_max + 1)); | 478 | i = (uint32_t) (d / (double) (hop_count_max + 1)); |
483 | ret.rel_value_us = i; | 479 | ret.rel_value_us = i; |
484 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 480 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
485 | "Randomizing flood using latencies up to %s\n", | 481 | "Randomizing flood using latencies up to %s\n", |
486 | GNUNET_STRINGS_relative_time_to_string (ret, | 482 | GNUNET_STRINGS_relative_time_to_string (ret, GNUNET_YES)); |
487 | GNUNET_YES)); | 483 | ret.rel_value_us = |
488 | ret.rel_value_us = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, i + 1); | 484 | GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, i + 1); |
489 | return ret; | 485 | return ret; |
490 | #else | 486 | #else |
491 | return GNUNET_TIME_UNIT_ZERO; | 487 | return GNUNET_TIME_UNIT_ZERO; |
@@ -501,19 +497,18 @@ get_delay_randomization (uint32_t matching_bits) | |||
501 | * @param result where to write the resulting hash | 497 | * @param result where to write the resulting hash |
502 | */ | 498 | */ |
503 | static void | 499 | static void |
504 | pow_hash (const void *buf, | 500 | pow_hash (const void *buf, size_t buf_len, struct GNUNET_HashCode *result) |
505 | size_t buf_len, | ||
506 | struct GNUNET_HashCode *result) | ||
507 | { | 501 | { |
508 | GNUNET_break (0 == | 502 | GNUNET_break ( |
509 | gcry_kdf_derive (buf, buf_len, | 503 | 0 == gcry_kdf_derive (buf, |
510 | GCRY_KDF_SCRYPT, | 504 | buf_len, |
511 | 1 /* subalgo */, | 505 | GCRY_KDF_SCRYPT, |
512 | "gnunet-proof-of-work", | 506 | 1 /* subalgo */, |
513 | strlen ("gnunet-proof-of-work"), | 507 | "gnunet-proof-of-work", |
514 | 2 /* iterations; keep cost of individual op small */, | 508 | strlen ("gnunet-proof-of-work"), |
515 | sizeof (struct GNUNET_HashCode), | 509 | 2 /* iterations; keep cost of individual op small */, |
516 | result)); | 510 | sizeof (struct GNUNET_HashCode), |
511 | result)); | ||
517 | } | 512 | } |
518 | 513 | ||
519 | 514 | ||
@@ -534,11 +529,8 @@ get_matching_bits (struct GNUNET_TIME_Absolute timestamp, | |||
534 | GNUNET_CRYPTO_hash (×tamp.abs_value_us, | 529 | GNUNET_CRYPTO_hash (×tamp.abs_value_us, |
535 | sizeof (timestamp.abs_value_us), | 530 | sizeof (timestamp.abs_value_us), |
536 | ×tamp_hash); | 531 | ×tamp_hash); |
537 | GNUNET_CRYPTO_hash (id, | 532 | GNUNET_CRYPTO_hash (id, sizeof (struct GNUNET_PeerIdentity), &pid_hash); |
538 | sizeof (struct GNUNET_PeerIdentity), | 533 | return GNUNET_CRYPTO_hash_matching_bits (×tamp_hash, &pid_hash); |
539 | &pid_hash); | ||
540 | return GNUNET_CRYPTO_hash_matching_bits (×tamp_hash, | ||
541 | &pid_hash); | ||
542 | } | 534 | } |
543 | 535 | ||
544 | 536 | ||
@@ -563,20 +555,19 @@ get_transmit_delay (int round_offset) | |||
563 | case -1: | 555 | case -1: |
564 | /* previous round is randomized between 0 and 50 ms */ | 556 | /* previous round is randomized between 0 and 50 ms */ |
565 | #if USE_RANDOM_DELAYS | 557 | #if USE_RANDOM_DELAYS |
566 | ret.rel_value_us = GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK, | 558 | ret.rel_value_us = |
567 | 50); | 559 | GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK, 50); |
568 | #else | 560 | #else |
569 | ret = GNUNET_TIME_UNIT_ZERO; | 561 | ret = GNUNET_TIME_UNIT_ZERO; |
570 | #endif | 562 | #endif |
571 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 563 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
572 | "Transmitting previous round behind schedule in %s\n", | 564 | "Transmitting previous round behind schedule in %s\n", |
573 | GNUNET_STRINGS_relative_time_to_string (ret, | 565 | GNUNET_STRINGS_relative_time_to_string (ret, GNUNET_YES)); |
574 | GNUNET_YES)); | ||
575 | return ret; | 566 | return ret; |
576 | case 0: | 567 | case 0: |
577 | /* current round is based on best-known matching_bits */ | 568 | /* current round is based on best-known matching_bits */ |
578 | matching_bits = | 569 | matching_bits = |
579 | ntohl (size_estimate_messages[estimate_index].matching_bits); | 570 | ntohl (size_estimate_messages[estimate_index].matching_bits); |
580 | dist_delay = get_matching_bits_delay (matching_bits); | 571 | dist_delay = get_matching_bits_delay (matching_bits); |
581 | dist_delay += get_delay_randomization (matching_bits).rel_value_us; | 572 | dist_delay += get_delay_randomization (matching_bits).rel_value_us; |
582 | ret.rel_value_us = (uint64_t) dist_delay; | 573 | ret.rel_value_us = (uint64_t) dist_delay; |
@@ -584,11 +575,9 @@ get_transmit_delay (int round_offset) | |||
584 | "For round %s, delay for %u matching bits is %s\n", | 575 | "For round %s, delay for %u matching bits is %s\n", |
585 | GNUNET_STRINGS_absolute_time_to_string (current_timestamp), | 576 | GNUNET_STRINGS_absolute_time_to_string (current_timestamp), |
586 | (unsigned int) matching_bits, | 577 | (unsigned int) matching_bits, |
587 | GNUNET_STRINGS_relative_time_to_string (ret, | 578 | GNUNET_STRINGS_relative_time_to_string (ret, GNUNET_YES)); |
588 | GNUNET_YES)); | ||
589 | /* now consider round start time and add delay to it */ | 579 | /* now consider round start time and add delay to it */ |
590 | tgt = GNUNET_TIME_absolute_add (current_timestamp, | 580 | tgt = GNUNET_TIME_absolute_add (current_timestamp, ret); |
591 | ret); | ||
592 | return GNUNET_TIME_absolute_get_remaining (tgt); | 581 | return GNUNET_TIME_absolute_get_remaining (tgt); |
593 | } | 582 | } |
594 | GNUNET_break (0); | 583 | GNUNET_break (0); |
@@ -614,10 +603,10 @@ transmit_task_cb (void *cls) | |||
614 | { | 603 | { |
615 | idx = (idx + HISTORY_SIZE - 1) % HISTORY_SIZE; | 604 | idx = (idx + HISTORY_SIZE - 1) % HISTORY_SIZE; |
616 | peer_entry->previous_round = GNUNET_YES; | 605 | peer_entry->previous_round = GNUNET_YES; |
617 | peer_entry->transmit_task | 606 | peer_entry->transmit_task = |
618 | = GNUNET_SCHEDULER_add_delayed (get_transmit_delay (0), | 607 | GNUNET_SCHEDULER_add_delayed (get_transmit_delay (0), |
619 | &transmit_task_cb, | 608 | &transmit_task_cb, |
620 | peer_entry); | 609 | peer_entry); |
621 | } | 610 | } |
622 | if ((0 == ntohl (size_estimate_messages[idx].hop_count)) && | 611 | if ((0 == ntohl (size_estimate_messages[idx].hop_count)) && |
623 | (NULL != proof_task)) | 612 | (NULL != proof_task)) |
@@ -625,7 +614,7 @@ transmit_task_cb (void *cls) | |||
625 | GNUNET_STATISTICS_update (stats, | 614 | GNUNET_STATISTICS_update (stats, |
626 | "# flood messages not generated (no proof yet)", | 615 | "# flood messages not generated (no proof yet)", |
627 | 1, | 616 | 1, |
628 | GNUNET_NO); | 617 | GNUNET_NO); |
629 | return; | 618 | return; |
630 | } | 619 | } |
631 | if (0 == ntohs (size_estimate_messages[idx].header.size)) | 620 | if (0 == ntohs (size_estimate_messages[idx].header.size)) |
@@ -633,31 +622,29 @@ transmit_task_cb (void *cls) | |||
633 | GNUNET_STATISTICS_update (stats, | 622 | GNUNET_STATISTICS_update (stats, |
634 | "# flood messages not generated (lack of history)", | 623 | "# flood messages not generated (lack of history)", |
635 | 1, | 624 | 1, |
636 | GNUNET_NO); | 625 | GNUNET_NO); |
637 | return; | 626 | return; |
638 | } | 627 | } |
639 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 628 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
640 | "In round %s, sending to `%s' estimate with %u bits\n", | 629 | "In round %s, sending to `%s' estimate with %u bits\n", |
641 | GNUNET_STRINGS_absolute_time_to_string (GNUNET_TIME_absolute_ntoh (size_estimate_messages[idx].timestamp)), | 630 | GNUNET_STRINGS_absolute_time_to_string ( |
631 | GNUNET_TIME_absolute_ntoh ( | ||
632 | size_estimate_messages[idx].timestamp)), | ||
642 | GNUNET_i2s (peer_entry->id), | 633 | GNUNET_i2s (peer_entry->id), |
643 | (unsigned int) ntohl (size_estimate_messages[idx].matching_bits)); | 634 | (unsigned int) ntohl (size_estimate_messages[idx].matching_bits)); |
644 | if (0 == ntohl (size_estimate_messages[idx].hop_count)) | 635 | if (0 == ntohl (size_estimate_messages[idx].hop_count)) |
645 | GNUNET_STATISTICS_update (stats, | 636 | GNUNET_STATISTICS_update (stats, "# flood messages started", 1, GNUNET_NO); |
646 | "# flood messages started", | ||
647 | 1, | ||
648 | GNUNET_NO); | ||
649 | GNUNET_STATISTICS_update (stats, | 637 | GNUNET_STATISTICS_update (stats, |
650 | "# flood messages transmitted", | 638 | "# flood messages transmitted", |
651 | 1, | 639 | 1, |
652 | GNUNET_NO); | 640 | GNUNET_NO); |
653 | #if ENABLE_NSE_HISTOGRAM | 641 | #if ENABLE_NSE_HISTOGRAM |
654 | peer_entry->transmitted_messages++; | 642 | peer_entry->transmitted_messages++; |
655 | peer_entry->last_transmitted_size | 643 | peer_entry->last_transmitted_size = |
656 | = ntohl(size_estimate_messages[idx].matching_bits); | 644 | ntohl (size_estimate_messages[idx].matching_bits); |
657 | #endif | 645 | #endif |
658 | env = GNUNET_MQ_msg_copy (&size_estimate_messages[idx].header); | 646 | env = GNUNET_MQ_msg_copy (&size_estimate_messages[idx].header); |
659 | GNUNET_MQ_send (peer_entry->mq, | 647 | GNUNET_MQ_send (peer_entry->mq, env); |
660 | env); | ||
661 | } | 648 | } |
662 | 649 | ||
663 | 650 | ||
@@ -673,9 +660,7 @@ update_network_size_estimate () | |||
673 | struct GNUNET_NSE_ClientMessage em; | 660 | struct GNUNET_NSE_ClientMessage em; |
674 | 661 | ||
675 | setup_estimate_message (&em); | 662 | setup_estimate_message (&em); |
676 | GNUNET_notification_context_broadcast (nc, | 663 | GNUNET_notification_context_broadcast (nc, &em.header, GNUNET_YES); |
677 | &em.header, | ||
678 | GNUNET_YES); | ||
679 | } | 664 | } |
680 | 665 | ||
681 | 666 | ||
@@ -687,36 +672,31 @@ update_network_size_estimate () | |||
687 | * @param ts timestamp to use | 672 | * @param ts timestamp to use |
688 | */ | 673 | */ |
689 | static void | 674 | static void |
690 | setup_flood_message (unsigned int slot, | 675 | setup_flood_message (unsigned int slot, struct GNUNET_TIME_Absolute ts) |
691 | struct GNUNET_TIME_Absolute ts) | ||
692 | { | 676 | { |
693 | struct GNUNET_NSE_FloodMessage *fm; | 677 | struct GNUNET_NSE_FloodMessage *fm; |
694 | uint32_t matching_bits; | 678 | uint32_t matching_bits; |
695 | 679 | ||
696 | matching_bits = get_matching_bits (ts, | 680 | matching_bits = get_matching_bits (ts, &my_identity); |
697 | &my_identity); | ||
698 | fm = &size_estimate_messages[slot]; | 681 | fm = &size_estimate_messages[slot]; |
699 | fm->header.size = htons (sizeof (struct GNUNET_NSE_FloodMessage)); | 682 | fm->header.size = htons (sizeof (struct GNUNET_NSE_FloodMessage)); |
700 | fm->header.type = htons (GNUNET_MESSAGE_TYPE_NSE_P2P_FLOOD); | 683 | fm->header.type = htons (GNUNET_MESSAGE_TYPE_NSE_P2P_FLOOD); |
701 | fm->hop_count = htonl (0); | 684 | fm->hop_count = htonl (0); |
702 | fm->purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_NSE_SEND); | 685 | fm->purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_NSE_SEND); |
703 | fm->purpose.size = | 686 | fm->purpose.size = |
704 | htonl (sizeof (struct GNUNET_NSE_FloodMessage) - | 687 | htonl (sizeof (struct GNUNET_NSE_FloodMessage) - |
705 | sizeof (struct GNUNET_MessageHeader) - sizeof (uint32_t) - | 688 | sizeof (struct GNUNET_MessageHeader) - sizeof (uint32_t) - |
706 | sizeof (struct GNUNET_CRYPTO_EddsaSignature)); | 689 | sizeof (struct GNUNET_CRYPTO_EddsaSignature)); |
707 | fm->matching_bits = htonl (matching_bits); | 690 | fm->matching_bits = htonl (matching_bits); |
708 | fm->timestamp = GNUNET_TIME_absolute_hton (ts); | 691 | fm->timestamp = GNUNET_TIME_absolute_hton (ts); |
709 | fm->origin = my_identity; | 692 | fm->origin = my_identity; |
710 | fm->proof_of_work = my_proof; | 693 | fm->proof_of_work = my_proof; |
711 | if (nse_work_required > 0) | 694 | if (nse_work_required > 0) |
712 | GNUNET_assert (GNUNET_OK == | 695 | GNUNET_assert (GNUNET_OK == GNUNET_CRYPTO_eddsa_sign (my_private_key, |
713 | GNUNET_CRYPTO_eddsa_sign (my_private_key, | 696 | &fm->purpose, |
714 | &fm->purpose, | 697 | &fm->signature)); |
715 | &fm->signature)); | ||
716 | else | 698 | else |
717 | memset (&fm->signature, | 699 | memset (&fm->signature, 0, sizeof (fm->signature)); |
718 | 0, | ||
719 | sizeof (fm->signature)); | ||
720 | } | 700 | } |
721 | 701 | ||
722 | 702 | ||
@@ -731,8 +711,8 @@ setup_flood_message (unsigned int slot, | |||
731 | */ | 711 | */ |
732 | static int | 712 | static int |
733 | schedule_current_round (void *cls, | 713 | schedule_current_round (void *cls, |
734 | const struct GNUNET_PeerIdentity * key, | 714 | const struct GNUNET_PeerIdentity *key, |
735 | void *value) | 715 | void *value) |
736 | { | 716 | { |
737 | struct NSEPeerEntry *peer_entry = value; | 717 | struct NSEPeerEntry *peer_entry = value; |
738 | struct GNUNET_TIME_Relative delay; | 718 | struct GNUNET_TIME_Relative delay; |
@@ -744,20 +724,18 @@ schedule_current_round (void *cls, | |||
744 | } | 724 | } |
745 | #if ENABLE_NSE_HISTOGRAM | 725 | #if ENABLE_NSE_HISTOGRAM |
746 | if (peer_entry->received_messages > 1) | 726 | if (peer_entry->received_messages > 1) |
747 | GNUNET_STATISTICS_update(stats, | 727 | GNUNET_STATISTICS_update (stats, |
748 | "# extra messages", | 728 | "# extra messages", |
749 | peer_entry->received_messages - 1, | 729 | peer_entry->received_messages - 1, |
750 | GNUNET_NO); | 730 | GNUNET_NO); |
751 | peer_entry->transmitted_messages = 0; | 731 | peer_entry->transmitted_messages = 0; |
752 | peer_entry->last_transmitted_size = 0; | 732 | peer_entry->last_transmitted_size = 0; |
753 | peer_entry->received_messages = 0; | 733 | peer_entry->received_messages = 0; |
754 | #endif | 734 | #endif |
755 | delay = | 735 | delay = |
756 | get_transmit_delay ((GNUNET_NO == peer_entry->previous_round) ? -1 : 0); | 736 | get_transmit_delay ((GNUNET_NO == peer_entry->previous_round) ? -1 : 0); |
757 | peer_entry->transmit_task = | 737 | peer_entry->transmit_task = |
758 | GNUNET_SCHEDULER_add_delayed (delay, | 738 | GNUNET_SCHEDULER_add_delayed (delay, &transmit_task_cb, peer_entry); |
759 | &transmit_task_cb, | ||
760 | peer_entry); | ||
761 | return GNUNET_OK; | 739 | return GNUNET_OK; |
762 | } | 740 | } |
763 | 741 | ||
@@ -779,9 +757,7 @@ update_flood_message (void *cls) | |||
779 | { | 757 | { |
780 | /* somehow run early, delay more */ | 758 | /* somehow run early, delay more */ |
781 | flood_task = | 759 | flood_task = |
782 | GNUNET_SCHEDULER_add_delayed (offset, | 760 | GNUNET_SCHEDULER_add_delayed (offset, &update_flood_message, NULL); |
783 | &update_flood_message, | ||
784 | NULL); | ||
785 | return; | 761 | return; |
786 | } | 762 | } |
787 | estimate_index = (estimate_index + 1) % HISTORY_SIZE; | 763 | estimate_index = (estimate_index + 1) % HISTORY_SIZE; |
@@ -789,32 +765,27 @@ update_flood_message (void *cls) | |||
789 | estimate_count++; | 765 | estimate_count++; |
790 | current_timestamp = next_timestamp; | 766 | current_timestamp = next_timestamp; |
791 | next_timestamp = | 767 | next_timestamp = |
792 | GNUNET_TIME_absolute_add (current_timestamp, gnunet_nse_interval); | 768 | GNUNET_TIME_absolute_add (current_timestamp, gnunet_nse_interval); |
793 | if ( (current_timestamp.abs_value_us == | 769 | if ((current_timestamp.abs_value_us == |
794 | GNUNET_TIME_absolute_ntoh (next_message.timestamp).abs_value_us) && | 770 | GNUNET_TIME_absolute_ntoh (next_message.timestamp).abs_value_us) && |
795 | (get_matching_bits (current_timestamp, &my_identity) < | 771 | (get_matching_bits (current_timestamp, &my_identity) < |
796 | ntohl(next_message.matching_bits)) ) | 772 | ntohl (next_message.matching_bits))) |
797 | { | 773 | { |
798 | /* we received a message for this round way early, use it! */ | 774 | /* we received a message for this round way early, use it! */ |
799 | size_estimate_messages[estimate_index] = next_message; | 775 | size_estimate_messages[estimate_index] = next_message; |
800 | size_estimate_messages[estimate_index].hop_count = | 776 | size_estimate_messages[estimate_index].hop_count = |
801 | htonl (1 + ntohl (next_message.hop_count)); | 777 | htonl (1 + ntohl (next_message.hop_count)); |
802 | } | 778 | } |
803 | else | 779 | else |
804 | setup_flood_message (estimate_index, | 780 | setup_flood_message (estimate_index, current_timestamp); |
805 | current_timestamp); | 781 | next_message.matching_bits = htonl (0); /* reset for 'next' round */ |
806 | next_message.matching_bits = htonl (0); /* reset for 'next' round */ | ||
807 | hop_count_max = 0; | 782 | hop_count_max = 0; |
808 | for (i = 0; i < HISTORY_SIZE; i++) | 783 | for (i = 0; i < HISTORY_SIZE; i++) |
809 | hop_count_max = GNUNET_MAX (ntohl (size_estimate_messages[i].hop_count), | 784 | hop_count_max = |
810 | hop_count_max); | 785 | GNUNET_MAX (ntohl (size_estimate_messages[i].hop_count), hop_count_max); |
811 | GNUNET_CONTAINER_multipeermap_iterate (peers, | 786 | GNUNET_CONTAINER_multipeermap_iterate (peers, &schedule_current_round, NULL); |
812 | &schedule_current_round, | 787 | flood_task = |
813 | NULL); | 788 | GNUNET_SCHEDULER_add_at (next_timestamp, &update_flood_message, NULL); |
814 | flood_task | ||
815 | = GNUNET_SCHEDULER_add_at (next_timestamp, | ||
816 | &update_flood_message, | ||
817 | NULL); | ||
818 | } | 789 | } |
819 | 790 | ||
820 | 791 | ||
@@ -830,8 +801,7 @@ count_leading_zeroes (const struct GNUNET_HashCode *hash) | |||
830 | unsigned int hash_count; | 801 | unsigned int hash_count; |
831 | 802 | ||
832 | hash_count = 0; | 803 | hash_count = 0; |
833 | while (0 == GNUNET_CRYPTO_hash_get_bit (hash, | 804 | while (0 == GNUNET_CRYPTO_hash_get_bit (hash, hash_count)) |
834 | hash_count)) | ||
835 | hash_count++; | 805 | hash_count++; |
836 | return hash_count; | 806 | return hash_count; |
837 | } | 807 | } |
@@ -853,17 +823,13 @@ check_proof_of_work (const struct GNUNET_CRYPTO_EddsaPublicKey *pkey, | |||
853 | sizeof (val)] GNUNET_ALIGN; | 823 | sizeof (val)] GNUNET_ALIGN; |
854 | struct GNUNET_HashCode result; | 824 | struct GNUNET_HashCode result; |
855 | 825 | ||
856 | GNUNET_memcpy (buf, | 826 | GNUNET_memcpy (buf, &val, sizeof (val)); |
857 | &val, | ||
858 | sizeof (val)); | ||
859 | GNUNET_memcpy (&buf[sizeof (val)], | 827 | GNUNET_memcpy (&buf[sizeof (val)], |
860 | pkey, | 828 | pkey, |
861 | sizeof (struct GNUNET_CRYPTO_EddsaPublicKey)); | 829 | sizeof (struct GNUNET_CRYPTO_EddsaPublicKey)); |
862 | pow_hash (buf, | 830 | pow_hash (buf, sizeof (buf), &result); |
863 | sizeof (buf), | 831 | return (count_leading_zeroes (&result) >= nse_work_required) ? GNUNET_YES |
864 | &result); | 832 | : GNUNET_NO; |
865 | return (count_leading_zeroes (&result) >= | ||
866 | nse_work_required) ? GNUNET_YES : GNUNET_NO; | ||
867 | } | 833 | } |
868 | 834 | ||
869 | 835 | ||
@@ -876,20 +842,14 @@ write_proof () | |||
876 | char *proof; | 842 | char *proof; |
877 | 843 | ||
878 | if (GNUNET_OK != | 844 | if (GNUNET_OK != |
879 | GNUNET_CONFIGURATION_get_value_filename (cfg, | 845 | GNUNET_CONFIGURATION_get_value_filename (cfg, "NSE", "PROOFFILE", &proof)) |
880 | "NSE", | ||
881 | "PROOFFILE", | ||
882 | &proof)) | ||
883 | return; | 846 | return; |
884 | if (sizeof (my_proof) != | 847 | if (sizeof (my_proof) != GNUNET_DISK_fn_write (proof, |
885 | GNUNET_DISK_fn_write (proof, | 848 | &my_proof, |
886 | &my_proof, | 849 | sizeof (my_proof), |
887 | sizeof (my_proof), | 850 | GNUNET_DISK_PERM_USER_READ | |
888 | GNUNET_DISK_PERM_USER_READ | | 851 | GNUNET_DISK_PERM_USER_WRITE)) |
889 | GNUNET_DISK_PERM_USER_WRITE)) | 852 | GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "write", proof); |
890 | GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, | ||
891 | "write", | ||
892 | proof); | ||
893 | GNUNET_free (proof); | 853 | GNUNET_free (proof); |
894 | } | 854 | } |
895 | 855 | ||
@@ -910,8 +870,9 @@ find_proof (void *cls) | |||
910 | unsigned int i; | 870 | unsigned int i; |
911 | 871 | ||
912 | proof_task = NULL; | 872 | proof_task = NULL; |
913 | GNUNET_memcpy (&buf[sizeof (uint64_t)], &my_identity, | 873 | GNUNET_memcpy (&buf[sizeof (uint64_t)], |
914 | sizeof (struct GNUNET_PeerIdentity)); | 874 | &my_identity, |
875 | sizeof (struct GNUNET_PeerIdentity)); | ||
915 | i = 0; | 876 | i = 0; |
916 | counter = my_proof; | 877 | counter = my_proof; |
917 | while ((counter != UINT64_MAX) && (i < ROUND_SIZE)) | 878 | while ((counter != UINT64_MAX) && (i < ROUND_SIZE)) |
@@ -921,7 +882,8 @@ find_proof (void *cls) | |||
921 | if (nse_work_required <= count_leading_zeroes (&result)) | 882 | if (nse_work_required <= count_leading_zeroes (&result)) |
922 | { | 883 | { |
923 | my_proof = counter; | 884 | my_proof = counter; |
924 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Proof of work found: %llu!\n", | 885 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
886 | "Proof of work found: %llu!\n", | ||
925 | (unsigned long long) GNUNET_ntohll (counter)); | 887 | (unsigned long long) GNUNET_ntohll (counter)); |
926 | write_proof (); | 888 | write_proof (); |
927 | setup_flood_message (estimate_index, current_timestamp); | 889 | setup_flood_message (estimate_index, current_timestamp); |
@@ -944,9 +906,10 @@ find_proof (void *cls) | |||
944 | my_proof = counter; | 906 | my_proof = counter; |
945 | } | 907 | } |
946 | proof_task = | 908 | proof_task = |
947 | GNUNET_SCHEDULER_add_delayed_with_priority (proof_find_delay, | 909 | GNUNET_SCHEDULER_add_delayed_with_priority (proof_find_delay, |
948 | GNUNET_SCHEDULER_PRIORITY_IDLE, | 910 | GNUNET_SCHEDULER_PRIORITY_IDLE, |
949 | &find_proof, NULL); | 911 | &find_proof, |
912 | NULL); | ||
950 | } | 913 | } |
951 | 914 | ||
952 | 915 | ||
@@ -962,23 +925,22 @@ find_proof (void *cls) | |||
962 | static int | 925 | static int |
963 | verify_message_crypto (const struct GNUNET_NSE_FloodMessage *incoming_flood) | 926 | verify_message_crypto (const struct GNUNET_NSE_FloodMessage *incoming_flood) |
964 | { | 927 | { |
965 | if (GNUNET_YES != | 928 | if (GNUNET_YES != check_proof_of_work (&incoming_flood->origin.public_key, |
966 | check_proof_of_work (&incoming_flood->origin.public_key, | 929 | incoming_flood->proof_of_work)) |
967 | incoming_flood->proof_of_work)) | ||
968 | { | 930 | { |
969 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 931 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
970 | "Proof of work invalid: %llu!\n", | 932 | "Proof of work invalid: %llu!\n", |
971 | (unsigned long long) | 933 | (unsigned long long) GNUNET_ntohll ( |
972 | GNUNET_ntohll (incoming_flood->proof_of_work)); | 934 | incoming_flood->proof_of_work)); |
973 | GNUNET_break_op (0); | 935 | GNUNET_break_op (0); |
974 | return GNUNET_NO; | 936 | return GNUNET_NO; |
975 | } | 937 | } |
976 | if ((nse_work_required > 0) && | 938 | if ((nse_work_required > 0) && |
977 | (GNUNET_OK != | 939 | (GNUNET_OK != |
978 | GNUNET_CRYPTO_eddsa_verify (GNUNET_SIGNATURE_PURPOSE_NSE_SEND, | 940 | GNUNET_CRYPTO_eddsa_verify (GNUNET_SIGNATURE_PURPOSE_NSE_SEND, |
979 | &incoming_flood->purpose, | 941 | &incoming_flood->purpose, |
980 | &incoming_flood->signature, | 942 | &incoming_flood->signature, |
981 | &incoming_flood->origin.public_key))) | 943 | &incoming_flood->origin.public_key))) |
982 | { | 944 | { |
983 | GNUNET_break_op (0); | 945 | GNUNET_break_op (0); |
984 | return GNUNET_NO; | 946 | return GNUNET_NO; |
@@ -998,15 +960,15 @@ verify_message_crypto (const struct GNUNET_NSE_FloodMessage *incoming_flood) | |||
998 | */ | 960 | */ |
999 | static int | 961 | static int |
1000 | update_flood_times (void *cls, | 962 | update_flood_times (void *cls, |
1001 | const struct GNUNET_PeerIdentity *key, | 963 | const struct GNUNET_PeerIdentity *key, |
1002 | void *value) | 964 | void *value) |
1003 | { | 965 | { |
1004 | struct NSEPeerEntry *exclude = cls; | 966 | struct NSEPeerEntry *exclude = cls; |
1005 | struct NSEPeerEntry *peer_entry = value; | 967 | struct NSEPeerEntry *peer_entry = value; |
1006 | struct GNUNET_TIME_Relative delay; | 968 | struct GNUNET_TIME_Relative delay; |
1007 | 969 | ||
1008 | if (peer_entry == exclude) | 970 | if (peer_entry == exclude) |
1009 | return GNUNET_OK; /* trigger of the update */ | 971 | return GNUNET_OK; /* trigger of the update */ |
1010 | if (GNUNET_NO == peer_entry->previous_round) | 972 | if (GNUNET_NO == peer_entry->previous_round) |
1011 | { | 973 | { |
1012 | /* still stuck in previous round, no point to update, check that | 974 | /* still stuck in previous round, no point to update, check that |
@@ -1024,8 +986,7 @@ update_flood_times (void *cls, | |||
1024 | } | 986 | } |
1025 | delay = get_transmit_delay (0); | 987 | delay = get_transmit_delay (0); |
1026 | peer_entry->transmit_task = | 988 | peer_entry->transmit_task = |
1027 | GNUNET_SCHEDULER_add_delayed (delay, | 989 | GNUNET_SCHEDULER_add_delayed (delay, &transmit_task_cb, peer_entry); |
1028 | &transmit_task_cb, peer_entry); | ||
1029 | return GNUNET_OK; | 990 | return GNUNET_OK; |
1030 | } | 991 | } |
1031 | 992 | ||
@@ -1038,7 +999,7 @@ update_flood_times (void *cls, | |||
1038 | */ | 999 | */ |
1039 | static void | 1000 | static void |
1040 | handle_p2p_estimate (void *cls, | 1001 | handle_p2p_estimate (void *cls, |
1041 | const struct GNUNET_NSE_FloodMessage *incoming_flood) | 1002 | const struct GNUNET_NSE_FloodMessage *incoming_flood) |
1042 | { | 1003 | { |
1043 | struct NSEPeerEntry *peer_entry = cls; | 1004 | struct NSEPeerEntry *peer_entry = cls; |
1044 | struct GNUNET_TIME_Absolute ts; | 1005 | struct GNUNET_TIME_Absolute ts; |
@@ -1049,17 +1010,14 @@ handle_p2p_estimate (void *cls, | |||
1049 | { | 1010 | { |
1050 | uint64_t t; | 1011 | uint64_t t; |
1051 | 1012 | ||
1052 | t = GNUNET_TIME_absolute_get().abs_value_us; | 1013 | t = GNUNET_TIME_absolute_get ().abs_value_us; |
1053 | if (NULL != lh) | 1014 | if (NULL != lh) |
1054 | GNUNET_TESTBED_LOGGER_write (lh, &t, sizeof (uint64_t)); | 1015 | GNUNET_TESTBED_LOGGER_write (lh, &t, sizeof (uint64_t)); |
1055 | if (NULL != histogram) | 1016 | if (NULL != histogram) |
1056 | GNUNET_BIO_write_int64 (histogram, t); | 1017 | GNUNET_BIO_write_int64 (histogram, t); |
1057 | } | 1018 | } |
1058 | #endif | 1019 | #endif |
1059 | GNUNET_STATISTICS_update (stats, | 1020 | GNUNET_STATISTICS_update (stats, "# flood messages received", 1, GNUNET_NO); |
1060 | "# flood messages received", | ||
1061 | 1, | ||
1062 | GNUNET_NO); | ||
1063 | matching_bits = ntohl (incoming_flood->matching_bits); | 1021 | matching_bits = ntohl (incoming_flood->matching_bits); |
1064 | #if DEBUG_NSE | 1022 | #if DEBUG_NSE |
1065 | { | 1023 | { |
@@ -1068,19 +1026,17 @@ handle_p2p_estimate (void *cls, | |||
1068 | struct GNUNET_PeerIdentity os; | 1026 | struct GNUNET_PeerIdentity os; |
1069 | 1027 | ||
1070 | GNUNET_snprintf (origin, | 1028 | GNUNET_snprintf (origin, |
1071 | sizeof (origin), | 1029 | sizeof (origin), |
1072 | "%s", | 1030 | "%s", |
1073 | GNUNET_i2s (&incoming_flood->origin)); | 1031 | GNUNET_i2s (&incoming_flood->origin)); |
1074 | GNUNET_snprintf (pred, | 1032 | GNUNET_snprintf (pred, sizeof (pred), "%s", GNUNET_i2s (peer_entry->id)); |
1075 | sizeof (pred), | ||
1076 | "%s", | ||
1077 | GNUNET_i2s (peer_entry->id)); | ||
1078 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 1033 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1079 | "Flood at %s from `%s' via `%s' at `%s' with bits %u\n", | 1034 | "Flood at %s from `%s' via `%s' at `%s' with bits %u\n", |
1080 | GNUNET_STRINGS_absolute_time_to_string (GNUNET_TIME_absolute_ntoh (incoming_flood->timestamp)), | 1035 | GNUNET_STRINGS_absolute_time_to_string ( |
1036 | GNUNET_TIME_absolute_ntoh (incoming_flood->timestamp)), | ||
1081 | origin, | 1037 | origin, |
1082 | pred, | 1038 | pred, |
1083 | GNUNET_i2s (&my_identity), | 1039 | GNUNET_i2s (&my_identity), |
1084 | (unsigned int) matching_bits); | 1040 | (unsigned int) matching_bits); |
1085 | } | 1041 | } |
1086 | #endif | 1042 | #endif |
@@ -1089,10 +1045,7 @@ handle_p2p_estimate (void *cls, | |||
1089 | peer_entry->received_messages++; | 1045 | peer_entry->received_messages++; |
1090 | if (peer_entry->transmitted_messages > 0 && | 1046 | if (peer_entry->transmitted_messages > 0 && |
1091 | peer_entry->last_transmitted_size >= matching_bits) | 1047 | peer_entry->last_transmitted_size >= matching_bits) |
1092 | GNUNET_STATISTICS_update(stats, | 1048 | GNUNET_STATISTICS_update (stats, "# cross messages", 1, GNUNET_NO); |
1093 | "# cross messages", | ||
1094 | 1, | ||
1095 | GNUNET_NO); | ||
1096 | #endif | 1049 | #endif |
1097 | 1050 | ||
1098 | ts = GNUNET_TIME_absolute_ntoh (incoming_flood->timestamp); | 1051 | ts = GNUNET_TIME_absolute_ntoh (incoming_flood->timestamp); |
@@ -1104,9 +1057,8 @@ handle_p2p_estimate (void *cls, | |||
1104 | else if (ts.abs_value_us == next_timestamp.abs_value_us) | 1057 | else if (ts.abs_value_us == next_timestamp.abs_value_us) |
1105 | { | 1058 | { |
1106 | if (matching_bits <= ntohl (next_message.matching_bits)) | 1059 | if (matching_bits <= ntohl (next_message.matching_bits)) |
1107 | return; /* ignore, simply too early/late */ | 1060 | return; /* ignore, simply too early/late */ |
1108 | if (GNUNET_YES != | 1061 | if (GNUNET_YES != verify_message_crypto (incoming_flood)) |
1109 | verify_message_crypto (incoming_flood)) | ||
1110 | { | 1062 | { |
1111 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 1063 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
1112 | "Peer %s is likely ill-configured!\n", | 1064 | "Peer %s is likely ill-configured!\n", |
@@ -1121,21 +1073,18 @@ handle_p2p_estimate (void *cls, | |||
1121 | { | 1073 | { |
1122 | GNUNET_STATISTICS_update (stats, | 1074 | GNUNET_STATISTICS_update (stats, |
1123 | "# flood messages discarded (clock skew too large)", | 1075 | "# flood messages discarded (clock skew too large)", |
1124 | 1, GNUNET_NO); | 1076 | 1, |
1077 | GNUNET_NO); | ||
1125 | return; | 1078 | return; |
1126 | } | 1079 | } |
1127 | if (0 == (GNUNET_memcmp (peer_entry->id, | 1080 | if (0 == (GNUNET_memcmp (peer_entry->id, &my_identity))) |
1128 | &my_identity))) | ||
1129 | { | 1081 | { |
1130 | /* send to self, update our own estimate IF this also comes from us! */ | 1082 | /* send to self, update our own estimate IF this also comes from us! */ |
1131 | if (0 == | 1083 | if (0 == GNUNET_memcmp (&incoming_flood->origin, &my_identity)) |
1132 | GNUNET_memcmp (&incoming_flood->origin, | ||
1133 | &my_identity)) | ||
1134 | update_network_size_estimate (); | 1084 | update_network_size_estimate (); |
1135 | return; | 1085 | return; |
1136 | } | 1086 | } |
1137 | if (matching_bits == | 1087 | if (matching_bits == ntohl (size_estimate_messages[idx].matching_bits)) |
1138 | ntohl (size_estimate_messages[idx].matching_bits)) | ||
1139 | { | 1088 | { |
1140 | /* Cancel transmission in the other direction, as this peer clearly has | 1089 | /* Cancel transmission in the other direction, as this peer clearly has |
1141 | up-to-date information already. Even if we didn't talk to this peer in | 1090 | up-to-date information already. Even if we didn't talk to this peer in |
@@ -1159,26 +1108,23 @@ handle_p2p_estimate (void *cls, | |||
1159 | } | 1108 | } |
1160 | if (matching_bits < ntohl (size_estimate_messages[idx].matching_bits)) | 1109 | if (matching_bits < ntohl (size_estimate_messages[idx].matching_bits)) |
1161 | { | 1110 | { |
1162 | if ( (idx < estimate_index) && | 1111 | if ((idx < estimate_index) && (peer_entry->previous_round == GNUNET_YES)) |
1163 | (peer_entry->previous_round == GNUNET_YES)) | ||
1164 | { | 1112 | { |
1165 | peer_entry->previous_round = GNUNET_NO; | 1113 | peer_entry->previous_round = GNUNET_NO; |
1166 | } | 1114 | } |
1167 | /* push back our result now, that peer is spreading bad information... */ | 1115 | /* push back our result now, that peer is spreading bad information... */ |
1168 | if (NULL != peer_entry->transmit_task) | 1116 | if (NULL != peer_entry->transmit_task) |
1169 | GNUNET_SCHEDULER_cancel (peer_entry->transmit_task); | 1117 | GNUNET_SCHEDULER_cancel (peer_entry->transmit_task); |
1170 | peer_entry->transmit_task | 1118 | peer_entry->transmit_task = |
1171 | = GNUNET_SCHEDULER_add_now (&transmit_task_cb, | 1119 | GNUNET_SCHEDULER_add_now (&transmit_task_cb, peer_entry); |
1172 | peer_entry); | ||
1173 | /* Not closer than our most recent message, no need to do work here */ | 1120 | /* Not closer than our most recent message, no need to do work here */ |
1174 | GNUNET_STATISTICS_update (stats, | 1121 | GNUNET_STATISTICS_update (stats, |
1175 | "# flood messages ignored (had closer already)", | 1122 | "# flood messages ignored (had closer already)", |
1176 | 1, | 1123 | 1, |
1177 | GNUNET_NO); | 1124 | GNUNET_NO); |
1178 | return; | 1125 | return; |
1179 | } | 1126 | } |
1180 | if (GNUNET_YES != | 1127 | if (GNUNET_YES != verify_message_crypto (incoming_flood)) |
1181 | verify_message_crypto (incoming_flood)) | ||
1182 | { | 1128 | { |
1183 | GNUNET_break_op (0); | 1129 | GNUNET_break_op (0); |
1184 | return; | 1130 | return; |
@@ -1200,20 +1146,20 @@ handle_p2p_estimate (void *cls, | |||
1200 | } | 1146 | } |
1201 | size_estimate_messages[idx] = *incoming_flood; | 1147 | size_estimate_messages[idx] = *incoming_flood; |
1202 | size_estimate_messages[idx].hop_count = | 1148 | size_estimate_messages[idx].hop_count = |
1203 | htonl (ntohl (incoming_flood->hop_count) + 1); | 1149 | htonl (ntohl (incoming_flood->hop_count) + 1); |
1204 | hop_count_max = | 1150 | hop_count_max = |
1205 | GNUNET_MAX (ntohl (incoming_flood->hop_count) + 1, | 1151 | GNUNET_MAX (ntohl (incoming_flood->hop_count) + 1, hop_count_max); |
1206 | hop_count_max); | ||
1207 | GNUNET_STATISTICS_set (stats, | 1152 | GNUNET_STATISTICS_set (stats, |
1208 | "# estimated network diameter", | 1153 | "# estimated network diameter", |
1209 | hop_count_max, GNUNET_NO); | 1154 | hop_count_max, |
1155 | GNUNET_NO); | ||
1210 | 1156 | ||
1211 | /* have a new, better size estimate, inform clients */ | 1157 | /* have a new, better size estimate, inform clients */ |
1212 | update_network_size_estimate (); | 1158 | update_network_size_estimate (); |
1213 | 1159 | ||
1214 | /* flood to rest */ | 1160 | /* flood to rest */ |
1215 | GNUNET_CONTAINER_multipeermap_iterate (peers, | 1161 | GNUNET_CONTAINER_multipeermap_iterate (peers, |
1216 | &update_flood_times, | 1162 | &update_flood_times, |
1217 | peer_entry); | 1163 | peer_entry); |
1218 | } | 1164 | } |
1219 | 1165 | ||
@@ -1227,40 +1173,31 @@ handle_p2p_estimate (void *cls, | |||
1227 | */ | 1173 | */ |
1228 | static void * | 1174 | static void * |
1229 | handle_core_connect (void *cls, | 1175 | handle_core_connect (void *cls, |
1230 | const struct GNUNET_PeerIdentity *peer, | 1176 | const struct GNUNET_PeerIdentity *peer, |
1231 | struct GNUNET_MQ_Handle *mq) | 1177 | struct GNUNET_MQ_Handle *mq) |
1232 | { | 1178 | { |
1233 | struct NSEPeerEntry *peer_entry; | 1179 | struct NSEPeerEntry *peer_entry; |
1234 | uint64_t flags; | ||
1235 | const void *extra; | ||
1236 | 1180 | ||
1237 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 1181 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1238 | "Peer `%s' connected to us\n", | 1182 | "Peer `%s' connected to us\n", |
1239 | GNUNET_i2s (peer)); | 1183 | GNUNET_i2s (peer)); |
1240 | /* set our default transmission options */ | 1184 | /* set our default transmission options */ |
1241 | extra = GNUNET_CORE_get_mq_options (GNUNET_NO, | 1185 | GNUNET_MQ_set_options (mq, NSE_PRIORITY); |
1242 | NSE_PRIORITY, | ||
1243 | &flags); | ||
1244 | GNUNET_MQ_set_options (mq, | ||
1245 | flags, | ||
1246 | extra); | ||
1247 | /* create our peer entry for this peer */ | 1186 | /* create our peer entry for this peer */ |
1248 | peer_entry = GNUNET_new (struct NSEPeerEntry); | 1187 | peer_entry = GNUNET_new (struct NSEPeerEntry); |
1249 | peer_entry->id = peer; | 1188 | peer_entry->id = peer; |
1250 | peer_entry->mq = mq; | 1189 | peer_entry->mq = mq; |
1251 | GNUNET_assert (GNUNET_OK == | 1190 | GNUNET_assert (GNUNET_OK == |
1252 | GNUNET_CONTAINER_multipeermap_put (peers, | 1191 | GNUNET_CONTAINER_multipeermap_put ( |
1253 | peer_entry->id, | 1192 | peers, |
1254 | peer_entry, | 1193 | peer_entry->id, |
1255 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); | 1194 | peer_entry, |
1195 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); | ||
1256 | peer_entry->transmit_task = | 1196 | peer_entry->transmit_task = |
1257 | GNUNET_SCHEDULER_add_delayed (get_transmit_delay (-1), | 1197 | GNUNET_SCHEDULER_add_delayed (get_transmit_delay (-1), |
1258 | &transmit_task_cb, | 1198 | &transmit_task_cb, |
1259 | peer_entry); | 1199 | peer_entry); |
1260 | GNUNET_STATISTICS_update (stats, | 1200 | GNUNET_STATISTICS_update (stats, "# peers connected", 1, GNUNET_NO); |
1261 | "# peers connected", | ||
1262 | 1, | ||
1263 | GNUNET_NO); | ||
1264 | return peer_entry; | 1201 | return peer_entry; |
1265 | } | 1202 | } |
1266 | 1203 | ||
@@ -1275,28 +1212,23 @@ handle_core_connect (void *cls, | |||
1275 | */ | 1212 | */ |
1276 | static void | 1213 | static void |
1277 | handle_core_disconnect (void *cls, | 1214 | handle_core_disconnect (void *cls, |
1278 | const struct GNUNET_PeerIdentity *peer, | 1215 | const struct GNUNET_PeerIdentity *peer, |
1279 | void *internal_cls) | 1216 | void *internal_cls) |
1280 | { | 1217 | { |
1281 | struct NSEPeerEntry *pos = internal_cls; | 1218 | struct NSEPeerEntry *pos = internal_cls; |
1282 | 1219 | ||
1283 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 1220 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1284 | "Peer `%s' disconnected from us\n", | 1221 | "Peer `%s' disconnected from us\n", |
1285 | GNUNET_i2s (peer)); | 1222 | GNUNET_i2s (peer)); |
1286 | GNUNET_assert (GNUNET_YES == | 1223 | GNUNET_assert (GNUNET_YES == |
1287 | GNUNET_CONTAINER_multipeermap_remove (peers, | 1224 | GNUNET_CONTAINER_multipeermap_remove (peers, peer, pos)); |
1288 | peer, | ||
1289 | pos)); | ||
1290 | if (NULL != pos->transmit_task) | 1225 | if (NULL != pos->transmit_task) |
1291 | { | 1226 | { |
1292 | GNUNET_SCHEDULER_cancel (pos->transmit_task); | 1227 | GNUNET_SCHEDULER_cancel (pos->transmit_task); |
1293 | pos->transmit_task = NULL; | 1228 | pos->transmit_task = NULL; |
1294 | } | 1229 | } |
1295 | GNUNET_free (pos); | 1230 | GNUNET_free (pos); |
1296 | GNUNET_STATISTICS_update (stats, | 1231 | GNUNET_STATISTICS_update (stats, "# peers connected", -1, GNUNET_NO); |
1297 | "# peers connected", | ||
1298 | -1, | ||
1299 | GNUNET_NO); | ||
1300 | } | 1232 | } |
1301 | 1233 | ||
1302 | 1234 | ||
@@ -1309,8 +1241,7 @@ handle_core_disconnect (void *cls, | |||
1309 | * @param size the amount of data sent (ignored) | 1241 | * @param size the amount of data sent (ignored) |
1310 | */ | 1242 | */ |
1311 | static void | 1243 | static void |
1312 | flush_comp_cb (void *cls, | 1244 | flush_comp_cb (void *cls, size_t size) |
1313 | size_t size) | ||
1314 | { | 1245 | { |
1315 | GNUNET_TESTBED_LOGGER_disconnect (lh); | 1246 | GNUNET_TESTBED_LOGGER_disconnect (lh); |
1316 | lh = NULL; | 1247 | lh = NULL; |
@@ -1335,7 +1266,7 @@ shutdown_task (void *cls) | |||
1335 | { | 1266 | { |
1336 | GNUNET_SCHEDULER_cancel (proof_task); | 1267 | GNUNET_SCHEDULER_cancel (proof_task); |
1337 | proof_task = NULL; | 1268 | proof_task = NULL; |
1338 | write_proof (); /* remember progress */ | 1269 | write_proof (); /* remember progress */ |
1339 | } | 1270 | } |
1340 | if (NULL != nc) | 1271 | if (NULL != nc) |
1341 | { | 1272 | { |
@@ -1370,9 +1301,7 @@ shutdown_task (void *cls) | |||
1370 | } | 1301 | } |
1371 | if (NULL != lh) | 1302 | if (NULL != lh) |
1372 | { | 1303 | { |
1373 | GNUNET_TESTBED_LOGGER_flush (lh, | 1304 | GNUNET_TESTBED_LOGGER_flush (lh, &flush_comp_cb, NULL); |
1374 | &flush_comp_cb, | ||
1375 | NULL); | ||
1376 | } | 1305 | } |
1377 | if (NULL != histogram) | 1306 | if (NULL != histogram) |
1378 | { | 1307 | { |
@@ -1390,48 +1319,37 @@ shutdown_task (void *cls) | |||
1390 | * @param identity the public identity of this peer | 1319 | * @param identity the public identity of this peer |
1391 | */ | 1320 | */ |
1392 | static void | 1321 | static void |
1393 | core_init (void *cls, | 1322 | core_init (void *cls, const struct GNUNET_PeerIdentity *identity) |
1394 | const struct GNUNET_PeerIdentity *identity) | ||
1395 | { | 1323 | { |
1396 | struct GNUNET_TIME_Absolute now; | 1324 | struct GNUNET_TIME_Absolute now; |
1397 | struct GNUNET_TIME_Absolute prev_time; | 1325 | struct GNUNET_TIME_Absolute prev_time; |
1398 | 1326 | ||
1399 | if (NULL == identity) | 1327 | if (NULL == identity) |
1400 | { | 1328 | { |
1401 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 1329 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Connection to core FAILED!\n"); |
1402 | "Connection to core FAILED!\n"); | ||
1403 | GNUNET_SCHEDULER_shutdown (); | 1330 | GNUNET_SCHEDULER_shutdown (); |
1404 | return; | 1331 | return; |
1405 | } | 1332 | } |
1406 | GNUNET_assert (0 == | 1333 | GNUNET_assert (0 == GNUNET_memcmp (&my_identity, identity)); |
1407 | GNUNET_memcmp (&my_identity, | ||
1408 | identity)); | ||
1409 | now = GNUNET_TIME_absolute_get (); | 1334 | now = GNUNET_TIME_absolute_get (); |
1410 | current_timestamp.abs_value_us = | 1335 | current_timestamp.abs_value_us = |
1411 | (now.abs_value_us / gnunet_nse_interval.rel_value_us) * | 1336 | (now.abs_value_us / gnunet_nse_interval.rel_value_us) * |
1412 | gnunet_nse_interval.rel_value_us; | 1337 | gnunet_nse_interval.rel_value_us; |
1413 | next_timestamp = | 1338 | next_timestamp = |
1414 | GNUNET_TIME_absolute_add (current_timestamp, | 1339 | GNUNET_TIME_absolute_add (current_timestamp, gnunet_nse_interval); |
1415 | gnunet_nse_interval); | ||
1416 | estimate_index = HISTORY_SIZE - 1; | 1340 | estimate_index = HISTORY_SIZE - 1; |
1417 | estimate_count = 0; | 1341 | estimate_count = 0; |
1418 | if (GNUNET_YES == | 1342 | if (GNUNET_YES == check_proof_of_work (&my_identity.public_key, my_proof)) |
1419 | check_proof_of_work (&my_identity.public_key, | ||
1420 | my_proof)) | ||
1421 | { | 1343 | { |
1422 | int idx = (estimate_index + HISTORY_SIZE - 1) % HISTORY_SIZE; | 1344 | int idx = (estimate_index + HISTORY_SIZE - 1) % HISTORY_SIZE; |
1423 | prev_time.abs_value_us = | 1345 | prev_time.abs_value_us = |
1424 | current_timestamp.abs_value_us - gnunet_nse_interval.rel_value_us; | 1346 | current_timestamp.abs_value_us - gnunet_nse_interval.rel_value_us; |
1425 | setup_flood_message (idx, | 1347 | setup_flood_message (idx, prev_time); |
1426 | prev_time); | 1348 | setup_flood_message (estimate_index, current_timestamp); |
1427 | setup_flood_message (estimate_index, | ||
1428 | current_timestamp); | ||
1429 | estimate_count++; | 1349 | estimate_count++; |
1430 | } | 1350 | } |
1431 | flood_task | 1351 | flood_task = |
1432 | = GNUNET_SCHEDULER_add_at (next_timestamp, | 1352 | GNUNET_SCHEDULER_add_at (next_timestamp, &update_flood_message, NULL); |
1433 | &update_flood_message, | ||
1434 | NULL); | ||
1435 | } | 1353 | } |
1436 | 1354 | ||
1437 | 1355 | ||
@@ -1445,14 +1363,12 @@ core_init (void *cls, | |||
1445 | * #GNUNET_SYSERR if the configuration is invalid | 1363 | * #GNUNET_SYSERR if the configuration is invalid |
1446 | */ | 1364 | */ |
1447 | static void | 1365 | static void |
1448 | status_cb (void *cls, | 1366 | status_cb (void *cls, int status) |
1449 | int status) | ||
1450 | { | 1367 | { |
1451 | logger_test = NULL; | 1368 | logger_test = NULL; |
1452 | if (GNUNET_YES != status) | 1369 | if (GNUNET_YES != status) |
1453 | { | 1370 | { |
1454 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | 1371 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Testbed logger not running\n"); |
1455 | "Testbed logger not running\n"); | ||
1456 | return; | 1372 | return; |
1457 | } | 1373 | } |
1458 | if (NULL == (lh = GNUNET_TESTBED_LOGGER_connect (cfg))) | 1374 | if (NULL == (lh = GNUNET_TESTBED_LOGGER_connect (cfg))) |
@@ -1477,59 +1393,49 @@ run (void *cls, | |||
1477 | const struct GNUNET_CONFIGURATION_Handle *c, | 1393 | const struct GNUNET_CONFIGURATION_Handle *c, |
1478 | struct GNUNET_SERVICE_Handle *service) | 1394 | struct GNUNET_SERVICE_Handle *service) |
1479 | { | 1395 | { |
1480 | struct GNUNET_MQ_MessageHandler core_handlers[] = { | 1396 | struct GNUNET_MQ_MessageHandler core_handlers[] = |
1481 | GNUNET_MQ_hd_fixed_size (p2p_estimate, | 1397 | {GNUNET_MQ_hd_fixed_size (p2p_estimate, |
1482 | GNUNET_MESSAGE_TYPE_NSE_P2P_FLOOD, | 1398 | GNUNET_MESSAGE_TYPE_NSE_P2P_FLOOD, |
1483 | struct GNUNET_NSE_FloodMessage, | 1399 | struct GNUNET_NSE_FloodMessage, |
1484 | NULL), | 1400 | NULL), |
1485 | GNUNET_MQ_handler_end () | 1401 | GNUNET_MQ_handler_end ()}; |
1486 | }; | ||
1487 | char *proof; | 1402 | char *proof; |
1488 | struct GNUNET_CRYPTO_EddsaPrivateKey *pk; | 1403 | struct GNUNET_CRYPTO_EddsaPrivateKey *pk; |
1489 | 1404 | ||
1490 | cfg = c; | 1405 | cfg = c; |
1491 | if (GNUNET_OK != | 1406 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_time (cfg, |
1492 | GNUNET_CONFIGURATION_get_value_time (cfg, | 1407 | "NSE", |
1493 | "NSE", | 1408 | "INTERVAL", |
1494 | "INTERVAL", | 1409 | &gnunet_nse_interval)) |
1495 | &gnunet_nse_interval)) | ||
1496 | { | 1410 | { |
1497 | GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, | 1411 | GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "NSE", "INTERVAL"); |
1498 | "NSE", | ||
1499 | "INTERVAL"); | ||
1500 | GNUNET_SCHEDULER_shutdown (); | 1412 | GNUNET_SCHEDULER_shutdown (); |
1501 | return; | 1413 | return; |
1502 | } | 1414 | } |
1503 | if (GNUNET_OK != | 1415 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_time (cfg, |
1504 | GNUNET_CONFIGURATION_get_value_time (cfg, | 1416 | "NSE", |
1505 | "NSE", | 1417 | "WORKDELAY", |
1506 | "WORKDELAY", | 1418 | &proof_find_delay)) |
1507 | &proof_find_delay)) | ||
1508 | { | 1419 | { |
1509 | GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, | 1420 | GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "NSE", "WORKDELAY"); |
1510 | "NSE", | ||
1511 | "WORKDELAY"); | ||
1512 | GNUNET_SCHEDULER_shutdown (); | 1421 | GNUNET_SCHEDULER_shutdown (); |
1513 | return; | 1422 | return; |
1514 | } | 1423 | } |
1515 | if (GNUNET_OK != | 1424 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (cfg, |
1516 | GNUNET_CONFIGURATION_get_value_number (cfg, | 1425 | "NSE", |
1517 | "NSE", | 1426 | "WORKBITS", |
1518 | "WORKBITS", | 1427 | &nse_work_required)) |
1519 | &nse_work_required)) | ||
1520 | { | 1428 | { |
1521 | GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, | 1429 | GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "NSE", "WORKBITS"); |
1522 | "NSE", | ||
1523 | "WORKBITS"); | ||
1524 | GNUNET_SCHEDULER_shutdown (); | 1430 | GNUNET_SCHEDULER_shutdown (); |
1525 | return; | 1431 | return; |
1526 | } | 1432 | } |
1527 | if (nse_work_required >= sizeof (struct GNUNET_HashCode) * 8) | 1433 | if (nse_work_required >= sizeof (struct GNUNET_HashCode) * 8) |
1528 | { | 1434 | { |
1529 | GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR, | 1435 | GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR, |
1530 | "NSE", | 1436 | "NSE", |
1531 | "WORKBITS", | 1437 | "WORKBITS", |
1532 | _("Value is too large.\n")); | 1438 | _ ("Value is too large.\n")); |
1533 | GNUNET_SCHEDULER_shutdown (); | 1439 | GNUNET_SCHEDULER_shutdown (); |
1534 | return; | 1440 | return; |
1535 | } | 1441 | } |
@@ -1539,49 +1445,38 @@ run (void *cls, | |||
1539 | char *histogram_dir; | 1445 | char *histogram_dir; |
1540 | char *histogram_fn; | 1446 | char *histogram_fn; |
1541 | 1447 | ||
1542 | if (GNUNET_OK == | 1448 | if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_filename (cfg, |
1543 | GNUNET_CONFIGURATION_get_value_filename (cfg, | 1449 | "NSE", |
1544 | "NSE", | 1450 | "HISTOGRAM_DIR", |
1545 | "HISTOGRAM_DIR", | 1451 | &histogram_dir)) |
1546 | &histogram_dir)) | ||
1547 | { | 1452 | { |
1548 | GNUNET_assert (0 < GNUNET_asprintf (&histogram_fn, | 1453 | GNUNET_assert ( |
1549 | "%s/timestamps", | 1454 | 0 < GNUNET_asprintf (&histogram_fn, "%s/timestamps", histogram_dir)); |
1550 | histogram_dir)); | ||
1551 | GNUNET_free (histogram_dir); | 1455 | GNUNET_free (histogram_dir); |
1552 | histogram = GNUNET_BIO_write_open (histogram_fn); | 1456 | histogram = GNUNET_BIO_write_open (histogram_fn); |
1553 | if (NULL == histogram) | 1457 | if (NULL == histogram) |
1554 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | 1458 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
1555 | "Unable to open histogram file `%s'\n", | 1459 | "Unable to open histogram file `%s'\n", |
1556 | histogram_fn); | 1460 | histogram_fn); |
1557 | GNUNET_free (histogram_fn); | 1461 | GNUNET_free (histogram_fn); |
1558 | } | 1462 | } |
1559 | logger_test = | 1463 | logger_test = GNUNET_CLIENT_service_test ("testbed-logger", |
1560 | GNUNET_CLIENT_service_test ("testbed-logger", | 1464 | cfg, |
1561 | cfg, | 1465 | GNUNET_TIME_UNIT_SECONDS, |
1562 | GNUNET_TIME_UNIT_SECONDS, | 1466 | &status_cb, |
1563 | &status_cb, | 1467 | NULL); |
1564 | NULL); | ||
1565 | |||
1566 | } | 1468 | } |
1567 | #endif | 1469 | #endif |
1568 | 1470 | ||
1569 | GNUNET_SCHEDULER_add_shutdown (&shutdown_task, | 1471 | GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL); |
1570 | NULL); | ||
1571 | pk = GNUNET_CRYPTO_eddsa_key_create_from_configuration (cfg); | 1472 | pk = GNUNET_CRYPTO_eddsa_key_create_from_configuration (cfg); |
1572 | GNUNET_assert (NULL != pk); | 1473 | GNUNET_assert (NULL != pk); |
1573 | my_private_key = pk; | 1474 | my_private_key = pk; |
1574 | GNUNET_CRYPTO_eddsa_key_get_public (my_private_key, | 1475 | GNUNET_CRYPTO_eddsa_key_get_public (my_private_key, &my_identity.public_key); |
1575 | &my_identity.public_key); | ||
1576 | if (GNUNET_OK != | 1476 | if (GNUNET_OK != |
1577 | GNUNET_CONFIGURATION_get_value_filename (cfg, | 1477 | GNUNET_CONFIGURATION_get_value_filename (cfg, "NSE", "PROOFFILE", &proof)) |
1578 | "NSE", | ||
1579 | "PROOFFILE", | ||
1580 | &proof)) | ||
1581 | { | 1478 | { |
1582 | GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, | 1479 | GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "NSE", "PROOFFILE"); |
1583 | "NSE", | ||
1584 | "PROOFFILE"); | ||
1585 | GNUNET_free (my_private_key); | 1480 | GNUNET_free (my_private_key); |
1586 | my_private_key = NULL; | 1481 | my_private_key = NULL; |
1587 | GNUNET_SCHEDULER_shutdown (); | 1482 | GNUNET_SCHEDULER_shutdown (); |
@@ -1589,33 +1484,30 @@ run (void *cls, | |||
1589 | } | 1484 | } |
1590 | if ((GNUNET_YES != GNUNET_DISK_file_test (proof)) || | 1485 | if ((GNUNET_YES != GNUNET_DISK_file_test (proof)) || |
1591 | (sizeof (my_proof) != | 1486 | (sizeof (my_proof) != |
1592 | GNUNET_DISK_fn_read (proof, | 1487 | GNUNET_DISK_fn_read (proof, &my_proof, sizeof (my_proof)))) |
1593 | &my_proof, | ||
1594 | sizeof (my_proof)))) | ||
1595 | my_proof = 0; | 1488 | my_proof = 0; |
1596 | GNUNET_free (proof); | 1489 | GNUNET_free (proof); |
1597 | proof_task = | 1490 | proof_task = |
1598 | GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_IDLE, | 1491 | GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_IDLE, |
1599 | &find_proof, | 1492 | &find_proof, |
1600 | NULL); | 1493 | NULL); |
1601 | 1494 | ||
1602 | peers = GNUNET_CONTAINER_multipeermap_create (128, | 1495 | peers = GNUNET_CONTAINER_multipeermap_create (128, GNUNET_YES); |
1603 | GNUNET_YES); | ||
1604 | nc = GNUNET_notification_context_create (1); | 1496 | nc = GNUNET_notification_context_create (1); |
1605 | /* Connect to core service and register core handlers */ | 1497 | /* Connect to core service and register core handlers */ |
1606 | core_api = GNUNET_CORE_connect (cfg, /* Main configuration */ | 1498 | core_api = |
1607 | NULL, /* Closure passed to functions */ | 1499 | GNUNET_CORE_connect (cfg, /* Main configuration */ |
1608 | &core_init, /* Call core_init once connected */ | 1500 | NULL, /* Closure passed to functions */ |
1609 | &handle_core_connect, /* Handle connects */ | 1501 | &core_init, /* Call core_init once connected */ |
1610 | &handle_core_disconnect, /* Handle disconnects */ | 1502 | &handle_core_connect, /* Handle connects */ |
1611 | core_handlers); /* Register these handlers */ | 1503 | &handle_core_disconnect, /* Handle disconnects */ |
1504 | core_handlers); /* Register these handlers */ | ||
1612 | if (NULL == core_api) | 1505 | if (NULL == core_api) |
1613 | { | 1506 | { |
1614 | GNUNET_SCHEDULER_shutdown (); | 1507 | GNUNET_SCHEDULER_shutdown (); |
1615 | return; | 1508 | return; |
1616 | } | 1509 | } |
1617 | stats = GNUNET_STATISTICS_create ("nse", | 1510 | stats = GNUNET_STATISTICS_create ("nse", cfg); |
1618 | cfg); | ||
1619 | } | 1511 | } |
1620 | 1512 | ||
1621 | 1513 | ||
@@ -1629,8 +1521,8 @@ run (void *cls, | |||
1629 | */ | 1521 | */ |
1630 | static void * | 1522 | static void * |
1631 | client_connect_cb (void *cls, | 1523 | client_connect_cb (void *cls, |
1632 | struct GNUNET_SERVICE_Client *c, | 1524 | struct GNUNET_SERVICE_Client *c, |
1633 | struct GNUNET_MQ_Handle *mq) | 1525 | struct GNUNET_MQ_Handle *mq) |
1634 | { | 1526 | { |
1635 | return c; | 1527 | return c; |
1636 | } | 1528 | } |
@@ -1645,8 +1537,8 @@ client_connect_cb (void *cls, | |||
1645 | */ | 1537 | */ |
1646 | static void | 1538 | static void |
1647 | client_disconnect_cb (void *cls, | 1539 | client_disconnect_cb (void *cls, |
1648 | struct GNUNET_SERVICE_Client *c, | 1540 | struct GNUNET_SERVICE_Client *c, |
1649 | void *internal_cls) | 1541 | void *internal_cls) |
1650 | { | 1542 | { |
1651 | GNUNET_assert (c == internal_cls); | 1543 | GNUNET_assert (c == internal_cls); |
1652 | } | 1544 | } |
@@ -1655,18 +1547,17 @@ client_disconnect_cb (void *cls, | |||
1655 | /** | 1547 | /** |
1656 | * Define "main" method using service macro. | 1548 | * Define "main" method using service macro. |
1657 | */ | 1549 | */ |
1658 | GNUNET_SERVICE_MAIN | 1550 | GNUNET_SERVICE_MAIN ("nse", |
1659 | ("nse", | 1551 | GNUNET_SERVICE_OPTION_NONE, |
1660 | GNUNET_SERVICE_OPTION_NONE, | 1552 | &run, |
1661 | &run, | 1553 | &client_connect_cb, |
1662 | &client_connect_cb, | 1554 | &client_disconnect_cb, |
1663 | &client_disconnect_cb, | 1555 | NULL, |
1664 | NULL, | 1556 | GNUNET_MQ_hd_fixed_size (start, |
1665 | GNUNET_MQ_hd_fixed_size (start, | 1557 | GNUNET_MESSAGE_TYPE_NSE_START, |
1666 | GNUNET_MESSAGE_TYPE_NSE_START, | 1558 | struct GNUNET_MessageHeader, |
1667 | struct GNUNET_MessageHeader, | 1559 | NULL), |
1668 | NULL), | 1560 | GNUNET_MQ_handler_end ()); |
1669 | GNUNET_MQ_handler_end ()); | ||
1670 | 1561 | ||
1671 | 1562 | ||
1672 | #if defined(LINUX) && defined(__GLIBC__) | 1563 | #if defined(LINUX) && defined(__GLIBC__) |
@@ -1675,8 +1566,7 @@ GNUNET_SERVICE_MAIN | |||
1675 | /** | 1566 | /** |
1676 | * MINIMIZE heap size (way below 128k) since this process doesn't need much. | 1567 | * MINIMIZE heap size (way below 128k) since this process doesn't need much. |
1677 | */ | 1568 | */ |
1678 | void __attribute__ ((constructor)) | 1569 | void __attribute__ ((constructor)) GNUNET_ARM_memory_init () |
1679 | GNUNET_ARM_memory_init () | ||
1680 | { | 1570 | { |
1681 | mallopt (M_TRIM_THRESHOLD, 4 * 1024); | 1571 | mallopt (M_TRIM_THRESHOLD, 4 * 1024); |
1682 | mallopt (M_TOP_PAD, 1 * 1024); | 1572 | mallopt (M_TOP_PAD, 1 * 1024); |
@@ -1685,5 +1575,4 @@ GNUNET_ARM_memory_init () | |||
1685 | #endif | 1575 | #endif |
1686 | 1576 | ||
1687 | 1577 | ||
1688 | |||
1689 | /* end of gnunet-service-nse.c */ | 1578 | /* end of gnunet-service-nse.c */ |
diff --git a/src/topology/gnunet-daemon-topology.c b/src/topology/gnunet-daemon-topology.c index e5734abb4..5a22ee0d2 100644 --- a/src/topology/gnunet-daemon-topology.c +++ b/src/topology/gnunet-daemon-topology.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 | ||
@@ -51,12 +51,14 @@ | |||
51 | /** | 51 | /** |
52 | * At what frequency do we sent HELLOs to a peer? | 52 | * At what frequency do we sent HELLOs to a peer? |
53 | */ | 53 | */ |
54 | #define HELLO_ADVERTISEMENT_MIN_FREQUENCY GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5) | 54 | #define HELLO_ADVERTISEMENT_MIN_FREQUENCY \ |
55 | GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5) | ||
55 | 56 | ||
56 | /** | 57 | /** |
57 | * After what time period do we expire the HELLO Bloom filter? | 58 | * After what time period do we expire the HELLO Bloom filter? |
58 | */ | 59 | */ |
59 | #define HELLO_ADVERTISEMENT_MIN_REPEAT_FREQUENCY GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, 4) | 60 | #define HELLO_ADVERTISEMENT_MIN_REPEAT_FREQUENCY \ |
61 | GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, 4) | ||
60 | 62 | ||
61 | 63 | ||
62 | /** | 64 | /** |
@@ -116,7 +118,6 @@ struct Peer | |||
116 | * Is this peer listed here because it is a friend? | 118 | * Is this peer listed here because it is a friend? |
117 | */ | 119 | */ |
118 | int is_friend; | 120 | int is_friend; |
119 | |||
120 | }; | 121 | }; |
121 | 122 | ||
122 | 123 | ||
@@ -216,15 +217,12 @@ static unsigned int friend_count; | |||
216 | * @return #GNUNET_OK if the connection is allowed | 217 | * @return #GNUNET_OK if the connection is allowed |
217 | */ | 218 | */ |
218 | static int | 219 | static int |
219 | blacklist_check (void *cls, | 220 | blacklist_check (void *cls, const struct GNUNET_PeerIdentity *pid) |
220 | const struct GNUNET_PeerIdentity *pid) | ||
221 | { | 221 | { |
222 | struct Peer *pos; | 222 | struct Peer *pos; |
223 | 223 | ||
224 | pos = GNUNET_CONTAINER_multipeermap_get (peers, | 224 | pos = GNUNET_CONTAINER_multipeermap_get (peers, pid); |
225 | pid); | 225 | if ((NULL != pos) && (GNUNET_YES == pos->is_friend)) |
226 | if ( (NULL != pos) && | ||
227 | (GNUNET_YES == pos->is_friend)) | ||
228 | return GNUNET_OK; | 226 | return GNUNET_OK; |
229 | GNUNET_STATISTICS_update (stats, | 227 | GNUNET_STATISTICS_update (stats, |
230 | gettext_noop ("# peers blacklisted"), | 228 | gettext_noop ("# peers blacklisted"), |
@@ -258,17 +256,13 @@ whitelist_peers () | |||
258 | * @return #GNUNET_YES (always: continue to iterate) | 256 | * @return #GNUNET_YES (always: continue to iterate) |
259 | */ | 257 | */ |
260 | static int | 258 | static int |
261 | free_peer (void *cls, | 259 | free_peer (void *cls, const struct GNUNET_PeerIdentity *pid, void *value) |
262 | const struct GNUNET_PeerIdentity * pid, | ||
263 | void *value) | ||
264 | { | 260 | { |
265 | struct Peer *pos = value; | 261 | struct Peer *pos = value; |
266 | 262 | ||
267 | GNUNET_break (NULL == pos->mq); | 263 | GNUNET_break (NULL == pos->mq); |
268 | GNUNET_break (GNUNET_OK == | 264 | GNUNET_break (GNUNET_OK == |
269 | GNUNET_CONTAINER_multipeermap_remove (peers, | 265 | GNUNET_CONTAINER_multipeermap_remove (peers, pid, pos)); |
270 | pid, | ||
271 | pos)); | ||
272 | if (NULL != pos->hello_delay_task) | 266 | if (NULL != pos->hello_delay_task) |
273 | { | 267 | { |
274 | GNUNET_SCHEDULER_cancel (pos->hello_delay_task); | 268 | GNUNET_SCHEDULER_cancel (pos->hello_delay_task); |
@@ -305,16 +299,13 @@ attempt_connect (struct Peer *pos) | |||
305 | { | 299 | { |
306 | uint32_t strength; | 300 | uint32_t strength; |
307 | 301 | ||
308 | if (0 == | 302 | if (0 == GNUNET_memcmp (&my_identity, &pos->pid)) |
309 | GNUNET_memcmp (&my_identity, | ||
310 | &pos->pid)) | ||
311 | return; /* This is myself, nothing to do. */ | 303 | return; /* This is myself, nothing to do. */ |
312 | if (connection_count < target_connection_count) | 304 | if (connection_count < target_connection_count) |
313 | strength = 1; | 305 | strength = 1; |
314 | else | 306 | else |
315 | strength = 0; | 307 | strength = 0; |
316 | if ( (friend_count < minimum_friend_count) || | 308 | if ((friend_count < minimum_friend_count) || (GNUNET_YES == friends_only)) |
317 | (GNUNET_YES == friends_only) ) | ||
318 | { | 309 | { |
319 | if (pos->is_friend) | 310 | if (pos->is_friend) |
320 | strength += 10; /* urgently needed */ | 311 | strength += 10; /* urgently needed */ |
@@ -343,9 +334,7 @@ attempt_connect (struct Peer *pos) | |||
343 | gettext_noop ("# connect requests issued to ATS"), | 334 | gettext_noop ("# connect requests issued to ATS"), |
344 | 1, | 335 | 1, |
345 | GNUNET_NO); | 336 | GNUNET_NO); |
346 | pos->sh = GNUNET_ATS_connectivity_suggest (ats, | 337 | pos->sh = GNUNET_ATS_connectivity_suggest (ats, &pos->pid, strength); |
347 | &pos->pid, | ||
348 | strength); | ||
349 | } | 338 | } |
350 | } | 339 | } |
351 | 340 | ||
@@ -371,15 +360,14 @@ make_peer (const struct GNUNET_PeerIdentity *peer, | |||
371 | if (NULL != hello) | 360 | if (NULL != hello) |
372 | { | 361 | { |
373 | ret->hello = GNUNET_malloc (GNUNET_HELLO_size (hello)); | 362 | ret->hello = GNUNET_malloc (GNUNET_HELLO_size (hello)); |
374 | GNUNET_memcpy (ret->hello, | 363 | GNUNET_memcpy (ret->hello, hello, GNUNET_HELLO_size (hello)); |
375 | hello, | ||
376 | GNUNET_HELLO_size (hello)); | ||
377 | } | 364 | } |
378 | GNUNET_break (GNUNET_OK == | 365 | GNUNET_break (GNUNET_OK == |
379 | GNUNET_CONTAINER_multipeermap_put (peers, | 366 | GNUNET_CONTAINER_multipeermap_put ( |
380 | peer, | 367 | peers, |
381 | ret, | 368 | peer, |
382 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); | 369 | ret, |
370 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); | ||
383 | return ret; | 371 | return ret; |
384 | } | 372 | } |
385 | 373 | ||
@@ -403,12 +391,9 @@ setup_filter (struct Peer *peer) | |||
403 | * any case; hence 64, 5 as bloomfilter parameters. */ | 391 | * any case; hence 64, 5 as bloomfilter parameters. */ |
404 | peer->filter = GNUNET_CONTAINER_bloomfilter_init (NULL, 64, 5); | 392 | peer->filter = GNUNET_CONTAINER_bloomfilter_init (NULL, 64, 5); |
405 | peer->filter_expiration = | 393 | peer->filter_expiration = |
406 | GNUNET_TIME_relative_to_absolute | 394 | GNUNET_TIME_relative_to_absolute (HELLO_ADVERTISEMENT_MIN_REPEAT_FREQUENCY); |
407 | (HELLO_ADVERTISEMENT_MIN_REPEAT_FREQUENCY); | ||
408 | /* never send a peer its own HELLO */ | 395 | /* never send a peer its own HELLO */ |
409 | GNUNET_CRYPTO_hash (&peer->pid, | 396 | GNUNET_CRYPTO_hash (&peer->pid, sizeof (struct GNUNET_PeerIdentity), &hc); |
410 | sizeof (struct GNUNET_PeerIdentity), | ||
411 | &hc); | ||
412 | GNUNET_CONTAINER_bloomfilter_add (peer->filter, &hc); | 397 | GNUNET_CONTAINER_bloomfilter_add (peer->filter, &hc); |
413 | } | 398 | } |
414 | 399 | ||
@@ -473,10 +458,9 @@ find_advertisable_hello (void *cls, | |||
473 | if (hs > fah->max_size) | 458 | if (hs > fah->max_size) |
474 | return GNUNET_YES; | 459 | return GNUNET_YES; |
475 | GNUNET_CRYPTO_hash (&fah->peer->pid, | 460 | GNUNET_CRYPTO_hash (&fah->peer->pid, |
476 | sizeof (struct GNUNET_PeerIdentity), &hc); | 461 | sizeof (struct GNUNET_PeerIdentity), |
477 | if (GNUNET_NO == | 462 | &hc); |
478 | GNUNET_CONTAINER_bloomfilter_test (pos->filter, | 463 | if (GNUNET_NO == GNUNET_CONTAINER_bloomfilter_test (pos->filter, &hc)) |
479 | &hc)) | ||
480 | fah->result = pos; | 464 | fah->result = pos; |
481 | return GNUNET_YES; | 465 | return GNUNET_YES; |
482 | } | 466 | } |
@@ -505,13 +489,9 @@ schedule_next_hello (void *cls) | |||
505 | fah.result = NULL; | 489 | fah.result = NULL; |
506 | fah.max_size = GNUNET_MAX_MESSAGE_SIZE - 1; | 490 | fah.max_size = GNUNET_MAX_MESSAGE_SIZE - 1; |
507 | fah.next_adv = GNUNET_TIME_UNIT_FOREVER_REL; | 491 | fah.next_adv = GNUNET_TIME_UNIT_FOREVER_REL; |
508 | GNUNET_CONTAINER_multipeermap_iterate (peers, | 492 | GNUNET_CONTAINER_multipeermap_iterate (peers, &find_advertisable_hello, &fah); |
509 | &find_advertisable_hello, | ||
510 | &fah); | ||
511 | pl->hello_delay_task = | 493 | pl->hello_delay_task = |
512 | GNUNET_SCHEDULER_add_delayed (fah.next_adv, | 494 | GNUNET_SCHEDULER_add_delayed (fah.next_adv, &schedule_next_hello, pl); |
513 | &schedule_next_hello, | ||
514 | pl); | ||
515 | if (NULL == fah.result) | 495 | if (NULL == fah.result) |
516 | return; | 496 | return; |
517 | delay = GNUNET_TIME_absolute_get_remaining (pl->next_hello_allowed); | 497 | delay = GNUNET_TIME_absolute_get_remaining (pl->next_hello_allowed); |
@@ -520,31 +500,25 @@ schedule_next_hello (void *cls) | |||
520 | 500 | ||
521 | want = GNUNET_HELLO_size (fah.result->hello); | 501 | want = GNUNET_HELLO_size (fah.result->hello); |
522 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 502 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
523 | "Sending HELLO with %u bytes", | 503 | "Sending HELLO with %u bytes", |
524 | (unsigned int) want); | 504 | (unsigned int) want); |
525 | env = GNUNET_MQ_msg_copy (&fah.result->hello->header); | 505 | env = GNUNET_MQ_msg_copy (&fah.result->hello->header); |
526 | GNUNET_MQ_send (pl->mq, | 506 | GNUNET_MQ_send (pl->mq, env); |
527 | env); | ||
528 | 507 | ||
529 | /* avoid sending this one again soon */ | 508 | /* avoid sending this one again soon */ |
530 | GNUNET_CRYPTO_hash (&pl->pid, | 509 | GNUNET_CRYPTO_hash (&pl->pid, sizeof (struct GNUNET_PeerIdentity), &hc); |
531 | sizeof (struct GNUNET_PeerIdentity), | 510 | GNUNET_CONTAINER_bloomfilter_add (fah.result->filter, &hc); |
532 | &hc); | ||
533 | GNUNET_CONTAINER_bloomfilter_add (fah.result->filter, | ||
534 | &hc); | ||
535 | 511 | ||
536 | GNUNET_STATISTICS_update (stats, | 512 | GNUNET_STATISTICS_update (stats, |
537 | gettext_noop ("# HELLO messages gossipped"), | 513 | gettext_noop ("# HELLO messages gossipped"), |
538 | 1, | 514 | 1, |
539 | GNUNET_NO); | 515 | GNUNET_NO); |
540 | /* prepare to send the next one */ | 516 | /* prepare to send the next one */ |
541 | pl->next_hello_allowed | 517 | pl->next_hello_allowed = |
542 | = GNUNET_TIME_relative_to_absolute (HELLO_ADVERTISEMENT_MIN_FREQUENCY); | 518 | GNUNET_TIME_relative_to_absolute (HELLO_ADVERTISEMENT_MIN_FREQUENCY); |
543 | if (NULL != pl->hello_delay_task) | 519 | if (NULL != pl->hello_delay_task) |
544 | GNUNET_SCHEDULER_cancel (pl->hello_delay_task); | 520 | GNUNET_SCHEDULER_cancel (pl->hello_delay_task); |
545 | pl->hello_delay_task | 521 | pl->hello_delay_task = GNUNET_SCHEDULER_add_now (&schedule_next_hello, pl); |
546 | = GNUNET_SCHEDULER_add_now (&schedule_next_hello, | ||
547 | pl); | ||
548 | } | 522 | } |
549 | 523 | ||
550 | 524 | ||
@@ -576,7 +550,7 @@ reschedule_hellos (void *cls, | |||
576 | peer->hello_delay_task = NULL; | 550 | peer->hello_delay_task = NULL; |
577 | } | 551 | } |
578 | peer->hello_delay_task = | 552 | peer->hello_delay_task = |
579 | GNUNET_SCHEDULER_add_now (&schedule_next_hello, peer); | 553 | GNUNET_SCHEDULER_add_now (&schedule_next_hello, peer); |
580 | return GNUNET_YES; | 554 | return GNUNET_YES; |
581 | } | 555 | } |
582 | 556 | ||
@@ -592,36 +566,25 @@ reschedule_hellos (void *cls, | |||
592 | static void * | 566 | static void * |
593 | connect_notify (void *cls, | 567 | connect_notify (void *cls, |
594 | const struct GNUNET_PeerIdentity *peer, | 568 | const struct GNUNET_PeerIdentity *peer, |
595 | struct GNUNET_MQ_Handle *mq) | 569 | struct GNUNET_MQ_Handle *mq) |
596 | { | 570 | { |
597 | struct Peer *pos; | 571 | struct Peer *pos; |
598 | uint64_t flags; | ||
599 | const void *extra; | ||
600 | 572 | ||
601 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 573 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
602 | "Core told us that we are connecting to `%s'\n", | 574 | "Core told us that we are connecting to `%s'\n", |
603 | GNUNET_i2s (peer)); | 575 | GNUNET_i2s (peer)); |
604 | if (0 == GNUNET_memcmp (&my_identity, | 576 | if (0 == GNUNET_memcmp (&my_identity, peer)) |
605 | peer)) | ||
606 | return NULL; | 577 | return NULL; |
607 | extra = GNUNET_CORE_get_mq_options (GNUNET_YES, | 578 | GNUNET_MQ_set_options (mq, GNUNET_MQ_PRIO_BEST_EFFORT); |
608 | GNUNET_CORE_PRIO_BEST_EFFORT, | ||
609 | &flags); | ||
610 | GNUNET_MQ_set_options (mq, | ||
611 | flags, | ||
612 | extra); | ||
613 | connection_count++; | 579 | connection_count++; |
614 | GNUNET_STATISTICS_set (stats, | 580 | GNUNET_STATISTICS_set (stats, |
615 | gettext_noop ("# peers connected"), | 581 | gettext_noop ("# peers connected"), |
616 | connection_count, | 582 | connection_count, |
617 | GNUNET_NO); | 583 | GNUNET_NO); |
618 | pos = GNUNET_CONTAINER_multipeermap_get (peers, | 584 | pos = GNUNET_CONTAINER_multipeermap_get (peers, peer); |
619 | peer); | ||
620 | if (NULL == pos) | 585 | if (NULL == pos) |
621 | { | 586 | { |
622 | pos = make_peer (peer, | 587 | pos = make_peer (peer, NULL, GNUNET_NO); |
623 | NULL, | ||
624 | GNUNET_NO); | ||
625 | } | 588 | } |
626 | else | 589 | else |
627 | { | 590 | { |
@@ -631,17 +594,14 @@ connect_notify (void *cls, | |||
631 | if (pos->is_friend) | 594 | if (pos->is_friend) |
632 | { | 595 | { |
633 | friend_count++; | 596 | friend_count++; |
634 | if ( (friend_count == minimum_friend_count) && | 597 | if ((friend_count == minimum_friend_count) && (GNUNET_YES != friends_only)) |
635 | (GNUNET_YES != friends_only) ) | ||
636 | whitelist_peers (); | 598 | whitelist_peers (); |
637 | GNUNET_STATISTICS_set (stats, | 599 | GNUNET_STATISTICS_set (stats, |
638 | gettext_noop ("# friends connected"), | 600 | gettext_noop ("# friends connected"), |
639 | friend_count, | 601 | friend_count, |
640 | GNUNET_NO); | 602 | GNUNET_NO); |
641 | } | 603 | } |
642 | reschedule_hellos (NULL, | 604 | reschedule_hellos (NULL, peer, pos); |
643 | peer, | ||
644 | pos); | ||
645 | return pos; | 605 | return pos; |
646 | } | 606 | } |
647 | 607 | ||
@@ -655,9 +615,7 @@ connect_notify (void *cls, | |||
655 | * @return #GNUNET_YES (continue to iterate) | 615 | * @return #GNUNET_YES (continue to iterate) |
656 | */ | 616 | */ |
657 | static int | 617 | static int |
658 | try_add_peers (void *cls, | 618 | try_add_peers (void *cls, const struct GNUNET_PeerIdentity *pid, void *value) |
659 | const struct GNUNET_PeerIdentity *pid, | ||
660 | void *value) | ||
661 | { | 619 | { |
662 | struct Peer *pos = value; | 620 | struct Peer *pos = value; |
663 | 621 | ||
@@ -676,9 +634,7 @@ add_peer_task (void *cls) | |||
676 | { | 634 | { |
677 | add_task = NULL; | 635 | add_task = NULL; |
678 | 636 | ||
679 | GNUNET_CONTAINER_multipeermap_iterate (peers, | 637 | GNUNET_CONTAINER_multipeermap_iterate (peers, &try_add_peers, NULL); |
680 | &try_add_peers, | ||
681 | NULL); | ||
682 | } | 638 | } |
683 | 639 | ||
684 | 640 | ||
@@ -692,7 +648,7 @@ add_peer_task (void *cls) | |||
692 | static void | 648 | static void |
693 | disconnect_notify (void *cls, | 649 | disconnect_notify (void *cls, |
694 | const struct GNUNET_PeerIdentity *peer, | 650 | const struct GNUNET_PeerIdentity *peer, |
695 | void *internal_cls) | 651 | void *internal_cls) |
696 | { | 652 | { |
697 | struct Peer *pos = internal_cls; | 653 | struct Peer *pos = internal_cls; |
698 | 654 | ||
@@ -725,16 +681,12 @@ disconnect_notify (void *cls, | |||
725 | friend_count, | 681 | friend_count, |
726 | GNUNET_NO); | 682 | GNUNET_NO); |
727 | } | 683 | } |
728 | if ( ( (connection_count < target_connection_count) || | 684 | if (((connection_count < target_connection_count) || |
729 | (friend_count < minimum_friend_count)) && | 685 | (friend_count < minimum_friend_count)) && |
730 | (NULL == add_task) ) | 686 | (NULL == add_task)) |
731 | add_task = GNUNET_SCHEDULER_add_now (&add_peer_task, | 687 | add_task = GNUNET_SCHEDULER_add_now (&add_peer_task, NULL); |
732 | NULL); | 688 | if ((friend_count < minimum_friend_count) && (NULL == blacklist)) |
733 | if ( (friend_count < minimum_friend_count) && | 689 | blacklist = GNUNET_TRANSPORT_blacklist (cfg, &blacklist_check, NULL); |
734 | (NULL == blacklist)) | ||
735 | blacklist = GNUNET_TRANSPORT_blacklist (cfg, | ||
736 | &blacklist_check, | ||
737 | NULL); | ||
738 | } | 690 | } |
739 | 691 | ||
740 | 692 | ||
@@ -779,38 +731,32 @@ consider_for_advertising (const struct GNUNET_HELLO_Message *hello) | |||
779 | GNUNET_break (0); | 731 | GNUNET_break (0); |
780 | return; | 732 | return; |
781 | } | 733 | } |
782 | if (0 == GNUNET_memcmp (&pid, | 734 | if (0 == GNUNET_memcmp (&pid, &my_identity)) |
783 | &my_identity)) | 735 | return; /* that's me! */ |
784 | return; /* that's me! */ | ||
785 | have_address = GNUNET_NO; | 736 | have_address = GNUNET_NO; |
786 | GNUNET_HELLO_iterate_addresses (hello, | 737 | GNUNET_HELLO_iterate_addresses (hello, |
787 | GNUNET_NO, | 738 | GNUNET_NO, |
788 | &address_iterator, | 739 | &address_iterator, |
789 | &have_address); | 740 | &have_address); |
790 | if (GNUNET_NO == have_address) | 741 | if (GNUNET_NO == have_address) |
791 | return; /* no point in advertising this one... */ | 742 | return; /* no point in advertising this one... */ |
792 | peer = GNUNET_CONTAINER_multipeermap_get (peers, &pid); | 743 | peer = GNUNET_CONTAINER_multipeermap_get (peers, &pid); |
793 | if (NULL == peer) | 744 | if (NULL == peer) |
794 | { | 745 | { |
795 | peer = make_peer (&pid, | 746 | peer = make_peer (&pid, hello, GNUNET_NO); |
796 | hello, | ||
797 | GNUNET_NO); | ||
798 | } | 747 | } |
799 | else if (NULL != peer->hello) | 748 | else if (NULL != peer->hello) |
800 | { | 749 | { |
801 | dt = GNUNET_HELLO_equals (peer->hello, | 750 | dt = GNUNET_HELLO_equals (peer->hello, hello, GNUNET_TIME_absolute_get ()); |
802 | hello, | ||
803 | GNUNET_TIME_absolute_get ()); | ||
804 | if (dt.abs_value_us == GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us) | 751 | if (dt.abs_value_us == GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us) |
805 | return; /* nothing new here */ | 752 | return; /* nothing new here */ |
806 | } | 753 | } |
807 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 754 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
808 | "Found HELLO from peer `%s' for advertising\n", | 755 | "Found HELLO from peer `%s' for advertising\n", |
809 | GNUNET_i2s (&pid)); | 756 | GNUNET_i2s (&pid)); |
810 | if (NULL != peer->hello) | 757 | if (NULL != peer->hello) |
811 | { | 758 | { |
812 | nh = GNUNET_HELLO_merge (peer->hello, | 759 | nh = GNUNET_HELLO_merge (peer->hello, hello); |
813 | hello); | ||
814 | GNUNET_free (peer->hello); | 760 | GNUNET_free (peer->hello); |
815 | peer->hello = nh; | 761 | peer->hello = nh; |
816 | } | 762 | } |
@@ -818,9 +764,7 @@ consider_for_advertising (const struct GNUNET_HELLO_Message *hello) | |||
818 | { | 764 | { |
819 | size = GNUNET_HELLO_size (hello); | 765 | size = GNUNET_HELLO_size (hello); |
820 | peer->hello = GNUNET_malloc (size); | 766 | peer->hello = GNUNET_malloc (size); |
821 | GNUNET_memcpy (peer->hello, | 767 | GNUNET_memcpy (peer->hello, hello, size); |
822 | hello, | ||
823 | size); | ||
824 | } | 768 | } |
825 | if (NULL != peer->filter) | 769 | if (NULL != peer->filter) |
826 | { | 770 | { |
@@ -830,9 +774,7 @@ consider_for_advertising (const struct GNUNET_HELLO_Message *hello) | |||
830 | setup_filter (peer); | 774 | setup_filter (peer); |
831 | /* since we have a new HELLO to pick from, re-schedule all | 775 | /* since we have a new HELLO to pick from, re-schedule all |
832 | * HELLO requests that are not bound by the HELLO send rate! */ | 776 | * HELLO requests that are not bound by the HELLO send rate! */ |
833 | GNUNET_CONTAINER_multipeermap_iterate (peers, | 777 | GNUNET_CONTAINER_multipeermap_iterate (peers, &reschedule_hellos, peer); |
834 | &reschedule_hellos, | ||
835 | peer); | ||
836 | } | 778 | } |
837 | 779 | ||
838 | 780 | ||
@@ -856,24 +798,20 @@ process_peer (void *cls, | |||
856 | if (NULL != err_msg) | 798 | if (NULL != err_msg) |
857 | { | 799 | { |
858 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 800 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
859 | _("Error in communication with PEERINFO service: %s\n"), | 801 | _ ("Error in communication with PEERINFO service: %s\n"), |
860 | err_msg); | 802 | err_msg); |
861 | GNUNET_PEERINFO_notify_cancel (peerinfo_notify); | 803 | GNUNET_PEERINFO_notify_cancel (peerinfo_notify); |
862 | peerinfo_notify = GNUNET_PEERINFO_notify (cfg, | 804 | peerinfo_notify = |
863 | GNUNET_NO, | 805 | GNUNET_PEERINFO_notify (cfg, GNUNET_NO, &process_peer, NULL); |
864 | &process_peer, | ||
865 | NULL); | ||
866 | return; | 806 | return; |
867 | } | 807 | } |
868 | GNUNET_assert (NULL != peer); | 808 | GNUNET_assert (NULL != peer); |
869 | if (0 == GNUNET_memcmp (&my_identity, | 809 | if (0 == GNUNET_memcmp (&my_identity, peer)) |
870 | peer)) | 810 | return; /* that's me! */ |
871 | return; /* that's me! */ | ||
872 | if (NULL == hello) | 811 | if (NULL == hello) |
873 | { | 812 | { |
874 | /* free existing HELLO, if any */ | 813 | /* free existing HELLO, if any */ |
875 | pos = GNUNET_CONTAINER_multipeermap_get (peers, | 814 | pos = GNUNET_CONTAINER_multipeermap_get (peers, peer); |
876 | peer); | ||
877 | if (NULL != pos) | 815 | if (NULL != pos) |
878 | { | 816 | { |
879 | GNUNET_free_non_null (pos->hello); | 817 | GNUNET_free_non_null (pos->hello); |
@@ -883,21 +821,15 @@ process_peer (void *cls, | |||
883 | GNUNET_CONTAINER_bloomfilter_free (pos->filter); | 821 | GNUNET_CONTAINER_bloomfilter_free (pos->filter); |
884 | pos->filter = NULL; | 822 | pos->filter = NULL; |
885 | } | 823 | } |
886 | if ( (NULL == pos->mq) && | 824 | if ((NULL == pos->mq) && (GNUNET_NO == pos->is_friend)) |
887 | (GNUNET_NO == pos->is_friend) ) | 825 | free_peer (NULL, &pos->pid, pos); |
888 | free_peer (NULL, | ||
889 | &pos->pid, | ||
890 | pos); | ||
891 | } | 826 | } |
892 | return; | 827 | return; |
893 | } | 828 | } |
894 | consider_for_advertising (hello); | 829 | consider_for_advertising (hello); |
895 | pos = GNUNET_CONTAINER_multipeermap_get (peers, | 830 | pos = GNUNET_CONTAINER_multipeermap_get (peers, peer); |
896 | peer); | ||
897 | if (NULL == pos) | 831 | if (NULL == pos) |
898 | pos = make_peer (peer, | 832 | pos = make_peer (peer, hello, GNUNET_NO); |
899 | hello, | ||
900 | GNUNET_NO); | ||
901 | attempt_connect (pos); | 833 | attempt_connect (pos); |
902 | } | 834 | } |
903 | 835 | ||
@@ -910,24 +842,20 @@ process_peer (void *cls, | |||
910 | * @param my_id ID of this peer, NULL if we failed | 842 | * @param my_id ID of this peer, NULL if we failed |
911 | */ | 843 | */ |
912 | static void | 844 | static void |
913 | core_init (void *cls, | 845 | core_init (void *cls, const struct GNUNET_PeerIdentity *my_id) |
914 | const struct GNUNET_PeerIdentity *my_id) | ||
915 | { | 846 | { |
916 | if (NULL == my_id) | 847 | if (NULL == my_id) |
917 | { | 848 | { |
918 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 849 | GNUNET_log ( |
919 | _("Failed to connect to core service, can not manage topology!\n")); | 850 | GNUNET_ERROR_TYPE_ERROR, |
851 | _ ("Failed to connect to core service, can not manage topology!\n")); | ||
920 | GNUNET_SCHEDULER_shutdown (); | 852 | GNUNET_SCHEDULER_shutdown (); |
921 | return; | 853 | return; |
922 | } | 854 | } |
923 | my_identity = *my_id; | 855 | my_identity = *my_id; |
924 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 856 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "I am peer `%s'\n", GNUNET_i2s (my_id)); |
925 | "I am peer `%s'\n", | 857 | peerinfo_notify = |
926 | GNUNET_i2s (my_id)); | 858 | GNUNET_PEERINFO_notify (cfg, GNUNET_NO, &process_peer, NULL); |
927 | peerinfo_notify = GNUNET_PEERINFO_notify (cfg, | ||
928 | GNUNET_NO, | ||
929 | &process_peer, | ||
930 | NULL); | ||
931 | } | 859 | } |
932 | 860 | ||
933 | 861 | ||
@@ -938,24 +866,22 @@ core_init (void *cls, | |||
938 | * @param pid identity of the friend | 866 | * @param pid identity of the friend |
939 | */ | 867 | */ |
940 | static void | 868 | static void |
941 | handle_friend (void *cls, | 869 | handle_friend (void *cls, const struct GNUNET_PeerIdentity *pid) |
942 | const struct GNUNET_PeerIdentity *pid) | ||
943 | { | 870 | { |
944 | unsigned int *entries_found = cls; | 871 | unsigned int *entries_found = cls; |
945 | struct Peer *fl; | 872 | struct Peer *fl; |
946 | 873 | ||
947 | if (0 == GNUNET_memcmp (pid, | 874 | if (0 == GNUNET_memcmp (pid, &my_identity)) |
948 | &my_identity)) | ||
949 | { | 875 | { |
950 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | 876 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
951 | _("Found myself `%s' in friend list (useless, ignored)\n"), | 877 | _ ("Found myself `%s' in friend list (useless, ignored)\n"), |
952 | GNUNET_i2s (pid)); | 878 | GNUNET_i2s (pid)); |
953 | return; | 879 | return; |
954 | } | 880 | } |
955 | (*entries_found)++; | 881 | (*entries_found)++; |
956 | fl = make_peer (pid, NULL, GNUNET_YES); | 882 | fl = make_peer (pid, NULL, GNUNET_YES); |
957 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 883 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
958 | _("Found friend `%s' in configuration\n"), | 884 | _ ("Found friend `%s' in configuration\n"), |
959 | GNUNET_i2s (&fl->pid)); | 885 | GNUNET_i2s (&fl->pid)); |
960 | } | 886 | } |
961 | 887 | ||
@@ -969,31 +895,30 @@ read_friends_file (const struct GNUNET_CONFIGURATION_Handle *cfg) | |||
969 | unsigned int entries_found; | 895 | unsigned int entries_found; |
970 | 896 | ||
971 | entries_found = 0; | 897 | entries_found = 0; |
972 | if (GNUNET_OK != | 898 | if (GNUNET_OK != GNUNET_FRIENDS_parse (cfg, &handle_friend, &entries_found)) |
973 | GNUNET_FRIENDS_parse (cfg, | ||
974 | &handle_friend, | ||
975 | &entries_found)) | ||
976 | { | 899 | { |
977 | if ( (GNUNET_YES == friends_only) || | 900 | if ((GNUNET_YES == friends_only) || (minimum_friend_count > 0)) |
978 | (minimum_friend_count > 0)) | ||
979 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | 901 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
980 | _("Encountered errors parsing friends list!\n")); | 902 | _ ("Encountered errors parsing friends list!\n")); |
981 | } | 903 | } |
982 | GNUNET_STATISTICS_update (stats, | 904 | GNUNET_STATISTICS_update (stats, |
983 | gettext_noop ("# friends in configuration"), | 905 | gettext_noop ("# friends in configuration"), |
984 | entries_found, | 906 | entries_found, |
985 | GNUNET_NO); | 907 | GNUNET_NO); |
986 | if ( (minimum_friend_count > entries_found) && | 908 | if ((minimum_friend_count > entries_found) && (GNUNET_NO == friends_only)) |
987 | (GNUNET_NO == friends_only) ) | ||
988 | { | 909 | { |
989 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | 910 | GNUNET_log ( |
990 | _("Fewer friends specified than required by minimum friend count. Will only connect to friends.\n")); | 911 | GNUNET_ERROR_TYPE_WARNING, |
912 | _ ( | ||
913 | "Fewer friends specified than required by minimum friend count. Will only connect to friends.\n")); | ||
991 | } | 914 | } |
992 | if ( (minimum_friend_count > target_connection_count) && | 915 | if ((minimum_friend_count > target_connection_count) && |
993 | (GNUNET_NO == friends_only)) | 916 | (GNUNET_NO == friends_only)) |
994 | { | 917 | { |
995 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | 918 | GNUNET_log ( |
996 | _("More friendly connections required than target total number of connections.\n")); | 919 | GNUNET_ERROR_TYPE_WARNING, |
920 | _ ( | ||
921 | "More friendly connections required than target total number of connections.\n")); | ||
997 | } | 922 | } |
998 | } | 923 | } |
999 | 924 | ||
@@ -1008,14 +933,11 @@ read_friends_file (const struct GNUNET_CONFIGURATION_Handle *cfg) | |||
1008 | * #GNUNET_SYSERR if @a message is invalid | 933 | * #GNUNET_SYSERR if @a message is invalid |
1009 | */ | 934 | */ |
1010 | static int | 935 | static int |
1011 | check_hello (void *cls, | 936 | check_hello (void *cls, const struct GNUNET_HELLO_Message *message) |
1012 | const struct GNUNET_HELLO_Message *message) | ||
1013 | { | 937 | { |
1014 | struct GNUNET_PeerIdentity pid; | 938 | struct GNUNET_PeerIdentity pid; |
1015 | 939 | ||
1016 | if (GNUNET_OK != | 940 | if (GNUNET_OK != GNUNET_HELLO_get_id (message, &pid)) |
1017 | GNUNET_HELLO_get_id (message, | ||
1018 | &pid)) | ||
1019 | { | 941 | { |
1020 | GNUNET_break_op (0); | 942 | GNUNET_break_op (0); |
1021 | return GNUNET_SYSERR; | 943 | return GNUNET_SYSERR; |
@@ -1032,8 +954,7 @@ check_hello (void *cls, | |||
1032 | * @param message the actual HELLO message | 954 | * @param message the actual HELLO message |
1033 | */ | 955 | */ |
1034 | static void | 956 | static void |
1035 | handle_hello (void *cls, | 957 | handle_hello (void *cls, const struct GNUNET_HELLO_Message *message) |
1036 | const struct GNUNET_HELLO_Message *message) | ||
1037 | { | 958 | { |
1038 | const struct GNUNET_PeerIdentity *other = cls; | 959 | const struct GNUNET_PeerIdentity *other = cls; |
1039 | struct Peer *peer; | 960 | struct Peer *peer; |
@@ -1042,34 +963,26 @@ handle_hello (void *cls, | |||
1042 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 963 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1043 | "Received encrypted HELLO from peer `%s'", | 964 | "Received encrypted HELLO from peer `%s'", |
1044 | GNUNET_i2s (other)); | 965 | GNUNET_i2s (other)); |
1045 | GNUNET_assert (GNUNET_OK == | 966 | GNUNET_assert (GNUNET_OK == GNUNET_HELLO_get_id (message, &pid)); |
1046 | GNUNET_HELLO_get_id (message, | ||
1047 | &pid)); | ||
1048 | GNUNET_STATISTICS_update (stats, | 967 | GNUNET_STATISTICS_update (stats, |
1049 | gettext_noop ("# HELLO messages received"), | 968 | gettext_noop ("# HELLO messages received"), |
1050 | 1, | 969 | 1, |
1051 | GNUNET_NO); | 970 | GNUNET_NO); |
1052 | peer = GNUNET_CONTAINER_multipeermap_get (peers, | 971 | peer = GNUNET_CONTAINER_multipeermap_get (peers, &pid); |
1053 | &pid); | ||
1054 | if (NULL == peer) | 972 | if (NULL == peer) |
1055 | { | 973 | { |
1056 | if ( (GNUNET_YES == friends_only) || | 974 | if ((GNUNET_YES == friends_only) || (friend_count < minimum_friend_count)) |
1057 | (friend_count < minimum_friend_count) ) | ||
1058 | return; | 975 | return; |
1059 | } | 976 | } |
1060 | else | 977 | else |
1061 | { | 978 | { |
1062 | if ( (GNUNET_YES != peer->is_friend) && | 979 | if ((GNUNET_YES != peer->is_friend) && (GNUNET_YES == friends_only)) |
1063 | (GNUNET_YES == friends_only) ) | ||
1064 | return; | 980 | return; |
1065 | if ((GNUNET_YES != peer->is_friend) && | 981 | if ((GNUNET_YES != peer->is_friend) && |
1066 | (friend_count < minimum_friend_count)) | 982 | (friend_count < minimum_friend_count)) |
1067 | return; | 983 | return; |
1068 | } | 984 | } |
1069 | (void) GNUNET_PEERINFO_add_peer (pi, | 985 | (void) GNUNET_PEERINFO_add_peer (pi, message, NULL, NULL); |
1070 | message, | ||
1071 | NULL, | ||
1072 | NULL); | ||
1073 | } | 986 | } |
1074 | 987 | ||
1075 | 988 | ||
@@ -1103,9 +1016,7 @@ cleaning_task (void *cls) | |||
1103 | GNUNET_TRANSPORT_offer_hello_cancel (oh); | 1016 | GNUNET_TRANSPORT_offer_hello_cancel (oh); |
1104 | oh = NULL; | 1017 | oh = NULL; |
1105 | } | 1018 | } |
1106 | GNUNET_CONTAINER_multipeermap_iterate (peers, | 1019 | GNUNET_CONTAINER_multipeermap_iterate (peers, &free_peer, NULL); |
1107 | &free_peer, | ||
1108 | NULL); | ||
1109 | GNUNET_CONTAINER_multipeermap_destroy (peers); | 1020 | GNUNET_CONTAINER_multipeermap_destroy (peers); |
1110 | peers = NULL; | 1021 | peers = NULL; |
1111 | if (NULL != ats) | 1022 | if (NULL != ats) |
@@ -1140,26 +1051,22 @@ run (void *cls, | |||
1140 | const char *cfgfile, | 1051 | const char *cfgfile, |
1141 | const struct GNUNET_CONFIGURATION_Handle *c) | 1052 | const struct GNUNET_CONFIGURATION_Handle *c) |
1142 | { | 1053 | { |
1143 | struct GNUNET_MQ_MessageHandler handlers[] = { | 1054 | struct GNUNET_MQ_MessageHandler handlers[] = |
1144 | GNUNET_MQ_hd_var_size (hello, | 1055 | {GNUNET_MQ_hd_var_size (hello, |
1145 | GNUNET_MESSAGE_TYPE_HELLO, | 1056 | GNUNET_MESSAGE_TYPE_HELLO, |
1146 | struct GNUNET_HELLO_Message, | 1057 | struct GNUNET_HELLO_Message, |
1147 | NULL), | 1058 | NULL), |
1148 | GNUNET_MQ_handler_end () | 1059 | GNUNET_MQ_handler_end ()}; |
1149 | }; | ||
1150 | unsigned long long opt; | 1060 | unsigned long long opt; |
1151 | 1061 | ||
1152 | cfg = c; | 1062 | cfg = c; |
1153 | stats = GNUNET_STATISTICS_create ("topology", cfg); | 1063 | stats = GNUNET_STATISTICS_create ("topology", cfg); |
1154 | friends_only = | 1064 | friends_only = |
1155 | GNUNET_CONFIGURATION_get_value_yesno (cfg, | 1065 | GNUNET_CONFIGURATION_get_value_yesno (cfg, "TOPOLOGY", "FRIENDS-ONLY"); |
1156 | "TOPOLOGY", | 1066 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (cfg, |
1157 | "FRIENDS-ONLY"); | 1067 | "TOPOLOGY", |
1158 | if (GNUNET_OK != | 1068 | "MINIMUM-FRIENDS", |
1159 | GNUNET_CONFIGURATION_get_value_number (cfg, | 1069 | &opt)) |
1160 | "TOPOLOGY", | ||
1161 | "MINIMUM-FRIENDS", | ||
1162 | &opt)) | ||
1163 | opt = 0; | 1070 | opt = 0; |
1164 | minimum_friend_count = (unsigned int) opt; | 1071 | minimum_friend_count = (unsigned int) opt; |
1165 | if (GNUNET_OK != | 1072 | if (GNUNET_OK != |
@@ -1176,25 +1083,21 @@ run (void *cls, | |||
1176 | "Topology would like %u connections with at least %u friends\n", | 1083 | "Topology would like %u connections with at least %u friends\n", |
1177 | target_connection_count, | 1084 | target_connection_count, |
1178 | minimum_friend_count); | 1085 | minimum_friend_count); |
1179 | if ( (GNUNET_YES == friends_only) || | 1086 | if ((GNUNET_YES == friends_only) || (minimum_friend_count > 0)) |
1180 | (minimum_friend_count > 0)) | 1087 | blacklist = GNUNET_TRANSPORT_blacklist (cfg, &blacklist_check, NULL); |
1181 | blacklist = GNUNET_TRANSPORT_blacklist (cfg, | ||
1182 | &blacklist_check, | ||
1183 | NULL); | ||
1184 | ats = GNUNET_ATS_connectivity_init (cfg); | 1088 | ats = GNUNET_ATS_connectivity_init (cfg); |
1185 | pi = GNUNET_PEERINFO_connect (cfg); | 1089 | pi = GNUNET_PEERINFO_connect (cfg); |
1186 | handle = GNUNET_CORE_connect (cfg, | 1090 | handle = GNUNET_CORE_connect (cfg, |
1187 | NULL, | 1091 | NULL, |
1188 | &core_init, | 1092 | &core_init, |
1189 | &connect_notify, | 1093 | &connect_notify, |
1190 | &disconnect_notify, | 1094 | &disconnect_notify, |
1191 | handlers); | 1095 | handlers); |
1192 | GNUNET_SCHEDULER_add_shutdown (&cleaning_task, | 1096 | GNUNET_SCHEDULER_add_shutdown (&cleaning_task, NULL); |
1193 | NULL); | ||
1194 | if (NULL == handle) | 1097 | if (NULL == handle) |
1195 | { | 1098 | { |
1196 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 1099 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
1197 | _("Failed to connect to `%s' service.\n"), | 1100 | _ ("Failed to connect to `%s' service.\n"), |
1198 | "core"); | 1101 | "core"); |
1199 | GNUNET_SCHEDULER_shutdown (); | 1102 | GNUNET_SCHEDULER_shutdown (); |
1200 | return; | 1103 | return; |
@@ -1210,24 +1113,25 @@ run (void *cls, | |||
1210 | * @return 0 ok, 1 on error | 1113 | * @return 0 ok, 1 on error |
1211 | */ | 1114 | */ |
1212 | int | 1115 | int |
1213 | main (int argc, | 1116 | main (int argc, char *const *argv) |
1214 | char *const *argv) | ||
1215 | { | 1117 | { |
1216 | static const struct GNUNET_GETOPT_CommandLineOption options[] = { | 1118 | static const struct GNUNET_GETOPT_CommandLineOption options[] = { |
1217 | GNUNET_GETOPT_OPTION_END | 1119 | GNUNET_GETOPT_OPTION_END}; |
1218 | }; | ||
1219 | int ret; | 1120 | int ret; |
1220 | 1121 | ||
1221 | if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv)) | 1122 | if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv)) |
1222 | return 2; | 1123 | return 2; |
1223 | 1124 | ||
1224 | ret = | 1125 | ret = (GNUNET_OK == GNUNET_PROGRAM_run (argc, |
1225 | (GNUNET_OK == | 1126 | argv, |
1226 | GNUNET_PROGRAM_run (argc, argv, | 1127 | "gnunet-daemon-topology", |
1227 | "gnunet-daemon-topology", | 1128 | _ ("GNUnet topology control"), |
1228 | _("GNUnet topology control"), | 1129 | options, |
1229 | options, &run, NULL)) ? 0 : 1; | 1130 | &run, |
1230 | GNUNET_free ((void*) argv); | 1131 | NULL)) |
1132 | ? 0 | ||
1133 | : 1; | ||
1134 | GNUNET_free ((void *) argv); | ||
1231 | return ret; | 1135 | return ret; |
1232 | } | 1136 | } |
1233 | 1137 | ||
@@ -1238,8 +1142,7 @@ main (int argc, | |||
1238 | /** | 1142 | /** |
1239 | * MINIMIZE heap size (way below 128k) since this process doesn't need much. | 1143 | * MINIMIZE heap size (way below 128k) since this process doesn't need much. |
1240 | */ | 1144 | */ |
1241 | void __attribute__ ((constructor)) | 1145 | void __attribute__ ((constructor)) GNUNET_ARM_memory_init () |
1242 | GNUNET_ARM_memory_init () | ||
1243 | { | 1146 | { |
1244 | mallopt (M_TRIM_THRESHOLD, 4 * 1024); | 1147 | mallopt (M_TRIM_THRESHOLD, 4 * 1024); |
1245 | mallopt (M_TOP_PAD, 1 * 1024); | 1148 | mallopt (M_TOP_PAD, 1 * 1024); |
diff --git a/src/transport/gnunet-service-tng.c b/src/transport/gnunet-service-tng.c index 95ea102df..b217c8aa9 100644 --- a/src/transport/gnunet-service-tng.c +++ b/src/transport/gnunet-service-tng.c | |||
@@ -3743,10 +3743,13 @@ handle_client_send (void *cls, const struct OutboundMessage *obm) | |||
3743 | size_t payload_size; | 3743 | size_t payload_size; |
3744 | struct TransportDVBoxMessage *dvb; | 3744 | struct TransportDVBoxMessage *dvb; |
3745 | struct VirtualLink *vl; | 3745 | struct VirtualLink *vl; |
3746 | enum GNUNET_MQ_PriorityPreferences pp; | ||
3746 | 3747 | ||
3747 | GNUNET_assert (CT_CORE == tc->type); | 3748 | GNUNET_assert (CT_CORE == tc->type); |
3748 | obmm = (const struct GNUNET_MessageHeader *) &obm[1]; | 3749 | obmm = (const struct GNUNET_MessageHeader *) &obm[1]; |
3749 | bytes_msg = ntohs (obmm->size); | 3750 | bytes_msg = ntohs (obmm->size); |
3751 | pp = (enum GNUNET_MQ_PriorityPreferences) ntohl (obm->priority); | ||
3752 | /* FIXME: actually make use of pp */ (void) pp; | ||
3750 | vl = GNUNET_CONTAINER_multipeermap_get (links, &obm->peer); | 3753 | vl = GNUNET_CONTAINER_multipeermap_get (links, &obm->peer); |
3751 | if (NULL == vl) | 3754 | if (NULL == vl) |
3752 | { | 3755 | { |
diff --git a/src/transport/transport.h b/src/transport/transport.h index 4ba628112..7fe869fa8 100644 --- a/src/transport/transport.h +++ b/src/transport/transport.h | |||
@@ -302,9 +302,9 @@ struct OutboundMessage | |||
302 | struct GNUNET_MessageHeader header; | 302 | struct GNUNET_MessageHeader header; |
303 | 303 | ||
304 | /** | 304 | /** |
305 | * Always zero. | 305 | * An `enum GNUNET_MQ_PriorityPreferences` in NBO. |
306 | */ | 306 | */ |
307 | uint32_t reserved GNUNET_PACKED; | 307 | uint32_t priority GNUNET_PACKED; |
308 | 308 | ||
309 | #if ! (defined(GNUNET_TRANSPORT_COMMUNICATION_VERSION) || \ | 309 | #if ! (defined(GNUNET_TRANSPORT_COMMUNICATION_VERSION) || \ |
310 | defined(GNUNET_TRANSPORT_CORE_VERSION)) | 310 | defined(GNUNET_TRANSPORT_CORE_VERSION)) |
diff --git a/src/transport/transport_api2_core.c b/src/transport/transport_api2_core.c index a3c49e94f..20bbf2994 100644 --- a/src/transport/transport_api2_core.c +++ b/src/transport/transport_api2_core.c | |||
@@ -329,7 +329,12 @@ mq_send_impl (struct GNUNET_MQ_Handle *mq, | |||
329 | n->env = | 329 | n->env = |
330 | GNUNET_MQ_msg_nested_mh (obm, GNUNET_MESSAGE_TYPE_TRANSPORT_SEND, msg); | 330 | GNUNET_MQ_msg_nested_mh (obm, GNUNET_MESSAGE_TYPE_TRANSPORT_SEND, msg); |
331 | n->env_size = ntohs (msg->size); | 331 | n->env_size = ntohs (msg->size); |
332 | obm->reserved = htonl (0); | 332 | { |
333 | struct GNUNET_MQ_Envelope *env; | ||
334 | |||
335 | env = GNUNET_MQ_get_current_envelope (mq); | ||
336 | obm->priority = htonl ((uint32_t) GNUNET_MQ_env_get_options (env)); | ||
337 | } | ||
333 | obm->peer = n->id; | 338 | obm->peer = n->id; |
334 | if (0 == n->ready_window) | 339 | if (0 == n->ready_window) |
335 | { | 340 | { |
diff --git a/src/transport/transport_api_core.c b/src/transport/transport_api_core.c index a163d7ccf..54dc7f4c3 100644 --- a/src/transport/transport_api_core.c +++ b/src/transport/transport_api_core.c | |||
@@ -418,7 +418,12 @@ mq_send_impl (struct GNUNET_MQ_Handle *mq, | |||
418 | GNUNET_assert (NULL == n->env); | 418 | GNUNET_assert (NULL == n->env); |
419 | n->env = | 419 | n->env = |
420 | GNUNET_MQ_msg_nested_mh (obm, GNUNET_MESSAGE_TYPE_TRANSPORT_SEND, msg); | 420 | GNUNET_MQ_msg_nested_mh (obm, GNUNET_MESSAGE_TYPE_TRANSPORT_SEND, msg); |
421 | obm->reserved = htonl (0); | 421 | { |
422 | struct GNUNET_MQ_Envelope *env; | ||
423 | |||
424 | env = GNUNET_MQ_get_current_envelope (mq); | ||
425 | obm->priority = htonl ((uint32_t) GNUNET_MQ_env_get_options (env)); | ||
426 | } | ||
422 | obm->timeout = GNUNET_TIME_relative_hton ( | 427 | obm->timeout = GNUNET_TIME_relative_hton ( |
423 | GNUNET_TIME_UNIT_MINUTES); /* FIXME: to be removed */ | 428 | GNUNET_TIME_UNIT_MINUTES); /* FIXME: to be removed */ |
424 | obm->peer = n->id; | 429 | obm->peer = n->id; |
diff --git a/src/util/mq.c b/src/util/mq.c index 513c008ee..2f9e650b6 100644 --- a/src/util/mq.c +++ b/src/util/mq.c | |||
@@ -26,7 +26,7 @@ | |||
26 | #include "platform.h" | 26 | #include "platform.h" |
27 | #include "gnunet_util_lib.h" | 27 | #include "gnunet_util_lib.h" |
28 | 28 | ||
29 | #define LOG(kind,...) GNUNET_log_from (kind, "util-mq",__VA_ARGS__) | 29 | #define LOG(kind, ...) GNUNET_log_from (kind, "util-mq", __VA_ARGS__) |
30 | 30 | ||
31 | 31 | ||
32 | struct GNUNET_MQ_Envelope | 32 | struct GNUNET_MQ_Envelope |
@@ -70,14 +70,7 @@ struct GNUNET_MQ_Envelope | |||
70 | * #GNUNET_MQ_env_set_options(). Only valid if | 70 | * #GNUNET_MQ_env_set_options(). Only valid if |
71 | * @e have_custom_options is set. | 71 | * @e have_custom_options is set. |
72 | */ | 72 | */ |
73 | uint64_t flags; | 73 | enum GNUNET_MQ_PriorityPreferences priority; |
74 | |||
75 | /** | ||
76 | * Additional options buffer set for this envelope by | ||
77 | * #GNUNET_MQ_env_set_options(). Only valid if | ||
78 | * @e have_custom_options is set. | ||
79 | */ | ||
80 | const void *extra; | ||
81 | 74 | ||
82 | /** | 75 | /** |
83 | * Did the application call #GNUNET_MQ_env_set_options()? | 76 | * Did the application call #GNUNET_MQ_env_set_options()? |
@@ -165,16 +158,10 @@ struct GNUNET_MQ_Handle | |||
165 | struct GNUNET_MQ_DestroyNotificationHandle *dnh_tail; | 158 | struct GNUNET_MQ_DestroyNotificationHandle *dnh_tail; |
166 | 159 | ||
167 | /** | 160 | /** |
168 | * Additional options buffer set for this queue by | ||
169 | * #GNUNET_MQ_set_options(). Default is 0. | ||
170 | */ | ||
171 | const void *default_extra; | ||
172 | |||
173 | /** | ||
174 | * Flags that were set for this queue by | 161 | * Flags that were set for this queue by |
175 | * #GNUNET_MQ_set_options(). Default is 0. | 162 | * #GNUNET_MQ_set_options(). Default is 0. |
176 | */ | 163 | */ |
177 | uint64_t default_flags; | 164 | enum GNUNET_MQ_PriorityPreferences priority; |
178 | 165 | ||
179 | /** | 166 | /** |
180 | * Next id that should be used for the @e assoc_map, | 167 | * Next id that should be used for the @e assoc_map, |
@@ -217,12 +204,10 @@ GNUNET_MQ_inject_message (struct GNUNET_MQ_Handle *mq, | |||
217 | { | 204 | { |
218 | int ret; | 205 | int ret; |
219 | 206 | ||
220 | ret = GNUNET_MQ_handle_message (mq->handlers, | 207 | ret = GNUNET_MQ_handle_message (mq->handlers, mh); |
221 | mh); | ||
222 | if (GNUNET_SYSERR == ret) | 208 | if (GNUNET_SYSERR == ret) |
223 | { | 209 | { |
224 | GNUNET_MQ_inject_error (mq, | 210 | GNUNET_MQ_inject_error (mq, GNUNET_MQ_ERROR_MALFORMED); |
225 | GNUNET_MQ_ERROR_MALFORMED); | ||
226 | return; | 211 | return; |
227 | } | 212 | } |
228 | } | 213 | } |
@@ -251,7 +236,8 @@ GNUNET_MQ_handle_message (const struct GNUNET_MQ_MessageHandler *handlers, | |||
251 | 236 | ||
252 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 237 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
253 | "Received message of type %u and size %u\n", | 238 | "Received message of type %u and size %u\n", |
254 | mtype, msize); | 239 | mtype, |
240 | msize); | ||
255 | 241 | ||
256 | if (NULL == handlers) | 242 | if (NULL == handlers) |
257 | goto done; | 243 | goto done; |
@@ -260,41 +246,40 @@ GNUNET_MQ_handle_message (const struct GNUNET_MQ_MessageHandler *handlers, | |||
260 | if (handler->type == mtype) | 246 | if (handler->type == mtype) |
261 | { | 247 | { |
262 | handled = GNUNET_YES; | 248 | handled = GNUNET_YES; |
263 | if ( (handler->expected_size > msize) || | 249 | if ((handler->expected_size > msize) || |
264 | ( (handler->expected_size != msize) && | 250 | ((handler->expected_size != msize) && (NULL == handler->mv))) |
265 | (NULL == handler->mv) ) ) | ||
266 | { | 251 | { |
267 | /* Too small, or not an exact size and | 252 | /* Too small, or not an exact size and |
268 | no 'mv' handler to check rest */ | 253 | no 'mv' handler to check rest */ |
269 | LOG (GNUNET_ERROR_TYPE_ERROR, | 254 | LOG (GNUNET_ERROR_TYPE_ERROR, |
270 | "Received malformed message of type %u\n", | 255 | "Received malformed message of type %u\n", |
271 | (unsigned int) handler->type); | 256 | (unsigned int) handler->type); |
272 | return GNUNET_SYSERR; | 257 | return GNUNET_SYSERR; |
273 | } | 258 | } |
274 | if ( (NULL == handler->mv) || | 259 | if ((NULL == handler->mv) || |
275 | (GNUNET_OK == | 260 | (GNUNET_OK == handler->mv (handler->cls, mh))) |
276 | handler->mv (handler->cls, mh)) ) | ||
277 | { | 261 | { |
278 | /* message well-formed, pass to handler */ | 262 | /* message well-formed, pass to handler */ |
279 | handler->cb (handler->cls, mh); | 263 | handler->cb (handler->cls, mh); |
280 | } | 264 | } |
281 | else | 265 | else |
282 | { | 266 | { |
283 | /* Message rejected by check routine */ | 267 | /* Message rejected by check routine */ |
284 | LOG (GNUNET_ERROR_TYPE_ERROR, | 268 | LOG (GNUNET_ERROR_TYPE_ERROR, |
285 | "Received malformed message of type %u\n", | 269 | "Received malformed message of type %u\n", |
286 | (unsigned int) handler->type); | 270 | (unsigned int) handler->type); |
287 | return GNUNET_SYSERR; | 271 | return GNUNET_SYSERR; |
288 | } | 272 | } |
289 | break; | 273 | break; |
290 | } | 274 | } |
291 | } | 275 | } |
292 | done: | 276 | done: |
293 | if (GNUNET_NO == handled) | 277 | if (GNUNET_NO == handled) |
294 | { | 278 | { |
295 | LOG (GNUNET_ERROR_TYPE_INFO, | 279 | LOG (GNUNET_ERROR_TYPE_INFO, |
296 | "No handler for message of type %u and size %u\n", | 280 | "No handler for message of type %u and size %u\n", |
297 | mtype, msize); | 281 | mtype, |
282 | msize); | ||
298 | return GNUNET_NO; | 283 | return GNUNET_NO; |
299 | } | 284 | } |
300 | return GNUNET_OK; | 285 | return GNUNET_OK; |
@@ -312,8 +297,7 @@ GNUNET_MQ_handle_message (const struct GNUNET_MQ_MessageHandler *handlers, | |||
312 | * @param error the error type | 297 | * @param error the error type |
313 | */ | 298 | */ |
314 | void | 299 | void |
315 | GNUNET_MQ_inject_error (struct GNUNET_MQ_Handle *mq, | 300 | GNUNET_MQ_inject_error (struct GNUNET_MQ_Handle *mq, enum GNUNET_MQ_Error error) |
316 | enum GNUNET_MQ_Error error) | ||
317 | { | 301 | { |
318 | if (NULL == mq->error_handler) | 302 | if (NULL == mq->error_handler) |
319 | { | 303 | { |
@@ -322,8 +306,7 @@ GNUNET_MQ_inject_error (struct GNUNET_MQ_Handle *mq, | |||
322 | (int) error); | 306 | (int) error); |
323 | return; | 307 | return; |
324 | } | 308 | } |
325 | mq->error_handler (mq->error_handler_cls, | 309 | mq->error_handler (mq->error_handler_cls, error); |
326 | error); | ||
327 | } | 310 | } |
328 | 311 | ||
329 | 312 | ||
@@ -367,8 +350,7 @@ GNUNET_MQ_get_length (struct GNUNET_MQ_Handle *mq) | |||
367 | * @param ev the envelope with the message to send. | 350 | * @param ev the envelope with the message to send. |
368 | */ | 351 | */ |
369 | void | 352 | void |
370 | GNUNET_MQ_send (struct GNUNET_MQ_Handle *mq, | 353 | GNUNET_MQ_send (struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev) |
371 | struct GNUNET_MQ_Envelope *ev) | ||
372 | { | 354 | { |
373 | GNUNET_assert (NULL != mq); | 355 | GNUNET_assert (NULL != mq); |
374 | GNUNET_assert (NULL == ev->parent_queue); | 356 | GNUNET_assert (NULL == ev->parent_queue); |
@@ -378,18 +360,15 @@ GNUNET_MQ_send (struct GNUNET_MQ_Handle *mq, | |||
378 | { | 360 | { |
379 | /* This would seem like a bug... */ | 361 | /* This would seem like a bug... */ |
380 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 362 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
381 | "MQ with %u entries extended by message of type %u (FC broken?)\n", | 363 | "MQ with %u entries extended by message of type %u (FC broken?)\n", |
382 | (unsigned int) mq->queue_length, | 364 | (unsigned int) mq->queue_length, |
383 | (unsigned int) ntohs (ev->mh->type)); | 365 | (unsigned int) ntohs (ev->mh->type)); |
384 | } | 366 | } |
385 | ev->parent_queue = mq; | 367 | ev->parent_queue = mq; |
386 | /* is the implementation busy? queue it! */ | 368 | /* is the implementation busy? queue it! */ |
387 | if ( (NULL != mq->current_envelope) || | 369 | if ((NULL != mq->current_envelope) || (NULL != mq->send_task)) |
388 | (NULL != mq->send_task) ) | ||
389 | { | 370 | { |
390 | GNUNET_CONTAINER_DLL_insert_tail (mq->envelope_head, | 371 | GNUNET_CONTAINER_DLL_insert_tail (mq->envelope_head, mq->envelope_tail, ev); |
391 | mq->envelope_tail, | ||
392 | ev); | ||
393 | return; | 372 | return; |
394 | } | 373 | } |
395 | GNUNET_assert (NULL == mq->envelope_head); | 374 | GNUNET_assert (NULL == mq->envelope_head); |
@@ -397,12 +376,10 @@ GNUNET_MQ_send (struct GNUNET_MQ_Handle *mq, | |||
397 | 376 | ||
398 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 377 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
399 | "sending message of type %u, queue empty (MQ: %p)\n", | 378 | "sending message of type %u, queue empty (MQ: %p)\n", |
400 | ntohs(ev->mh->type), | 379 | ntohs (ev->mh->type), |
401 | mq); | 380 | mq); |
402 | 381 | ||
403 | mq->send_impl (mq, | 382 | mq->send_impl (mq, ev->mh, mq->impl_state); |
404 | ev->mh, | ||
405 | mq->impl_state); | ||
406 | } | 383 | } |
407 | 384 | ||
408 | 385 | ||
@@ -419,9 +396,7 @@ GNUNET_MQ_unsent_head (struct GNUNET_MQ_Handle *mq) | |||
419 | struct GNUNET_MQ_Envelope *env; | 396 | struct GNUNET_MQ_Envelope *env; |
420 | 397 | ||
421 | env = mq->envelope_head; | 398 | env = mq->envelope_head; |
422 | GNUNET_CONTAINER_DLL_remove (mq->envelope_head, | 399 | GNUNET_CONTAINER_DLL_remove (mq->envelope_head, mq->envelope_tail, env); |
423 | mq->envelope_tail, | ||
424 | env); | ||
425 | mq->queue_length--; | 400 | mq->queue_length--; |
426 | env->parent_queue = NULL; | 401 | env->parent_queue = NULL; |
427 | return env; | 402 | return env; |
@@ -461,16 +436,12 @@ GNUNET_MQ_send_copy (struct GNUNET_MQ_Handle *mq, | |||
461 | uint16_t msize; | 436 | uint16_t msize; |
462 | 437 | ||
463 | msize = ntohs (ev->mh->size); | 438 | msize = ntohs (ev->mh->size); |
464 | env = GNUNET_malloc (sizeof (struct GNUNET_MQ_Envelope) + | 439 | env = GNUNET_malloc (sizeof (struct GNUNET_MQ_Envelope) + msize); |
465 | msize); | ||
466 | env->mh = (struct GNUNET_MessageHeader *) &env[1]; | 440 | env->mh = (struct GNUNET_MessageHeader *) &env[1]; |
467 | env->sent_cb = ev->sent_cb; | 441 | env->sent_cb = ev->sent_cb; |
468 | env->sent_cls = ev->sent_cls; | 442 | env->sent_cls = ev->sent_cls; |
469 | GNUNET_memcpy (&env[1], | 443 | GNUNET_memcpy (&env[1], ev->mh, msize); |
470 | ev->mh, | 444 | GNUNET_MQ_send (mq, env); |
471 | msize); | ||
472 | GNUNET_MQ_send (mq, | ||
473 | env); | ||
474 | } | 445 | } |
475 | 446 | ||
476 | 447 | ||
@@ -493,16 +464,14 @@ impl_send_continue (void *cls) | |||
493 | return; | 464 | return; |
494 | mq->current_envelope = mq->envelope_head; | 465 | mq->current_envelope = mq->envelope_head; |
495 | GNUNET_CONTAINER_DLL_remove (mq->envelope_head, | 466 | GNUNET_CONTAINER_DLL_remove (mq->envelope_head, |
496 | mq->envelope_tail, | 467 | mq->envelope_tail, |
497 | mq->current_envelope); | 468 | mq->current_envelope); |
498 | 469 | ||
499 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 470 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
500 | "sending message of type %u from queue\n", | 471 | "sending message of type %u from queue\n", |
501 | ntohs(mq->current_envelope->mh->type)); | 472 | ntohs (mq->current_envelope->mh->type)); |
502 | 473 | ||
503 | mq->send_impl (mq, | 474 | mq->send_impl (mq, mq->current_envelope->mh, mq->impl_state); |
504 | mq->current_envelope->mh, | ||
505 | mq->impl_state); | ||
506 | } | 475 | } |
507 | 476 | ||
508 | 477 | ||
@@ -526,8 +495,7 @@ GNUNET_MQ_impl_send_continue (struct GNUNET_MQ_Handle *mq) | |||
526 | current_envelope->parent_queue = NULL; | 495 | current_envelope->parent_queue = NULL; |
527 | mq->current_envelope = NULL; | 496 | mq->current_envelope = NULL; |
528 | GNUNET_assert (NULL == mq->send_task); | 497 | GNUNET_assert (NULL == mq->send_task); |
529 | mq->send_task = GNUNET_SCHEDULER_add_now (&impl_send_continue, | 498 | mq->send_task = GNUNET_SCHEDULER_add_now (&impl_send_continue, mq); |
530 | mq); | ||
531 | if (NULL != (cb = current_envelope->sent_cb)) | 499 | if (NULL != (cb = current_envelope->sent_cb)) |
532 | { | 500 | { |
533 | current_envelope->sent_cb = NULL; | 501 | current_envelope->sent_cb = NULL; |
@@ -612,12 +580,11 @@ GNUNET_MQ_queue_for_callbacks (GNUNET_MQ_SendImpl send, | |||
612 | * @param handlers_cls new closure to use | 580 | * @param handlers_cls new closure to use |
613 | */ | 581 | */ |
614 | void | 582 | void |
615 | GNUNET_MQ_set_handlers_closure (struct GNUNET_MQ_Handle *mq, | 583 | GNUNET_MQ_set_handlers_closure (struct GNUNET_MQ_Handle *mq, void *handlers_cls) |
616 | void *handlers_cls) | ||
617 | { | 584 | { |
618 | if (NULL == mq->handlers) | 585 | if (NULL == mq->handlers) |
619 | return; | 586 | return; |
620 | for (unsigned int i=0;NULL != mq->handlers[i].cb; i++) | 587 | for (unsigned int i = 0; NULL != mq->handlers[i].cb; i++) |
621 | mq->handlers[i].cls = handlers_cls; | 588 | mq->handlers[i].cls = handlers_cls; |
622 | } | 589 | } |
623 | 590 | ||
@@ -662,9 +629,7 @@ GNUNET_MQ_impl_state (struct GNUNET_MQ_Handle *mq) | |||
662 | 629 | ||
663 | 630 | ||
664 | struct GNUNET_MQ_Envelope * | 631 | struct GNUNET_MQ_Envelope * |
665 | GNUNET_MQ_msg_ (struct GNUNET_MessageHeader **mhp, | 632 | GNUNET_MQ_msg_ (struct GNUNET_MessageHeader **mhp, uint16_t size, uint16_t type) |
666 | uint16_t size, | ||
667 | uint16_t type) | ||
668 | { | 633 | { |
669 | struct GNUNET_MQ_Envelope *ev; | 634 | struct GNUNET_MQ_Envelope *ev; |
670 | 635 | ||
@@ -692,9 +657,7 @@ GNUNET_MQ_msg_copy (const struct GNUNET_MessageHeader *hdr) | |||
692 | 657 | ||
693 | mqm = GNUNET_malloc (sizeof (*mqm) + size); | 658 | mqm = GNUNET_malloc (sizeof (*mqm) + size); |
694 | mqm->mh = (struct GNUNET_MessageHeader *) &mqm[1]; | 659 | mqm->mh = (struct GNUNET_MessageHeader *) &mqm[1]; |
695 | GNUNET_memcpy (mqm->mh, | 660 | GNUNET_memcpy (mqm->mh, hdr, size); |
696 | hdr, | ||
697 | size); | ||
698 | return mqm; | 661 | return mqm; |
699 | } | 662 | } |
700 | 663 | ||
@@ -728,8 +691,8 @@ GNUNET_MQ_msg_nested_mh_ (struct GNUNET_MessageHeader **mhp, | |||
728 | 691 | ||
729 | mqm = GNUNET_MQ_msg_ (mhp, size, type); | 692 | mqm = GNUNET_MQ_msg_ (mhp, size, type); |
730 | GNUNET_memcpy ((char *) mqm->mh + base_size, | 693 | GNUNET_memcpy ((char *) mqm->mh + base_size, |
731 | nested_mh, | 694 | nested_mh, |
732 | ntohs (nested_mh->size)); | 695 | ntohs (nested_mh->size)); |
733 | 696 | ||
734 | return mqm; | 697 | return mqm; |
735 | } | 698 | } |
@@ -742,8 +705,7 @@ GNUNET_MQ_msg_nested_mh_ (struct GNUNET_MessageHeader **mhp, | |||
742 | * @param assoc_data to associate | 705 | * @param assoc_data to associate |
743 | */ | 706 | */ |
744 | uint32_t | 707 | uint32_t |
745 | GNUNET_MQ_assoc_add (struct GNUNET_MQ_Handle *mq, | 708 | GNUNET_MQ_assoc_add (struct GNUNET_MQ_Handle *mq, void *assoc_data) |
746 | void *assoc_data) | ||
747 | { | 709 | { |
748 | uint32_t id; | 710 | uint32_t id; |
749 | 711 | ||
@@ -754,10 +716,11 @@ GNUNET_MQ_assoc_add (struct GNUNET_MQ_Handle *mq, | |||
754 | } | 716 | } |
755 | id = mq->assoc_id++; | 717 | id = mq->assoc_id++; |
756 | GNUNET_assert (GNUNET_OK == | 718 | GNUNET_assert (GNUNET_OK == |
757 | GNUNET_CONTAINER_multihashmap32_put (mq->assoc_map, | 719 | GNUNET_CONTAINER_multihashmap32_put ( |
758 | id, | 720 | mq->assoc_map, |
759 | assoc_data, | 721 | id, |
760 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); | 722 | assoc_data, |
723 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); | ||
761 | return id; | 724 | return id; |
762 | } | 725 | } |
763 | 726 | ||
@@ -770,13 +733,11 @@ GNUNET_MQ_assoc_add (struct GNUNET_MQ_Handle *mq, | |||
770 | * @return the associated data | 733 | * @return the associated data |
771 | */ | 734 | */ |
772 | void * | 735 | void * |
773 | GNUNET_MQ_assoc_get (struct GNUNET_MQ_Handle *mq, | 736 | GNUNET_MQ_assoc_get (struct GNUNET_MQ_Handle *mq, uint32_t request_id) |
774 | uint32_t request_id) | ||
775 | { | 737 | { |
776 | if (NULL == mq->assoc_map) | 738 | if (NULL == mq->assoc_map) |
777 | return NULL; | 739 | return NULL; |
778 | return GNUNET_CONTAINER_multihashmap32_get (mq->assoc_map, | 740 | return GNUNET_CONTAINER_multihashmap32_get (mq->assoc_map, request_id); |
779 | request_id); | ||
780 | } | 741 | } |
781 | 742 | ||
782 | 743 | ||
@@ -788,17 +749,14 @@ GNUNET_MQ_assoc_get (struct GNUNET_MQ_Handle *mq, | |||
788 | * @return the associated data | 749 | * @return the associated data |
789 | */ | 750 | */ |
790 | void * | 751 | void * |
791 | GNUNET_MQ_assoc_remove (struct GNUNET_MQ_Handle *mq, | 752 | GNUNET_MQ_assoc_remove (struct GNUNET_MQ_Handle *mq, uint32_t request_id) |
792 | uint32_t request_id) | ||
793 | { | 753 | { |
794 | void *val; | 754 | void *val; |
795 | 755 | ||
796 | if (NULL == mq->assoc_map) | 756 | if (NULL == mq->assoc_map) |
797 | return NULL; | 757 | return NULL; |
798 | val = GNUNET_CONTAINER_multihashmap32_get (mq->assoc_map, | 758 | val = GNUNET_CONTAINER_multihashmap32_get (mq->assoc_map, request_id); |
799 | request_id); | 759 | GNUNET_CONTAINER_multihashmap32_remove_all (mq->assoc_map, request_id); |
800 | GNUNET_CONTAINER_multihashmap32_remove_all (mq->assoc_map, | ||
801 | request_id); | ||
802 | return val; | 760 | return val; |
803 | } | 761 | } |
804 | 762 | ||
@@ -818,8 +776,7 @@ GNUNET_MQ_notify_sent (struct GNUNET_MQ_Envelope *ev, | |||
818 | void *cb_cls) | 776 | void *cb_cls) |
819 | { | 777 | { |
820 | /* allow setting *OR* clearing callback */ | 778 | /* allow setting *OR* clearing callback */ |
821 | GNUNET_assert ( (NULL == ev->sent_cb) || | 779 | GNUNET_assert ((NULL == ev->sent_cb) || (NULL == cb)); |
822 | (NULL == cb) ); | ||
823 | ev->sent_cb = cb; | 780 | ev->sent_cb = cb; |
824 | ev->sent_cls = cb_cls; | 781 | ev->sent_cls = cb_cls; |
825 | } | 782 | } |
@@ -883,9 +840,7 @@ GNUNET_MQ_destroy (struct GNUNET_MQ_Handle *mq) | |||
883 | 840 | ||
884 | ev = mq->envelope_head; | 841 | ev = mq->envelope_head; |
885 | ev->parent_queue = NULL; | 842 | ev->parent_queue = NULL; |
886 | GNUNET_CONTAINER_DLL_remove (mq->envelope_head, | 843 | GNUNET_CONTAINER_DLL_remove (mq->envelope_head, mq->envelope_tail, ev); |
887 | mq->envelope_tail, | ||
888 | ev); | ||
889 | GNUNET_assert (0 < mq->queue_length); | 844 | GNUNET_assert (0 < mq->queue_length); |
890 | mq->queue_length--; | 845 | mq->queue_length--; |
891 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 846 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
@@ -974,8 +929,7 @@ GNUNET_MQ_send_cancel (struct GNUNET_MQ_Envelope *ev) | |||
974 | GNUNET_assert (GNUNET_NO == mq->in_flight); | 929 | GNUNET_assert (GNUNET_NO == mq->in_flight); |
975 | GNUNET_assert (0 < mq->queue_length); | 930 | GNUNET_assert (0 < mq->queue_length); |
976 | mq->queue_length--; | 931 | mq->queue_length--; |
977 | mq->cancel_impl (mq, | 932 | mq->cancel_impl (mq, mq->impl_state); |
978 | mq->impl_state); | ||
979 | /* continue sending the next message, if any */ | 933 | /* continue sending the next message, if any */ |
980 | mq->current_envelope = mq->envelope_head; | 934 | mq->current_envelope = mq->envelope_head; |
981 | if (NULL != mq->current_envelope) | 935 | if (NULL != mq->current_envelope) |
@@ -986,19 +940,15 @@ GNUNET_MQ_send_cancel (struct GNUNET_MQ_Envelope *ev) | |||
986 | 940 | ||
987 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 941 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
988 | "sending canceled message of type %u queue\n", | 942 | "sending canceled message of type %u queue\n", |
989 | ntohs(ev->mh->type)); | 943 | ntohs (ev->mh->type)); |
990 | 944 | ||
991 | mq->send_impl (mq, | 945 | mq->send_impl (mq, mq->current_envelope->mh, mq->impl_state); |
992 | mq->current_envelope->mh, | ||
993 | mq->impl_state); | ||
994 | } | 946 | } |
995 | } | 947 | } |
996 | else | 948 | else |
997 | { | 949 | { |
998 | /* simple case, message is still waiting in the queue */ | 950 | /* simple case, message is still waiting in the queue */ |
999 | GNUNET_CONTAINER_DLL_remove (mq->envelope_head, | 951 | GNUNET_CONTAINER_DLL_remove (mq->envelope_head, mq->envelope_tail, ev); |
1000 | mq->envelope_tail, | ||
1001 | ev); | ||
1002 | GNUNET_assert (0 < mq->queue_length); | 952 | GNUNET_assert (0 < mq->queue_length); |
1003 | mq->queue_length--; | 953 | mq->queue_length--; |
1004 | } | 954 | } |
@@ -1044,21 +994,18 @@ GNUNET_MQ_get_last_envelope (struct GNUNET_MQ_Handle *mq) | |||
1044 | 994 | ||
1045 | 995 | ||
1046 | /** | 996 | /** |
1047 | * Set application-specific options for this envelope. | 997 | * Set application-specific preferences for this envelope. |
1048 | * Overrides the options set for the queue with | 998 | * Overrides the options set for the queue with |
1049 | * #GNUNET_MQ_set_options() for this message only. | 999 | * #GNUNET_MQ_set_options() for this message only. |
1050 | * | 1000 | * |
1051 | * @param env message to set options for | 1001 | * @param env message to set options for |
1052 | * @param flags flags to use (meaning is queue-specific) | 1002 | * @param pp priorities and preferences to apply |
1053 | * @param extra additional buffer for further data (also queue-specific) | ||
1054 | */ | 1003 | */ |
1055 | void | 1004 | void |
1056 | GNUNET_MQ_env_set_options (struct GNUNET_MQ_Envelope *env, | 1005 | GNUNET_MQ_env_set_options (struct GNUNET_MQ_Envelope *env, |
1057 | uint64_t flags, | 1006 | enum GNUNET_MQ_PriorityPreferences pp) |
1058 | const void *extra) | ||
1059 | { | 1007 | { |
1060 | env->flags = flags; | 1008 | env->priority = pp; |
1061 | env->extra = extra; | ||
1062 | env->have_custom_options = GNUNET_YES; | 1009 | env->have_custom_options = GNUNET_YES; |
1063 | } | 1010 | } |
1064 | 1011 | ||
@@ -1067,44 +1014,57 @@ GNUNET_MQ_env_set_options (struct GNUNET_MQ_Envelope *env, | |||
1067 | * Get application-specific options for this envelope. | 1014 | * Get application-specific options for this envelope. |
1068 | * | 1015 | * |
1069 | * @param env message to set options for | 1016 | * @param env message to set options for |
1070 | * @param[out] flags set to flags to use (meaning is queue-specific) | 1017 | * @return priorities and preferences to apply for @a env |
1071 | * @return extra additional buffer for further data (also queue-specific) | ||
1072 | */ | 1018 | */ |
1073 | const void * | 1019 | enum GNUNET_MQ_PriorityPreferences |
1074 | GNUNET_MQ_env_get_options (struct GNUNET_MQ_Envelope *env, | 1020 | GNUNET_MQ_env_get_options (struct GNUNET_MQ_Envelope *env) |
1075 | uint64_t *flags) | ||
1076 | { | 1021 | { |
1077 | struct GNUNET_MQ_Handle *mq = env->parent_queue; | 1022 | struct GNUNET_MQ_Handle *mq = env->parent_queue; |
1078 | 1023 | ||
1079 | if (GNUNET_YES == env->have_custom_options) | 1024 | if (GNUNET_YES == env->have_custom_options) |
1080 | { | 1025 | return env->priority; |
1081 | *flags = env->flags; | ||
1082 | return env->extra; | ||
1083 | } | ||
1084 | if (NULL == mq) | 1026 | if (NULL == mq) |
1085 | { | 1027 | return 0; |
1086 | *flags = 0; | 1028 | return mq->priority; |
1087 | return NULL; | 1029 | } |
1088 | } | 1030 | |
1089 | *flags = mq->default_flags; | 1031 | |
1090 | return mq->default_extra; | 1032 | /** |
1033 | * Combine performance preferences set for different | ||
1034 | * envelopes that are being combined into one larger envelope. | ||
1035 | * | ||
1036 | * @param p1 one set of preferences | ||
1037 | * @param p2 second set of preferences | ||
1038 | * @return combined priority and preferences to use | ||
1039 | */ | ||
1040 | enum GNUNET_MQ_PriorityPreferences | ||
1041 | GNUNET_MQ_env_combine_options (enum GNUNET_MQ_PriorityPreferences p1, | ||
1042 | enum GNUNET_MQ_PriorityPreferences p2) | ||
1043 | { | ||
1044 | enum GNUNET_MQ_PriorityPreferences ret; | ||
1045 | |||
1046 | ret = GNUNET_MAX (p1 & GNUNET_MQ_PRIORITY_MASK, p2 & GNUNET_MQ_PRIORITY_MASK); | ||
1047 | ret |= ((p1 & GNUNET_MQ_PREF_UNRELIABLE) & (p2 & GNUNET_MQ_PREF_UNRELIABLE)); | ||
1048 | ret |= | ||
1049 | ((p1 & GNUNET_MQ_PREF_LOW_LATENCY) | (p2 & GNUNET_MQ_PREF_LOW_LATENCY)); | ||
1050 | ret |= | ||
1051 | ((p1 & GNUNET_MQ_PREF_CORK_ALLOWED) & (p2 & GNUNET_MQ_PREF_CORK_ALLOWED)); | ||
1052 | ret |= ((p1 & GNUNET_MQ_PREF_GOODPUT) & (p2 & GNUNET_MQ_PREF_GOODPUT)); | ||
1053 | return ret; | ||
1091 | } | 1054 | } |
1092 | 1055 | ||
1093 | 1056 | ||
1094 | /** | 1057 | /** |
1095 | * Set application-specific options for this queue. | 1058 | * Set application-specific default options for this queue. |
1096 | * | 1059 | * |
1097 | * @param mq message queue to set options for | 1060 | * @param mq message queue to set options for |
1098 | * @param flags flags to use (meaning is queue-specific) | 1061 | * @param pp priorities and preferences to apply |
1099 | * @param extra additional buffer for further data (also queue-specific) | ||
1100 | */ | 1062 | */ |
1101 | void | 1063 | void |
1102 | GNUNET_MQ_set_options (struct GNUNET_MQ_Handle *mq, | 1064 | GNUNET_MQ_set_options (struct GNUNET_MQ_Handle *mq, |
1103 | uint64_t flags, | 1065 | enum GNUNET_MQ_PriorityPreferences pp) |
1104 | const void *extra) | ||
1105 | { | 1066 | { |
1106 | mq->default_flags = flags; | 1067 | mq->priority = pp; |
1107 | mq->default_extra = extra; | ||
1108 | } | 1068 | } |
1109 | 1069 | ||
1110 | 1070 | ||
@@ -1145,8 +1105,8 @@ GNUNET_MQ_env_next (const struct GNUNET_MQ_Envelope *env) | |||
1145 | */ | 1105 | */ |
1146 | struct GNUNET_MQ_DestroyNotificationHandle * | 1106 | struct GNUNET_MQ_DestroyNotificationHandle * |
1147 | GNUNET_MQ_destroy_notify (struct GNUNET_MQ_Handle *mq, | 1107 | GNUNET_MQ_destroy_notify (struct GNUNET_MQ_Handle *mq, |
1148 | GNUNET_SCHEDULER_TaskCallback cb, | 1108 | GNUNET_SCHEDULER_TaskCallback cb, |
1149 | void *cb_cls) | 1109 | void *cb_cls) |
1150 | { | 1110 | { |
1151 | struct GNUNET_MQ_DestroyNotificationHandle *dnh; | 1111 | struct GNUNET_MQ_DestroyNotificationHandle *dnh; |
1152 | 1112 | ||
@@ -1154,9 +1114,7 @@ GNUNET_MQ_destroy_notify (struct GNUNET_MQ_Handle *mq, | |||
1154 | dnh->mq = mq; | 1114 | dnh->mq = mq; |
1155 | dnh->cb = cb; | 1115 | dnh->cb = cb; |
1156 | dnh->cb_cls = cb_cls; | 1116 | dnh->cb_cls = cb_cls; |
1157 | GNUNET_CONTAINER_DLL_insert (mq->dnh_head, | 1117 | GNUNET_CONTAINER_DLL_insert (mq->dnh_head, mq->dnh_tail, dnh); |
1158 | mq->dnh_tail, | ||
1159 | dnh); | ||
1160 | return dnh; | 1118 | return dnh; |
1161 | } | 1119 | } |
1162 | 1120 | ||
@@ -1167,13 +1125,12 @@ GNUNET_MQ_destroy_notify (struct GNUNET_MQ_Handle *mq, | |||
1167 | * @param dnh handle for registration to cancel | 1125 | * @param dnh handle for registration to cancel |
1168 | */ | 1126 | */ |
1169 | void | 1127 | void |
1170 | GNUNET_MQ_destroy_notify_cancel (struct GNUNET_MQ_DestroyNotificationHandle *dnh) | 1128 | GNUNET_MQ_destroy_notify_cancel ( |
1129 | struct GNUNET_MQ_DestroyNotificationHandle *dnh) | ||
1171 | { | 1130 | { |
1172 | struct GNUNET_MQ_Handle *mq = dnh->mq; | 1131 | struct GNUNET_MQ_Handle *mq = dnh->mq; |
1173 | 1132 | ||
1174 | GNUNET_CONTAINER_DLL_remove (mq->dnh_head, | 1133 | GNUNET_CONTAINER_DLL_remove (mq->dnh_head, mq->dnh_tail, dnh); |
1175 | mq->dnh_tail, | ||
1176 | dnh); | ||
1177 | GNUNET_free (dnh); | 1134 | GNUNET_free (dnh); |
1178 | } | 1135 | } |
1179 | 1136 | ||
@@ -1195,9 +1152,7 @@ GNUNET_MQ_dll_insert_tail (struct GNUNET_MQ_Envelope **env_head, | |||
1195 | struct GNUNET_MQ_Envelope **env_tail, | 1152 | struct GNUNET_MQ_Envelope **env_tail, |
1196 | struct GNUNET_MQ_Envelope *env) | 1153 | struct GNUNET_MQ_Envelope *env) |
1197 | { | 1154 | { |
1198 | GNUNET_CONTAINER_DLL_insert_tail (*env_head, | 1155 | GNUNET_CONTAINER_DLL_insert_tail (*env_head, *env_tail, env); |
1199 | *env_tail, | ||
1200 | env); | ||
1201 | } | 1156 | } |
1202 | 1157 | ||
1203 | 1158 | ||
@@ -1218,9 +1173,7 @@ GNUNET_MQ_dll_remove (struct GNUNET_MQ_Envelope **env_head, | |||
1218 | struct GNUNET_MQ_Envelope **env_tail, | 1173 | struct GNUNET_MQ_Envelope **env_tail, |
1219 | struct GNUNET_MQ_Envelope *env) | 1174 | struct GNUNET_MQ_Envelope *env) |
1220 | { | 1175 | { |
1221 | GNUNET_CONTAINER_DLL_remove (*env_head, | 1176 | GNUNET_CONTAINER_DLL_remove (*env_head, *env_tail, env); |
1222 | *env_tail, | ||
1223 | env); | ||
1224 | } | 1177 | } |
1225 | 1178 | ||
1226 | 1179 | ||
@@ -1244,8 +1197,7 @@ GNUNET_MQ_copy_handlers (const struct GNUNET_MQ_MessageHandler *handlers) | |||
1244 | return NULL; | 1197 | return NULL; |
1245 | 1198 | ||
1246 | count = GNUNET_MQ_count_handlers (handlers); | 1199 | count = GNUNET_MQ_count_handlers (handlers); |
1247 | copy = GNUNET_new_array (count + 1, | 1200 | copy = GNUNET_new_array (count + 1, struct GNUNET_MQ_MessageHandler); |
1248 | struct GNUNET_MQ_MessageHandler); | ||
1249 | GNUNET_memcpy (copy, | 1201 | GNUNET_memcpy (copy, |
1250 | handlers, | 1202 | handlers, |
1251 | count * sizeof (struct GNUNET_MQ_MessageHandler)); | 1203 | count * sizeof (struct GNUNET_MQ_MessageHandler)); |
@@ -1276,8 +1228,7 @@ GNUNET_MQ_copy_handlers2 (const struct GNUNET_MQ_MessageHandler *handlers, | |||
1276 | if (NULL == handlers) | 1228 | if (NULL == handlers) |
1277 | return NULL; | 1229 | return NULL; |
1278 | count = GNUNET_MQ_count_handlers (handlers); | 1230 | count = GNUNET_MQ_count_handlers (handlers); |
1279 | copy = GNUNET_new_array (count + 2, | 1231 | copy = GNUNET_new_array (count + 2, struct GNUNET_MQ_MessageHandler); |
1280 | struct GNUNET_MQ_MessageHandler); | ||
1281 | GNUNET_memcpy (copy, | 1232 | GNUNET_memcpy (copy, |
1282 | handlers, | 1233 | handlers, |
1283 | count * sizeof (struct GNUNET_MQ_MessageHandler)); | 1234 | count * sizeof (struct GNUNET_MQ_MessageHandler)); |
@@ -1304,7 +1255,8 @@ GNUNET_MQ_count_handlers (const struct GNUNET_MQ_MessageHandler *handlers) | |||
1304 | if (NULL == handlers) | 1255 | if (NULL == handlers) |
1305 | return 0; | 1256 | return 0; |
1306 | 1257 | ||
1307 | for (i=0; NULL != handlers[i].cb; i++) ; | 1258 | for (i = 0; NULL != handlers[i].cb; i++) |
1259 | ; | ||
1308 | 1260 | ||
1309 | return i; | 1261 | return i; |
1310 | } | 1262 | } |
@@ -1319,7 +1271,8 @@ GNUNET_MQ_count_handlers (const struct GNUNET_MQ_MessageHandler *handlers) | |||
1319 | const char * | 1271 | const char * |
1320 | GNUNET_MQ_preference_to_string (enum GNUNET_MQ_PreferenceKind type) | 1272 | GNUNET_MQ_preference_to_string (enum GNUNET_MQ_PreferenceKind type) |
1321 | { | 1273 | { |
1322 | switch (type) { | 1274 | switch (type) |
1275 | { | ||
1323 | case GNUNET_MQ_PREFERENCE_NONE: | 1276 | case GNUNET_MQ_PREFERENCE_NONE: |
1324 | return "NONE"; | 1277 | return "NONE"; |
1325 | case GNUNET_MQ_PREFERENCE_BANDWIDTH: | 1278 | case GNUNET_MQ_PREFERENCE_BANDWIDTH: |