diff options
author | David Barksdale <amatus.amongus@gmail.com> | 2016-08-18 00:03:29 +0000 |
---|---|---|
committer | David Barksdale <amatus.amongus@gmail.com> | 2016-08-18 00:03:29 +0000 |
commit | 7f937e3781f36538d9864fa841822eecdaf0bf27 (patch) | |
tree | 318eb592dae2bbf59d094f5df140c24a4b6184c9 | |
parent | 94a717fab18ed25e6bec4b349526212045f6ca70 (diff) | |
download | gnunet-7f937e3781f36538d9864fa841822eecdaf0bf27.tar.gz gnunet-7f937e3781f36538d9864fa841822eecdaf0bf27.zip |
Use statement exprs instead of local function
This change lets us compile with clang again.
74 files changed, 926 insertions, 976 deletions
diff --git a/src/arm/arm_api.c b/src/arm/arm_api.c index c8c5e8ba6..5c4a1c794 100644 --- a/src/arm/arm_api.c +++ b/src/arm/arm_api.c | |||
@@ -453,19 +453,19 @@ mq_error_handler (void *cls, | |||
453 | static int | 453 | static int |
454 | reconnect_arm (struct GNUNET_ARM_Handle *h) | 454 | reconnect_arm (struct GNUNET_ARM_Handle *h) |
455 | { | 455 | { |
456 | GNUNET_MQ_hd_fixed_size (arm_result, | ||
457 | GNUNET_MESSAGE_TYPE_ARM_RESULT, | ||
458 | struct GNUNET_ARM_ResultMessage); | ||
459 | GNUNET_MQ_hd_var_size (arm_list_result, | ||
460 | GNUNET_MESSAGE_TYPE_ARM_LIST_RESULT, | ||
461 | struct GNUNET_ARM_ListResultMessage); | ||
462 | GNUNET_MQ_hd_fixed_size (confirm, | ||
463 | GNUNET_MESSAGE_TYPE_TEST, | ||
464 | struct GNUNET_MessageHeader); | ||
465 | struct GNUNET_MQ_MessageHandler handlers[] = { | 456 | struct GNUNET_MQ_MessageHandler handlers[] = { |
466 | make_arm_result_handler (h), | 457 | GNUNET_MQ_hd_fixed_size (arm_result, |
467 | make_arm_list_result_handler (h), | 458 | GNUNET_MESSAGE_TYPE_ARM_RESULT, |
468 | make_confirm_handler (h), | 459 | struct GNUNET_ARM_ResultMessage, |
460 | h), | ||
461 | GNUNET_MQ_hd_var_size (arm_list_result, | ||
462 | GNUNET_MESSAGE_TYPE_ARM_LIST_RESULT, | ||
463 | struct GNUNET_ARM_ListResultMessage, | ||
464 | h), | ||
465 | GNUNET_MQ_hd_fixed_size (confirm, | ||
466 | GNUNET_MESSAGE_TYPE_TEST, | ||
467 | struct GNUNET_MessageHeader, | ||
468 | h), | ||
469 | GNUNET_MQ_handler_end () | 469 | GNUNET_MQ_handler_end () |
470 | }; | 470 | }; |
471 | struct GNUNET_MessageHeader *test; | 471 | struct GNUNET_MessageHeader *test; |
diff --git a/src/arm/arm_monitor_api.c b/src/arm/arm_monitor_api.c index 442320fe8..471393c7e 100644 --- a/src/arm/arm_monitor_api.c +++ b/src/arm/arm_monitor_api.c | |||
@@ -198,11 +198,11 @@ mq_error_handler (void *cls, | |||
198 | static int | 198 | static int |
199 | reconnect_arm_monitor (struct GNUNET_ARM_MonitorHandle *h) | 199 | reconnect_arm_monitor (struct GNUNET_ARM_MonitorHandle *h) |
200 | { | 200 | { |
201 | GNUNET_MQ_hd_var_size (monitor_notify, | ||
202 | GNUNET_MESSAGE_TYPE_ARM_STATUS, | ||
203 | struct GNUNET_ARM_StatusMessage); | ||
204 | struct GNUNET_MQ_MessageHandler handlers[] = { | 201 | struct GNUNET_MQ_MessageHandler handlers[] = { |
205 | make_monitor_notify_handler (h), | 202 | GNUNET_MQ_hd_var_size (monitor_notify, |
203 | GNUNET_MESSAGE_TYPE_ARM_STATUS, | ||
204 | struct GNUNET_ARM_StatusMessage, | ||
205 | h), | ||
206 | GNUNET_MQ_handler_end () | 206 | GNUNET_MQ_handler_end () |
207 | }; | 207 | }; |
208 | struct GNUNET_MessageHeader *msg; | 208 | struct GNUNET_MessageHeader *msg; |
diff --git a/src/ats-tests/ats-testing.c b/src/ats-tests/ats-testing.c index 9f0519fa3..eb30daa6b 100644 --- a/src/ats-tests/ats-testing.c +++ b/src/ats-tests/ats-testing.c | |||
@@ -348,16 +348,16 @@ static void * | |||
348 | transport_connect_adapter (void *cls, | 348 | transport_connect_adapter (void *cls, |
349 | const struct GNUNET_CONFIGURATION_Handle *cfg) | 349 | const struct GNUNET_CONFIGURATION_Handle *cfg) |
350 | { | 350 | { |
351 | GNUNET_MQ_hd_fixed_size (ping, | ||
352 | TEST_MESSAGE_TYPE_PING, | ||
353 | struct TestMessage); | ||
354 | GNUNET_MQ_hd_fixed_size (pong, | ||
355 | TEST_MESSAGE_TYPE_PONG, | ||
356 | struct TestMessage); | ||
357 | struct BenchmarkPeer *me = cls; | 351 | struct BenchmarkPeer *me = cls; |
358 | struct GNUNET_MQ_MessageHandler handlers[] = { | 352 | struct GNUNET_MQ_MessageHandler handlers[] = { |
359 | make_ping_handler (me), | 353 | GNUNET_MQ_hd_fixed_size (ping, |
360 | make_pong_handler (me), | 354 | TEST_MESSAGE_TYPE_PING, |
355 | struct TestMessage, | ||
356 | me), | ||
357 | GNUNET_MQ_hd_fixed_size (pong, | ||
358 | TEST_MESSAGE_TYPE_PONG, | ||
359 | struct TestMessage, | ||
360 | me), | ||
361 | GNUNET_MQ_handler_end () | 361 | GNUNET_MQ_handler_end () |
362 | }; | 362 | }; |
363 | 363 | ||
@@ -390,16 +390,16 @@ static void * | |||
390 | core_connect_adapter (void *cls, | 390 | core_connect_adapter (void *cls, |
391 | const struct GNUNET_CONFIGURATION_Handle *cfg) | 391 | const struct GNUNET_CONFIGURATION_Handle *cfg) |
392 | { | 392 | { |
393 | GNUNET_MQ_hd_fixed_size (ping, | ||
394 | TEST_MESSAGE_TYPE_PING, | ||
395 | struct TestMessage); | ||
396 | GNUNET_MQ_hd_fixed_size (pong, | ||
397 | TEST_MESSAGE_TYPE_PONG, | ||
398 | struct TestMessage); | ||
399 | struct BenchmarkPeer *me = cls; | 393 | struct BenchmarkPeer *me = cls; |
400 | struct GNUNET_MQ_MessageHandler handlers[] = { | 394 | struct GNUNET_MQ_MessageHandler handlers[] = { |
401 | make_ping_handler (me), | 395 | GNUNET_MQ_hd_fixed_size (ping, |
402 | make_pong_handler (me), | 396 | TEST_MESSAGE_TYPE_PING, |
397 | struct TestMessage, | ||
398 | me), | ||
399 | GNUNET_MQ_hd_fixed_size (pong, | ||
400 | TEST_MESSAGE_TYPE_PONG, | ||
401 | struct TestMessage, | ||
402 | me), | ||
403 | GNUNET_MQ_handler_end () | 403 | GNUNET_MQ_handler_end () |
404 | }; | 404 | }; |
405 | 405 | ||
diff --git a/src/ats/ats_api_performance.c b/src/ats/ats_api_performance.c index 7edc39e38..dd8666d4c 100644 --- a/src/ats/ats_api_performance.c +++ b/src/ats/ats_api_performance.c | |||
@@ -566,19 +566,19 @@ mq_error_handler (void *cls, | |||
566 | static void | 566 | static void |
567 | reconnect (struct GNUNET_ATS_PerformanceHandle *ph) | 567 | reconnect (struct GNUNET_ATS_PerformanceHandle *ph) |
568 | { | 568 | { |
569 | GNUNET_MQ_hd_var_size (peer_information, | ||
570 | GNUNET_MESSAGE_TYPE_ATS_PEER_INFORMATION, | ||
571 | struct PeerInformationMessage); | ||
572 | GNUNET_MQ_hd_fixed_size (reservation_result, | ||
573 | GNUNET_MESSAGE_TYPE_ATS_RESERVATION_RESULT, | ||
574 | struct ReservationResultMessage); | ||
575 | GNUNET_MQ_hd_var_size (address_list, | ||
576 | GNUNET_MESSAGE_TYPE_ATS_ADDRESSLIST_RESPONSE, | ||
577 | struct PeerInformationMessage); | ||
578 | struct GNUNET_MQ_MessageHandler handlers[] = { | 569 | struct GNUNET_MQ_MessageHandler handlers[] = { |
579 | make_peer_information_handler (ph), | 570 | GNUNET_MQ_hd_var_size (peer_information, |
580 | make_reservation_result_handler (ph), | 571 | GNUNET_MESSAGE_TYPE_ATS_PEER_INFORMATION, |
581 | make_address_list_handler (ph), | 572 | struct PeerInformationMessage, |
573 | ph), | ||
574 | GNUNET_MQ_hd_fixed_size (reservation_result, | ||
575 | GNUNET_MESSAGE_TYPE_ATS_RESERVATION_RESULT, | ||
576 | struct ReservationResultMessage, | ||
577 | ph), | ||
578 | GNUNET_MQ_hd_var_size (address_list, | ||
579 | GNUNET_MESSAGE_TYPE_ATS_ADDRESSLIST_RESPONSE, | ||
580 | struct PeerInformationMessage, | ||
581 | ph), | ||
582 | GNUNET_MQ_handler_end () | 582 | GNUNET_MQ_handler_end () |
583 | }; | 583 | }; |
584 | struct GNUNET_MQ_Envelope *env; | 584 | struct GNUNET_MQ_Envelope *env; |
diff --git a/src/ats/ats_api_scheduling.c b/src/ats/ats_api_scheduling.c index c4174f99e..4a872b90a 100644 --- a/src/ats/ats_api_scheduling.c +++ b/src/ats/ats_api_scheduling.c | |||
@@ -515,15 +515,15 @@ send_add_address_message (struct GNUNET_ATS_SchedulingHandle *sh, | |||
515 | static void | 515 | static void |
516 | reconnect (struct GNUNET_ATS_SchedulingHandle *sh) | 516 | reconnect (struct GNUNET_ATS_SchedulingHandle *sh) |
517 | { | 517 | { |
518 | GNUNET_MQ_hd_fixed_size (ats_session_release, | ||
519 | GNUNET_MESSAGE_TYPE_ATS_SESSION_RELEASE, | ||
520 | struct GNUNET_ATS_SessionReleaseMessage); | ||
521 | GNUNET_MQ_hd_fixed_size (ats_address_suggestion, | ||
522 | GNUNET_MESSAGE_TYPE_ATS_ADDRESS_SUGGESTION, | ||
523 | struct AddressSuggestionMessage); | ||
524 | struct GNUNET_MQ_MessageHandler handlers[] = { | 518 | struct GNUNET_MQ_MessageHandler handlers[] = { |
525 | make_ats_session_release_handler (sh), | 519 | GNUNET_MQ_hd_fixed_size (ats_session_release, |
526 | make_ats_address_suggestion_handler (sh), | 520 | GNUNET_MESSAGE_TYPE_ATS_SESSION_RELEASE, |
521 | struct GNUNET_ATS_SessionReleaseMessage, | ||
522 | sh), | ||
523 | GNUNET_MQ_hd_fixed_size (ats_address_suggestion, | ||
524 | GNUNET_MESSAGE_TYPE_ATS_ADDRESS_SUGGESTION, | ||
525 | struct AddressSuggestionMessage, | ||
526 | sh), | ||
527 | GNUNET_MQ_handler_end () | 527 | GNUNET_MQ_handler_end () |
528 | }; | 528 | }; |
529 | struct GNUNET_MQ_Envelope *ev; | 529 | struct GNUNET_MQ_Envelope *ev; |
diff --git a/src/cadet/cadet_api.c b/src/cadet/cadet_api.c index 1d4530b6f..d75815588 100644 --- a/src/cadet/cadet_api.c +++ b/src/cadet/cadet_api.c | |||
@@ -1239,43 +1239,43 @@ handle_get_tunnel (void *cls, | |||
1239 | static int | 1239 | static int |
1240 | do_reconnect (struct GNUNET_CADET_Handle *h) | 1240 | do_reconnect (struct GNUNET_CADET_Handle *h) |
1241 | { | 1241 | { |
1242 | GNUNET_MQ_hd_fixed_size (channel_created, | 1242 | struct GNUNET_MQ_MessageHandler handlers[] = { |
1243 | GNUNET_MESSAGE_TYPE_CADET_CHANNEL_CREATE, | 1243 | GNUNET_MQ_hd_fixed_size (channel_created, |
1244 | struct GNUNET_CADET_ChannelCreateMessage); | 1244 | GNUNET_MESSAGE_TYPE_CADET_CHANNEL_CREATE, |
1245 | GNUNET_MQ_hd_fixed_size (channel_destroy, | 1245 | struct GNUNET_CADET_ChannelCreateMessage, |
1246 | GNUNET_MESSAGE_TYPE_CADET_CHANNEL_DESTROY, | 1246 | h), |
1247 | struct GNUNET_CADET_ChannelDestroyMessage); | 1247 | GNUNET_MQ_hd_fixed_size (channel_destroy, |
1248 | GNUNET_MQ_hd_var_size (local_data, | 1248 | GNUNET_MESSAGE_TYPE_CADET_CHANNEL_DESTROY, |
1249 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_DATA, | 1249 | struct GNUNET_CADET_ChannelDestroyMessage, |
1250 | struct GNUNET_CADET_LocalData); | 1250 | h), |
1251 | GNUNET_MQ_hd_fixed_size (local_ack, | 1251 | GNUNET_MQ_hd_var_size (local_data, |
1252 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_ACK, | 1252 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_DATA, |
1253 | struct GNUNET_CADET_LocalAck); | 1253 | struct GNUNET_CADET_LocalData, |
1254 | GNUNET_MQ_hd_var_size (get_peers, | 1254 | h), |
1255 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PEERS, | 1255 | GNUNET_MQ_hd_fixed_size (local_ack, |
1256 | struct GNUNET_CADET_LocalInfoPeer); | 1256 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_ACK, |
1257 | GNUNET_MQ_hd_var_size (get_peer, | 1257 | struct GNUNET_CADET_LocalAck, |
1258 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PEER, | 1258 | h), |
1259 | struct GNUNET_CADET_LocalInfoPeer); | 1259 | GNUNET_MQ_hd_var_size (get_peers, |
1260 | GNUNET_MQ_hd_var_size (get_tunnels, | 1260 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PEERS, |
1261 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNELS, | 1261 | struct GNUNET_CADET_LocalInfoPeer, |
1262 | struct GNUNET_CADET_LocalInfoTunnel); | 1262 | h), |
1263 | GNUNET_MQ_hd_var_size (get_tunnel, | 1263 | GNUNET_MQ_hd_var_size (get_peer, |
1264 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNEL, | 1264 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PEER, |
1265 | struct GNUNET_CADET_LocalInfoTunnel); | 1265 | struct GNUNET_CADET_LocalInfoPeer, |
1266 | h), | ||
1267 | GNUNET_MQ_hd_var_size (get_tunnels, | ||
1268 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNELS, | ||
1269 | struct GNUNET_CADET_LocalInfoTunnel, | ||
1270 | h), | ||
1271 | GNUNET_MQ_hd_var_size (get_tunnel, | ||
1272 | GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNEL, | ||
1273 | struct GNUNET_CADET_LocalInfoTunnel, | ||
1274 | h), | ||
1266 | // FIXME | 1275 | // FIXME |
1267 | // GNUNET_MQ_hd_fixed_Y size (channel_destroyed, | 1276 | // GNUNET_MQ_hd_fixed_Y size (channel_destroyed, |
1268 | // GNUNET_MESSAGE_TYPE_CADET_CHANNEL_NACK, | 1277 | // GNUNET_MESSAGE_TYPE_CADET_CHANNEL_NACK, |
1269 | // struct GNUNET_CADET_ChannelDestroyMessage); | 1278 | // struct GNUNET_CADET_ChannelDestroyMessage); |
1270 | struct GNUNET_MQ_MessageHandler handlers[] = { | ||
1271 | make_channel_created_handler (h), | ||
1272 | make_channel_destroy_handler (h), | ||
1273 | make_local_data_handler (h), | ||
1274 | make_local_ack_handler (h), | ||
1275 | make_get_peers_handler (h), | ||
1276 | make_get_peer_handler (h), | ||
1277 | make_get_tunnels_handler (h), | ||
1278 | make_get_tunnel_handler (h), | ||
1279 | GNUNET_MQ_handler_end () | 1279 | GNUNET_MQ_handler_end () |
1280 | }; | 1280 | }; |
1281 | 1281 | ||
diff --git a/src/consensus/consensus_api.c b/src/consensus/consensus_api.c index 088fafd08..18898bebd 100644 --- a/src/consensus/consensus_api.c +++ b/src/consensus/consensus_api.c | |||
@@ -202,17 +202,17 @@ GNUNET_CONSENSUS_create (const struct GNUNET_CONFIGURATION_Handle *cfg, | |||
202 | GNUNET_CONSENSUS_ElementCallback new_element_cb, | 202 | GNUNET_CONSENSUS_ElementCallback new_element_cb, |
203 | void *new_element_cls) | 203 | void *new_element_cls) |
204 | { | 204 | { |
205 | GNUNET_MQ_hd_var_size (new_element, | ||
206 | GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_RECEIVED_ELEMENT, | ||
207 | struct GNUNET_CONSENSUS_ElementMessage); | ||
208 | GNUNET_MQ_hd_fixed_size (conclude_done, | ||
209 | GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_CONCLUDE_DONE, | ||
210 | struct GNUNET_MessageHeader); | ||
211 | struct GNUNET_CONSENSUS_Handle *consensus | 205 | struct GNUNET_CONSENSUS_Handle *consensus |
212 | = GNUNET_new (struct GNUNET_CONSENSUS_Handle); | 206 | = GNUNET_new (struct GNUNET_CONSENSUS_Handle); |
213 | struct GNUNET_MQ_MessageHandler mq_handlers[] = { | 207 | struct GNUNET_MQ_MessageHandler mq_handlers[] = { |
214 | make_new_element_handler (consensus), | 208 | GNUNET_MQ_hd_var_size (new_element, |
215 | make_conclude_done_handler (consensus), | 209 | GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_RECEIVED_ELEMENT, |
210 | struct GNUNET_CONSENSUS_ElementMessage, | ||
211 | consensus), | ||
212 | GNUNET_MQ_hd_fixed_size (conclude_done, | ||
213 | GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_CONCLUDE_DONE, | ||
214 | struct GNUNET_MessageHeader, | ||
215 | consensus), | ||
216 | GNUNET_MQ_handler_end () | 216 | GNUNET_MQ_handler_end () |
217 | }; | 217 | }; |
218 | struct GNUNET_CONSENSUS_JoinMessage *join_msg; | 218 | struct GNUNET_CONSENSUS_JoinMessage *join_msg; |
diff --git a/src/conversation/conversation_api.c b/src/conversation/conversation_api.c index 5dd9cf79e..8a74f0ca6 100644 --- a/src/conversation/conversation_api.c +++ b/src/conversation/conversation_api.c | |||
@@ -551,27 +551,27 @@ clean_up_callers (struct GNUNET_CONVERSATION_Phone *phone) | |||
551 | static void | 551 | static void |
552 | reconnect_phone (struct GNUNET_CONVERSATION_Phone *phone) | 552 | reconnect_phone (struct GNUNET_CONVERSATION_Phone *phone) |
553 | { | 553 | { |
554 | GNUNET_MQ_hd_fixed_size (phone_ring, | ||
555 | GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RING, | ||
556 | struct ClientPhoneRingMessage); | ||
557 | GNUNET_MQ_hd_fixed_size (phone_hangup, | ||
558 | GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_HANG_UP, | ||
559 | struct ClientPhoneHangupMessage); | ||
560 | GNUNET_MQ_hd_fixed_size (phone_suspend, | ||
561 | GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_SUSPEND, | ||
562 | struct ClientPhoneSuspendMessage); | ||
563 | GNUNET_MQ_hd_fixed_size (phone_resume, | ||
564 | GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RESUME, | ||
565 | struct ClientPhoneResumeMessage); | ||
566 | GNUNET_MQ_hd_var_size (phone_audio, | ||
567 | GNUNET_MESSAGE_TYPE_CONVERSATION_CS_AUDIO, | ||
568 | struct ClientAudioMessage); | ||
569 | struct GNUNET_MQ_MessageHandler handlers[] = { | 554 | struct GNUNET_MQ_MessageHandler handlers[] = { |
570 | make_phone_ring_handler (phone), | 555 | GNUNET_MQ_hd_fixed_size (phone_ring, |
571 | make_phone_hangup_handler (phone), | 556 | GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RING, |
572 | make_phone_suspend_handler (phone), | 557 | struct ClientPhoneRingMessage, |
573 | make_phone_resume_handler (phone), | 558 | phone), |
574 | make_phone_audio_handler (phone), | 559 | GNUNET_MQ_hd_fixed_size (phone_hangup, |
560 | GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_HANG_UP, | ||
561 | struct ClientPhoneHangupMessage, | ||
562 | phone), | ||
563 | GNUNET_MQ_hd_fixed_size (phone_suspend, | ||
564 | GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_SUSPEND, | ||
565 | struct ClientPhoneSuspendMessage, | ||
566 | phone), | ||
567 | GNUNET_MQ_hd_fixed_size (phone_resume, | ||
568 | GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RESUME, | ||
569 | struct ClientPhoneResumeMessage, | ||
570 | phone), | ||
571 | GNUNET_MQ_hd_var_size (phone_audio, | ||
572 | GNUNET_MESSAGE_TYPE_CONVERSATION_CS_AUDIO, | ||
573 | struct ClientAudioMessage, | ||
574 | phone), | ||
575 | GNUNET_MQ_handler_end () | 575 | GNUNET_MQ_handler_end () |
576 | }; | 576 | }; |
577 | struct GNUNET_MQ_Envelope *e; | 577 | struct GNUNET_MQ_Envelope *e; |
diff --git a/src/conversation/conversation_api_call.c b/src/conversation/conversation_api_call.c index af05f3ea6..17e26465e 100644 --- a/src/conversation/conversation_api_call.c +++ b/src/conversation/conversation_api_call.c | |||
@@ -543,29 +543,29 @@ GNUNET_CONVERSATION_call_start (const struct GNUNET_CONFIGURATION_Handle *cfg, | |||
543 | GNUNET_CONVERSATION_CallEventHandler event_handler, | 543 | GNUNET_CONVERSATION_CallEventHandler event_handler, |
544 | void *event_handler_cls) | 544 | void *event_handler_cls) |
545 | { | 545 | { |
546 | GNUNET_MQ_hd_fixed_size (call_suspend, | ||
547 | GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_SUSPEND, | ||
548 | struct ClientPhoneSuspendMessage); | ||
549 | GNUNET_MQ_hd_fixed_size (call_resume, | ||
550 | GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RESUME, | ||
551 | struct ClientPhoneResumeMessage); | ||
552 | GNUNET_MQ_hd_fixed_size (call_picked_up, | ||
553 | GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_PICKED_UP, | ||
554 | struct ClientPhonePickedupMessage); | ||
555 | GNUNET_MQ_hd_fixed_size (call_hangup, | ||
556 | GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_HANG_UP, | ||
557 | struct ClientPhoneHangupMessage); | ||
558 | GNUNET_MQ_hd_var_size (call_audio, | ||
559 | GNUNET_MESSAGE_TYPE_CONVERSATION_CS_AUDIO, | ||
560 | struct ClientAudioMessage); | ||
561 | struct GNUNET_CONVERSATION_Call *call | 546 | struct GNUNET_CONVERSATION_Call *call |
562 | = GNUNET_new (struct GNUNET_CONVERSATION_Call); | 547 | = GNUNET_new (struct GNUNET_CONVERSATION_Call); |
563 | struct GNUNET_MQ_MessageHandler handlers[] = { | 548 | struct GNUNET_MQ_MessageHandler handlers[] = { |
564 | make_call_suspend_handler (call), | 549 | GNUNET_MQ_hd_fixed_size (call_suspend, |
565 | make_call_resume_handler (call), | 550 | GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_SUSPEND, |
566 | make_call_picked_up_handler (call), | 551 | struct ClientPhoneSuspendMessage, |
567 | make_call_hangup_handler (call), | 552 | call), |
568 | make_call_audio_handler (call), | 553 | GNUNET_MQ_hd_fixed_size (call_resume, |
554 | GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RESUME, | ||
555 | struct ClientPhoneResumeMessage, | ||
556 | call), | ||
557 | GNUNET_MQ_hd_fixed_size (call_picked_up, | ||
558 | GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_PICKED_UP, | ||
559 | struct ClientPhonePickedupMessage, | ||
560 | call), | ||
561 | GNUNET_MQ_hd_fixed_size (call_hangup, | ||
562 | GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_HANG_UP, | ||
563 | struct ClientPhoneHangupMessage, | ||
564 | call), | ||
565 | GNUNET_MQ_hd_var_size (call_audio, | ||
566 | GNUNET_MESSAGE_TYPE_CONVERSATION_CS_AUDIO, | ||
567 | struct ClientAudioMessage, | ||
568 | call), | ||
569 | GNUNET_MQ_handler_end () | 569 | GNUNET_MQ_handler_end () |
570 | }; | 570 | }; |
571 | struct GNUNET_CRYPTO_EcdsaPublicKey my_zone; | 571 | struct GNUNET_CRYPTO_EcdsaPublicKey my_zone; |
diff --git a/src/core/core_api.c b/src/core/core_api.c index caf614afc..6055b99c1 100644 --- a/src/core/core_api.c +++ b/src/core/core_api.c | |||
@@ -767,31 +767,31 @@ handle_send_ready (void *cls, | |||
767 | static void | 767 | static void |
768 | reconnect (struct GNUNET_CORE_Handle *h) | 768 | reconnect (struct GNUNET_CORE_Handle *h) |
769 | { | 769 | { |
770 | GNUNET_MQ_hd_fixed_size (init_reply, | 770 | struct GNUNET_MQ_MessageHandler handlers[] = { |
771 | GNUNET_MESSAGE_TYPE_CORE_INIT_REPLY, | 771 | GNUNET_MQ_hd_fixed_size (init_reply, |
772 | struct InitReplyMessage); | 772 | GNUNET_MESSAGE_TYPE_CORE_INIT_REPLY, |
773 | GNUNET_MQ_hd_fixed_size (connect_notify, | 773 | struct InitReplyMessage, |
774 | GNUNET_MESSAGE_TYPE_CORE_NOTIFY_CONNECT, | 774 | h), |
775 | struct ConnectNotifyMessage); | 775 | GNUNET_MQ_hd_fixed_size (connect_notify, |
776 | GNUNET_MQ_hd_fixed_size (disconnect_notify, | 776 | GNUNET_MESSAGE_TYPE_CORE_NOTIFY_CONNECT, |
777 | GNUNET_MESSAGE_TYPE_CORE_NOTIFY_DISCONNECT, | 777 | struct ConnectNotifyMessage, |
778 | struct DisconnectNotifyMessage); | 778 | h), |
779 | GNUNET_MQ_hd_var_size (notify_inbound, | 779 | GNUNET_MQ_hd_fixed_size (disconnect_notify, |
780 | GNUNET_MESSAGE_TYPE_CORE_NOTIFY_INBOUND, | 780 | GNUNET_MESSAGE_TYPE_CORE_NOTIFY_DISCONNECT, |
781 | struct NotifyTrafficMessage); | 781 | struct DisconnectNotifyMessage, |
782 | GNUNET_MQ_hd_var_size (notify_outbound, | 782 | h), |
783 | GNUNET_MESSAGE_TYPE_CORE_NOTIFY_OUTBOUND, | 783 | GNUNET_MQ_hd_var_size (notify_inbound, |
784 | struct NotifyTrafficMessage); | 784 | GNUNET_MESSAGE_TYPE_CORE_NOTIFY_INBOUND, |
785 | GNUNET_MQ_hd_fixed_size (send_ready, | 785 | struct NotifyTrafficMessage, |
786 | GNUNET_MESSAGE_TYPE_CORE_SEND_READY, | 786 | h), |
787 | struct SendMessageReady); | 787 | GNUNET_MQ_hd_var_size (notify_outbound, |
788 | struct GNUNET_MQ_MessageHandler handlers[] = { | 788 | GNUNET_MESSAGE_TYPE_CORE_NOTIFY_OUTBOUND, |
789 | make_init_reply_handler (h), | 789 | struct NotifyTrafficMessage, |
790 | make_connect_notify_handler (h), | 790 | h), |
791 | make_disconnect_notify_handler (h), | 791 | GNUNET_MQ_hd_fixed_size (send_ready, |
792 | make_notify_inbound_handler (h), | 792 | GNUNET_MESSAGE_TYPE_CORE_SEND_READY, |
793 | make_notify_outbound_handler (h), | 793 | struct SendMessageReady, |
794 | make_send_ready_handler (h), | 794 | h), |
795 | GNUNET_MQ_handler_end () | 795 | GNUNET_MQ_handler_end () |
796 | }; | 796 | }; |
797 | struct InitMessage *init; | 797 | struct InitMessage *init; |
diff --git a/src/core/core_api_2.c b/src/core/core_api_2.c index 536fe597c..d810bf2ec 100644 --- a/src/core/core_api_2.c +++ b/src/core/core_api_2.c | |||
@@ -700,27 +700,27 @@ handle_send_ready (void *cls, | |||
700 | static void | 700 | static void |
701 | reconnect (struct GNUNET_CORE_Handle *h) | 701 | reconnect (struct GNUNET_CORE_Handle *h) |
702 | { | 702 | { |
703 | GNUNET_MQ_hd_fixed_size (init_reply, | ||
704 | GNUNET_MESSAGE_TYPE_CORE_INIT_REPLY, | ||
705 | struct InitReplyMessage); | ||
706 | GNUNET_MQ_hd_fixed_size (connect_notify, | ||
707 | GNUNET_MESSAGE_TYPE_CORE_NOTIFY_CONNECT, | ||
708 | struct ConnectNotifyMessage); | ||
709 | GNUNET_MQ_hd_fixed_size (disconnect_notify, | ||
710 | GNUNET_MESSAGE_TYPE_CORE_NOTIFY_DISCONNECT, | ||
711 | struct DisconnectNotifyMessage); | ||
712 | GNUNET_MQ_hd_var_size (notify_inbound, | ||
713 | GNUNET_MESSAGE_TYPE_CORE_NOTIFY_INBOUND, | ||
714 | struct NotifyTrafficMessage); | ||
715 | GNUNET_MQ_hd_fixed_size (send_ready, | ||
716 | GNUNET_MESSAGE_TYPE_CORE_SEND_READY, | ||
717 | struct SendMessageReady); | ||
718 | struct GNUNET_MQ_MessageHandler handlers[] = { | 703 | struct GNUNET_MQ_MessageHandler handlers[] = { |
719 | make_init_reply_handler (h), | 704 | GNUNET_MQ_hd_fixed_size (init_reply, |
720 | make_connect_notify_handler (h), | 705 | GNUNET_MESSAGE_TYPE_CORE_INIT_REPLY, |
721 | make_disconnect_notify_handler (h), | 706 | struct InitReplyMessage, |
722 | make_notify_inbound_handler (h), | 707 | h), |
723 | make_send_ready_handler (h), | 708 | GNUNET_MQ_hd_fixed_size (connect_notify, |
709 | GNUNET_MESSAGE_TYPE_CORE_NOTIFY_CONNECT, | ||
710 | struct ConnectNotifyMessage, | ||
711 | h), | ||
712 | GNUNET_MQ_hd_fixed_size (disconnect_notify, | ||
713 | GNUNET_MESSAGE_TYPE_CORE_NOTIFY_DISCONNECT, | ||
714 | struct DisconnectNotifyMessage, | ||
715 | h), | ||
716 | GNUNET_MQ_hd_var_size (notify_inbound, | ||
717 | GNUNET_MESSAGE_TYPE_CORE_NOTIFY_INBOUND, | ||
718 | struct NotifyTrafficMessage, | ||
719 | h), | ||
720 | GNUNET_MQ_hd_fixed_size (send_ready, | ||
721 | GNUNET_MESSAGE_TYPE_CORE_SEND_READY, | ||
722 | struct SendMessageReady, | ||
723 | h), | ||
724 | GNUNET_MQ_handler_end () | 724 | GNUNET_MQ_handler_end () |
725 | }; | 725 | }; |
726 | struct InitMessage *init; | 726 | struct InitMessage *init; |
diff --git a/src/core/core_api_monitor_peers.c b/src/core/core_api_monitor_peers.c index bafcd3e94..1455eb2b0 100644 --- a/src/core/core_api_monitor_peers.c +++ b/src/core/core_api_monitor_peers.c | |||
@@ -114,11 +114,11 @@ handle_receive_info (void *cls, | |||
114 | static void | 114 | static void |
115 | reconnect (struct GNUNET_CORE_MonitorHandle *mh) | 115 | reconnect (struct GNUNET_CORE_MonitorHandle *mh) |
116 | { | 116 | { |
117 | GNUNET_MQ_hd_fixed_size (receive_info, | ||
118 | GNUNET_MESSAGE_TYPE_CORE_MONITOR_NOTIFY, | ||
119 | struct MonitorNotifyMessage); | ||
120 | struct GNUNET_MQ_MessageHandler handlers[] = { | 117 | struct GNUNET_MQ_MessageHandler handlers[] = { |
121 | make_receive_info_handler (mh), | 118 | GNUNET_MQ_hd_fixed_size (receive_info, |
119 | GNUNET_MESSAGE_TYPE_CORE_MONITOR_NOTIFY, | ||
120 | struct MonitorNotifyMessage, | ||
121 | mh), | ||
122 | GNUNET_MQ_handler_end () | 122 | GNUNET_MQ_handler_end () |
123 | }; | 123 | }; |
124 | struct GNUNET_MQ_Envelope *env; | 124 | struct GNUNET_MQ_Envelope *env; |
diff --git a/src/core/gnunet-service-core_kx.c b/src/core/gnunet-service-core_kx.c index b2949a688..6f6786d89 100644 --- a/src/core/gnunet-service-core_kx.c +++ b/src/core/gnunet-service-core_kx.c | |||
@@ -1814,23 +1814,23 @@ int | |||
1814 | GSC_KX_init (struct GNUNET_CRYPTO_EddsaPrivateKey *pk, | 1814 | GSC_KX_init (struct GNUNET_CRYPTO_EddsaPrivateKey *pk, |
1815 | struct GNUNET_SERVER_Handle *server) | 1815 | struct GNUNET_SERVER_Handle *server) |
1816 | { | 1816 | { |
1817 | GNUNET_MQ_hd_fixed_size (ephemeral_key, | ||
1818 | GNUNET_MESSAGE_TYPE_CORE_EPHEMERAL_KEY, | ||
1819 | struct EphemeralKeyMessage); | ||
1820 | GNUNET_MQ_hd_fixed_size (ping, | ||
1821 | GNUNET_MESSAGE_TYPE_CORE_PING, | ||
1822 | struct PingMessage); | ||
1823 | GNUNET_MQ_hd_fixed_size (pong, | ||
1824 | GNUNET_MESSAGE_TYPE_CORE_PONG, | ||
1825 | struct PongMessage); | ||
1826 | GNUNET_MQ_hd_var_size (encrypted, | ||
1827 | GNUNET_MESSAGE_TYPE_CORE_ENCRYPTED_MESSAGE, | ||
1828 | struct EncryptedMessage); | ||
1829 | struct GNUNET_MQ_MessageHandler handlers[] = { | 1817 | struct GNUNET_MQ_MessageHandler handlers[] = { |
1830 | make_ephemeral_key_handler (NULL), | 1818 | GNUNET_MQ_hd_fixed_size (ephemeral_key, |
1831 | make_ping_handler (NULL), | 1819 | GNUNET_MESSAGE_TYPE_CORE_EPHEMERAL_KEY, |
1832 | make_pong_handler (NULL), | 1820 | struct EphemeralKeyMessage, |
1833 | make_encrypted_handler (NULL), | 1821 | NULL), |
1822 | GNUNET_MQ_hd_fixed_size (ping, | ||
1823 | GNUNET_MESSAGE_TYPE_CORE_PING, | ||
1824 | struct PingMessage, | ||
1825 | NULL), | ||
1826 | GNUNET_MQ_hd_fixed_size (pong, | ||
1827 | GNUNET_MESSAGE_TYPE_CORE_PONG, | ||
1828 | struct PongMessage, | ||
1829 | NULL), | ||
1830 | GNUNET_MQ_hd_var_size (encrypted, | ||
1831 | GNUNET_MESSAGE_TYPE_CORE_ENCRYPTED_MESSAGE, | ||
1832 | struct EncryptedMessage, | ||
1833 | NULL), | ||
1834 | GNUNET_MQ_handler_end() | 1834 | GNUNET_MQ_handler_end() |
1835 | }; | 1835 | }; |
1836 | 1836 | ||
diff --git a/src/core/test_core_api.c b/src/core/test_core_api.c index 772ded991..650c89cda 100644 --- a/src/core/test_core_api.c +++ b/src/core/test_core_api.c | |||
@@ -225,12 +225,12 @@ static void | |||
225 | init_notify (void *cls, | 225 | init_notify (void *cls, |
226 | const struct GNUNET_PeerIdentity *my_identity) | 226 | const struct GNUNET_PeerIdentity *my_identity) |
227 | { | 227 | { |
228 | GNUNET_MQ_hd_fixed_size (test, | ||
229 | MTYPE, | ||
230 | struct GNUNET_MessageHeader); | ||
231 | struct PeerContext *p = cls; | 228 | struct PeerContext *p = cls; |
232 | struct GNUNET_MQ_MessageHandler handlers[] = { | 229 | struct GNUNET_MQ_MessageHandler handlers[] = { |
233 | make_test_handler (NULL), | 230 | GNUNET_MQ_hd_fixed_size (test, |
231 | MTYPE, | ||
232 | struct GNUNET_MessageHeader, | ||
233 | NULL); | ||
234 | GNUNET_MQ_handler_end () | 234 | GNUNET_MQ_handler_end () |
235 | }; | 235 | }; |
236 | 236 | ||
@@ -298,11 +298,11 @@ run (void *cls, | |||
298 | const char *cfgfile, | 298 | const char *cfgfile, |
299 | const struct GNUNET_CONFIGURATION_Handle *cfg) | 299 | const struct GNUNET_CONFIGURATION_Handle *cfg) |
300 | { | 300 | { |
301 | GNUNET_MQ_hd_fixed_size (test, | ||
302 | MTYPE, | ||
303 | struct GNUNET_MessageHeader); | ||
304 | struct GNUNET_MQ_MessageHandler handlers[] = { | 301 | struct GNUNET_MQ_MessageHandler handlers[] = { |
305 | make_test_handler (NULL), | 302 | GNUNET_MQ_hd_fixed_size (test, |
303 | MTYPE, | ||
304 | struct GNUNET_MessageHeader, | ||
305 | NULL); | ||
306 | GNUNET_MQ_handler_end () | 306 | GNUNET_MQ_handler_end () |
307 | }; | 307 | }; |
308 | 308 | ||
diff --git a/src/core/test_core_api_reliability.c b/src/core/test_core_api_reliability.c index d7d4a6bd6..4d8d54028 100644 --- a/src/core/test_core_api_reliability.c +++ b/src/core/test_core_api_reliability.c | |||
@@ -322,12 +322,12 @@ static void | |||
322 | init_notify (void *cls, | 322 | init_notify (void *cls, |
323 | const struct GNUNET_PeerIdentity *my_identity) | 323 | const struct GNUNET_PeerIdentity *my_identity) |
324 | { | 324 | { |
325 | GNUNET_MQ_hd_var_size (test, | ||
326 | MTYPE, | ||
327 | struct TestMessage); | ||
328 | struct PeerContext *p = cls; | 325 | struct PeerContext *p = cls; |
329 | struct GNUNET_MQ_MessageHandler handlers[] = { | 326 | struct GNUNET_MQ_MessageHandler handlers[] = { |
330 | make_test_handler (NULL), | 327 | GNUNET_MQ_hd_var_size (test, |
328 | MTYPE, | ||
329 | struct TestMessage, | ||
330 | NULL); | ||
331 | GNUNET_MQ_handler_end () | 331 | GNUNET_MQ_handler_end () |
332 | }; | 332 | }; |
333 | 333 | ||
@@ -442,11 +442,11 @@ run (void *cls, | |||
442 | const char *cfgfile, | 442 | const char *cfgfile, |
443 | const struct GNUNET_CONFIGURATION_Handle *cfg) | 443 | const struct GNUNET_CONFIGURATION_Handle *cfg) |
444 | { | 444 | { |
445 | GNUNET_MQ_hd_fixed_size (test, | ||
446 | MTYPE, | ||
447 | struct TestMessage); | ||
448 | struct GNUNET_MQ_MessageHandler handlers[] = { | 445 | struct GNUNET_MQ_MessageHandler handlers[] = { |
449 | make_test_handler (NULL), | 446 | GNUNET_MQ_hd_fixed_size (test, |
447 | MTYPE, | ||
448 | struct TestMessage, | ||
449 | NULL); | ||
450 | GNUNET_MQ_handler_end () | 450 | GNUNET_MQ_handler_end () |
451 | }; | 451 | }; |
452 | 452 | ||
diff --git a/src/core/test_core_api_send_to_self.c b/src/core/test_core_api_send_to_self.c index 111aea900..d29da651b 100644 --- a/src/core/test_core_api_send_to_self.c +++ b/src/core/test_core_api_send_to_self.c | |||
@@ -150,11 +150,11 @@ run (void *cls, | |||
150 | const struct GNUNET_CONFIGURATION_Handle *cfg, | 150 | const struct GNUNET_CONFIGURATION_Handle *cfg, |
151 | struct GNUNET_TESTING_Peer *peer) | 151 | struct GNUNET_TESTING_Peer *peer) |
152 | { | 152 | { |
153 | GNUNET_MQ_hd_fixed_size (test, | ||
154 | GNUNET_MESSAGE_TYPE_DUMMY, | ||
155 | struct GNUNET_MessageHeader); | ||
156 | struct GNUNET_MQ_MessageHandler handlers[] = { | 153 | struct GNUNET_MQ_MessageHandler handlers[] = { |
157 | make_test_handler (NULL), | 154 | GNUNET_MQ_hd_fixed_size (test, |
155 | GNUNET_MESSAGE_TYPE_DUMMY, | ||
156 | struct GNUNET_MessageHeader, | ||
157 | NULL), | ||
158 | GNUNET_MQ_handler_end () | 158 | GNUNET_MQ_handler_end () |
159 | }; | 159 | }; |
160 | 160 | ||
diff --git a/src/core/test_core_quota_compliance.c b/src/core/test_core_quota_compliance.c index 31063b814..4dee958f2 100644 --- a/src/core/test_core_quota_compliance.c +++ b/src/core/test_core_quota_compliance.c | |||
@@ -461,12 +461,12 @@ static void | |||
461 | init_notify (void *cls, | 461 | init_notify (void *cls, |
462 | const struct GNUNET_PeerIdentity *my_identity) | 462 | const struct GNUNET_PeerIdentity *my_identity) |
463 | { | 463 | { |
464 | GNUNET_MQ_hd_fixed_size (test, | ||
465 | MTYPE, | ||
466 | struct TestMessage); | ||
467 | struct PeerContext *p = cls; | 464 | struct PeerContext *p = cls; |
468 | struct GNUNET_MQ_MessageHandler handlers[] = { | 465 | struct GNUNET_MQ_MessageHandler handlers[] = { |
469 | make_test_handler (NULL), | 466 | GNUNET_MQ_hd_fixed_size (test, |
467 | MTYPE, | ||
468 | struct TestMessage, | ||
469 | NULL), | ||
470 | GNUNET_MQ_handler_end () | 470 | GNUNET_MQ_handler_end () |
471 | }; | 471 | }; |
472 | 472 | ||
@@ -593,11 +593,11 @@ run (void *cls, | |||
593 | const char *cfgfile, | 593 | const char *cfgfile, |
594 | const struct GNUNET_CONFIGURATION_Handle *cfg) | 594 | const struct GNUNET_CONFIGURATION_Handle *cfg) |
595 | { | 595 | { |
596 | GNUNET_MQ_hd_fixed_size (test, | ||
597 | MTYPE, | ||
598 | struct TestMessage); | ||
599 | struct GNUNET_MQ_MessageHandler handlers[] = { | 596 | struct GNUNET_MQ_MessageHandler handlers[] = { |
600 | make_test_handler (NULL), | 597 | GNUNET_MQ_hd_fixed_size (test, |
598 | MTYPE, | ||
599 | struct TestMessage, | ||
600 | NULL), | ||
601 | GNUNET_MQ_handler_end () | 601 | GNUNET_MQ_handler_end () |
602 | }; | 602 | }; |
603 | 603 | ||
diff --git a/src/datastore/datastore_api.c b/src/datastore/datastore_api.c index 3f8ef9db4..d75a58552 100644 --- a/src/datastore/datastore_api.c +++ b/src/datastore/datastore_api.c | |||
@@ -848,20 +848,20 @@ handle_data_end (void *cls, | |||
848 | static void | 848 | static void |
849 | try_reconnect (void *cls) | 849 | try_reconnect (void *cls) |
850 | { | 850 | { |
851 | GNUNET_MQ_hd_var_size (status, | ||
852 | GNUNET_MESSAGE_TYPE_DATASTORE_STATUS, | ||
853 | struct StatusMessage); | ||
854 | GNUNET_MQ_hd_var_size (data, | ||
855 | GNUNET_MESSAGE_TYPE_DATASTORE_DATA, | ||
856 | struct DataMessage); | ||
857 | GNUNET_MQ_hd_fixed_size (data_end, | ||
858 | GNUNET_MESSAGE_TYPE_DATASTORE_DATA_END, | ||
859 | struct GNUNET_MessageHeader); | ||
860 | struct GNUNET_DATASTORE_Handle *h = cls; | 851 | struct GNUNET_DATASTORE_Handle *h = cls; |
861 | struct GNUNET_MQ_MessageHandler handlers[] = { | 852 | struct GNUNET_MQ_MessageHandler handlers[] = { |
862 | make_status_handler (h), | 853 | GNUNET_MQ_hd_var_size (status, |
863 | make_data_handler (h), | 854 | GNUNET_MESSAGE_TYPE_DATASTORE_STATUS, |
864 | make_data_end_handler (h), | 855 | struct StatusMessage, |
856 | h), | ||
857 | GNUNET_MQ_hd_var_size (data, | ||
858 | GNUNET_MESSAGE_TYPE_DATASTORE_DATA, | ||
859 | struct DataMessage, | ||
860 | h), | ||
861 | GNUNET_MQ_hd_fixed_size (data_end, | ||
862 | GNUNET_MESSAGE_TYPE_DATASTORE_DATA_END, | ||
863 | struct GNUNET_MessageHeader, | ||
864 | h), | ||
865 | GNUNET_MQ_handler_end () | 865 | GNUNET_MQ_handler_end () |
866 | }; | 866 | }; |
867 | 867 | ||
diff --git a/src/dht/dht_api.c b/src/dht/dht_api.c index 0ada41662..57880165e 100644 --- a/src/dht/dht_api.c +++ b/src/dht/dht_api.c | |||
@@ -842,27 +842,27 @@ handle_put_confirmation (void *cls, | |||
842 | static int | 842 | static int |
843 | try_connect (struct GNUNET_DHT_Handle *h) | 843 | try_connect (struct GNUNET_DHT_Handle *h) |
844 | { | 844 | { |
845 | GNUNET_MQ_hd_var_size (monitor_get, | ||
846 | GNUNET_MESSAGE_TYPE_DHT_MONITOR_GET, | ||
847 | struct GNUNET_DHT_MonitorGetMessage); | ||
848 | GNUNET_MQ_hd_var_size (monitor_get_resp, | ||
849 | GNUNET_MESSAGE_TYPE_DHT_MONITOR_GET_RESP, | ||
850 | struct GNUNET_DHT_MonitorGetRespMessage); | ||
851 | GNUNET_MQ_hd_var_size (monitor_put, | ||
852 | GNUNET_MESSAGE_TYPE_DHT_MONITOR_PUT, | ||
853 | struct GNUNET_DHT_MonitorPutMessage); | ||
854 | GNUNET_MQ_hd_var_size (client_result, | ||
855 | GNUNET_MESSAGE_TYPE_DHT_CLIENT_RESULT, | ||
856 | struct GNUNET_DHT_ClientResultMessage); | ||
857 | GNUNET_MQ_hd_fixed_size (put_confirmation, | ||
858 | GNUNET_MESSAGE_TYPE_DHT_CLIENT_PUT_OK, | ||
859 | struct GNUNET_DHT_ClientPutConfirmationMessage); | ||
860 | struct GNUNET_MQ_MessageHandler handlers[] = { | 845 | struct GNUNET_MQ_MessageHandler handlers[] = { |
861 | make_monitor_get_handler (h), | 846 | GNUNET_MQ_hd_var_size (monitor_get, |
862 | make_monitor_get_resp_handler (h), | 847 | GNUNET_MESSAGE_TYPE_DHT_MONITOR_GET, |
863 | make_monitor_put_handler (h), | 848 | struct GNUNET_DHT_MonitorGetMessage, |
864 | make_client_result_handler (h), | 849 | h), |
865 | make_put_confirmation_handler (h), | 850 | GNUNET_MQ_hd_var_size (monitor_get_resp, |
851 | GNUNET_MESSAGE_TYPE_DHT_MONITOR_GET_RESP, | ||
852 | struct GNUNET_DHT_MonitorGetRespMessage, | ||
853 | h), | ||
854 | GNUNET_MQ_hd_var_size (monitor_put, | ||
855 | GNUNET_MESSAGE_TYPE_DHT_MONITOR_PUT, | ||
856 | struct GNUNET_DHT_MonitorPutMessage, | ||
857 | h), | ||
858 | GNUNET_MQ_hd_var_size (client_result, | ||
859 | GNUNET_MESSAGE_TYPE_DHT_CLIENT_RESULT, | ||
860 | struct GNUNET_DHT_ClientResultMessage, | ||
861 | h), | ||
862 | GNUNET_MQ_hd_fixed_size (put_confirmation, | ||
863 | GNUNET_MESSAGE_TYPE_DHT_CLIENT_PUT_OK, | ||
864 | struct GNUNET_DHT_ClientPutConfirmationMessage, | ||
865 | h), | ||
866 | GNUNET_MQ_handler_end () | 866 | GNUNET_MQ_handler_end () |
867 | }; | 867 | }; |
868 | if (NULL != h->mq) | 868 | if (NULL != h->mq) |
diff --git a/src/dht/gnunet-service-dht_neighbours.c b/src/dht/gnunet-service-dht_neighbours.c index 2dd6c800b..683e0991a 100644 --- a/src/dht/gnunet-service-dht_neighbours.c +++ b/src/dht/gnunet-service-dht_neighbours.c | |||
@@ -2298,19 +2298,19 @@ handle_dht_p2p_result (void *cls, | |||
2298 | int | 2298 | int |
2299 | GDS_NEIGHBOURS_init () | 2299 | GDS_NEIGHBOURS_init () |
2300 | { | 2300 | { |
2301 | GNUNET_MQ_hd_var_size (dht_p2p_get, | ||
2302 | GNUNET_MESSAGE_TYPE_DHT_P2P_GET, | ||
2303 | struct PeerGetMessage); | ||
2304 | GNUNET_MQ_hd_var_size (dht_p2p_put, | ||
2305 | GNUNET_MESSAGE_TYPE_DHT_P2P_PUT, | ||
2306 | struct PeerPutMessage); | ||
2307 | GNUNET_MQ_hd_var_size (dht_p2p_result, | ||
2308 | GNUNET_MESSAGE_TYPE_DHT_P2P_RESULT, | ||
2309 | struct PeerResultMessage); | ||
2310 | struct GNUNET_MQ_MessageHandler core_handlers[] = { | 2301 | struct GNUNET_MQ_MessageHandler core_handlers[] = { |
2311 | make_dht_p2p_get_handler (NULL), | 2302 | GNUNET_MQ_hd_var_size (dht_p2p_get, |
2312 | make_dht_p2p_put_handler (NULL), | 2303 | GNUNET_MESSAGE_TYPE_DHT_P2P_GET, |
2313 | make_dht_p2p_result_handler (NULL), | 2304 | struct PeerGetMessage, |
2305 | NULL), | ||
2306 | GNUNET_MQ_hd_var_size (dht_p2p_put, | ||
2307 | GNUNET_MESSAGE_TYPE_DHT_P2P_PUT, | ||
2308 | struct PeerPutMessage, | ||
2309 | NULL), | ||
2310 | GNUNET_MQ_hd_var_size (dht_p2p_result, | ||
2311 | GNUNET_MESSAGE_TYPE_DHT_P2P_RESULT, | ||
2312 | struct PeerResultMessage, | ||
2313 | NULL), | ||
2314 | GNUNET_MQ_handler_end () | 2314 | GNUNET_MQ_handler_end () |
2315 | }; | 2315 | }; |
2316 | unsigned long long temp_config_num; | 2316 | unsigned long long temp_config_num; |
diff --git a/src/dht/gnunet-service-wdht_neighbours.c b/src/dht/gnunet-service-wdht_neighbours.c index 1d5fd67c0..a6ebdb033 100644 --- a/src/dht/gnunet-service-wdht_neighbours.c +++ b/src/dht/gnunet-service-wdht_neighbours.c | |||
@@ -1666,23 +1666,23 @@ handle_dht_p2p_trail_route (void *cls, | |||
1666 | int | 1666 | int |
1667 | GDS_NEIGHBOURS_init (void) | 1667 | GDS_NEIGHBOURS_init (void) |
1668 | { | 1668 | { |
1669 | GNUNET_MQ_hd_fixed_size (dht_p2p_random_walk, | ||
1670 | GNUNET_MESSAGE_TYPE_WDHT_RANDOM_WALK, | ||
1671 | struct RandomWalkMessage); | ||
1672 | GNUNET_MQ_hd_fixed_size (dht_p2p_random_walk_response, | ||
1673 | GNUNET_MESSAGE_TYPE_WDHT_RANDOM_WALK_RESPONSE, | ||
1674 | struct RandomWalkResponseMessage); | ||
1675 | GNUNET_MQ_hd_fixed_size (dht_p2p_trail_destroy, | ||
1676 | GNUNET_MESSAGE_TYPE_WDHT_TRAIL_DESTROY, | ||
1677 | struct TrailDestroyMessage); | ||
1678 | GNUNET_MQ_hd_var_size (dht_p2p_trail_route, | ||
1679 | GNUNET_MESSAGE_TYPE_WDHT_TRAIL_ROUTE, | ||
1680 | struct TrailRouteMessage); | ||
1681 | struct GNUNET_MQ_MessageHandler core_handlers[] = { | 1669 | struct GNUNET_MQ_MessageHandler core_handlers[] = { |
1682 | make_dht_p2p_random_walk_handler (NULL), | 1670 | GNUNET_MQ_hd_fixed_size (dht_p2p_random_walk, |
1683 | make_dht_p2p_random_walk_response_handler (NULL), | 1671 | GNUNET_MESSAGE_TYPE_WDHT_RANDOM_WALK, |
1684 | make_dht_p2p_trail_destroy_handler (NULL), | 1672 | struct RandomWalkMessage, |
1685 | make_dht_p2p_trail_route_handler (NULL), | 1673 | NULL), |
1674 | GNUNET_MQ_hd_fixed_size (dht_p2p_random_walk_response, | ||
1675 | GNUNET_MESSAGE_TYPE_WDHT_RANDOM_WALK_RESPONSE, | ||
1676 | struct RandomWalkResponseMessage, | ||
1677 | NULL), | ||
1678 | GNUNET_MQ_hd_fixed_size (dht_p2p_trail_destroy, | ||
1679 | GNUNET_MESSAGE_TYPE_WDHT_TRAIL_DESTROY, | ||
1680 | struct TrailDestroyMessage, | ||
1681 | NULL), | ||
1682 | GNUNET_MQ_hd_var_size (dht_p2p_trail_route, | ||
1683 | GNUNET_MESSAGE_TYPE_WDHT_TRAIL_ROUTE, | ||
1684 | struct TrailRouteMessage, | ||
1685 | NULL), | ||
1686 | GNUNET_MQ_handler_end () | 1686 | GNUNET_MQ_handler_end () |
1687 | }; | 1687 | }; |
1688 | 1688 | ||
diff --git a/src/dht/gnunet-service-xdht_neighbours.c b/src/dht/gnunet-service-xdht_neighbours.c index 7bfc11918..9ae39e0a0 100644 --- a/src/dht/gnunet-service-xdht_neighbours.c +++ b/src/dht/gnunet-service-xdht_neighbours.c | |||
@@ -6039,55 +6039,55 @@ finger_table_init () | |||
6039 | int | 6039 | int |
6040 | GDS_NEIGHBOURS_init (void) | 6040 | GDS_NEIGHBOURS_init (void) |
6041 | { | 6041 | { |
6042 | GNUNET_MQ_hd_var_size (dht_p2p_put, | ||
6043 | GNUNET_MESSAGE_TYPE_XDHT_P2P_PUT, | ||
6044 | struct PeerPutMessage); | ||
6045 | GNUNET_MQ_hd_var_size (dht_p2p_get, | ||
6046 | GNUNET_MESSAGE_TYPE_XDHT_P2P_GET, | ||
6047 | struct PeerGetMessage); | ||
6048 | GNUNET_MQ_hd_var_size (dht_p2p_get_result, | ||
6049 | GNUNET_MESSAGE_TYPE_XDHT_P2P_GET_RESULT, | ||
6050 | struct PeerGetResultMessage); | ||
6051 | GNUNET_MQ_hd_var_size (dht_p2p_trail_setup, | ||
6052 | GNUNET_MESSAGE_TYPE_XDHT_P2P_TRAIL_SETUP, | ||
6053 | struct PeerTrailSetupMessage); | ||
6054 | GNUNET_MQ_hd_var_size (dht_p2p_trail_setup_result, | ||
6055 | GNUNET_MESSAGE_TYPE_XDHT_P2P_TRAIL_SETUP_RESULT, | ||
6056 | struct PeerTrailSetupResultMessage); | ||
6057 | GNUNET_MQ_hd_var_size (dht_p2p_verify_successor, | ||
6058 | GNUNET_MESSAGE_TYPE_XDHT_P2P_VERIFY_SUCCESSOR, | ||
6059 | struct PeerVerifySuccessorMessage); | ||
6060 | GNUNET_MQ_hd_var_size (dht_p2p_verify_successor_result, | ||
6061 | GNUNET_MESSAGE_TYPE_XDHT_P2P_VERIFY_SUCCESSOR_RESULT, | ||
6062 | struct PeerVerifySuccessorResultMessage); | ||
6063 | GNUNET_MQ_hd_var_size (dht_p2p_notify_new_successor, | ||
6064 | GNUNET_MESSAGE_TYPE_XDHT_P2P_NOTIFY_NEW_SUCCESSOR, | ||
6065 | struct PeerNotifyNewSuccessorMessage); | ||
6066 | GNUNET_MQ_hd_var_size (dht_p2p_trail_setup_rejection, | ||
6067 | GNUNET_MESSAGE_TYPE_XDHT_P2P_TRAIL_SETUP_REJECTION, | ||
6068 | struct PeerTrailRejectionMessage); | ||
6069 | GNUNET_MQ_hd_fixed_size (dht_p2p_trail_teardown, | ||
6070 | GNUNET_MESSAGE_TYPE_XDHT_P2P_TRAIL_TEARDOWN, | ||
6071 | struct PeerTrailTearDownMessage); | ||
6072 | GNUNET_MQ_hd_var_size (dht_p2p_add_trail, | ||
6073 | GNUNET_MESSAGE_TYPE_XDHT_P2P_ADD_TRAIL, | ||
6074 | struct PeerAddTrailMessage); | ||
6075 | GNUNET_MQ_hd_fixed_size (dht_p2p_notify_succ_confirmation, | ||
6076 | GNUNET_MESSAGE_TYPE_XDHT_P2P_NOTIFY_SUCCESSOR_CONFIRMATION, | ||
6077 | struct PeerNotifyConfirmationMessage); | ||
6078 | struct GNUNET_MQ_MessageHandler core_handlers[] = { | 6042 | struct GNUNET_MQ_MessageHandler core_handlers[] = { |
6079 | make_dht_p2p_put_handler (NULL), | 6043 | GNUNET_MQ_hd_var_size (dht_p2p_put, |
6080 | make_dht_p2p_get_handler (NULL), | 6044 | GNUNET_MESSAGE_TYPE_XDHT_P2P_PUT, |
6081 | make_dht_p2p_get_result_handler (NULL), | 6045 | struct PeerPutMessage, |
6082 | make_dht_p2p_trail_setup_handler (NULL), | 6046 | NULL), |
6083 | make_dht_p2p_trail_setup_result_handler (NULL), | 6047 | GNUNET_MQ_hd_var_size (dht_p2p_get, |
6084 | make_dht_p2p_verify_successor_handler (NULL), | 6048 | GNUNET_MESSAGE_TYPE_XDHT_P2P_GET, |
6085 | make_dht_p2p_verify_successor_result_handler (NULL), | 6049 | struct PeerGetMessage, |
6086 | make_dht_p2p_notify_new_successor_handler (NULL), | 6050 | NULL), |
6087 | make_dht_p2p_trail_setup_rejection_handler (NULL), | 6051 | GNUNET_MQ_hd_var_size (dht_p2p_get_result, |
6088 | make_dht_p2p_trail_teardown_handler (NULL), | 6052 | GNUNET_MESSAGE_TYPE_XDHT_P2P_GET_RESULT, |
6089 | make_dht_p2p_add_trail_handler (NULL), | 6053 | struct PeerGetResultMessage, |
6090 | make_dht_p2p_notify_succ_confirmation_handler (NULL), | 6054 | NULL), |
6055 | GNUNET_MQ_hd_var_size (dht_p2p_trail_setup, | ||
6056 | GNUNET_MESSAGE_TYPE_XDHT_P2P_TRAIL_SETUP, | ||
6057 | struct PeerTrailSetupMessage, | ||
6058 | NULL), | ||
6059 | GNUNET_MQ_hd_var_size (dht_p2p_trail_setup_result, | ||
6060 | GNUNET_MESSAGE_TYPE_XDHT_P2P_TRAIL_SETUP_RESULT, | ||
6061 | struct PeerTrailSetupResultMessag, | ||
6062 | NULL), | ||
6063 | GNUNET_MQ_hd_var_size (dht_p2p_verify_successor, | ||
6064 | GNUNET_MESSAGE_TYPE_XDHT_P2P_VERIFY_SUCCESSOR, | ||
6065 | struct PeerVerifySuccessorMessage, | ||
6066 | NULL), | ||
6067 | GNUNET_MQ_hd_var_size (dht_p2p_verify_successor_result, | ||
6068 | GNUNET_MESSAGE_TYPE_XDHT_P2P_VERIFY_SUCCESSOR_RESULT, | ||
6069 | struct PeerVerifySuccessorResultMessage, | ||
6070 | NULL), | ||
6071 | GNUNET_MQ_hd_var_size (dht_p2p_notify_new_successor, | ||
6072 | GNUNET_MESSAGE_TYPE_XDHT_P2P_NOTIFY_NEW_SUCCESSOR, | ||
6073 | struct PeerNotifyNewSuccessorMessage, | ||
6074 | NULL), | ||
6075 | GNUNET_MQ_hd_var_size (dht_p2p_trail_setup_rejection, | ||
6076 | GNUNET_MESSAGE_TYPE_XDHT_P2P_TRAIL_SETUP_REJECTION, | ||
6077 | struct PeerTrailRejectionMessage, | ||
6078 | NULL), | ||
6079 | GNUNET_MQ_hd_fixed_size (dht_p2p_trail_teardown, | ||
6080 | GNUNET_MESSAGE_TYPE_XDHT_P2P_TRAIL_TEARDOWN, | ||
6081 | struct PeerTrailTearDownMessage, | ||
6082 | NULL), | ||
6083 | GNUNET_MQ_hd_var_size (dht_p2p_add_trail, | ||
6084 | GNUNET_MESSAGE_TYPE_XDHT_P2P_ADD_TRAIL, | ||
6085 | struct PeerAddTrailMessage, | ||
6086 | NULL), | ||
6087 | GNUNET_MQ_hd_fixed_size (dht_p2p_notify_succ_confirmation, | ||
6088 | GNUNET_MESSAGE_TYPE_XDHT_P2P_NOTIFY_SUCCESSOR_CONFIRMATION, | ||
6089 | struct PeerNotifyConfirmationMessage, | ||
6090 | NULL), | ||
6091 | GNUNET_MQ_handler_end () | 6091 | GNUNET_MQ_handler_end () |
6092 | }; | 6092 | }; |
6093 | 6093 | ||
diff --git a/src/dns/dns_api.c b/src/dns/dns_api.c index 08d5df4a1..4803fe3fc 100644 --- a/src/dns/dns_api.c +++ b/src/dns/dns_api.c | |||
@@ -205,12 +205,12 @@ handle_request (void *cls, | |||
205 | static void | 205 | static void |
206 | reconnect (void *cls) | 206 | reconnect (void *cls) |
207 | { | 207 | { |
208 | GNUNET_MQ_hd_var_size (request, | ||
209 | GNUNET_MESSAGE_TYPE_DNS_CLIENT_REQUEST, | ||
210 | struct GNUNET_DNS_Request); | ||
211 | struct GNUNET_DNS_Handle *dh = cls; | 208 | struct GNUNET_DNS_Handle *dh = cls; |
212 | struct GNUNET_MQ_MessageHandler handlers[] = { | 209 | struct GNUNET_MQ_MessageHandler handlers[] = { |
213 | make_request_handler (dh), | 210 | GNUNET_MQ_hd_var_size (request, |
211 | GNUNET_MESSAGE_TYPE_DNS_CLIENT_REQUEST, | ||
212 | struct GNUNET_DNS_Request, | ||
213 | dh), | ||
214 | GNUNET_MQ_handler_end () | 214 | GNUNET_MQ_handler_end () |
215 | }; | 215 | }; |
216 | struct GNUNET_MQ_Envelope *env; | 216 | struct GNUNET_MQ_Envelope *env; |
diff --git a/src/dv/dv_api.c b/src/dv/dv_api.c index 76a6ea484..43b6c7db1 100644 --- a/src/dv/dv_api.c +++ b/src/dv/dv_api.c | |||
@@ -314,23 +314,23 @@ mq_error_handler (void *cls, | |||
314 | static void | 314 | static void |
315 | reconnect (struct GNUNET_DV_ServiceHandle *sh) | 315 | reconnect (struct GNUNET_DV_ServiceHandle *sh) |
316 | { | 316 | { |
317 | GNUNET_MQ_hd_fixed_size (connect, | ||
318 | GNUNET_MESSAGE_TYPE_DV_CONNECT, | ||
319 | struct GNUNET_DV_ConnectMessage); | ||
320 | GNUNET_MQ_hd_fixed_size (disconnect, | ||
321 | GNUNET_MESSAGE_TYPE_DV_DISCONNECT, | ||
322 | struct GNUNET_DV_DisconnectMessage); | ||
323 | GNUNET_MQ_hd_fixed_size (distance_update, | ||
324 | GNUNET_MESSAGE_TYPE_DV_DISTANCE_CHANGED, | ||
325 | struct GNUNET_DV_DistanceUpdateMessage); | ||
326 | GNUNET_MQ_hd_var_size (received, | ||
327 | GNUNET_MESSAGE_TYPE_DV_RECV, | ||
328 | struct GNUNET_DV_ReceivedMessage); | ||
329 | struct GNUNET_MQ_MessageHandler handlers[] = { | 317 | struct GNUNET_MQ_MessageHandler handlers[] = { |
330 | make_connect_handler (sh), | 318 | GNUNET_MQ_hd_fixed_size (connect, |
331 | make_disconnect_handler (sh), | 319 | GNUNET_MESSAGE_TYPE_DV_CONNECT, |
332 | make_distance_update_handler (sh), | 320 | struct GNUNET_DV_ConnectMessage, |
333 | make_received_handler (sh), | 321 | sh), |
322 | GNUNET_MQ_hd_fixed_size (disconnect, | ||
323 | GNUNET_MESSAGE_TYPE_DV_DISCONNECT, | ||
324 | struct GNUNET_DV_DisconnectMessage, | ||
325 | sh), | ||
326 | GNUNET_MQ_hd_fixed_size (distance_update, | ||
327 | GNUNET_MESSAGE_TYPE_DV_DISTANCE_CHANGED, | ||
328 | struct GNUNET_DV_DistanceUpdateMessage, | ||
329 | sh), | ||
330 | GNUNET_MQ_hd_var_size (received, | ||
331 | GNUNET_MESSAGE_TYPE_DV_RECV, | ||
332 | struct GNUNET_DV_ReceivedMessage, | ||
333 | sh), | ||
334 | GNUNET_MQ_handler_end () | 334 | GNUNET_MQ_handler_end () |
335 | }; | 335 | }; |
336 | struct GNUNET_MessageHeader *sm; | 336 | struct GNUNET_MessageHeader *sm; |
diff --git a/src/dv/gnunet-service-dv.c b/src/dv/gnunet-service-dv.c index 11ec13387..667970b75 100644 --- a/src/dv/gnunet-service-dv.c +++ b/src/dv/gnunet-service-dv.c | |||
@@ -2033,11 +2033,11 @@ run (void *cls, | |||
2033 | struct GNUNET_SERVER_Handle *server, | 2033 | struct GNUNET_SERVER_Handle *server, |
2034 | const struct GNUNET_CONFIGURATION_Handle *c) | 2034 | const struct GNUNET_CONFIGURATION_Handle *c) |
2035 | { | 2035 | { |
2036 | GNUNET_MQ_hd_var_size (dv_route_message, | ||
2037 | GNUNET_MESSAGE_TYPE_DV_ROUTE, | ||
2038 | struct RouteMessage); | ||
2039 | struct GNUNET_MQ_MessageHandler core_handlers[] = { | 2036 | struct GNUNET_MQ_MessageHandler core_handlers[] = { |
2040 | make_dv_route_message_handler (NULL), | 2037 | GNUNET_MQ_hd_var_size (dv_route_message, |
2038 | GNUNET_MESSAGE_TYPE_DV_ROUTE, | ||
2039 | struct RouteMessage, | ||
2040 | NULL), | ||
2041 | GNUNET_MQ_handler_end () | 2041 | GNUNET_MQ_handler_end () |
2042 | }; | 2042 | }; |
2043 | static struct GNUNET_SERVER_MessageHandler plugin_handlers[] = { | 2043 | static struct GNUNET_SERVER_MessageHandler plugin_handlers[] = { |
diff --git a/src/fs/fs_download.c b/src/fs/fs_download.c index 98c76882a..eacc3c2df 100644 --- a/src/fs/fs_download.c +++ b/src/fs/fs_download.c | |||
@@ -1325,12 +1325,12 @@ download_mq_error_handler (void *cls, | |||
1325 | static void | 1325 | static void |
1326 | do_reconnect (void *cls) | 1326 | do_reconnect (void *cls) |
1327 | { | 1327 | { |
1328 | GNUNET_MQ_hd_var_size (put, | ||
1329 | GNUNET_MESSAGE_TYPE_FS_PUT, | ||
1330 | struct ClientPutMessage); | ||
1331 | struct GNUNET_FS_DownloadContext *dc = cls; | 1328 | struct GNUNET_FS_DownloadContext *dc = cls; |
1332 | struct GNUNET_MQ_MessageHandler handlers[] = { | 1329 | struct GNUNET_MQ_MessageHandler handlers[] = { |
1333 | make_put_handler (dc), | 1330 | GNUNET_MQ_hd_var_size (put, |
1331 | GNUNET_MESSAGE_TYPE_FS_PUT, | ||
1332 | struct ClientPutMessage, | ||
1333 | dc), | ||
1334 | GNUNET_MQ_handler_end () | 1334 | GNUNET_MQ_handler_end () |
1335 | }; | 1335 | }; |
1336 | 1336 | ||
diff --git a/src/fs/fs_list_indexed.c b/src/fs/fs_list_indexed.c index 21385d40b..67183fce2 100644 --- a/src/fs/fs_list_indexed.c +++ b/src/fs/fs_list_indexed.c | |||
@@ -169,17 +169,17 @@ GNUNET_FS_get_indexed_files (struct GNUNET_FS_Handle *h, | |||
169 | GNUNET_FS_IndexedFileProcessor iterator, | 169 | GNUNET_FS_IndexedFileProcessor iterator, |
170 | void *iterator_cls) | 170 | void *iterator_cls) |
171 | { | 171 | { |
172 | GNUNET_MQ_hd_fixed_size (index_info_end, | ||
173 | GNUNET_MESSAGE_TYPE_FS_INDEX_LIST_END, | ||
174 | struct GNUNET_MessageHeader); | ||
175 | GNUNET_MQ_hd_var_size (index_info, | ||
176 | GNUNET_MESSAGE_TYPE_FS_INDEX_LIST_ENTRY, | ||
177 | struct IndexInfoMessage); | ||
178 | struct GNUNET_FS_GetIndexedContext *gic | 172 | struct GNUNET_FS_GetIndexedContext *gic |
179 | = GNUNET_new (struct GNUNET_FS_GetIndexedContext); | 173 | = GNUNET_new (struct GNUNET_FS_GetIndexedContext); |
180 | struct GNUNET_MQ_MessageHandler handlers[] = { | 174 | struct GNUNET_MQ_MessageHandler handlers[] = { |
181 | make_index_info_end_handler (gic), | 175 | GNUNET_MQ_hd_fixed_size (index_info_end, |
182 | make_index_info_handler (gic), | 176 | GNUNET_MESSAGE_TYPE_FS_INDEX_LIST_END, |
177 | struct GNUNET_MessageHeader, | ||
178 | gic), | ||
179 | GNUNET_MQ_hd_var_size (index_info, | ||
180 | GNUNET_MESSAGE_TYPE_FS_INDEX_LIST_ENTRY, | ||
181 | struct IndexInfoMessage, | ||
182 | gic), | ||
183 | GNUNET_MQ_handler_end () | 183 | GNUNET_MQ_handler_end () |
184 | }; | 184 | }; |
185 | struct GNUNET_MQ_Envelope *env; | 185 | struct GNUNET_MQ_Envelope *env; |
diff --git a/src/fs/fs_publish.c b/src/fs/fs_publish.c index 01305d678..5820c3d0c 100644 --- a/src/fs/fs_publish.c +++ b/src/fs/fs_publish.c | |||
@@ -795,16 +795,16 @@ static void | |||
795 | hash_for_index_cb (void *cls, | 795 | hash_for_index_cb (void *cls, |
796 | const struct GNUNET_HashCode *res) | 796 | const struct GNUNET_HashCode *res) |
797 | { | 797 | { |
798 | GNUNET_MQ_hd_fixed_size (index_start_ok, | ||
799 | GNUNET_MESSAGE_TYPE_FS_INDEX_START_OK, | ||
800 | struct GNUNET_MessageHeader); | ||
801 | GNUNET_MQ_hd_var_size (index_start_failed, | ||
802 | GNUNET_MESSAGE_TYPE_FS_INDEX_START_FAILED, | ||
803 | struct GNUNET_MessageHeader); | ||
804 | struct GNUNET_FS_PublishContext *pc = cls; | 798 | struct GNUNET_FS_PublishContext *pc = cls; |
805 | struct GNUNET_MQ_MessageHandler handlers[] = { | 799 | struct GNUNET_MQ_MessageHandler handlers[] = { |
806 | make_index_start_ok_handler (pc), | 800 | GNUNET_MQ_hd_fixed_size (index_start_ok, |
807 | make_index_start_failed_handler (pc), | 801 | GNUNET_MESSAGE_TYPE_FS_INDEX_START_OK, |
802 | struct GNUNET_MessageHeader, | ||
803 | pc), | ||
804 | GNUNET_MQ_hd_var_size (index_start_failed, | ||
805 | GNUNET_MESSAGE_TYPE_FS_INDEX_START_FAILED, | ||
806 | struct GNUNET_MessageHeader, | ||
807 | pc), | ||
808 | GNUNET_MQ_handler_end () | 808 | GNUNET_MQ_handler_end () |
809 | }; | 809 | }; |
810 | struct GNUNET_FS_FileInformation *p; | 810 | struct GNUNET_FS_FileInformation *p; |
@@ -1003,11 +1003,11 @@ loc_mq_error_handler (void *cls, | |||
1003 | static void | 1003 | static void |
1004 | create_loc_uri (struct GNUNET_FS_PublishContext *pc) | 1004 | create_loc_uri (struct GNUNET_FS_PublishContext *pc) |
1005 | { | 1005 | { |
1006 | GNUNET_MQ_hd_fixed_size (signature_response, | ||
1007 | GNUNET_MESSAGE_TYPE_FS_REQUEST_LOC_SIGNATURE, | ||
1008 | struct ResponseLocSignatureMessage); | ||
1009 | struct GNUNET_MQ_MessageHandler handlers[] = { | 1006 | struct GNUNET_MQ_MessageHandler handlers[] = { |
1010 | make_signature_response_handler (pc), | 1007 | GNUNET_MQ_hd_fixed_size (signature_response, |
1008 | GNUNET_MESSAGE_TYPE_FS_REQUEST_LOC_SIGNATURE, | ||
1009 | struct ResponseLocSignatureMessage, | ||
1010 | pc), | ||
1011 | GNUNET_MQ_handler_end () | 1011 | GNUNET_MQ_handler_end () |
1012 | }; | 1012 | }; |
1013 | struct GNUNET_MQ_Envelope *env; | 1013 | struct GNUNET_MQ_Envelope *env; |
diff --git a/src/fs/fs_search.c b/src/fs/fs_search.c index 8a3652e3f..7874bb6e0 100644 --- a/src/fs/fs_search.c +++ b/src/fs/fs_search.c | |||
@@ -1234,12 +1234,12 @@ search_mq_error_handler (void *cls, | |||
1234 | static void | 1234 | static void |
1235 | do_reconnect (void *cls) | 1235 | do_reconnect (void *cls) |
1236 | { | 1236 | { |
1237 | GNUNET_MQ_hd_var_size (result, | ||
1238 | GNUNET_MESSAGE_TYPE_FS_PUT, | ||
1239 | struct ClientPutMessage); | ||
1240 | struct GNUNET_FS_SearchContext *sc = cls; | 1237 | struct GNUNET_FS_SearchContext *sc = cls; |
1241 | struct GNUNET_MQ_MessageHandler handlers[] = { | 1238 | struct GNUNET_MQ_MessageHandler handlers[] = { |
1242 | make_result_handler (sc), | 1239 | GNUNET_MQ_hd_var_size (result, |
1240 | GNUNET_MESSAGE_TYPE_FS_PUT, | ||
1241 | struct ClientPutMessage, | ||
1242 | sc), | ||
1243 | GNUNET_MQ_handler_end () | 1243 | GNUNET_MQ_handler_end () |
1244 | }; | 1244 | }; |
1245 | 1245 | ||
diff --git a/src/fs/fs_unindex.c b/src/fs/fs_unindex.c index f43725a59..2a024ecbb 100644 --- a/src/fs/fs_unindex.c +++ b/src/fs/fs_unindex.c | |||
@@ -288,11 +288,11 @@ unindex_mq_error_handler (void *cls, | |||
288 | static void | 288 | static void |
289 | unindex_finish (struct GNUNET_FS_UnindexContext *uc) | 289 | unindex_finish (struct GNUNET_FS_UnindexContext *uc) |
290 | { | 290 | { |
291 | GNUNET_MQ_hd_fixed_size (unindex_response, | ||
292 | GNUNET_MESSAGE_TYPE_FS_UNINDEX_OK, | ||
293 | struct GNUNET_MessageHeader); | ||
294 | struct GNUNET_MQ_MessageHandler handlers[] = { | 291 | struct GNUNET_MQ_MessageHandler handlers[] = { |
295 | make_unindex_response_handler (uc), | 292 | GNUNET_MQ_hd_fixed_size (unindex_response, |
293 | GNUNET_MESSAGE_TYPE_FS_UNINDEX_OK, | ||
294 | struct GNUNET_MessageHeader, | ||
295 | uc), | ||
296 | GNUNET_MQ_handler_end () | 296 | GNUNET_MQ_handler_end () |
297 | }; | 297 | }; |
298 | char *emsg; | 298 | char *emsg; |
diff --git a/src/fs/gnunet-service-fs.c b/src/fs/gnunet-service-fs.c index bc0da09bc..4131b1670 100644 --- a/src/fs/gnunet-service-fs.c +++ b/src/fs/gnunet-service-fs.c | |||
@@ -617,22 +617,22 @@ static int | |||
617 | main_init (struct GNUNET_SERVER_Handle *server, | 617 | main_init (struct GNUNET_SERVER_Handle *server, |
618 | const struct GNUNET_CONFIGURATION_Handle *c) | 618 | const struct GNUNET_CONFIGURATION_Handle *c) |
619 | { | 619 | { |
620 | GNUNET_MQ_hd_var_size (p2p_get, | ||
621 | GNUNET_MESSAGE_TYPE_FS_GET, | ||
622 | struct GetMessage); | ||
623 | GNUNET_MQ_hd_var_size (p2p_put, | ||
624 | GNUNET_MESSAGE_TYPE_FS_PUT, | ||
625 | struct PutMessage); | ||
626 | GNUNET_MQ_hd_fixed_size (p2p_migration_stop, | ||
627 | GNUNET_MESSAGE_TYPE_FS_MIGRATION_STOP, | ||
628 | struct MigrationStopMessage); | ||
629 | struct GNUNET_MQ_MessageHandler no_p2p_handlers[] = { | 620 | struct GNUNET_MQ_MessageHandler no_p2p_handlers[] = { |
630 | GNUNET_MQ_handler_end () | 621 | GNUNET_MQ_handler_end () |
631 | }; | 622 | }; |
632 | struct GNUNET_MQ_MessageHandler p2p_handlers[] = { | 623 | struct GNUNET_MQ_MessageHandler p2p_handlers[] = { |
633 | make_p2p_get_handler (NULL), | 624 | GNUNET_MQ_hd_var_size (p2p_get, |
634 | make_p2p_put_handler (NULL), | 625 | GNUNET_MESSAGE_TYPE_FS_GET, |
635 | make_p2p_migration_stop_handler (NULL), | 626 | struct GetMessage, |
627 | NULL), | ||
628 | GNUNET_MQ_hd_var_size (p2p_put, | ||
629 | GNUNET_MESSAGE_TYPE_FS_PUT, | ||
630 | struct PutMessage, | ||
631 | NULL), | ||
632 | GNUNET_MQ_hd_fixed_size (p2p_migration_stop, | ||
633 | GNUNET_MESSAGE_TYPE_FS_MIGRATION_STOP, | ||
634 | struct MigrationStopMessage, | ||
635 | NULL), | ||
636 | GNUNET_MQ_handler_end () | 636 | GNUNET_MQ_handler_end () |
637 | }; | 637 | }; |
638 | static const struct GNUNET_SERVER_MessageHandler handlers[] = { | 638 | static const struct GNUNET_SERVER_MessageHandler handlers[] = { |
diff --git a/src/gns/gns_api.c b/src/gns/gns_api.c index c45f5bc3d..475d5b5cd 100644 --- a/src/gns/gns_api.c +++ b/src/gns/gns_api.c | |||
@@ -264,11 +264,11 @@ handle_result (void *cls, | |||
264 | static void | 264 | static void |
265 | reconnect (struct GNUNET_GNS_Handle *handle) | 265 | reconnect (struct GNUNET_GNS_Handle *handle) |
266 | { | 266 | { |
267 | GNUNET_MQ_hd_var_size (result, | ||
268 | GNUNET_MESSAGE_TYPE_GNS_LOOKUP_RESULT, | ||
269 | struct GNUNET_GNS_ClientLookupResultMessage); | ||
270 | struct GNUNET_MQ_MessageHandler handlers[] = { | 267 | struct GNUNET_MQ_MessageHandler handlers[] = { |
271 | make_result_handler (handle), | 268 | GNUNET_MQ_hd_var_size (result, |
269 | GNUNET_MESSAGE_TYPE_GNS_LOOKUP_RESULT, | ||
270 | struct GNUNET_GNS_ClientLookupResultMessage, | ||
271 | handle), | ||
272 | GNUNET_MQ_handler_end () | 272 | GNUNET_MQ_handler_end () |
273 | }; | 273 | }; |
274 | struct GNUNET_GNS_LookupRequest *lh; | 274 | struct GNUNET_GNS_LookupRequest *lh; |
diff --git a/src/hostlist/gnunet-daemon-hostlist.c b/src/hostlist/gnunet-daemon-hostlist.c index 44db59949..7181a913b 100644 --- a/src/hostlist/gnunet-daemon-hostlist.c +++ b/src/hostlist/gnunet-daemon-hostlist.c | |||
@@ -296,11 +296,11 @@ run (void *cls, | |||
296 | const char *cfgfile, | 296 | const char *cfgfile, |
297 | const struct GNUNET_CONFIGURATION_Handle *cfg) | 297 | const struct GNUNET_CONFIGURATION_Handle *cfg) |
298 | { | 298 | { |
299 | GNUNET_MQ_hd_var_size (advertisement, | ||
300 | GNUNET_MESSAGE_TYPE_HOSTLIST_ADVERTISEMENT, | ||
301 | struct GNUNET_MessageHeader); | ||
302 | struct GNUNET_MQ_MessageHandler learn_handlers[] = { | 299 | struct GNUNET_MQ_MessageHandler learn_handlers[] = { |
303 | make_advertisement_handler (NULL), | 300 | GNUNET_MQ_hd_var_size (advertisement, |
301 | GNUNET_MESSAGE_TYPE_HOSTLIST_ADVERTISEMENT, | ||
302 | struct GNUNET_MessageHeader, | ||
303 | NULL), | ||
304 | GNUNET_MQ_handler_end () | 304 | GNUNET_MQ_handler_end () |
305 | }; | 305 | }; |
306 | struct GNUNET_MQ_MessageHandler no_learn_handlers[] = { | 306 | struct GNUNET_MQ_MessageHandler no_learn_handlers[] = { |
diff --git a/src/hostlist/test_gnunet_daemon_hostlist_learning.c b/src/hostlist/test_gnunet_daemon_hostlist_learning.c index 041898abd..c39c57eb3 100644 --- a/src/hostlist/test_gnunet_daemon_hostlist_learning.c +++ b/src/hostlist/test_gnunet_daemon_hostlist_learning.c | |||
@@ -394,11 +394,11 @@ static void | |||
394 | setup_learn_peer (struct PeerContext *p, | 394 | setup_learn_peer (struct PeerContext *p, |
395 | const char *cfgname) | 395 | const char *cfgname) |
396 | { | 396 | { |
397 | GNUNET_MQ_hd_var_size (ad_arrive, | ||
398 | GNUNET_MESSAGE_TYPE_HOSTLIST_ADVERTISEMENT, | ||
399 | struct GNUNET_MessageHeader); | ||
400 | struct GNUNET_MQ_MessageHandler learn_handlers[] = { | 397 | struct GNUNET_MQ_MessageHandler learn_handlers[] = { |
401 | make_ad_arrive_handler (NULL), | 398 | GNUNET_MQ_hd_var_size (ad_arrive, |
399 | GNUNET_MESSAGE_TYPE_HOSTLIST_ADVERTISEMENT, | ||
400 | struct GNUNET_MessageHeader, | ||
401 | NULL), | ||
402 | GNUNET_MQ_handler_end () | 402 | GNUNET_MQ_handler_end () |
403 | }; | 403 | }; |
404 | char *filename; | 404 | char *filename; |
diff --git a/src/identity-provider/identity_provider_api.c b/src/identity-provider/identity_provider_api.c index 6e1b867de..8317d18ad 100644 --- a/src/identity-provider/identity_provider_api.c +++ b/src/identity-provider/identity_provider_api.c | |||
@@ -363,15 +363,15 @@ handle_result (void *cls, | |||
363 | static void | 363 | static void |
364 | reconnect (struct GNUNET_IDENTITY_PROVIDER_Handle *h) | 364 | reconnect (struct GNUNET_IDENTITY_PROVIDER_Handle *h) |
365 | { | 365 | { |
366 | GNUNET_MQ_hd_var_size (result, | ||
367 | GNUNET_MESSAGE_TYPE_IDENTITY_PROVIDER_ISSUE_RESULT, | ||
368 | struct GNUNET_IDENTITY_PROVIDER_IssueResultMessage); | ||
369 | GNUNET_MQ_hd_var_size (exchange_result, | ||
370 | GNUNET_MESSAGE_TYPE_IDENTITY_PROVIDER_EXCHANGE_RESULT, | ||
371 | struct GNUNET_IDENTITY_PROVIDER_ExchangeResultMessage); | ||
372 | struct GNUNET_MQ_MessageHandler handlers[] = { | 366 | struct GNUNET_MQ_MessageHandler handlers[] = { |
373 | make_result_handler (h), | 367 | GNUNET_MQ_hd_var_size (result, |
374 | make_exchange_result_handler (h), | 368 | GNUNET_MESSAGE_TYPE_IDENTITY_PROVIDER_ISSUE_RESULT, |
369 | struct GNUNET_IDENTITY_PROVIDER_IssueResultMessage, | ||
370 | h), | ||
371 | GNUNET_MQ_hd_var_size (exchange_result, | ||
372 | GNUNET_MESSAGE_TYPE_IDENTITY_PROVIDER_EXCHANGE_RESULT, | ||
373 | struct GNUNET_IDENTITY_PROVIDER_ExchangeResultMessage, | ||
374 | h), | ||
375 | GNUNET_MQ_handler_end () | 375 | GNUNET_MQ_handler_end () |
376 | }; | 376 | }; |
377 | struct GNUNET_IDENTITY_PROVIDER_Operation *op; | 377 | struct GNUNET_IDENTITY_PROVIDER_Operation *op; |
diff --git a/src/identity/identity_api.c b/src/identity/identity_api.c index 4c8a35dc2..dd61fdfb4 100644 --- a/src/identity/identity_api.c +++ b/src/identity/identity_api.c | |||
@@ -552,20 +552,20 @@ handle_identity_set_default (void *cls, | |||
552 | static void | 552 | static void |
553 | reconnect (void *cls) | 553 | reconnect (void *cls) |
554 | { | 554 | { |
555 | GNUNET_MQ_hd_var_size (identity_result_code, | ||
556 | GNUNET_MESSAGE_TYPE_IDENTITY_RESULT_CODE, | ||
557 | struct GNUNET_IDENTITY_ResultCodeMessage); | ||
558 | GNUNET_MQ_hd_var_size (identity_update, | ||
559 | GNUNET_MESSAGE_TYPE_IDENTITY_UPDATE, | ||
560 | struct GNUNET_IDENTITY_UpdateMessage); | ||
561 | GNUNET_MQ_hd_var_size (identity_set_default, | ||
562 | GNUNET_MESSAGE_TYPE_IDENTITY_SET_DEFAULT, | ||
563 | struct GNUNET_IDENTITY_SetDefaultMessage); | ||
564 | struct GNUNET_IDENTITY_Handle *h = cls; | 555 | struct GNUNET_IDENTITY_Handle *h = cls; |
565 | struct GNUNET_MQ_MessageHandler handlers[] = { | 556 | struct GNUNET_MQ_MessageHandler handlers[] = { |
566 | make_identity_result_code_handler (h), | 557 | GNUNET_MQ_hd_var_size (identity_result_code, |
567 | make_identity_update_handler (h), | 558 | GNUNET_MESSAGE_TYPE_IDENTITY_RESULT_CODE, |
568 | make_identity_set_default_handler (h), | 559 | struct GNUNET_IDENTITY_ResultCodeMessage, |
560 | h), | ||
561 | GNUNET_MQ_hd_var_size (identity_update, | ||
562 | GNUNET_MESSAGE_TYPE_IDENTITY_UPDATE, | ||
563 | struct GNUNET_IDENTITY_UpdateMessage, | ||
564 | h), | ||
565 | GNUNET_MQ_hd_var_size (identity_set_default, | ||
566 | GNUNET_MESSAGE_TYPE_IDENTITY_SET_DEFAULT, | ||
567 | struct GNUNET_IDENTITY_SetDefaultMessage, | ||
568 | h), | ||
569 | GNUNET_MQ_handler_end () | 569 | GNUNET_MQ_handler_end () |
570 | }; | 570 | }; |
571 | struct GNUNET_MQ_Envelope *env; | 571 | struct GNUNET_MQ_Envelope *env; |
diff --git a/src/include/gnunet_mq_lib.h b/src/include/gnunet_mq_lib.h index d383adbb5..86144abca 100644 --- a/src/include/gnunet_mq_lib.h +++ b/src/include/gnunet_mq_lib.h | |||
@@ -323,27 +323,26 @@ struct GNUNET_MQ_MessageHandler | |||
323 | * const struct GNUNET_MessageTest *msg) | 323 | * const struct GNUNET_MessageTest *msg) |
324 | * { ... } | 324 | * { ... } |
325 | * | 325 | * |
326 | * GNUNET_MQ_hd_fixed_size(test_message, | ||
327 | * GNUNET_MESSAGE_TYPE_TEST, | ||
328 | * struct GNUNET_MessageTest); | ||
329 | * struct GNUNET_MQ_MessageHandler handlers[] = { | 326 | * struct GNUNET_MQ_MessageHandler handlers[] = { |
330 | * make_test_message_handler (NULL), | 327 | * GNUNET_MQ_hd_fixed_size(test_message, |
328 | * GNUNET_MESSAGE_TYPE_TEST, | ||
329 | * struct GNUNET_MessageTest, | ||
330 | * "context"), | ||
331 | * GNUNET_MQ_handler_end() | 331 | * GNUNET_MQ_handler_end() |
332 | * }; | 332 | * }; |
333 | * | 333 | * |
334 | * @param name unique basename for the functions | 334 | * @param name unique basename for the functions |
335 | * @param code message type constant | 335 | * @param code message type constant |
336 | * @param str type of the message (a struct) | 336 | * @param str type of the message (a struct) |
337 | * @param ctx context for the callbacks | ||
337 | */ | 338 | */ |
338 | #define GNUNET_MQ_hd_fixed_size(name,code,str) \ | 339 | #define GNUNET_MQ_hd_fixed_size(name,code,str,ctx) \ |
339 | struct GNUNET_MQ_MessageHandler \ | 340 | ({ \ |
340 | make_##name##_handler (void *cls) { \ | 341 | void (*_cb)(void *cls, const str *msg) = &handle_##name; \ |
341 | void (*cb)(void *cls, const str *msg) = &handle_##name; \ | 342 | ((struct GNUNET_MQ_MessageHandler) { \ |
342 | struct GNUNET_MQ_MessageHandler mh = { \ | 343 | NULL, (GNUNET_MQ_MessageCallback) _cb, \ |
343 | NULL, (GNUNET_MQ_MessageCallback) cb, \ | 344 | (ctx), (code), sizeof (str) }); \ |
344 | cls, code, sizeof (str) }; \ | 345 | }) |
345 | return mh; \ | ||
346 | } | ||
347 | 346 | ||
348 | 347 | ||
349 | /** | 348 | /** |
@@ -356,9 +355,6 @@ struct GNUNET_MQ_MessageHandler | |||
356 | * The macro is to be used as follows: | 355 | * The macro is to be used as follows: |
357 | * <code> | 356 | * <code> |
358 | * struct GNUNET_MessageTest { ... }; // can be variable size | 357 | * struct GNUNET_MessageTest { ... }; // can be variable size |
359 | * GNUNET_MQ_hd_var_size(test_message, | ||
360 | * GNUNET_MESSAGE_TYPE_TEST, | ||
361 | * struct GNUNET_MessageTest); | ||
362 | * static int | 358 | * static int |
363 | * check_test (void *cls, | 359 | * check_test (void *cls, |
364 | * const struct GNUNET_MessageTest *msg) | 360 | * const struct GNUNET_MessageTest *msg) |
@@ -377,25 +373,27 @@ struct GNUNET_MQ_MessageHandler | |||
377 | * } | 373 | * } |
378 | * | 374 | * |
379 | * struct GNUNET_MQ_MessageHandler handlers[] = { | 375 | * struct GNUNET_MQ_MessageHandler handlers[] = { |
380 | * make_test_message_handler ("context"), | 376 | * GNUNET_MQ_hd_var_size(test_message, |
377 | * GNUNET_MESSAGE_TYPE_TEST, | ||
378 | * struct GNUNET_MessageTest, | ||
379 | * "context"), | ||
381 | * GNUNET_MQ_handler_end() | 380 | * GNUNET_MQ_handler_end() |
382 | * }; | 381 | * }; |
383 | * | 382 | * |
384 | * @param name unique basename for the functions | 383 | * @param name unique basename for the functions |
385 | * @param code message type constant | 384 | * @param code message type constant |
386 | * @param str type of the message (a struct) | 385 | * @param str type of the message (a struct) |
387 | */ | 386 | * @param ctx context for the callbacks |
388 | #define GNUNET_MQ_hd_var_size(name,code,str) \ | 387 | */ |
389 | struct GNUNET_MQ_MessageHandler \ | 388 | #define GNUNET_MQ_hd_var_size(name,code,str,ctx) \ |
390 | make_##name##_handler (void *ctx) { \ | 389 | ({ \ |
391 | int (*mv)(void *cls, const str *msg) = &check_##name; \ | 390 | int (*_mv)(void *cls, const str *msg) = &check_##name; \ |
392 | void (*cb)(void *cls, const str *msg) = &handle_##name;\ | 391 | void (*_cb)(void *cls, const str *msg) = &handle_##name; \ |
393 | struct GNUNET_MQ_MessageHandler mh = \ | 392 | ((struct GNUNET_MQ_MessageHandler) \ |
394 | { (GNUNET_MQ_MessageValidationCallback) mv, \ | 393 | { (GNUNET_MQ_MessageValidationCallback) _mv, \ |
395 | (GNUNET_MQ_MessageCallback) cb, \ | 394 | (GNUNET_MQ_MessageCallback) _cb, \ |
396 | ctx, code, sizeof (str) }; \ | 395 | (ctx), (code), sizeof (str) }); \ |
397 | return mh; \ | 396 | }) |
398 | } | ||
399 | 397 | ||
400 | 398 | ||
401 | /** | 399 | /** |
diff --git a/src/multicast/multicast_api.c b/src/multicast/multicast_api.c index ad9929dca..7cfe70835 100644 --- a/src/multicast/multicast_api.c +++ b/src/multicast/multicast_api.c | |||
@@ -762,32 +762,27 @@ origin_connect (struct GNUNET_MULTICAST_Origin *orig) | |||
762 | { | 762 | { |
763 | struct GNUNET_MULTICAST_Group *grp = &orig->grp; | 763 | struct GNUNET_MULTICAST_Group *grp = &orig->grp; |
764 | 764 | ||
765 | GNUNET_MQ_hd_var_size (group_message, | ||
766 | GNUNET_MESSAGE_TYPE_MULTICAST_MESSAGE, | ||
767 | struct GNUNET_MULTICAST_MessageHeader); | ||
768 | |||
769 | GNUNET_MQ_hd_var_size (origin_request, | ||
770 | GNUNET_MESSAGE_TYPE_MULTICAST_REQUEST, | ||
771 | struct GNUNET_MULTICAST_RequestHeader); | ||
772 | |||
773 | GNUNET_MQ_hd_fixed_size (group_fragment_ack, | ||
774 | GNUNET_MESSAGE_TYPE_MULTICAST_FRAGMENT_ACK, | ||
775 | struct GNUNET_MessageHeader); | ||
776 | |||
777 | GNUNET_MQ_hd_var_size (group_join_request, | ||
778 | GNUNET_MESSAGE_TYPE_MULTICAST_JOIN_REQUEST, | ||
779 | struct MulticastJoinRequestMessage); | ||
780 | |||
781 | GNUNET_MQ_hd_fixed_size (group_replay_request, | ||
782 | GNUNET_MESSAGE_TYPE_MULTICAST_REPLAY_REQUEST, | ||
783 | struct MulticastReplayRequestMessage); | ||
784 | |||
785 | struct GNUNET_MQ_MessageHandler handlers[] = { | 765 | struct GNUNET_MQ_MessageHandler handlers[] = { |
786 | make_group_message_handler (grp), | 766 | GNUNET_MQ_hd_var_size (group_message, |
787 | make_origin_request_handler (orig), | 767 | GNUNET_MESSAGE_TYPE_MULTICAST_MESSAGE, |
788 | make_group_fragment_ack_handler (grp), | 768 | struct GNUNET_MULTICAST_MessageHeader, |
789 | make_group_join_request_handler (grp), | 769 | grp), |
790 | make_group_replay_request_handler (grp), | 770 | GNUNET_MQ_hd_var_size (origin_request, |
771 | GNUNET_MESSAGE_TYPE_MULTICAST_REQUEST, | ||
772 | struct GNUNET_MULTICAST_RequestHeader, | ||
773 | orig), | ||
774 | GNUNET_MQ_hd_fixed_size (group_fragment_ack, | ||
775 | GNUNET_MESSAGE_TYPE_MULTICAST_FRAGMENT_ACK, | ||
776 | struct GNUNET_MessageHeader, | ||
777 | grp), | ||
778 | GNUNET_MQ_hd_var_size (group_join_request, | ||
779 | GNUNET_MESSAGE_TYPE_MULTICAST_JOIN_REQUEST, | ||
780 | struct MulticastJoinRequestMessage, | ||
781 | grp), | ||
782 | GNUNET_MQ_hd_fixed_size (group_replay_request, | ||
783 | GNUNET_MESSAGE_TYPE_MULTICAST_REPLAY_REQUEST, | ||
784 | struct MulticastReplayRequestMessage, | ||
785 | grp), | ||
791 | GNUNET_MQ_handler_end () | 786 | GNUNET_MQ_handler_end () |
792 | }; | 787 | }; |
793 | 788 | ||
@@ -1053,37 +1048,31 @@ member_connect (struct GNUNET_MULTICAST_Member *mem) | |||
1053 | { | 1048 | { |
1054 | struct GNUNET_MULTICAST_Group *grp = &mem->grp; | 1049 | struct GNUNET_MULTICAST_Group *grp = &mem->grp; |
1055 | 1050 | ||
1056 | GNUNET_MQ_hd_var_size (group_message, | ||
1057 | GNUNET_MESSAGE_TYPE_MULTICAST_MESSAGE, | ||
1058 | struct GNUNET_MULTICAST_MessageHeader); | ||
1059 | |||
1060 | GNUNET_MQ_hd_fixed_size (group_fragment_ack, | ||
1061 | GNUNET_MESSAGE_TYPE_MULTICAST_FRAGMENT_ACK, | ||
1062 | struct GNUNET_MessageHeader); | ||
1063 | |||
1064 | GNUNET_MQ_hd_var_size (group_join_request, | ||
1065 | GNUNET_MESSAGE_TYPE_MULTICAST_JOIN_REQUEST, | ||
1066 | struct MulticastJoinRequestMessage); | ||
1067 | |||
1068 | GNUNET_MQ_hd_var_size (member_join_decision, | ||
1069 | GNUNET_MESSAGE_TYPE_MULTICAST_JOIN_DECISION, | ||
1070 | struct MulticastJoinDecisionMessageHeader); | ||
1071 | |||
1072 | GNUNET_MQ_hd_fixed_size (group_replay_request, | ||
1073 | GNUNET_MESSAGE_TYPE_MULTICAST_REPLAY_REQUEST, | ||
1074 | struct MulticastReplayRequestMessage); | ||
1075 | |||
1076 | GNUNET_MQ_hd_var_size (member_replay_response, | ||
1077 | GNUNET_MESSAGE_TYPE_MULTICAST_REPLAY_RESPONSE, | ||
1078 | struct MulticastReplayResponseMessage); | ||
1079 | |||
1080 | struct GNUNET_MQ_MessageHandler handlers[] = { | 1051 | struct GNUNET_MQ_MessageHandler handlers[] = { |
1081 | make_group_message_handler (grp), | 1052 | GNUNET_MQ_hd_var_size (group_message, |
1082 | make_group_fragment_ack_handler (grp), | 1053 | GNUNET_MESSAGE_TYPE_MULTICAST_MESSAGE, |
1083 | make_group_join_request_handler (grp), | 1054 | struct GNUNET_MULTICAST_MessageHeader, |
1084 | make_member_join_decision_handler (mem), | 1055 | grp), |
1085 | make_group_replay_request_handler (grp), | 1056 | GNUNET_MQ_hd_fixed_size (group_fragment_ack, |
1086 | make_member_replay_response_handler (mem), | 1057 | GNUNET_MESSAGE_TYPE_MULTICAST_FRAGMENT_ACK, |
1058 | struct GNUNET_MessageHeader, | ||
1059 | grp), | ||
1060 | GNUNET_MQ_hd_var_size (group_join_request, | ||
1061 | GNUNET_MESSAGE_TYPE_MULTICAST_JOIN_REQUEST, | ||
1062 | struct MulticastJoinRequestMessage, | ||
1063 | grp), | ||
1064 | GNUNET_MQ_hd_var_size (member_join_decision, | ||
1065 | GNUNET_MESSAGE_TYPE_MULTICAST_JOIN_DECISION, | ||
1066 | struct MulticastJoinDecisionMessageHeader, | ||
1067 | mem), | ||
1068 | GNUNET_MQ_hd_fixed_size (group_replay_request, | ||
1069 | GNUNET_MESSAGE_TYPE_MULTICAST_REPLAY_REQUEST, | ||
1070 | struct MulticastReplayRequestMessage, | ||
1071 | grp), | ||
1072 | GNUNET_MQ_hd_var_size (member_replay_response, | ||
1073 | GNUNET_MESSAGE_TYPE_MULTICAST_REPLAY_RESPONSE, | ||
1074 | struct MulticastReplayResponseMessage, | ||
1075 | mem), | ||
1087 | GNUNET_MQ_handler_end () | 1076 | GNUNET_MQ_handler_end () |
1088 | }; | 1077 | }; |
1089 | 1078 | ||
diff --git a/src/namecache/namecache_api.c b/src/namecache/namecache_api.c index 46d685a26..9ccb91bc8 100644 --- a/src/namecache/namecache_api.c +++ b/src/namecache/namecache_api.c | |||
@@ -324,15 +324,15 @@ mq_error_handler (void *cls, | |||
324 | static void | 324 | static void |
325 | reconnect (struct GNUNET_NAMECACHE_Handle *h) | 325 | reconnect (struct GNUNET_NAMECACHE_Handle *h) |
326 | { | 326 | { |
327 | GNUNET_MQ_hd_var_size (lookup_block_response, | ||
328 | GNUNET_MESSAGE_TYPE_NAMECACHE_LOOKUP_BLOCK_RESPONSE, | ||
329 | struct LookupBlockResponseMessage); | ||
330 | GNUNET_MQ_hd_fixed_size (block_cache_response, | ||
331 | GNUNET_MESSAGE_TYPE_NAMECACHE_BLOCK_CACHE_RESPONSE, | ||
332 | struct BlockCacheResponseMessage); | ||
333 | struct GNUNET_MQ_MessageHandler handlers[] = { | 327 | struct GNUNET_MQ_MessageHandler handlers[] = { |
334 | make_lookup_block_response_handler (h), | 328 | GNUNET_MQ_hd_var_size (lookup_block_response, |
335 | make_block_cache_response_handler (h), | 329 | GNUNET_MESSAGE_TYPE_NAMECACHE_LOOKUP_BLOCK_RESPONSE, |
330 | struct LookupBlockResponseMessage, | ||
331 | h), | ||
332 | GNUNET_MQ_hd_fixed_size (block_cache_response, | ||
333 | GNUNET_MESSAGE_TYPE_NAMECACHE_BLOCK_CACHE_RESPONSE, | ||
334 | struct BlockCacheResponseMessage, | ||
335 | h), | ||
336 | GNUNET_MQ_handler_end () | 336 | GNUNET_MQ_handler_end () |
337 | }; | 337 | }; |
338 | GNUNET_assert (NULL == h->mq); | 338 | GNUNET_assert (NULL == h->mq); |
diff --git a/src/namestore/namestore_api.c b/src/namestore/namestore_api.c index 61d8385b6..6dc0df6fd 100644 --- a/src/namestore/namestore_api.c +++ b/src/namestore/namestore_api.c | |||
@@ -783,23 +783,23 @@ mq_error_handler (void *cls, | |||
783 | static void | 783 | static void |
784 | reconnect (struct GNUNET_NAMESTORE_Handle *h) | 784 | reconnect (struct GNUNET_NAMESTORE_Handle *h) |
785 | { | 785 | { |
786 | GNUNET_MQ_hd_fixed_size (record_store_response, | ||
787 | GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_STORE_RESPONSE, | ||
788 | struct RecordStoreResponseMessage); | ||
789 | GNUNET_MQ_hd_var_size (zone_to_name_response, | ||
790 | GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME_RESPONSE, | ||
791 | struct ZoneToNameResponseMessage); | ||
792 | GNUNET_MQ_hd_var_size (record_result, | ||
793 | GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT, | ||
794 | struct RecordResultMessage); | ||
795 | GNUNET_MQ_hd_var_size (lookup_result, | ||
796 | GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP_RESPONSE, | ||
797 | struct LabelLookupResponseMessage); | ||
798 | struct GNUNET_MQ_MessageHandler handlers[] = { | 786 | struct GNUNET_MQ_MessageHandler handlers[] = { |
799 | make_record_store_response_handler (h), | 787 | GNUNET_MQ_hd_fixed_size (record_store_response, |
800 | make_zone_to_name_response_handler (h), | 788 | GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_STORE_RESPONSE, |
801 | make_record_result_handler (h), | 789 | struct RecordStoreResponseMessage, |
802 | make_lookup_result_handler (h), | 790 | h), |
791 | GNUNET_MQ_hd_var_size (zone_to_name_response, | ||
792 | GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME_RESPONSE, | ||
793 | struct ZoneToNameResponseMessage, | ||
794 | h), | ||
795 | GNUNET_MQ_hd_var_size (record_result, | ||
796 | GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT, | ||
797 | struct RecordResultMessage, | ||
798 | h), | ||
799 | GNUNET_MQ_hd_var_size (lookup_result, | ||
800 | GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP_RESPONSE, | ||
801 | struct LabelLookupResponseMessage, | ||
802 | h), | ||
803 | GNUNET_MQ_handler_end () | 803 | GNUNET_MQ_handler_end () |
804 | }; | 804 | }; |
805 | struct GNUNET_NAMESTORE_ZoneIterator *it; | 805 | struct GNUNET_NAMESTORE_ZoneIterator *it; |
diff --git a/src/namestore/namestore_api_monitor.c b/src/namestore/namestore_api_monitor.c index 7e75b07e5..00f0887d4 100644 --- a/src/namestore/namestore_api_monitor.c +++ b/src/namestore/namestore_api_monitor.c | |||
@@ -243,15 +243,15 @@ mq_error_handler (void *cls, | |||
243 | static void | 243 | static void |
244 | reconnect (struct GNUNET_NAMESTORE_ZoneMonitor *zm) | 244 | reconnect (struct GNUNET_NAMESTORE_ZoneMonitor *zm) |
245 | { | 245 | { |
246 | GNUNET_MQ_hd_fixed_size (sync, | ||
247 | GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_SYNC, | ||
248 | struct GNUNET_MessageHeader); | ||
249 | GNUNET_MQ_hd_var_size (result, | ||
250 | GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT, | ||
251 | struct RecordResultMessage); | ||
252 | struct GNUNET_MQ_MessageHandler handlers[] = { | 246 | struct GNUNET_MQ_MessageHandler handlers[] = { |
253 | make_sync_handler (zm), | 247 | GNUNET_MQ_hd_fixed_size (sync, |
254 | make_result_handler (zm), | 248 | GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_SYNC, |
249 | struct GNUNET_MessageHeader, | ||
250 | zm), | ||
251 | GNUNET_MQ_hd_var_size (result, | ||
252 | GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT, | ||
253 | struct RecordResultMessage, | ||
254 | zm), | ||
255 | GNUNET_MQ_handler_end () | 255 | GNUNET_MQ_handler_end () |
256 | }; | 256 | }; |
257 | struct GNUNET_MQ_Envelope *env; | 257 | struct GNUNET_MQ_Envelope *env; |
diff --git a/src/nse/gnunet-service-nse.c b/src/nse/gnunet-service-nse.c index 2b6780c08..1f06c0a75 100644 --- a/src/nse/gnunet-service-nse.c +++ b/src/nse/gnunet-service-nse.c | |||
@@ -1484,16 +1484,16 @@ run (void *cls, | |||
1484 | struct GNUNET_SERVER_Handle *server, | 1484 | struct GNUNET_SERVER_Handle *server, |
1485 | const struct GNUNET_CONFIGURATION_Handle *c) | 1485 | const struct GNUNET_CONFIGURATION_Handle *c) |
1486 | { | 1486 | { |
1487 | GNUNET_MQ_hd_fixed_size (p2p_estimate, | ||
1488 | GNUNET_MESSAGE_TYPE_NSE_P2P_FLOOD, | ||
1489 | struct GNUNET_NSE_FloodMessage); | ||
1490 | static const struct GNUNET_SERVER_MessageHandler handlers[] = { | 1487 | static const struct GNUNET_SERVER_MessageHandler handlers[] = { |
1491 | {&handle_start_message, NULL, GNUNET_MESSAGE_TYPE_NSE_START, | 1488 | {&handle_start_message, NULL, GNUNET_MESSAGE_TYPE_NSE_START, |
1492 | sizeof (struct GNUNET_MessageHeader)}, | 1489 | sizeof (struct GNUNET_MessageHeader)}, |
1493 | {NULL, NULL, 0, 0} | 1490 | {NULL, NULL, 0, 0} |
1494 | }; | 1491 | }; |
1495 | struct GNUNET_MQ_MessageHandler core_handlers[] = { | 1492 | struct GNUNET_MQ_MessageHandler core_handlers[] = { |
1496 | make_p2p_estimate_handler (NULL), | 1493 | GNUNET_MQ_hd_fixed_size (p2p_estimate, |
1494 | GNUNET_MESSAGE_TYPE_NSE_P2P_FLOOD, | ||
1495 | struct GNUNET_NSE_FloodMessage, | ||
1496 | NULL), | ||
1497 | GNUNET_MQ_handler_end () | 1497 | GNUNET_MQ_handler_end () |
1498 | }; | 1498 | }; |
1499 | char *proof; | 1499 | char *proof; |
diff --git a/src/nse/nse_api.c b/src/nse/nse_api.c index e9b704be9..cfe5482eb 100644 --- a/src/nse/nse_api.c +++ b/src/nse/nse_api.c | |||
@@ -135,12 +135,12 @@ handle_estimate (void *cls, | |||
135 | static void | 135 | static void |
136 | reconnect (void *cls) | 136 | reconnect (void *cls) |
137 | { | 137 | { |
138 | GNUNET_MQ_hd_fixed_size (estimate, | ||
139 | GNUNET_MESSAGE_TYPE_NSE_ESTIMATE, | ||
140 | struct GNUNET_NSE_ClientMessage); | ||
141 | struct GNUNET_NSE_Handle *h = cls; | 138 | struct GNUNET_NSE_Handle *h = cls; |
142 | struct GNUNET_MQ_MessageHandler handlers[] = { | 139 | struct GNUNET_MQ_MessageHandler handlers[] = { |
143 | make_estimate_handler (h), | 140 | GNUNET_MQ_hd_fixed_size (estimate, |
141 | GNUNET_MESSAGE_TYPE_NSE_ESTIMATE, | ||
142 | struct GNUNET_NSE_ClientMessage, | ||
143 | h), | ||
144 | GNUNET_MQ_handler_end () | 144 | GNUNET_MQ_handler_end () |
145 | }; | 145 | }; |
146 | struct GNUNET_MessageHeader *msg; | 146 | struct GNUNET_MessageHeader *msg; |
diff --git a/src/peerinfo/peerinfo_api.c b/src/peerinfo/peerinfo_api.c index e477186ee..3080fb503 100644 --- a/src/peerinfo/peerinfo_api.c +++ b/src/peerinfo/peerinfo_api.c | |||
@@ -440,15 +440,15 @@ handle_end_iteration (void *cls, | |||
440 | static void | 440 | static void |
441 | reconnect (struct GNUNET_PEERINFO_Handle *h) | 441 | reconnect (struct GNUNET_PEERINFO_Handle *h) |
442 | { | 442 | { |
443 | GNUNET_MQ_hd_var_size (info, | ||
444 | GNUNET_MESSAGE_TYPE_PEERINFO_INFO, | ||
445 | struct InfoMessage); | ||
446 | GNUNET_MQ_hd_fixed_size (end_iteration, | ||
447 | GNUNET_MESSAGE_TYPE_PEERINFO_INFO_END, | ||
448 | struct GNUNET_MessageHeader); | ||
449 | struct GNUNET_MQ_MessageHandler handlers[] = { | 443 | struct GNUNET_MQ_MessageHandler handlers[] = { |
450 | make_info_handler (h), | 444 | GNUNET_MQ_hd_var_size (info, |
451 | make_end_iteration_handler (h), | 445 | GNUNET_MESSAGE_TYPE_PEERINFO_INFO, |
446 | struct InfoMessage, | ||
447 | h), | ||
448 | GNUNET_MQ_hd_fixed_size (end_iteration, | ||
449 | GNUNET_MESSAGE_TYPE_PEERINFO_INFO_END, | ||
450 | struct GNUNET_MessageHeader, | ||
451 | h), | ||
452 | GNUNET_MQ_handler_end () | 452 | GNUNET_MQ_handler_end () |
453 | }; | 453 | }; |
454 | 454 | ||
diff --git a/src/peerinfo/peerinfo_api_notify.c b/src/peerinfo/peerinfo_api_notify.c index c3dac5064..625cfb8f6 100644 --- a/src/peerinfo/peerinfo_api_notify.c +++ b/src/peerinfo/peerinfo_api_notify.c | |||
@@ -179,12 +179,12 @@ handle_notification (void *cls, | |||
179 | static void | 179 | static void |
180 | reconnect (void *cls) | 180 | reconnect (void *cls) |
181 | { | 181 | { |
182 | GNUNET_MQ_hd_var_size (notification, | ||
183 | GNUNET_MESSAGE_TYPE_PEERINFO_INFO, | ||
184 | struct InfoMessage); | ||
185 | struct GNUNET_PEERINFO_NotifyContext *nc = cls; | 182 | struct GNUNET_PEERINFO_NotifyContext *nc = cls; |
186 | struct GNUNET_MQ_MessageHandler handlers[] = { | 183 | struct GNUNET_MQ_MessageHandler handlers[] = { |
187 | make_notification_handler (nc), | 184 | GNUNET_MQ_hd_var_size (notification, |
185 | GNUNET_MESSAGE_TYPE_PEERINFO_INFO, | ||
186 | struct InfoMessage, | ||
187 | nc), | ||
188 | GNUNET_MQ_handler_end () | 188 | GNUNET_MQ_handler_end () |
189 | }; | 189 | }; |
190 | struct GNUNET_MQ_Envelope *env; | 190 | struct GNUNET_MQ_Envelope *env; |
diff --git a/src/peerstore/peerstore_api.c b/src/peerstore/peerstore_api.c index a288e74d2..f6910c017 100644 --- a/src/peerstore/peerstore_api.c +++ b/src/peerstore/peerstore_api.c | |||
@@ -786,19 +786,19 @@ handle_watch_record (void *cls, | |||
786 | static void | 786 | static void |
787 | reconnect (struct GNUNET_PEERSTORE_Handle *h) | 787 | reconnect (struct GNUNET_PEERSTORE_Handle *h) |
788 | { | 788 | { |
789 | GNUNET_MQ_hd_fixed_size (iterate_end, | ||
790 | GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE_END, | ||
791 | struct GNUNET_MessageHeader); | ||
792 | GNUNET_MQ_hd_var_size (iterate_result, | ||
793 | GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE_RECORD, | ||
794 | struct GNUNET_MessageHeader); | ||
795 | GNUNET_MQ_hd_var_size (watch_record, | ||
796 | GNUNET_MESSAGE_TYPE_PEERSTORE_WATCH_RECORD, | ||
797 | struct GNUNET_MessageHeader); | ||
798 | struct GNUNET_MQ_MessageHandler mq_handlers[] = { | 789 | struct GNUNET_MQ_MessageHandler mq_handlers[] = { |
799 | make_iterate_end_handler (h), | 790 | GNUNET_MQ_hd_fixed_size (iterate_end, |
800 | make_iterate_result_handler (h), | 791 | GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE_END, |
801 | make_watch_record_handler (h), | 792 | struct GNUNET_MessageHeader, |
793 | h), | ||
794 | GNUNET_MQ_hd_var_size (iterate_result, | ||
795 | GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE_RECORD, | ||
796 | struct GNUNET_MessageHeader, | ||
797 | h), | ||
798 | GNUNET_MQ_hd_var_size (watch_record, | ||
799 | GNUNET_MESSAGE_TYPE_PEERSTORE_WATCH_RECORD, | ||
800 | struct GNUNET_MessageHeader, | ||
801 | h), | ||
802 | GNUNET_MQ_handler_end () | 802 | GNUNET_MQ_handler_end () |
803 | }; | 803 | }; |
804 | struct GNUNET_PEERSTORE_IterateContext *ic; | 804 | struct GNUNET_PEERSTORE_IterateContext *ic; |
diff --git a/src/psyc/psyc_api.c b/src/psyc/psyc_api.c index 8e960c7be..45e4135a3 100644 --- a/src/psyc/psyc_api.c +++ b/src/psyc/psyc_api.c | |||
@@ -642,42 +642,35 @@ master_connect (struct GNUNET_PSYC_Master *mst) | |||
642 | { | 642 | { |
643 | struct GNUNET_PSYC_Channel *chn = &mst->chn; | 643 | struct GNUNET_PSYC_Channel *chn = &mst->chn; |
644 | 644 | ||
645 | GNUNET_MQ_hd_fixed_size (master_start_ack, | ||
646 | GNUNET_MESSAGE_TYPE_PSYC_MASTER_START_ACK, | ||
647 | struct GNUNET_PSYC_CountersResultMessage); | ||
648 | |||
649 | GNUNET_MQ_hd_var_size (master_join_request, | ||
650 | GNUNET_MESSAGE_TYPE_PSYC_JOIN_REQUEST, | ||
651 | struct GNUNET_PSYC_JoinRequestMessage); | ||
652 | |||
653 | GNUNET_MQ_hd_var_size (channel_message, | ||
654 | GNUNET_MESSAGE_TYPE_PSYC_MESSAGE, | ||
655 | struct GNUNET_PSYC_MessageHeader); | ||
656 | |||
657 | GNUNET_MQ_hd_fixed_size (channel_message_ack, | ||
658 | GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_ACK, | ||
659 | struct GNUNET_MessageHeader); | ||
660 | |||
661 | GNUNET_MQ_hd_var_size (channel_history_result, | ||
662 | GNUNET_MESSAGE_TYPE_PSYC_HISTORY_RESULT, | ||
663 | struct GNUNET_OperationResultMessage); | ||
664 | |||
665 | GNUNET_MQ_hd_var_size (channel_state_result, | ||
666 | GNUNET_MESSAGE_TYPE_PSYC_STATE_RESULT, | ||
667 | struct GNUNET_OperationResultMessage); | ||
668 | |||
669 | GNUNET_MQ_hd_var_size (channel_result, | ||
670 | GNUNET_MESSAGE_TYPE_PSYC_RESULT_CODE, | ||
671 | struct GNUNET_OperationResultMessage); | ||
672 | |||
673 | struct GNUNET_MQ_MessageHandler handlers[] = { | 645 | struct GNUNET_MQ_MessageHandler handlers[] = { |
674 | make_master_start_ack_handler (mst), | 646 | GNUNET_MQ_hd_fixed_size (master_start_ack, |
675 | make_master_join_request_handler (mst), | 647 | GNUNET_MESSAGE_TYPE_PSYC_MASTER_START_ACK, |
676 | make_channel_message_handler (chn), | 648 | struct GNUNET_PSYC_CountersResultMessage, |
677 | make_channel_message_ack_handler (chn), | 649 | mst), |
678 | make_channel_history_result_handler (chn), | 650 | GNUNET_MQ_hd_var_size (master_join_request, |
679 | make_channel_state_result_handler (chn), | 651 | GNUNET_MESSAGE_TYPE_PSYC_JOIN_REQUEST, |
680 | make_channel_result_handler (chn), | 652 | struct GNUNET_PSYC_JoinRequestMessage, |
653 | mst), | ||
654 | GNUNET_MQ_hd_var_size (channel_message, | ||
655 | GNUNET_MESSAGE_TYPE_PSYC_MESSAGE, | ||
656 | struct GNUNET_PSYC_MessageHeader, | ||
657 | chn), | ||
658 | GNUNET_MQ_hd_fixed_size (channel_message_ack, | ||
659 | GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_ACK, | ||
660 | struct GNUNET_MessageHeader, | ||
661 | chn), | ||
662 | GNUNET_MQ_hd_var_size (channel_history_result, | ||
663 | GNUNET_MESSAGE_TYPE_PSYC_HISTORY_RESULT, | ||
664 | struct GNUNET_OperationResultMessage, | ||
665 | chn), | ||
666 | GNUNET_MQ_hd_var_size (channel_state_result, | ||
667 | GNUNET_MESSAGE_TYPE_PSYC_STATE_RESULT, | ||
668 | struct GNUNET_OperationResultMessage, | ||
669 | chn), | ||
670 | GNUNET_MQ_hd_var_size (channel_result, | ||
671 | GNUNET_MESSAGE_TYPE_PSYC_RESULT_CODE, | ||
672 | struct GNUNET_OperationResultMessage, | ||
673 | chn), | ||
681 | GNUNET_MQ_handler_end () | 674 | GNUNET_MQ_handler_end () |
682 | }; | 675 | }; |
683 | 676 | ||
@@ -948,42 +941,35 @@ slave_connect (struct GNUNET_PSYC_Slave *slv) | |||
948 | { | 941 | { |
949 | struct GNUNET_PSYC_Channel *chn = &slv->chn; | 942 | struct GNUNET_PSYC_Channel *chn = &slv->chn; |
950 | 943 | ||
951 | GNUNET_MQ_hd_fixed_size (slave_join_ack, | ||
952 | GNUNET_MESSAGE_TYPE_PSYC_SLAVE_JOIN_ACK, | ||
953 | struct GNUNET_PSYC_CountersResultMessage); | ||
954 | |||
955 | GNUNET_MQ_hd_var_size (slave_join_decision, | ||
956 | GNUNET_MESSAGE_TYPE_PSYC_JOIN_DECISION, | ||
957 | struct GNUNET_PSYC_JoinDecisionMessage); | ||
958 | |||
959 | GNUNET_MQ_hd_var_size (channel_message, | ||
960 | GNUNET_MESSAGE_TYPE_PSYC_MESSAGE, | ||
961 | struct GNUNET_PSYC_MessageHeader); | ||
962 | |||
963 | GNUNET_MQ_hd_fixed_size (channel_message_ack, | ||
964 | GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_ACK, | ||
965 | struct GNUNET_MessageHeader); | ||
966 | |||
967 | GNUNET_MQ_hd_var_size (channel_history_result, | ||
968 | GNUNET_MESSAGE_TYPE_PSYC_HISTORY_RESULT, | ||
969 | struct GNUNET_OperationResultMessage); | ||
970 | |||
971 | GNUNET_MQ_hd_var_size (channel_state_result, | ||
972 | GNUNET_MESSAGE_TYPE_PSYC_STATE_RESULT, | ||
973 | struct GNUNET_OperationResultMessage); | ||
974 | |||
975 | GNUNET_MQ_hd_var_size (channel_result, | ||
976 | GNUNET_MESSAGE_TYPE_PSYC_RESULT_CODE, | ||
977 | struct GNUNET_OperationResultMessage); | ||
978 | |||
979 | struct GNUNET_MQ_MessageHandler handlers[] = { | 944 | struct GNUNET_MQ_MessageHandler handlers[] = { |
980 | make_slave_join_ack_handler (slv), | 945 | GNUNET_MQ_hd_fixed_size (slave_join_ack, |
981 | make_slave_join_decision_handler (slv), | 946 | GNUNET_MESSAGE_TYPE_PSYC_SLAVE_JOIN_ACK, |
982 | make_channel_message_handler (chn), | 947 | struct GNUNET_PSYC_CountersResultMessage, |
983 | make_channel_message_ack_handler (chn), | 948 | slv), |
984 | make_channel_history_result_handler (chn), | 949 | GNUNET_MQ_hd_var_size (slave_join_decision, |
985 | make_channel_state_result_handler (chn), | 950 | GNUNET_MESSAGE_TYPE_PSYC_JOIN_DECISION, |
986 | make_channel_result_handler (chn), | 951 | struct GNUNET_PSYC_JoinDecisionMessage, |
952 | slv), | ||
953 | GNUNET_MQ_hd_var_size (channel_message, | ||
954 | GNUNET_MESSAGE_TYPE_PSYC_MESSAGE, | ||
955 | struct GNUNET_PSYC_MessageHeader, | ||
956 | chn), | ||
957 | GNUNET_MQ_hd_fixed_size (channel_message_ack, | ||
958 | GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_ACK, | ||
959 | struct GNUNET_MessageHeader, | ||
960 | chn), | ||
961 | GNUNET_MQ_hd_var_size (channel_history_result, | ||
962 | GNUNET_MESSAGE_TYPE_PSYC_HISTORY_RESULT, | ||
963 | struct GNUNET_OperationResultMessage, | ||
964 | chn), | ||
965 | GNUNET_MQ_hd_var_size (channel_state_result, | ||
966 | GNUNET_MESSAGE_TYPE_PSYC_STATE_RESULT, | ||
967 | struct GNUNET_OperationResultMessage, | ||
968 | chn), | ||
969 | GNUNET_MQ_hd_var_size (channel_result, | ||
970 | GNUNET_MESSAGE_TYPE_PSYC_RESULT_CODE, | ||
971 | struct GNUNET_OperationResultMessage, | ||
972 | chn), | ||
987 | GNUNET_MQ_handler_end () | 973 | GNUNET_MQ_handler_end () |
988 | }; | 974 | }; |
989 | 975 | ||
diff --git a/src/psycstore/psycstore_api.c b/src/psycstore/psycstore_api.c index 89be19a42..7bbf2e3d8 100644 --- a/src/psycstore/psycstore_api.c +++ b/src/psycstore/psycstore_api.c | |||
@@ -323,27 +323,23 @@ do_connect (struct GNUNET_PSYCSTORE_Handle *h) | |||
323 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 323 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
324 | "Connecting to PSYCstore service.\n"); | 324 | "Connecting to PSYCstore service.\n"); |
325 | 325 | ||
326 | GNUNET_MQ_hd_var_size (result_code, | ||
327 | GNUNET_MESSAGE_TYPE_PSYCSTORE_RESULT_CODE, | ||
328 | struct OperationResult); | ||
329 | |||
330 | GNUNET_MQ_hd_fixed_size (result_counters, | ||
331 | GNUNET_MESSAGE_TYPE_PSYCSTORE_RESULT_COUNTERS, | ||
332 | struct CountersResult); | ||
333 | |||
334 | GNUNET_MQ_hd_var_size (result_fragment, | ||
335 | GNUNET_MESSAGE_TYPE_PSYCSTORE_RESULT_FRAGMENT, | ||
336 | struct FragmentResult); | ||
337 | |||
338 | GNUNET_MQ_hd_var_size (result_state, | ||
339 | GNUNET_MESSAGE_TYPE_PSYCSTORE_RESULT_STATE, | ||
340 | struct StateResult); | ||
341 | |||
342 | struct GNUNET_MQ_MessageHandler handlers[] = { | 326 | struct GNUNET_MQ_MessageHandler handlers[] = { |
343 | make_result_code_handler (h), | 327 | GNUNET_MQ_hd_var_size (result_code, |
344 | make_result_counters_handler (h), | 328 | GNUNET_MESSAGE_TYPE_PSYCSTORE_RESULT_CODE, |
345 | make_result_fragment_handler (h), | 329 | struct OperationResult, |
346 | make_result_state_handler (h), | 330 | h), |
331 | GNUNET_MQ_hd_fixed_size (result_counters, | ||
332 | GNUNET_MESSAGE_TYPE_PSYCSTORE_RESULT_COUNTERS, | ||
333 | struct CountersResult, | ||
334 | h), | ||
335 | GNUNET_MQ_hd_var_size (result_fragment, | ||
336 | GNUNET_MESSAGE_TYPE_PSYCSTORE_RESULT_FRAGMENT, | ||
337 | struct FragmentResult, | ||
338 | h), | ||
339 | GNUNET_MQ_hd_var_size (result_state, | ||
340 | GNUNET_MESSAGE_TYPE_PSYCSTORE_RESULT_STATE, | ||
341 | struct StateResult, | ||
342 | h), | ||
347 | GNUNET_MQ_handler_end () | 343 | GNUNET_MQ_handler_end () |
348 | }; | 344 | }; |
349 | 345 | ||
diff --git a/src/regex/regex_api_search.c b/src/regex/regex_api_search.c index 84a58f367..ff85f5748 100644 --- a/src/regex/regex_api_search.c +++ b/src/regex/regex_api_search.c | |||
@@ -155,11 +155,11 @@ mq_error_handler (void *cls, | |||
155 | static void | 155 | static void |
156 | search_reconnect (struct GNUNET_REGEX_Search *s) | 156 | search_reconnect (struct GNUNET_REGEX_Search *s) |
157 | { | 157 | { |
158 | GNUNET_MQ_hd_var_size (search_response, | ||
159 | GNUNET_MESSAGE_TYPE_REGEX_RESULT, | ||
160 | struct ResultMessage); | ||
161 | struct GNUNET_MQ_MessageHandler handlers[] = { | 158 | struct GNUNET_MQ_MessageHandler handlers[] = { |
162 | make_search_response_handler (s), | 159 | GNUNET_MQ_hd_var_size (search_response, |
160 | GNUNET_MESSAGE_TYPE_REGEX_RESULT, | ||
161 | struct ResultMessage, | ||
162 | s), | ||
163 | GNUNET_MQ_handler_end () | 163 | GNUNET_MQ_handler_end () |
164 | }; | 164 | }; |
165 | size_t slen = strlen (s->string) + 1; | 165 | size_t slen = strlen (s->string) + 1; |
diff --git a/src/revocation/gnunet-service-revocation.c b/src/revocation/gnunet-service-revocation.c index 0f67977a1..706432ece 100644 --- a/src/revocation/gnunet-service-revocation.c +++ b/src/revocation/gnunet-service-revocation.c | |||
@@ -777,9 +777,6 @@ run (void *cls, | |||
777 | struct GNUNET_SERVER_Handle *server, | 777 | struct GNUNET_SERVER_Handle *server, |
778 | const struct GNUNET_CONFIGURATION_Handle *c) | 778 | const struct GNUNET_CONFIGURATION_Handle *c) |
779 | { | 779 | { |
780 | GNUNET_MQ_hd_fixed_size (p2p_revoke, | ||
781 | GNUNET_MESSAGE_TYPE_REVOCATION_REVOKE, | ||
782 | struct RevokeMessage); | ||
783 | static const struct GNUNET_SERVER_MessageHandler handlers[] = { | 780 | static const struct GNUNET_SERVER_MessageHandler handlers[] = { |
784 | {&handle_query_message, NULL, GNUNET_MESSAGE_TYPE_REVOCATION_QUERY, | 781 | {&handle_query_message, NULL, GNUNET_MESSAGE_TYPE_REVOCATION_QUERY, |
785 | sizeof (struct QueryMessage)}, | 782 | sizeof (struct QueryMessage)}, |
@@ -788,7 +785,10 @@ run (void *cls, | |||
788 | {NULL, NULL, 0, 0} | 785 | {NULL, NULL, 0, 0} |
789 | }; | 786 | }; |
790 | struct GNUNET_MQ_MessageHandler core_handlers[] = { | 787 | struct GNUNET_MQ_MessageHandler core_handlers[] = { |
791 | make_p2p_revoke_handler (NULL), | 788 | GNUNET_MQ_hd_fixed_size (p2p_revoke, |
789 | GNUNET_MESSAGE_TYPE_REVOCATION_REVOKE, | ||
790 | struct RevokeMessage, | ||
791 | NULL), | ||
792 | GNUNET_MQ_handler_end () | 792 | GNUNET_MQ_handler_end () |
793 | }; | 793 | }; |
794 | char *fn; | 794 | char *fn; |
diff --git a/src/revocation/revocation_api.c b/src/revocation/revocation_api.c index 0b9bc4ea6..8c00ac2ae 100644 --- a/src/revocation/revocation_api.c +++ b/src/revocation/revocation_api.c | |||
@@ -113,13 +113,13 @@ GNUNET_REVOCATION_query (const struct GNUNET_CONFIGURATION_Handle *cfg, | |||
113 | GNUNET_REVOCATION_Callback func, | 113 | GNUNET_REVOCATION_Callback func, |
114 | void *func_cls) | 114 | void *func_cls) |
115 | { | 115 | { |
116 | GNUNET_MQ_hd_fixed_size (revocation_query_response, | ||
117 | GNUNET_MESSAGE_TYPE_REVOCATION_QUERY_RESPONSE, | ||
118 | struct QueryResponseMessage); | ||
119 | struct GNUNET_REVOCATION_Query *q | 116 | struct GNUNET_REVOCATION_Query *q |
120 | = GNUNET_new (struct GNUNET_REVOCATION_Query); | 117 | = GNUNET_new (struct GNUNET_REVOCATION_Query); |
121 | struct GNUNET_MQ_MessageHandler handlers[] = { | 118 | struct GNUNET_MQ_MessageHandler handlers[] = { |
122 | make_revocation_query_response_handler (q), | 119 | GNUNET_MQ_hd_fixed_size (revocation_query_response, |
120 | GNUNET_MESSAGE_TYPE_REVOCATION_QUERY_RESPONSE, | ||
121 | struct QueryResponseMessage, | ||
122 | q), | ||
123 | GNUNET_MQ_handler_end () | 123 | GNUNET_MQ_handler_end () |
124 | }; | 124 | }; |
125 | struct QueryMessage *qm; | 125 | struct QueryMessage *qm; |
@@ -255,13 +255,13 @@ GNUNET_REVOCATION_revoke (const struct GNUNET_CONFIGURATION_Handle *cfg, | |||
255 | GNUNET_REVOCATION_Callback func, | 255 | GNUNET_REVOCATION_Callback func, |
256 | void *func_cls) | 256 | void *func_cls) |
257 | { | 257 | { |
258 | GNUNET_MQ_hd_fixed_size (revocation_response, | ||
259 | GNUNET_MESSAGE_TYPE_REVOCATION_REVOKE_RESPONSE, | ||
260 | struct RevocationResponseMessage); | ||
261 | struct GNUNET_REVOCATION_Handle *h | 258 | struct GNUNET_REVOCATION_Handle *h |
262 | = GNUNET_new (struct GNUNET_REVOCATION_Handle); | 259 | = GNUNET_new (struct GNUNET_REVOCATION_Handle); |
263 | struct GNUNET_MQ_MessageHandler handlers[] = { | 260 | struct GNUNET_MQ_MessageHandler handlers[] = { |
264 | make_revocation_response_handler (h), | 261 | GNUNET_MQ_hd_fixed_size (revocation_response, |
262 | GNUNET_MESSAGE_TYPE_REVOCATION_REVOKE_RESPONSE, | ||
263 | struct RevocationResponseMessage, | ||
264 | h), | ||
265 | GNUNET_MQ_handler_end () | 265 | GNUNET_MQ_handler_end () |
266 | }; | 266 | }; |
267 | unsigned long long matching_bits; | 267 | unsigned long long matching_bits; |
diff --git a/src/rps/rps_api.c b/src/rps/rps_api.c index 39fb0168b..c04056c58 100644 --- a/src/rps/rps_api.c +++ b/src/rps/rps_api.c | |||
@@ -211,11 +211,11 @@ mq_error_handler (void *cls, | |||
211 | static void | 211 | static void |
212 | reconnect (struct GNUNET_RPS_Handle *h) | 212 | reconnect (struct GNUNET_RPS_Handle *h) |
213 | { | 213 | { |
214 | GNUNET_MQ_hd_var_size (reply, | ||
215 | GNUNET_MESSAGE_TYPE_RPS_CS_REPLY, | ||
216 | struct GNUNET_RPS_CS_ReplyMessage); | ||
217 | struct GNUNET_MQ_MessageHandler mq_handlers[] = { | 214 | struct GNUNET_MQ_MessageHandler mq_handlers[] = { |
218 | make_reply_handler (h), | 215 | GNUNET_MQ_hd_var_size (reply, |
216 | GNUNET_MESSAGE_TYPE_RPS_CS_REPLY, | ||
217 | struct GNUNET_RPS_CS_ReplyMessage, | ||
218 | h), | ||
219 | GNUNET_MQ_handler_end () | 219 | GNUNET_MQ_handler_end () |
220 | }; | 220 | }; |
221 | 221 | ||
diff --git a/src/scalarproduct/scalarproduct_api.c b/src/scalarproduct/scalarproduct_api.c index 09e06d5a0..5ad64f4be 100644 --- a/src/scalarproduct/scalarproduct_api.c +++ b/src/scalarproduct/scalarproduct_api.c | |||
@@ -230,13 +230,13 @@ GNUNET_SCALARPRODUCT_accept_computation (const struct GNUNET_CONFIGURATION_Handl | |||
230 | GNUNET_SCALARPRODUCT_ContinuationWithStatus cont, | 230 | GNUNET_SCALARPRODUCT_ContinuationWithStatus cont, |
231 | void *cont_cls) | 231 | void *cont_cls) |
232 | { | 232 | { |
233 | GNUNET_MQ_hd_var_size (response, | ||
234 | GNUNET_MESSAGE_TYPE_SCALARPRODUCT_RESULT, | ||
235 | struct ClientResponseMessage); | ||
236 | struct GNUNET_SCALARPRODUCT_ComputationHandle *h | 233 | struct GNUNET_SCALARPRODUCT_ComputationHandle *h |
237 | = GNUNET_new (struct GNUNET_SCALARPRODUCT_ComputationHandle); | 234 | = GNUNET_new (struct GNUNET_SCALARPRODUCT_ComputationHandle); |
238 | struct GNUNET_MQ_MessageHandler handlers[] = { | 235 | struct GNUNET_MQ_MessageHandler handlers[] = { |
239 | make_response_handler (h), | 236 | GNUNET_MQ_hd_var_size (response, |
237 | GNUNET_MESSAGE_TYPE_SCALARPRODUCT_RESULT, | ||
238 | struct ClientResponseMessage, | ||
239 | h), | ||
240 | GNUNET_MQ_handler_end () | 240 | GNUNET_MQ_handler_end () |
241 | }; | 241 | }; |
242 | struct GNUNET_MQ_Envelope *env; | 242 | struct GNUNET_MQ_Envelope *env; |
@@ -388,13 +388,13 @@ GNUNET_SCALARPRODUCT_start_computation (const struct GNUNET_CONFIGURATION_Handle | |||
388 | GNUNET_SCALARPRODUCT_DatumProcessor cont, | 388 | GNUNET_SCALARPRODUCT_DatumProcessor cont, |
389 | void *cont_cls) | 389 | void *cont_cls) |
390 | { | 390 | { |
391 | GNUNET_MQ_hd_var_size (response, | ||
392 | GNUNET_MESSAGE_TYPE_SCALARPRODUCT_RESULT, | ||
393 | struct ClientResponseMessage); | ||
394 | struct GNUNET_SCALARPRODUCT_ComputationHandle *h | 391 | struct GNUNET_SCALARPRODUCT_ComputationHandle *h |
395 | = GNUNET_new (struct GNUNET_SCALARPRODUCT_ComputationHandle); | 392 | = GNUNET_new (struct GNUNET_SCALARPRODUCT_ComputationHandle); |
396 | struct GNUNET_MQ_MessageHandler handlers[] = { | 393 | struct GNUNET_MQ_MessageHandler handlers[] = { |
397 | make_response_handler (h), | 394 | GNUNET_MQ_hd_var_size (response, |
395 | GNUNET_MESSAGE_TYPE_SCALARPRODUCT_RESULT, | ||
396 | struct ClientResponseMessage, | ||
397 | h), | ||
398 | GNUNET_MQ_handler_end () | 398 | GNUNET_MQ_handler_end () |
399 | }; | 399 | }; |
400 | struct GNUNET_MQ_Envelope *env; | 400 | struct GNUNET_MQ_Envelope *env; |
diff --git a/src/secretsharing/secretsharing_api.c b/src/secretsharing/secretsharing_api.c index 429aec47e..78167b671 100644 --- a/src/secretsharing/secretsharing_api.c +++ b/src/secretsharing/secretsharing_api.c | |||
@@ -249,13 +249,13 @@ GNUNET_SECRETSHARING_create_session (const struct GNUNET_CONFIGURATION_Handle *c | |||
249 | GNUNET_SECRETSHARING_SecretReadyCallback cb, | 249 | GNUNET_SECRETSHARING_SecretReadyCallback cb, |
250 | void *cls) | 250 | void *cls) |
251 | { | 251 | { |
252 | GNUNET_MQ_hd_var_size (secret_ready, | ||
253 | GNUNET_MESSAGE_TYPE_SECRETSHARING_CLIENT_SECRET_READY, | ||
254 | struct GNUNET_SECRETSHARING_SecretReadyMessage); | ||
255 | struct GNUNET_SECRETSHARING_Session *s | 252 | struct GNUNET_SECRETSHARING_Session *s |
256 | = GNUNET_new (struct GNUNET_SECRETSHARING_Session); | 253 | = GNUNET_new (struct GNUNET_SECRETSHARING_Session); |
257 | struct GNUNET_MQ_MessageHandler mq_handlers[] = { | 254 | struct GNUNET_MQ_MessageHandler mq_handlers[] = { |
258 | make_secret_ready_handler (s), | 255 | GNUNET_MQ_hd_var_size (secret_ready, |
256 | GNUNET_MESSAGE_TYPE_SECRETSHARING_CLIENT_SECRET_READY, | ||
257 | struct GNUNET_SECRETSHARING_SecretReadyMessage, | ||
258 | s), | ||
259 | GNUNET_MQ_handler_end () | 259 | GNUNET_MQ_handler_end () |
260 | }; | 260 | }; |
261 | struct GNUNET_MQ_Envelope *ev; | 261 | struct GNUNET_MQ_Envelope *ev; |
@@ -333,13 +333,13 @@ GNUNET_SECRETSHARING_decrypt (const struct GNUNET_CONFIGURATION_Handle *cfg, | |||
333 | GNUNET_SECRETSHARING_DecryptCallback decrypt_cb, | 333 | GNUNET_SECRETSHARING_DecryptCallback decrypt_cb, |
334 | void *decrypt_cb_cls) | 334 | void *decrypt_cb_cls) |
335 | { | 335 | { |
336 | GNUNET_MQ_hd_fixed_size (decrypt_done, | ||
337 | GNUNET_MESSAGE_TYPE_SECRETSHARING_CLIENT_DECRYPT_DONE, | ||
338 | struct GNUNET_SECRETSHARING_DecryptResponseMessage); | ||
339 | struct GNUNET_SECRETSHARING_DecryptionHandle *s | 336 | struct GNUNET_SECRETSHARING_DecryptionHandle *s |
340 | = GNUNET_new (struct GNUNET_SECRETSHARING_DecryptionHandle); | 337 | = GNUNET_new (struct GNUNET_SECRETSHARING_DecryptionHandle); |
341 | struct GNUNET_MQ_MessageHandler mq_handlers[] = { | 338 | struct GNUNET_MQ_MessageHandler mq_handlers[] = { |
342 | make_decrypt_done_handler (s), | 339 | GNUNET_MQ_hd_fixed_size (decrypt_done, |
340 | GNUNET_MESSAGE_TYPE_SECRETSHARING_CLIENT_DECRYPT_DONE, | ||
341 | struct GNUNET_SECRETSHARING_DecryptResponseMessage, | ||
342 | s), | ||
343 | GNUNET_MQ_handler_end () | 343 | GNUNET_MQ_handler_end () |
344 | }; | 344 | }; |
345 | struct GNUNET_MQ_Envelope *ev; | 345 | struct GNUNET_MQ_Envelope *ev; |
diff --git a/src/set/set_api.c b/src/set/set_api.c index 3e9a4fdcf..7a33b86ea 100644 --- a/src/set/set_api.c +++ b/src/set/set_api.c | |||
@@ -561,24 +561,24 @@ create_internal (const struct GNUNET_CONFIGURATION_Handle *cfg, | |||
561 | enum GNUNET_SET_OperationType op, | 561 | enum GNUNET_SET_OperationType op, |
562 | const uint32_t *cookie) | 562 | const uint32_t *cookie) |
563 | { | 563 | { |
564 | GNUNET_MQ_hd_var_size (result, | ||
565 | GNUNET_MESSAGE_TYPE_SET_RESULT, | ||
566 | struct GNUNET_SET_ResultMessage); | ||
567 | GNUNET_MQ_hd_var_size (iter_element, | ||
568 | GNUNET_MESSAGE_TYPE_SET_ITER_ELEMENT, | ||
569 | struct GNUNET_SET_IterResponseMessage); | ||
570 | GNUNET_MQ_hd_fixed_size (iter_done, | ||
571 | GNUNET_MESSAGE_TYPE_SET_ITER_DONE, | ||
572 | struct GNUNET_MessageHeader); | ||
573 | GNUNET_MQ_hd_fixed_size (copy_lazy, | ||
574 | GNUNET_MESSAGE_TYPE_SET_COPY_LAZY_RESPONSE, | ||
575 | struct GNUNET_SET_CopyLazyResponseMessage); | ||
576 | struct GNUNET_SET_Handle *set = GNUNET_new (struct GNUNET_SET_Handle); | 564 | struct GNUNET_SET_Handle *set = GNUNET_new (struct GNUNET_SET_Handle); |
577 | struct GNUNET_MQ_MessageHandler mq_handlers[] = { | 565 | struct GNUNET_MQ_MessageHandler mq_handlers[] = { |
578 | make_result_handler (set), | 566 | GNUNET_MQ_hd_var_size (result, |
579 | make_iter_element_handler (set), | 567 | GNUNET_MESSAGE_TYPE_SET_RESULT, |
580 | make_iter_done_handler (set), | 568 | struct GNUNET_SET_ResultMessage, |
581 | make_copy_lazy_handler (set), | 569 | set), |
570 | GNUNET_MQ_hd_var_size (iter_element, | ||
571 | GNUNET_MESSAGE_TYPE_SET_ITER_ELEMENT, | ||
572 | struct GNUNET_SET_IterResponseMessage, | ||
573 | set), | ||
574 | GNUNET_MQ_hd_fixed_size (iter_done, | ||
575 | GNUNET_MESSAGE_TYPE_SET_ITER_DONE, | ||
576 | struct GNUNET_MessageHeader, | ||
577 | set), | ||
578 | GNUNET_MQ_hd_fixed_size (copy_lazy, | ||
579 | GNUNET_MESSAGE_TYPE_SET_COPY_LAZY_RESPONSE, | ||
580 | struct GNUNET_SET_CopyLazyResponseMessage, | ||
581 | set), | ||
582 | GNUNET_MQ_handler_end () | 582 | GNUNET_MQ_handler_end () |
583 | }; | 583 | }; |
584 | struct GNUNET_MQ_Envelope *mqm; | 584 | struct GNUNET_MQ_Envelope *mqm; |
@@ -901,12 +901,12 @@ handle_client_listener_error (void *cls, | |||
901 | static void | 901 | static void |
902 | listen_connect (void *cls) | 902 | listen_connect (void *cls) |
903 | { | 903 | { |
904 | GNUNET_MQ_hd_var_size (request, | ||
905 | GNUNET_MESSAGE_TYPE_SET_REQUEST, | ||
906 | struct GNUNET_SET_RequestMessage); | ||
907 | struct GNUNET_SET_ListenHandle *lh = cls; | 904 | struct GNUNET_SET_ListenHandle *lh = cls; |
908 | struct GNUNET_MQ_MessageHandler mq_handlers[] = { | 905 | struct GNUNET_MQ_MessageHandler mq_handlers[] = { |
909 | make_request_handler (lh), | 906 | GNUNET_MQ_hd_var_size (request, |
907 | GNUNET_MESSAGE_TYPE_SET_REQUEST, | ||
908 | struct GNUNET_SET_RequestMessage, | ||
909 | lh), | ||
910 | GNUNET_MQ_handler_end () | 910 | GNUNET_MQ_handler_end () |
911 | }; | 911 | }; |
912 | struct GNUNET_MQ_Envelope *mqm; | 912 | struct GNUNET_MQ_Envelope *mqm; |
diff --git a/src/social/social_api.c b/src/social/social_api.c index c08de0356..583ce6d1e 100644 --- a/src/social/social_api.c +++ b/src/social/social_api.c | |||
@@ -1155,42 +1155,35 @@ host_connect (struct GNUNET_SOCIAL_Host *hst) | |||
1155 | { | 1155 | { |
1156 | struct GNUNET_SOCIAL_Place *plc = &hst->plc; | 1156 | struct GNUNET_SOCIAL_Place *plc = &hst->plc; |
1157 | 1157 | ||
1158 | GNUNET_MQ_hd_fixed_size (host_enter_ack, | ||
1159 | GNUNET_MESSAGE_TYPE_SOCIAL_HOST_ENTER_ACK, | ||
1160 | struct HostEnterAck); | ||
1161 | |||
1162 | GNUNET_MQ_hd_var_size (host_enter_request, | ||
1163 | GNUNET_MESSAGE_TYPE_PSYC_JOIN_REQUEST, | ||
1164 | struct GNUNET_PSYC_JoinRequestMessage); | ||
1165 | |||
1166 | GNUNET_MQ_hd_var_size (host_message, | ||
1167 | GNUNET_MESSAGE_TYPE_PSYC_MESSAGE, | ||
1168 | struct GNUNET_PSYC_MessageHeader); | ||
1169 | |||
1170 | GNUNET_MQ_hd_fixed_size (place_message_ack, | ||
1171 | GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_ACK, | ||
1172 | struct GNUNET_MessageHeader); | ||
1173 | |||
1174 | GNUNET_MQ_hd_var_size (place_history_result, | ||
1175 | GNUNET_MESSAGE_TYPE_PSYC_HISTORY_RESULT, | ||
1176 | struct GNUNET_OperationResultMessage); | ||
1177 | |||
1178 | GNUNET_MQ_hd_var_size (place_state_result, | ||
1179 | GNUNET_MESSAGE_TYPE_PSYC_STATE_RESULT, | ||
1180 | struct GNUNET_OperationResultMessage); | ||
1181 | |||
1182 | GNUNET_MQ_hd_var_size (place_result, | ||
1183 | GNUNET_MESSAGE_TYPE_PSYC_RESULT_CODE, | ||
1184 | struct GNUNET_OperationResultMessage); | ||
1185 | |||
1186 | struct GNUNET_MQ_MessageHandler handlers[] = { | 1158 | struct GNUNET_MQ_MessageHandler handlers[] = { |
1187 | make_host_enter_ack_handler (hst), | 1159 | GNUNET_MQ_hd_fixed_size (host_enter_ack, |
1188 | make_host_enter_request_handler (hst), | 1160 | GNUNET_MESSAGE_TYPE_SOCIAL_HOST_ENTER_ACK, |
1189 | make_host_message_handler (plc), | 1161 | struct HostEnterAck, |
1190 | make_place_message_ack_handler (plc), | 1162 | hst), |
1191 | make_place_history_result_handler (plc), | 1163 | GNUNET_MQ_hd_var_size (host_enter_request, |
1192 | make_place_state_result_handler (plc), | 1164 | GNUNET_MESSAGE_TYPE_PSYC_JOIN_REQUEST, |
1193 | make_place_result_handler (plc), | 1165 | struct GNUNET_PSYC_JoinRequestMessage, |
1166 | hst), | ||
1167 | GNUNET_MQ_hd_var_size (host_message, | ||
1168 | GNUNET_MESSAGE_TYPE_PSYC_MESSAGE, | ||
1169 | struct GNUNET_PSYC_MessageHeader, | ||
1170 | hst), | ||
1171 | GNUNET_MQ_hd_fixed_size (place_message_ack, | ||
1172 | GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_ACK, | ||
1173 | struct GNUNET_MessageHeader, | ||
1174 | plc), | ||
1175 | GNUNET_MQ_hd_var_size (place_history_result, | ||
1176 | GNUNET_MESSAGE_TYPE_PSYC_HISTORY_RESULT, | ||
1177 | struct GNUNET_OperationResultMessage, | ||
1178 | plc), | ||
1179 | GNUNET_MQ_hd_var_size (place_state_result, | ||
1180 | GNUNET_MESSAGE_TYPE_PSYC_STATE_RESULT, | ||
1181 | struct GNUNET_OperationResultMessage, | ||
1182 | plc), | ||
1183 | GNUNET_MQ_hd_var_size (place_result, | ||
1184 | GNUNET_MESSAGE_TYPE_PSYC_RESULT_CODE, | ||
1185 | struct GNUNET_OperationResultMessage, | ||
1186 | plc), | ||
1194 | GNUNET_MQ_handler_end () | 1187 | GNUNET_MQ_handler_end () |
1195 | }; | 1188 | }; |
1196 | 1189 | ||
@@ -1664,42 +1657,35 @@ guest_connect (struct GNUNET_SOCIAL_Guest *gst) | |||
1664 | { | 1657 | { |
1665 | struct GNUNET_SOCIAL_Place *plc = &gst->plc; | 1658 | struct GNUNET_SOCIAL_Place *plc = &gst->plc; |
1666 | 1659 | ||
1667 | GNUNET_MQ_hd_fixed_size (guest_enter_ack, | ||
1668 | GNUNET_MESSAGE_TYPE_SOCIAL_GUEST_ENTER_ACK, | ||
1669 | struct GNUNET_PSYC_CountersResultMessage); | ||
1670 | |||
1671 | GNUNET_MQ_hd_var_size (guest_enter_decision, | ||
1672 | GNUNET_MESSAGE_TYPE_PSYC_JOIN_DECISION, | ||
1673 | struct GNUNET_PSYC_JoinDecisionMessage); | ||
1674 | |||
1675 | GNUNET_MQ_hd_var_size (place_message, | ||
1676 | GNUNET_MESSAGE_TYPE_PSYC_MESSAGE, | ||
1677 | struct GNUNET_PSYC_MessageHeader); | ||
1678 | |||
1679 | GNUNET_MQ_hd_fixed_size (place_message_ack, | ||
1680 | GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_ACK, | ||
1681 | struct GNUNET_MessageHeader); | ||
1682 | |||
1683 | GNUNET_MQ_hd_var_size (place_history_result, | ||
1684 | GNUNET_MESSAGE_TYPE_PSYC_HISTORY_RESULT, | ||
1685 | struct GNUNET_OperationResultMessage); | ||
1686 | |||
1687 | GNUNET_MQ_hd_var_size (place_state_result, | ||
1688 | GNUNET_MESSAGE_TYPE_PSYC_STATE_RESULT, | ||
1689 | struct GNUNET_OperationResultMessage); | ||
1690 | |||
1691 | GNUNET_MQ_hd_var_size (place_result, | ||
1692 | GNUNET_MESSAGE_TYPE_PSYC_RESULT_CODE, | ||
1693 | struct GNUNET_OperationResultMessage); | ||
1694 | |||
1695 | struct GNUNET_MQ_MessageHandler handlers[] = { | 1660 | struct GNUNET_MQ_MessageHandler handlers[] = { |
1696 | make_guest_enter_ack_handler (gst), | 1661 | GNUNET_MQ_hd_fixed_size (guest_enter_ack, |
1697 | make_guest_enter_decision_handler (gst), | 1662 | GNUNET_MESSAGE_TYPE_SOCIAL_GUEST_ENTER_ACK, |
1698 | make_place_message_handler (plc), | 1663 | struct GNUNET_PSYC_CountersResultMessage, |
1699 | make_place_message_ack_handler (plc), | 1664 | gst), |
1700 | make_place_history_result_handler (plc), | 1665 | GNUNET_MQ_hd_var_size (guest_enter_decision, |
1701 | make_place_state_result_handler (plc), | 1666 | GNUNET_MESSAGE_TYPE_PSYC_JOIN_DECISION, |
1702 | make_place_result_handler (plc), | 1667 | struct GNUNET_PSYC_JoinDecisionMessage, |
1668 | gst), | ||
1669 | GNUNET_MQ_hd_var_size (place_message, | ||
1670 | GNUNET_MESSAGE_TYPE_PSYC_MESSAGE, | ||
1671 | struct GNUNET_PSYC_MessageHeader, | ||
1672 | plc), | ||
1673 | GNUNET_MQ_hd_fixed_size (place_message_ack, | ||
1674 | GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_ACK, | ||
1675 | struct GNUNET_MessageHeader, | ||
1676 | plc), | ||
1677 | GNUNET_MQ_hd_var_size (place_history_result, | ||
1678 | GNUNET_MESSAGE_TYPE_PSYC_HISTORY_RESULT, | ||
1679 | struct GNUNET_OperationResultMessage, | ||
1680 | plc), | ||
1681 | GNUNET_MQ_hd_var_size (place_state_result, | ||
1682 | GNUNET_MESSAGE_TYPE_PSYC_STATE_RESULT, | ||
1683 | struct GNUNET_OperationResultMessage, | ||
1684 | plc), | ||
1685 | GNUNET_MQ_hd_var_size (place_result, | ||
1686 | GNUNET_MESSAGE_TYPE_PSYC_RESULT_CODE, | ||
1687 | struct GNUNET_OperationResultMessage, | ||
1688 | plc), | ||
1703 | GNUNET_MQ_handler_end () | 1689 | GNUNET_MQ_handler_end () |
1704 | }; | 1690 | }; |
1705 | 1691 | ||
@@ -2579,32 +2565,27 @@ app_disconnected (void *cls, enum GNUNET_MQ_Error error) | |||
2579 | static void | 2565 | static void |
2580 | app_connect (struct GNUNET_SOCIAL_App *app) | 2566 | app_connect (struct GNUNET_SOCIAL_App *app) |
2581 | { | 2567 | { |
2582 | GNUNET_MQ_hd_var_size (app_ego, | ||
2583 | GNUNET_MESSAGE_TYPE_SOCIAL_APP_EGO, | ||
2584 | struct AppEgoMessage); | ||
2585 | |||
2586 | GNUNET_MQ_hd_fixed_size (app_ego_end, | ||
2587 | GNUNET_MESSAGE_TYPE_SOCIAL_APP_EGO_END, | ||
2588 | struct GNUNET_MessageHeader); | ||
2589 | |||
2590 | GNUNET_MQ_hd_var_size (app_place, | ||
2591 | GNUNET_MESSAGE_TYPE_SOCIAL_APP_PLACE, | ||
2592 | struct AppPlaceMessage); | ||
2593 | |||
2594 | GNUNET_MQ_hd_fixed_size (app_place_end, | ||
2595 | GNUNET_MESSAGE_TYPE_SOCIAL_APP_PLACE_END, | ||
2596 | struct GNUNET_MessageHeader); | ||
2597 | |||
2598 | GNUNET_MQ_hd_var_size (app_result, | ||
2599 | GNUNET_MESSAGE_TYPE_PSYC_RESULT_CODE, | ||
2600 | struct GNUNET_OperationResultMessage); | ||
2601 | |||
2602 | struct GNUNET_MQ_MessageHandler handlers[] = { | 2568 | struct GNUNET_MQ_MessageHandler handlers[] = { |
2603 | make_app_ego_handler (app), | 2569 | GNUNET_MQ_hd_var_size (app_ego, |
2604 | make_app_ego_end_handler (app), | 2570 | GNUNET_MESSAGE_TYPE_SOCIAL_APP_EGO, |
2605 | make_app_place_handler (app), | 2571 | struct AppEgoMessage, |
2606 | make_app_place_end_handler (app), | 2572 | app), |
2607 | make_app_result_handler (app), | 2573 | GNUNET_MQ_hd_fixed_size (app_ego_end, |
2574 | GNUNET_MESSAGE_TYPE_SOCIAL_APP_EGO_END, | ||
2575 | struct GNUNET_MessageHeader, | ||
2576 | app), | ||
2577 | GNUNET_MQ_hd_var_size (app_place, | ||
2578 | GNUNET_MESSAGE_TYPE_SOCIAL_APP_PLACE, | ||
2579 | struct AppPlaceMessage, | ||
2580 | app), | ||
2581 | GNUNET_MQ_hd_fixed_size (app_place_end, | ||
2582 | GNUNET_MESSAGE_TYPE_SOCIAL_APP_PLACE_END, | ||
2583 | struct GNUNET_MessageHeader, | ||
2584 | app), | ||
2585 | GNUNET_MQ_hd_var_size (app_result, | ||
2586 | GNUNET_MESSAGE_TYPE_PSYC_RESULT_CODE, | ||
2587 | struct GNUNET_OperationResultMessage, | ||
2588 | app), | ||
2608 | GNUNET_MQ_handler_end () | 2589 | GNUNET_MQ_handler_end () |
2609 | }; | 2590 | }; |
2610 | 2591 | ||
diff --git a/src/statistics/statistics_api.c b/src/statistics/statistics_api.c index 7f5a257d9..acaa1cc45 100644 --- a/src/statistics/statistics_api.c +++ b/src/statistics/statistics_api.c | |||
@@ -646,23 +646,23 @@ handle_statistics_end (void *cls, | |||
646 | static int | 646 | static int |
647 | try_connect (struct GNUNET_STATISTICS_Handle *h) | 647 | try_connect (struct GNUNET_STATISTICS_Handle *h) |
648 | { | 648 | { |
649 | GNUNET_MQ_hd_fixed_size (test, | ||
650 | GNUNET_MESSAGE_TYPE_TEST, | ||
651 | struct GNUNET_MessageHeader); | ||
652 | GNUNET_MQ_hd_fixed_size (statistics_end, | ||
653 | GNUNET_MESSAGE_TYPE_STATISTICS_END, | ||
654 | struct GNUNET_MessageHeader); | ||
655 | GNUNET_MQ_hd_var_size (statistics_value, | ||
656 | GNUNET_MESSAGE_TYPE_STATISTICS_VALUE, | ||
657 | struct GNUNET_STATISTICS_ReplyMessage); | ||
658 | GNUNET_MQ_hd_fixed_size (statistics_watch_value, | ||
659 | GNUNET_MESSAGE_TYPE_STATISTICS_WATCH_VALUE, | ||
660 | struct GNUNET_STATISTICS_WatchValueMessage); | ||
661 | struct GNUNET_MQ_MessageHandler handlers[] = { | 649 | struct GNUNET_MQ_MessageHandler handlers[] = { |
662 | make_test_handler (h), | 650 | GNUNET_MQ_hd_fixed_size (test, |
663 | make_statistics_end_handler (h), | 651 | GNUNET_MESSAGE_TYPE_TEST, |
664 | make_statistics_value_handler (h), | 652 | struct GNUNET_MessageHeader, |
665 | make_statistics_watch_value_handler (h), | 653 | h), |
654 | GNUNET_MQ_hd_fixed_size (statistics_end, | ||
655 | GNUNET_MESSAGE_TYPE_STATISTICS_END, | ||
656 | struct GNUNET_MessageHeader, | ||
657 | h), | ||
658 | GNUNET_MQ_hd_var_size (statistics_value, | ||
659 | GNUNET_MESSAGE_TYPE_STATISTICS_VALUE, | ||
660 | struct GNUNET_STATISTICS_ReplyMessage, | ||
661 | h), | ||
662 | GNUNET_MQ_hd_fixed_size (statistics_watch_value, | ||
663 | GNUNET_MESSAGE_TYPE_STATISTICS_WATCH_VALUE, | ||
664 | struct GNUNET_STATISTICS_WatchValueMessage, | ||
665 | h), | ||
666 | GNUNET_MQ_handler_end () | 666 | GNUNET_MQ_handler_end () |
667 | }; | 667 | }; |
668 | struct GNUNET_STATISTICS_GetHandle *gh; | 668 | struct GNUNET_STATISTICS_GetHandle *gh; |
diff --git a/src/testbed/testbed_api.c b/src/testbed/testbed_api.c index 895800514..53f70a1c0 100644 --- a/src/testbed/testbed_api.c +++ b/src/testbed/testbed_api.c | |||
@@ -1549,49 +1549,49 @@ GNUNET_TESTBED_controller_connect (struct GNUNET_TESTBED_Host *host, | |||
1549 | GNUNET_TESTBED_ControllerCallback cc, | 1549 | GNUNET_TESTBED_ControllerCallback cc, |
1550 | void *cc_cls) | 1550 | void *cc_cls) |
1551 | { | 1551 | { |
1552 | GNUNET_MQ_hd_var_size (add_host_confirm, | ||
1553 | GNUNET_MESSAGE_TYPE_TESTBED_ADD_HOST_SUCCESS, | ||
1554 | struct GNUNET_TESTBED_HostConfirmedMessage); | ||
1555 | GNUNET_MQ_hd_fixed_size (peer_conevent, | ||
1556 | GNUNET_MESSAGE_TYPE_TESTBED_PEER_CONNECT_EVENT, | ||
1557 | struct GNUNET_TESTBED_ConnectionEventMessage); | ||
1558 | GNUNET_MQ_hd_fixed_size (opsuccess, | ||
1559 | GNUNET_MESSAGE_TYPE_TESTBED_GENERIC_OPERATION_SUCCESS, | ||
1560 | struct GNUNET_TESTBED_GenericOperationSuccessEventMessage); | ||
1561 | GNUNET_MQ_hd_var_size (op_fail_event, | ||
1562 | GNUNET_MESSAGE_TYPE_TESTBED_OPERATION_FAIL_EVENT, | ||
1563 | struct GNUNET_TESTBED_OperationFailureEventMessage); | ||
1564 | GNUNET_MQ_hd_fixed_size (peer_create_success, | ||
1565 | GNUNET_MESSAGE_TYPE_TESTBED_CREATE_PEER_SUCCESS, | ||
1566 | struct GNUNET_TESTBED_PeerCreateSuccessEventMessage); | ||
1567 | GNUNET_MQ_hd_fixed_size (peer_event, | ||
1568 | GNUNET_MESSAGE_TYPE_TESTBED_PEER_EVENT, | ||
1569 | struct GNUNET_TESTBED_PeerEventMessage); | ||
1570 | GNUNET_MQ_hd_var_size (peer_config, | ||
1571 | GNUNET_MESSAGE_TYPE_TESTBED_PEER_INFORMATION, | ||
1572 | struct GNUNET_TESTBED_PeerConfigurationInformationMessage); | ||
1573 | GNUNET_MQ_hd_var_size (slave_config, | ||
1574 | GNUNET_MESSAGE_TYPE_TESTBED_SLAVE_CONFIGURATION, | ||
1575 | struct GNUNET_TESTBED_SlaveConfiguration); | ||
1576 | GNUNET_MQ_hd_var_size (link_controllers_result, | ||
1577 | GNUNET_MESSAGE_TYPE_TESTBED_LINK_CONTROLLERS_RESULT, | ||
1578 | struct GNUNET_TESTBED_ControllerLinkResponse); | ||
1579 | GNUNET_MQ_hd_var_size (barrier_status, | ||
1580 | GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_STATUS, | ||
1581 | const struct GNUNET_TESTBED_BarrierStatusMsg); | ||
1582 | struct GNUNET_TESTBED_Controller *controller | 1552 | struct GNUNET_TESTBED_Controller *controller |
1583 | = GNUNET_new (struct GNUNET_TESTBED_Controller); | 1553 | = GNUNET_new (struct GNUNET_TESTBED_Controller); |
1584 | struct GNUNET_MQ_MessageHandler handlers[] = { | 1554 | struct GNUNET_MQ_MessageHandler handlers[] = { |
1585 | make_add_host_confirm_handler (controller), | 1555 | GNUNET_MQ_hd_var_size (add_host_confirm, |
1586 | make_peer_conevent_handler (controller), | 1556 | GNUNET_MESSAGE_TYPE_TESTBED_ADD_HOST_SUCCESS, |
1587 | make_opsuccess_handler (controller), | 1557 | struct GNUNET_TESTBED_HostConfirmedMessage, |
1588 | make_op_fail_event_handler (controller), | 1558 | controller), |
1589 | make_peer_create_success_handler (controller), | 1559 | GNUNET_MQ_hd_fixed_size (peer_conevent, |
1590 | make_peer_event_handler (controller), | 1560 | GNUNET_MESSAGE_TYPE_TESTBED_PEER_CONNECT_EVENT, |
1591 | make_peer_config_handler (controller), | 1561 | struct GNUNET_TESTBED_ConnectionEventMessage, |
1592 | make_slave_config_handler (controller), | 1562 | controller), |
1593 | make_link_controllers_result_handler (controller), | 1563 | GNUNET_MQ_hd_fixed_size (opsuccess, |
1594 | make_barrier_status_handler (controller), | 1564 | GNUNET_MESSAGE_TYPE_TESTBED_GENERIC_OPERATION_SUCCESS, |
1565 | struct GNUNET_TESTBED_GenericOperationSuccessEventMessage, | ||
1566 | controller), | ||
1567 | GNUNET_MQ_hd_var_size (op_fail_event, | ||
1568 | GNUNET_MESSAGE_TYPE_TESTBED_OPERATION_FAIL_EVENT, | ||
1569 | struct GNUNET_TESTBED_OperationFailureEventMessage, | ||
1570 | controller), | ||
1571 | GNUNET_MQ_hd_fixed_size (peer_create_success, | ||
1572 | GNUNET_MESSAGE_TYPE_TESTBED_CREATE_PEER_SUCCESS, | ||
1573 | struct GNUNET_TESTBED_PeerCreateSuccessEventMessage, | ||
1574 | controller), | ||
1575 | GNUNET_MQ_hd_fixed_size (peer_event, | ||
1576 | GNUNET_MESSAGE_TYPE_TESTBED_PEER_EVENT, | ||
1577 | struct GNUNET_TESTBED_PeerEventMessage, | ||
1578 | controller), | ||
1579 | GNUNET_MQ_hd_var_size (peer_config, | ||
1580 | GNUNET_MESSAGE_TYPE_TESTBED_PEER_INFORMATION, | ||
1581 | struct GNUNET_TESTBED_PeerConfigurationInformationMessage, | ||
1582 | controller), | ||
1583 | GNUNET_MQ_hd_var_size (slave_config, | ||
1584 | GNUNET_MESSAGE_TYPE_TESTBED_SLAVE_CONFIGURATION, | ||
1585 | struct GNUNET_TESTBED_SlaveConfiguration, | ||
1586 | controller), | ||
1587 | GNUNET_MQ_hd_var_size (link_controllers_result, | ||
1588 | GNUNET_MESSAGE_TYPE_TESTBED_LINK_CONTROLLERS_RESULT, | ||
1589 | struct GNUNET_TESTBED_ControllerLinkResponse, | ||
1590 | controller), | ||
1591 | GNUNET_MQ_hd_var_size (barrier_status, | ||
1592 | GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_STATUS, | ||
1593 | const struct GNUNET_TESTBED_BarrierStatusMsg, | ||
1594 | controller), | ||
1595 | GNUNET_MQ_handler_end () | 1595 | GNUNET_MQ_handler_end () |
1596 | }; | 1596 | }; |
1597 | struct GNUNET_TESTBED_InitMessage *msg; | 1597 | struct GNUNET_TESTBED_InitMessage *msg; |
diff --git a/src/testbed/testbed_api_barriers.c b/src/testbed/testbed_api_barriers.c index ee75e515c..3761fbbdf 100644 --- a/src/testbed/testbed_api_barriers.c +++ b/src/testbed/testbed_api_barriers.c | |||
@@ -171,13 +171,13 @@ GNUNET_TESTBED_barrier_wait (const char *name, | |||
171 | GNUNET_TESTBED_barrier_wait_cb cb, | 171 | GNUNET_TESTBED_barrier_wait_cb cb, |
172 | void *cb_cls) | 172 | void *cb_cls) |
173 | { | 173 | { |
174 | GNUNET_MQ_hd_var_size (status, | ||
175 | GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_STATUS, | ||
176 | struct GNUNET_TESTBED_BarrierStatusMsg); | ||
177 | struct GNUNET_TESTBED_BarrierWaitHandle *h | 174 | struct GNUNET_TESTBED_BarrierWaitHandle *h |
178 | = GNUNET_new (struct GNUNET_TESTBED_BarrierWaitHandle); | 175 | = GNUNET_new (struct GNUNET_TESTBED_BarrierWaitHandle); |
179 | struct GNUNET_MQ_MessageHandler handlers[] = { | 176 | struct GNUNET_MQ_MessageHandler handlers[] = { |
180 | make_status_handler (h), | 177 | GNUNET_MQ_hd_var_size (status, |
178 | GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_STATUS, | ||
179 | struct GNUNET_TESTBED_BarrierStatusMsg, | ||
180 | h), | ||
181 | GNUNET_MQ_handler_end () | 181 | GNUNET_MQ_handler_end () |
182 | }; | 182 | }; |
183 | struct GNUNET_MQ_Envelope *env; | 183 | struct GNUNET_MQ_Envelope *env; |
diff --git a/src/topology/gnunet-daemon-topology.c b/src/topology/gnunet-daemon-topology.c index f56cd4bc8..69f01e043 100644 --- a/src/topology/gnunet-daemon-topology.c +++ b/src/topology/gnunet-daemon-topology.c | |||
@@ -1147,11 +1147,11 @@ run (void *cls, | |||
1147 | const char *cfgfile, | 1147 | const char *cfgfile, |
1148 | const struct GNUNET_CONFIGURATION_Handle *c) | 1148 | const struct GNUNET_CONFIGURATION_Handle *c) |
1149 | { | 1149 | { |
1150 | GNUNET_MQ_hd_var_size (hello, | ||
1151 | GNUNET_MESSAGE_TYPE_HELLO, | ||
1152 | struct GNUNET_HELLO_Message); | ||
1153 | struct GNUNET_MQ_MessageHandler handlers[] = { | 1150 | struct GNUNET_MQ_MessageHandler handlers[] = { |
1154 | make_hello_handler (NULL), | 1151 | GNUNET_MQ_hd_var_size (hello, |
1152 | GNUNET_MESSAGE_TYPE_HELLO, | ||
1153 | struct GNUNET_HELLO_Message, | ||
1154 | NULL), | ||
1155 | GNUNET_MQ_handler_end () | 1155 | GNUNET_MQ_handler_end () |
1156 | }; | 1156 | }; |
1157 | unsigned long long opt; | 1157 | unsigned long long opt; |
diff --git a/src/transport/gnunet-transport-profiler.c b/src/transport/gnunet-transport-profiler.c index 6e2ac6121..dceff7e3b 100644 --- a/src/transport/gnunet-transport-profiler.c +++ b/src/transport/gnunet-transport-profiler.c | |||
@@ -509,11 +509,11 @@ run (void *cls, | |||
509 | const char *cfgfile, | 509 | const char *cfgfile, |
510 | const struct GNUNET_CONFIGURATION_Handle *mycfg) | 510 | const struct GNUNET_CONFIGURATION_Handle *mycfg) |
511 | { | 511 | { |
512 | GNUNET_MQ_hd_var_size (dummy, | ||
513 | GNUNET_MESSAGE_TYPE_DUMMY, | ||
514 | struct GNUNET_MessageHeader); | ||
515 | struct GNUNET_MQ_MessageHandler handlers[] = { | 512 | struct GNUNET_MQ_MessageHandler handlers[] = { |
516 | make_dummy_handler (NULL), | 513 | GNUNET_MQ_hd_var_size (dummy, |
514 | GNUNET_MESSAGE_TYPE_DUMMY, | ||
515 | struct GNUNET_MessageHeader, | ||
516 | NULL), | ||
517 | GNUNET_MQ_handler_end () | 517 | GNUNET_MQ_handler_end () |
518 | }; | 518 | }; |
519 | 519 | ||
diff --git a/src/transport/gnunet-transport.c b/src/transport/gnunet-transport.c index fc0eada7a..aceaceb87 100644 --- a/src/transport/gnunet-transport.c +++ b/src/transport/gnunet-transport.c | |||
@@ -1517,9 +1517,6 @@ run (void *cls, | |||
1517 | const char *cfgfile, | 1517 | const char *cfgfile, |
1518 | const struct GNUNET_CONFIGURATION_Handle *mycfg) | 1518 | const struct GNUNET_CONFIGURATION_Handle *mycfg) |
1519 | { | 1519 | { |
1520 | GNUNET_MQ_hd_var_size (dummy, | ||
1521 | GNUNET_MESSAGE_TYPE_DUMMY, | ||
1522 | struct GNUNET_MessageHeader); | ||
1523 | int counter = 0; | 1520 | int counter = 0; |
1524 | ret = 1; | 1521 | ret = 1; |
1525 | 1522 | ||
@@ -1630,7 +1627,10 @@ run (void *cls, | |||
1630 | else if (benchmark_receive) /* -b: Benchmark receiving */ | 1627 | else if (benchmark_receive) /* -b: Benchmark receiving */ |
1631 | { | 1628 | { |
1632 | struct GNUNET_MQ_MessageHandler handlers[] = { | 1629 | struct GNUNET_MQ_MessageHandler handlers[] = { |
1633 | make_dummy_handler (NULL), | 1630 | GNUNET_MQ_hd_var_size (dummy, |
1631 | GNUNET_MESSAGE_TYPE_DUMMY, | ||
1632 | struct GNUNET_MessageHeader, | ||
1633 | NULL), | ||
1634 | GNUNET_MQ_handler_end () | 1634 | GNUNET_MQ_handler_end () |
1635 | }; | 1635 | }; |
1636 | 1636 | ||
diff --git a/src/transport/transport-testing-main.c b/src/transport/transport-testing-main.c index bba37eee8..a79d81cb9 100644 --- a/src/transport/transport-testing-main.c +++ b/src/transport/transport-testing-main.c | |||
@@ -442,12 +442,6 @@ connect_check_run (void *cls, | |||
442 | const char *cfgfile, | 442 | const char *cfgfile, |
443 | const struct GNUNET_CONFIGURATION_Handle *cfg) | 443 | const struct GNUNET_CONFIGURATION_Handle *cfg) |
444 | { | 444 | { |
445 | GNUNET_MQ_hd_var_size (test, | ||
446 | GNUNET_TRANSPORT_TESTING_SIMPLE_MTYPE, | ||
447 | struct GNUNET_TRANSPORT_TESTING_TestMessage); | ||
448 | GNUNET_MQ_hd_var_size (test2, | ||
449 | GNUNET_TRANSPORT_TESTING_SIMPLE_MTYPE2, | ||
450 | struct GNUNET_TRANSPORT_TESTING_TestMessage); | ||
451 | struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext *ccc = cls; | 445 | struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext *ccc = cls; |
452 | int ok; | 446 | int ok; |
453 | 447 | ||
@@ -461,8 +455,14 @@ connect_check_run (void *cls, | |||
461 | for (unsigned int i=0;i<ccc->num_peers;i++) | 455 | for (unsigned int i=0;i<ccc->num_peers;i++) |
462 | { | 456 | { |
463 | struct GNUNET_MQ_MessageHandler handlers[] = { | 457 | struct GNUNET_MQ_MessageHandler handlers[] = { |
464 | make_test_handler (NULL), | 458 | GNUNET_MQ_hd_var_size (test, |
465 | make_test2_handler (NULL), | 459 | GNUNET_TRANSPORT_TESTING_SIMPLE_MTYPE, |
460 | struct GNUNET_TRANSPORT_TESTING_TestMessage, | ||
461 | NULL), | ||
462 | GNUNET_MQ_hd_var_size (test2, | ||
463 | GNUNET_TRANSPORT_TESTING_SIMPLE_MTYPE2, | ||
464 | struct GNUNET_TRANSPORT_TESTING_TestMessage, | ||
465 | NULL), | ||
466 | GNUNET_MQ_handler_end() | 466 | GNUNET_MQ_handler_end() |
467 | }; | 467 | }; |
468 | ccc->p[i] = GNUNET_TRANSPORT_TESTING_start_peer (ccc->tth, | 468 | ccc->p[i] = GNUNET_TRANSPORT_TESTING_start_peer (ccc->tth, |
diff --git a/src/transport/transport_api_address_to_string.c b/src/transport/transport_api_address_to_string.c index a2cad07b0..fd30230f7 100644 --- a/src/transport/transport_api_address_to_string.c +++ b/src/transport/transport_api_address_to_string.c | |||
@@ -182,13 +182,13 @@ GNUNET_TRANSPORT_address_to_string (const struct GNUNET_CONFIGURATION_Handle *cf | |||
182 | GNUNET_TRANSPORT_AddressToStringCallback aluc, | 182 | GNUNET_TRANSPORT_AddressToStringCallback aluc, |
183 | void *aluc_cls) | 183 | void *aluc_cls) |
184 | { | 184 | { |
185 | GNUNET_MQ_hd_var_size (reply, | ||
186 | GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_TO_STRING_REPLY, | ||
187 | struct AddressToStringResultMessage); | ||
188 | struct GNUNET_TRANSPORT_AddressToStringContext *alc | 185 | struct GNUNET_TRANSPORT_AddressToStringContext *alc |
189 | = GNUNET_new (struct GNUNET_TRANSPORT_AddressToStringContext); | 186 | = GNUNET_new (struct GNUNET_TRANSPORT_AddressToStringContext); |
190 | struct GNUNET_MQ_MessageHandler handlers[] = { | 187 | struct GNUNET_MQ_MessageHandler handlers[] = { |
191 | make_reply_handler (alc), | 188 | GNUNET_MQ_hd_var_size (reply, |
189 | GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_TO_STRING_REPLY, | ||
190 | struct AddressToStringResultMessage, | ||
191 | alc), | ||
192 | GNUNET_MQ_handler_end () | 192 | GNUNET_MQ_handler_end () |
193 | }; | 193 | }; |
194 | size_t alen; | 194 | size_t alen; |
diff --git a/src/transport/transport_api_blacklist.c b/src/transport/transport_api_blacklist.c index 2835e225f..4b758f9dc 100644 --- a/src/transport/transport_api_blacklist.c +++ b/src/transport/transport_api_blacklist.c | |||
@@ -120,11 +120,11 @@ mq_error_handler (void *cls, | |||
120 | static void | 120 | static void |
121 | reconnect (struct GNUNET_TRANSPORT_Blacklist *br) | 121 | reconnect (struct GNUNET_TRANSPORT_Blacklist *br) |
122 | { | 122 | { |
123 | GNUNET_MQ_hd_fixed_size (query, | ||
124 | GNUNET_MESSAGE_TYPE_TRANSPORT_BLACKLIST_QUERY, | ||
125 | struct BlacklistMessage); | ||
126 | struct GNUNET_MQ_MessageHandler handlers[] = { | 123 | struct GNUNET_MQ_MessageHandler handlers[] = { |
127 | make_query_handler (br), | 124 | GNUNET_MQ_hd_fixed_size (query, |
125 | GNUNET_MESSAGE_TYPE_TRANSPORT_BLACKLIST_QUERY, | ||
126 | struct BlacklistMessage, | ||
127 | br), | ||
128 | GNUNET_MQ_handler_end () | 128 | GNUNET_MQ_handler_end () |
129 | }; | 129 | }; |
130 | struct GNUNET_MQ_Envelope *env; | 130 | struct GNUNET_MQ_Envelope *env; |
diff --git a/src/transport/transport_api_core.c b/src/transport/transport_api_core.c index 6be9500fb..0705552f9 100644 --- a/src/transport/transport_api_core.c +++ b/src/transport/transport_api_core.c | |||
@@ -748,32 +748,32 @@ handle_set_quota (void *cls, | |||
748 | static void | 748 | static void |
749 | reconnect (void *cls) | 749 | reconnect (void *cls) |
750 | { | 750 | { |
751 | GNUNET_MQ_hd_var_size (hello, | ||
752 | GNUNET_MESSAGE_TYPE_HELLO, | ||
753 | struct GNUNET_MessageHeader); | ||
754 | GNUNET_MQ_hd_fixed_size (connect, | ||
755 | GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT, | ||
756 | struct ConnectInfoMessage); | ||
757 | GNUNET_MQ_hd_fixed_size (disconnect, | ||
758 | GNUNET_MESSAGE_TYPE_TRANSPORT_DISCONNECT, | ||
759 | struct DisconnectInfoMessage); | ||
760 | GNUNET_MQ_hd_fixed_size (send_ok, | ||
761 | GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_OK, | ||
762 | struct SendOkMessage); | ||
763 | GNUNET_MQ_hd_var_size (recv, | ||
764 | GNUNET_MESSAGE_TYPE_TRANSPORT_RECV, | ||
765 | struct InboundMessage); | ||
766 | GNUNET_MQ_hd_fixed_size (set_quota, | ||
767 | GNUNET_MESSAGE_TYPE_TRANSPORT_SET_QUOTA, | ||
768 | struct QuotaSetMessage); | ||
769 | struct GNUNET_TRANSPORT_CoreHandle *h = cls; | 751 | struct GNUNET_TRANSPORT_CoreHandle *h = cls; |
770 | struct GNUNET_MQ_MessageHandler handlers[] = { | 752 | struct GNUNET_MQ_MessageHandler handlers[] = { |
771 | make_hello_handler (h), | 753 | GNUNET_MQ_hd_var_size (hello, |
772 | make_connect_handler (h), | 754 | GNUNET_MESSAGE_TYPE_HELLO, |
773 | make_disconnect_handler (h), | 755 | struct GNUNET_MessageHeader, |
774 | make_send_ok_handler (h), | 756 | h), |
775 | make_recv_handler (h), | 757 | GNUNET_MQ_hd_fixed_size (connect, |
776 | make_set_quota_handler (h), | 758 | GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT, |
759 | struct ConnectInfoMessage, | ||
760 | h), | ||
761 | GNUNET_MQ_hd_fixed_size (disconnect, | ||
762 | GNUNET_MESSAGE_TYPE_TRANSPORT_DISCONNECT, | ||
763 | struct DisconnectInfoMessage, | ||
764 | h), | ||
765 | GNUNET_MQ_hd_fixed_size (send_ok, | ||
766 | GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_OK, | ||
767 | struct SendOkMessage, | ||
768 | h), | ||
769 | GNUNET_MQ_hd_var_size (recv, | ||
770 | GNUNET_MESSAGE_TYPE_TRANSPORT_RECV, | ||
771 | struct InboundMessage, | ||
772 | h), | ||
773 | GNUNET_MQ_hd_fixed_size (set_quota, | ||
774 | GNUNET_MESSAGE_TYPE_TRANSPORT_SET_QUOTA, | ||
775 | struct QuotaSetMessage, | ||
776 | h), | ||
777 | GNUNET_MQ_handler_end () | 777 | GNUNET_MQ_handler_end () |
778 | }; | 778 | }; |
779 | struct GNUNET_MQ_Envelope *env; | 779 | struct GNUNET_MQ_Envelope *env; |
diff --git a/src/transport/transport_api_hello_get.c b/src/transport/transport_api_hello_get.c index ec7b544d6..9c3a3e786 100644 --- a/src/transport/transport_api_hello_get.c +++ b/src/transport/transport_api_hello_get.c | |||
@@ -167,12 +167,12 @@ mq_error_handler (void *cls, | |||
167 | static void | 167 | static void |
168 | reconnect (void *cls) | 168 | reconnect (void *cls) |
169 | { | 169 | { |
170 | GNUNET_MQ_hd_var_size (hello, | ||
171 | GNUNET_MESSAGE_TYPE_HELLO, | ||
172 | struct GNUNET_MessageHeader); | ||
173 | struct GNUNET_TRANSPORT_HelloGetHandle *ghh = cls; | 170 | struct GNUNET_TRANSPORT_HelloGetHandle *ghh = cls; |
174 | struct GNUNET_MQ_MessageHandler handlers[] = { | 171 | struct GNUNET_MQ_MessageHandler handlers[] = { |
175 | make_hello_handler (ghh), | 172 | GNUNET_MQ_hd_var_size (hello, |
173 | GNUNET_MESSAGE_TYPE_HELLO, | ||
174 | struct GNUNET_MessageHeader, | ||
175 | ghh), | ||
176 | GNUNET_MQ_handler_end () | 176 | GNUNET_MQ_handler_end () |
177 | }; | 177 | }; |
178 | struct GNUNET_MQ_Envelope *env; | 178 | struct GNUNET_MQ_Envelope *env; |
diff --git a/src/transport/transport_api_monitor_peers.c b/src/transport/transport_api_monitor_peers.c index a5c70fcfa..345f2ad60 100644 --- a/src/transport/transport_api_monitor_peers.c +++ b/src/transport/transport_api_monitor_peers.c | |||
@@ -344,16 +344,16 @@ mq_error_handler (void *cls, | |||
344 | static void | 344 | static void |
345 | do_peer_connect (void *cls) | 345 | do_peer_connect (void *cls) |
346 | { | 346 | { |
347 | GNUNET_MQ_hd_var_size (response, | ||
348 | GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PEER_RESPONSE, | ||
349 | struct PeerIterateResponseMessage); | ||
350 | GNUNET_MQ_hd_fixed_size (response_end, | ||
351 | GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PEER_RESPONSE_END, | ||
352 | struct GNUNET_MessageHeader); | ||
353 | struct GNUNET_TRANSPORT_PeerMonitoringContext *pal_ctx = cls; | 347 | struct GNUNET_TRANSPORT_PeerMonitoringContext *pal_ctx = cls; |
354 | struct GNUNET_MQ_MessageHandler handlers[] = { | 348 | struct GNUNET_MQ_MessageHandler handlers[] = { |
355 | make_response_handler (pal_ctx), | 349 | GNUNET_MQ_hd_var_size (response, |
356 | make_response_end_handler (pal_ctx), | 350 | GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PEER_RESPONSE, |
351 | struct PeerIterateResponseMessage, | ||
352 | pal_ctx), | ||
353 | GNUNET_MQ_hd_fixed_size (response_end, | ||
354 | GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PEER_RESPONSE_END, | ||
355 | struct GNUNET_MessageHeader, | ||
356 | pal_ctx), | ||
357 | GNUNET_MQ_handler_end () | 357 | GNUNET_MQ_handler_end () |
358 | }; | 358 | }; |
359 | struct PeerMonitorMessage *msg; | 359 | struct PeerMonitorMessage *msg; |
diff --git a/src/transport/transport_api_monitor_plugins.c b/src/transport/transport_api_monitor_plugins.c index 01ec2074a..7547a3402 100644 --- a/src/transport/transport_api_monitor_plugins.c +++ b/src/transport/transport_api_monitor_plugins.c | |||
@@ -372,16 +372,16 @@ mq_error_handler (void *cls, | |||
372 | static void | 372 | static void |
373 | do_plugin_connect (void *cls) | 373 | do_plugin_connect (void *cls) |
374 | { | 374 | { |
375 | GNUNET_MQ_hd_var_size (event, | ||
376 | GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PLUGIN_EVENT, | ||
377 | struct TransportPluginMonitorMessage); | ||
378 | GNUNET_MQ_hd_fixed_size (sync, | ||
379 | GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PLUGIN_SYNC, | ||
380 | struct GNUNET_MessageHeader); | ||
381 | struct GNUNET_TRANSPORT_PluginMonitor *pm = cls; | 375 | struct GNUNET_TRANSPORT_PluginMonitor *pm = cls; |
382 | struct GNUNET_MQ_MessageHandler handlers[] = { | 376 | struct GNUNET_MQ_MessageHandler handlers[] = { |
383 | make_event_handler (pm), | 377 | GNUNET_MQ_hd_var_size (event, |
384 | make_sync_handler (pm), | 378 | GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PLUGIN_EVENT, |
379 | struct TransportPluginMonitorMessage, | ||
380 | pm), | ||
381 | GNUNET_MQ_hd_fixed_size (sync, | ||
382 | GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PLUGIN_SYNC, | ||
383 | struct GNUNET_MessageHeader, | ||
384 | pm), | ||
385 | GNUNET_MQ_handler_end () | 385 | GNUNET_MQ_handler_end () |
386 | }; | 386 | }; |
387 | struct GNUNET_MessageHeader *msg; | 387 | struct GNUNET_MessageHeader *msg; |
diff --git a/src/util/resolver_api.c b/src/util/resolver_api.c index c4ce1ccc2..481e99157 100644 --- a/src/util/resolver_api.c +++ b/src/util/resolver_api.c | |||
@@ -722,12 +722,12 @@ loopback_resolution (void *cls) | |||
722 | static void | 722 | static void |
723 | reconnect_task (void *cls) | 723 | reconnect_task (void *cls) |
724 | { | 724 | { |
725 | GNUNET_MQ_hd_var_size (response, | ||
726 | GNUNET_MESSAGE_TYPE_RESOLVER_RESPONSE, | ||
727 | struct GNUNET_MessageHeader); | ||
728 | struct GNUNET_MQ_MessageHandler handlers[] = { | 725 | struct GNUNET_MQ_MessageHandler handlers[] = { |
729 | make_response_handler (NULL), | 726 | GNUNET_MQ_hd_var_size (response, |
730 | GNUNET_MQ_handler_end () | 727 | GNUNET_MESSAGE_TYPE_RESOLVER_RESPONSE, |
728 | struct GNUNET_MessageHeader, | ||
729 | NULL), | ||
730 | GNUNET_MQ_handler_end () | ||
731 | }; | 731 | }; |
732 | 732 | ||
733 | r_task = NULL; | 733 | r_task = NULL; |
diff --git a/src/util/test_client.c b/src/util/test_client.c index 07af5ea35..558a3cf1e 100644 --- a/src/util/test_client.c +++ b/src/util/test_client.c | |||
@@ -136,11 +136,11 @@ task (void *cls) | |||
136 | socklen_t slens[2]; | 136 | socklen_t slens[2]; |
137 | struct GNUNET_MQ_Envelope *env; | 137 | struct GNUNET_MQ_Envelope *env; |
138 | struct GNUNET_MessageHeader *msg; | 138 | struct GNUNET_MessageHeader *msg; |
139 | GNUNET_MQ_hd_fixed_size (bounce, | ||
140 | MY_TYPE, | ||
141 | struct GNUNET_MessageHeader); | ||
142 | struct GNUNET_MQ_MessageHandler chandlers[] = { | 139 | struct GNUNET_MQ_MessageHandler chandlers[] = { |
143 | make_bounce_handler (cls), | 140 | GNUNET_MQ_hd_fixed_size (bounce, |
141 | MY_TYPE, | ||
142 | struct GNUNET_MessageHeader, | ||
143 | cls), | ||
144 | GNUNET_MQ_handler_end () | 144 | GNUNET_MQ_handler_end () |
145 | }; | 145 | }; |
146 | 146 | ||
diff --git a/src/util/test_server.c b/src/util/test_server.c index 6d8fffc69..eac45fc69 100644 --- a/src/util/test_server.c +++ b/src/util/test_server.c | |||
@@ -231,11 +231,11 @@ task (void *cls) | |||
231 | socklen_t slens[2]; | 231 | socklen_t slens[2]; |
232 | struct GNUNET_MQ_Envelope *env; | 232 | struct GNUNET_MQ_Envelope *env; |
233 | struct GNUNET_MessageHeader *msg; | 233 | struct GNUNET_MessageHeader *msg; |
234 | GNUNET_MQ_hd_fixed_size (reply, | ||
235 | MY_TYPE, | ||
236 | struct GNUNET_MessageHeader); | ||
237 | struct GNUNET_MQ_MessageHandler chandlers[] = { | 234 | struct GNUNET_MQ_MessageHandler chandlers[] = { |
238 | make_reply_handler (cls), | 235 | GNUNET_MQ_hd_fixed_size (reply, |
236 | MY_TYPE, | ||
237 | struct GNUNET_MessageHeader, | ||
238 | cls), | ||
239 | GNUNET_MQ_handler_end () | 239 | GNUNET_MQ_handler_end () |
240 | }; | 240 | }; |
241 | 241 | ||
diff --git a/src/util/test_socks.c b/src/util/test_socks.c index d6064afd5..416f32f62 100644 --- a/src/util/test_socks.c +++ b/src/util/test_socks.c | |||
@@ -133,11 +133,11 @@ task (void *cls) | |||
133 | socklen_t slens[2]; | 133 | socklen_t slens[2]; |
134 | struct GNUNET_MQ_Envelope *env; | 134 | struct GNUNET_MQ_Envelope *env; |
135 | struct GNUNET_MessageHeader *msg; | 135 | struct GNUNET_MessageHeader *msg; |
136 | GNUNET_MQ_hd_fixed_size (bounce, | ||
137 | MY_TYPE, | ||
138 | struct GNUNET_MessageHeader); | ||
139 | struct GNUNET_MQ_MessageHandler chandlers[] = { | 136 | struct GNUNET_MQ_MessageHandler chandlers[] = { |
140 | make_bounce_handler (cls), | 137 | GNUNET_MQ_hd_fixed_size (bounce, |
138 | MY_TYPE, | ||
139 | struct GNUNET_MessageHeader, | ||
140 | cls), | ||
141 | GNUNET_MQ_handler_end () | 141 | GNUNET_MQ_handler_end () |
142 | }; | 142 | }; |
143 | 143 | ||
diff --git a/src/vpn/vpn_api.c b/src/vpn/vpn_api.c index ad0b5e9f0..b22b805cd 100644 --- a/src/vpn/vpn_api.c +++ b/src/vpn/vpn_api.c | |||
@@ -314,11 +314,11 @@ static void | |||
314 | connect_task (void *cls) | 314 | connect_task (void *cls) |
315 | { | 315 | { |
316 | struct GNUNET_VPN_Handle *vh = cls; | 316 | struct GNUNET_VPN_Handle *vh = cls; |
317 | GNUNET_MQ_hd_var_size (use_ip, | ||
318 | GNUNET_MESSAGE_TYPE_VPN_CLIENT_USE_IP, | ||
319 | struct RedirectToIpResponseMessage); | ||
320 | struct GNUNET_MQ_MessageHandler handlers[] = { | 317 | struct GNUNET_MQ_MessageHandler handlers[] = { |
321 | make_use_ip_handler (cls), | 318 | GNUNET_MQ_hd_var_size (use_ip, |
319 | GNUNET_MESSAGE_TYPE_VPN_CLIENT_USE_IP, | ||
320 | struct RedirectToIpResponseMessage, | ||
321 | cls), | ||
322 | GNUNET_MQ_handler_end () | 322 | GNUNET_MQ_handler_end () |
323 | }; | 323 | }; |
324 | struct GNUNET_VPN_RedirectionRequest *rr; | 324 | struct GNUNET_VPN_RedirectionRequest *rr; |