General-purpose message queue. More...

Data Structures
struct	GNUNET_MQ_MessageHandler
	Message handler for a specific message type. More...

Macros
#define	GNUNET_MQ_msg_extra(mvar, esize, type)
	Allocate an envelope, with extra space allocated after the space needed by the message struct. More...

#define	GNUNET_MQ_msg(mvar, type) GNUNET_MQ_msg_extra (mvar, 0, type)
	Allocate a GNUNET_MQ_Envelope. More...

#define	GNUNET_MQ_msg_header(type) GNUNET_MQ_msg_ (NULL, sizeof(struct GNUNET_MessageHeader), type)
	Allocate a GNUNET_MQ_Envelope, where the message only consists of a header. More...

#define	GNUNET_MQ_msg_header_extra(mh, esize, type) GNUNET_MQ_msg_ (&mh, (esize) + sizeof(struct GNUNET_MessageHeader), type)
	Allocate a GNUNET_MQ_Envelope, where the message only consists of a header and extra space. More...

#define	GNUNET_MQ_msg_nested_mh(mvar, type, mh)
	Allocate a GNUNET_MQ_Envelope, and append a payload message after the given message struct. More...

#define	GNUNET_MQ_extract_nested_mh(var)
	Return a pointer to the message at the end of the given message. More...

#define	GNUNET_MQ_handler_end()
	End-marker for the handlers array. More...

Typedefs
typedef void(*	GNUNET_MQ_MessageCallback) (void cls, const struct GNUNET_MessageHeader msg)
	Called when a message has been received. More...

typedef int(*	GNUNET_MQ_MessageValidationCallback) (void cls, const struct GNUNET_MessageHeader msg)
	Called when a message needs to be validated. More...

typedef void(*	GNUNET_MQ_SendImpl) (struct GNUNET_MQ_Handle mq, const struct GNUNET_MessageHeader msg, void *impl_state)
	Signature of functions implementing the sending functionality of a message queue. More...

typedef void(*	GNUNET_MQ_DestroyImpl) (struct GNUNET_MQ_Handle mq, void impl_state)
	Signature of functions implementing the destruction of a message queue. More...

typedef void(*	GNUNET_MQ_CancelImpl) (struct GNUNET_MQ_Handle mq, void impl_state)
	Implementation function that cancels the currently sent message. More...

typedef void(*	GNUNET_MQ_ErrorHandler) (void *cls, enum GNUNET_MQ_Error error)
	Generic error handler, called with the appropriate error code and the same closure specified at the creation of the message queue. More...

Enumerations
enum	GNUNET_MQ_Error { GNUNET_MQ_ERROR_READ = 1, GNUNET_MQ_ERROR_WRITE = 2, GNUNET_MQ_ERROR_TIMEOUT = 4, GNUNET_MQ_ERROR_MALFORMED = 8, GNUNET_MQ_ERROR_NO_MATCH = 16 }
	Error codes for the queue. More...

enum	GNUNET_MQ_PriorityPreferences { GNUNET_MQ_PRIO_BACKGROUND = 0, GNUNET_MQ_PRIO_BEST_EFFORT = 1, GNUNET_MQ_PRIO_URGENT = 2, GNUNET_MQ_PRIO_CRITICAL_CONTROL = 3, GNUNET_MQ_PRIORITY_MASK = 3, GNUNET_MQ_PREF_UNRELIABLE = 16, GNUNET_MQ_PREF_LOW_LATENCY = 32, GNUNET_MQ_PREF_CORK_ALLOWED = 64, GNUNET_MQ_PREF_GOODPUT = 128, GNUNET_MQ_PREF_OUT_OF_ORDER = 256 }
	Per envelope preferences and priorities. More...

Functions
const struct GNUNET_MessageHeader *	GNUNET_MQ_extract_nested_mh_ (const struct GNUNET_MessageHeader *mh, uint16_t base_size)
	Implementation of the #GNUNET_MQ_extract_nexted_mh macro. More...

const struct GNUNET_MessageHeader *	GNUNET_MQ_env_get_msg (const struct GNUNET_MQ_Envelope *env)
	Obtain message contained in envelope. More...

const struct GNUNET_MQ_Envelope *	GNUNET_MQ_env_next (const struct GNUNET_MQ_Envelope *env)
	Return next envelope in queue. More...

struct GNUNET_MQ_Envelope *	GNUNET_MQ_msg_nested_mh_ (struct GNUNET_MessageHeader *mhp, uint16_t base_size, uint16_t type, const struct GNUNET_MessageHeader nested_mh)
	Implementation of the GNUNET_MQ_msg_nested_mh macro. More...

void	GNUNET_MQ_dll_insert_head (struct GNUNET_MQ_Envelope env_head, struct GNUNET_MQ_Envelope env_tail, struct GNUNET_MQ_Envelope *env)
	Insert env into the envelope DLL starting at env_head Note that env must not be in any MQ while this function is used with DLLs defined outside of the MQ module. More...

void	GNUNET_MQ_dll_insert_tail (struct GNUNET_MQ_Envelope env_head, struct GNUNET_MQ_Envelope env_tail, struct GNUNET_MQ_Envelope *env)
	Insert env into the envelope DLL starting at env_head Note that env must not be in any MQ while this function is used with DLLs defined outside of the MQ module. More...

void	GNUNET_MQ_dll_remove (struct GNUNET_MQ_Envelope env_head, struct GNUNET_MQ_Envelope env_tail, struct GNUNET_MQ_Envelope *env)
	Remove env from the envelope DLL starting at env_head. More...

struct GNUNET_MQ_MessageHandler *	GNUNET_MQ_copy_handlers (const struct GNUNET_MQ_MessageHandler *handlers)
	Copy an array of handlers. More...

struct GNUNET_MQ_MessageHandler *	GNUNET_MQ_copy_handlers2 (const struct GNUNET_MQ_MessageHandler handlers, GNUNET_MQ_MessageCallback agpl_handler, void agpl_cls)
	Copy an array of handlers, appending AGPL handler. More...

unsigned int	GNUNET_MQ_count_handlers (const struct GNUNET_MQ_MessageHandler *handlers)
	Count the handlers in a handler array. More...

struct GNUNET_NotificationContext *	GNUNET_notification_context_create (unsigned int queue_length)
	Create a new notification context. More...

void	GNUNET_notification_context_destroy (struct GNUNET_NotificationContext *nc)
	Destroy the context, force disconnect for all subscribers. More...

void	GNUNET_notification_context_add (struct GNUNET_NotificationContext nc, struct GNUNET_MQ_Handle mq)
	Add a subscriber to the notification context. More...

void	GNUNET_notification_context_broadcast (struct GNUNET_NotificationContext nc, const struct GNUNET_MessageHeader msg, int can_drop)
	Send a message to all subscribers of this context. More...

unsigned int	GNUNET_notification_context_get_size (struct GNUNET_NotificationContext *nc)
	Return active number of subscribers in this context. More...

Variables
GNUNET_MQ_MessageValidationCallback	GNUNET_MQ_MessageHandler::mv
	Callback to validate a message of the specified type. More...

GNUNET_MQ_MessageCallback	GNUNET_MQ_MessageHandler::cb
	Callback, called every time a new message of the specified type has been receied. More...

void *	GNUNET_MQ_MessageHandler::cls
	Closure for mv and cb. More...

uint16_t	GNUNET_MQ_MessageHandler::type
	Type of the message this handler covers, in host byte order. More...

uint16_t	GNUNET_MQ_MessageHandler::expected_size
	Expected size of messages of this type. More...

will return a `struct GNUNET_MQ_MessageHandler`

Defines a static function name which takes as a single argument a message handler for fixed-sized messages of type code and with a message type argument of str.

Given such an argument, the function for the given message type.

The macro is to be used as follows: struct GNUNET_MessageTest { ... }; // must be fixed size static void handle_test_message (void *cls, const struct GNUNET_MessageTest *msg) { ... }

struct GNUNET_MQ_MessageHandler handlers[] = { GNUNET_MQ_hd_fixed_size(test_message, GNUNET_MESSAGE_TYPE_TEST, struct GNUNET_MessageTest, "context"), GNUNET_MQ_handler_end() };

Parameters


  
    name unique basename for the functions 
    code message type constant 
    str type of the message (a struct) 
    ctx context for the callbacks

#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)

will return a `struct

Defines a static function name which takes two arguments and a context-pointer for validating and handling variable-sized messages of type code and with a message type argument of str.

Given such arguments, the function GNUNET_MQ_MessageHandler` for the given message type.

The macro is to be used as follows: struct GNUNET_MessageTest { ... }; // can be variable size static int check_test (void *cls, const struct GNUNET_MessageTest *msg) { const char *ctx = cls; GNUNET_assert (0 == strcmp ("context", ctx)); // ... } static void handle_test (void *cls, const struct GNUNET_MessageTest *msg) { const char *ctx = cls; GNUNET_assert (0 == strcmp ("context", ctx)); // ... }

struct GNUNET_MQ_MessageHandler handlers[] = { GNUNET_MQ_hd_var_size(test_message, GNUNET_MESSAGE_TYPE_TEST, struct GNUNET_MessageTest, "context"), GNUNET_MQ_handler_end() };

Parameters


  
    name unique basename for the functions 
    code message type constant 
    str type of the message (a struct) 
    ctx context for the callbacks

enum GNUNET_MQ_PreferenceKind { GNUNET_MQ_PREFERENCE_NONE = 0, GNUNET_MQ_PREFERENCE_BANDWIDTH = 1, GNUNET_MQ_PREFERENCE_LATENCY = 2, GNUNET_MQ_PREFERENCE_RELIABILITY }

Enum defining all known preference categories. More...

int GNUNET_MQ_handle_message (const struct GNUNET_MQ_MessageHandler *handlers, const struct GNUNET_MessageHeader *mh)

Call the message message handler that was registered for the type of the given message in the given handlers list. More...

struct GNUNET_MQ_Envelope * GNUNET_MQ_msg_ (struct GNUNET_MessageHeader **mhp, uint16_t size, uint16_t type)

Create a new envelope. More...

struct GNUNET_MQ_Envelope * GNUNET_MQ_msg_copy (const struct GNUNET_MessageHeader *hdr)

Create a new envelope by copying an existing message. More...

void GNUNET_MQ_discard (struct GNUNET_MQ_Envelope *mqm)

Discard the message queue message, free all allocated resources. More...

struct GNUNET_MQ_Envelope * GNUNET_MQ_get_current_envelope (struct GNUNET_MQ_Handle *mq)

Function to obtain the current envelope from within GNUNET_MQ_SendImpl implementations. More...

struct GNUNET_MQ_Envelope * GNUNET_MQ_env_copy (struct GNUNET_MQ_Envelope *env)

Function to copy an envelope. More...

struct GNUNET_MQ_Envelope * GNUNET_MQ_get_last_envelope (struct GNUNET_MQ_Handle *mq)

Function to obtain the last envelope in the queue. More...

void GNUNET_MQ_env_set_options (struct GNUNET_MQ_Envelope *env, enum GNUNET_MQ_PriorityPreferences pp)

Set application-specific options for this envelope. More...

enum GNUNET_MQ_PriorityPreferences GNUNET_MQ_env_get_options (struct GNUNET_MQ_Envelope *env)

Get performance preferences set for this envelope. More...

enum GNUNET_MQ_PriorityPreferences GNUNET_MQ_env_combine_options (enum GNUNET_MQ_PriorityPreferences p1, enum GNUNET_MQ_PriorityPreferences p2)

Combine performance preferences set for different envelopes that are being combined into one larger envelope. More...

struct GNUNET_MQ_Envelope * GNUNET_MQ_unsent_head (struct GNUNET_MQ_Handle *mq)

Remove the first envelope that has not yet been sent from the message queue and return it. More...

void GNUNET_MQ_set_options (struct GNUNET_MQ_Handle *mq, enum GNUNET_MQ_PriorityPreferences pp)

Set application-specific options for this queue. More...

unsigned int GNUNET_MQ_get_length (struct GNUNET_MQ_Handle *mq)

Obtain the current length of the message queue. More...

void GNUNET_MQ_send (struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)

Send a message with the given message queue. More...

void GNUNET_MQ_send_copy (struct GNUNET_MQ_Handle *mq, const struct GNUNET_MQ_Envelope *ev)

Send a copy of a message with the given message queue. More...

void GNUNET_MQ_send_cancel (struct GNUNET_MQ_Envelope *ev)

Cancel sending the message. More...

uint32_t GNUNET_MQ_assoc_add (struct GNUNET_MQ_Handle *mq, void *assoc_data)

Associate the assoc_data in mq with a unique request id. More...

void * GNUNET_MQ_assoc_get (struct GNUNET_MQ_Handle *mq, uint32_t request_id)

Get the data associated with a request_id in a queue. More...

void * GNUNET_MQ_assoc_remove (struct GNUNET_MQ_Handle *mq, uint32_t request_id)

Remove the association for a request_id. More...

struct GNUNET_MQ_Handle * GNUNET_MQ_queue_for_callbacks (GNUNET_MQ_SendImpl send, GNUNET_MQ_DestroyImpl destroy, GNUNET_MQ_CancelImpl cancel, void *impl_state, const struct GNUNET_MQ_MessageHandler *handlers, GNUNET_MQ_ErrorHandler error_handler, void *cls)

Create a message queue for the specified handlers. More...

void GNUNET_MQ_set_handlers_closure (struct GNUNET_MQ_Handle *mq, void *handlers_cls)

Change the closure argument in all of the handlers of the mq. More...

void GNUNET_MQ_notify_sent (struct GNUNET_MQ_Envelope *ev, GNUNET_SCHEDULER_TaskCallback cb, void *cb_cls)

Call a callback once the envelope has been sent, that is, sending it can not be canceled anymore. More...

void GNUNET_MQ_destroy (struct GNUNET_MQ_Handle *mq)

Destroy the message queue. More...

struct GNUNET_MQ_DestroyNotificationHandle * GNUNET_MQ_destroy_notify (struct GNUNET_MQ_Handle *mq, GNUNET_SCHEDULER_TaskCallback cb, void *cb_cls)

Register function to be called whenever mq is being destroyed. More...

void GNUNET_MQ_destroy_notify_cancel (struct GNUNET_MQ_DestroyNotificationHandle *dnh)

Cancel registration from GNUNET_MQ_destroy_notify(). More...

void GNUNET_MQ_inject_message (struct GNUNET_MQ_Handle *mq, const struct GNUNET_MessageHeader *mh)

Call the message message handler that was registered for the type of the given message in the given message queue. More...

void GNUNET_MQ_inject_error (struct GNUNET_MQ_Handle *mq, enum GNUNET_MQ_Error error)

Call the error handler of a message queue with the given error code. More...

void GNUNET_MQ_impl_send_continue (struct GNUNET_MQ_Handle *mq)

Call the send implementation for the next queued message, if any. More...

void GNUNET_MQ_impl_send_in_flight (struct GNUNET_MQ_Handle *mq)

Call the send notification for the current message, but do not try to send the next message until #gnunet_mq_impl_send_continue is called. More...

void * GNUNET_MQ_impl_state (struct GNUNET_MQ_Handle *mq)

Get the implementation state associated with the message queue. More...

const struct GNUNET_MessageHeader * GNUNET_MQ_impl_current (struct GNUNET_MQ_Handle *mq)

Get the message that should currently be sent. More...

const char * GNUNET_MQ_preference_to_string (enum GNUNET_MQ_PreferenceKind type)

Convert an enum GNUNET_MQ_PreferenceType to a string. More...

#define GNUNET_MQ_hd_var_size(name, code, str, ctx)

#define GNUNET_MQ_check_zero_termination(m)

Insert code for a "check_" function that verifies that a given variable-length message received over the network is followed by a 0-terminated string. More...

#define GNUNET_MQ_check_boxed_message(m)

Insert code for a "check_" function that verifies that a given variable-length message received over the network is followed by another variable-length message that fits exactly with the given size. More...

Detailed Description

General-purpose message queue.

General-purpose broadcast mechanism for message queues.

See also: Documentation; Documentation

Macro Definition Documentation

◆ GNUNET_MQ_msg_extra

#define GNUNET_MQ_msg_extra	(	mvar,
		esize,
		type
	)

Value:

GNUNET_MQ_msg_ (((struct GNUNET_MessageHeader **) &(mvar)), \
                  (esize) + sizeof *(mvar),                   \
                  (type))

Allocate an envelope, with extra space allocated after the space needed by the message struct.

The allocated message will already have the type and size field set.

Parameters

mvar	variable to store the allocated message in; must have a header field; can be NULL
esize	extra space to allocate after the message
type	type of the message

Returns: the MQ message

Definition at line 52 of file gnunet_mq_lib.h.

Referenced by add_to_tc(), adv_transmit(), announce_reconnect(), attr_iter_cb(), broadcast_status(), change_service(), client_response_handler(), conclude_autoconfig_request(), consume_result_cb(), create_set_default_message(), create_update_message(), decode_and_send(), dispatch_buffer(), dns_pre_request_handler(), do_send(), forward_reply(), GCCH_handle_channel_plaintext_data(), GCCH_handle_local_data(), GCT_send(), GDS_CLIENTS_process_get(), GDS_CLIENTS_process_get_resp(), GDS_CLIENTS_process_put(), GDS_NEIGHBOURS_handle_get(), GDS_NEIGHBOURS_handle_put(), GDS_NEIGHBOURS_handle_reply(), GNUNET_ABD_collect(), GNUNET_ABD_verify(), GNUNET_ATS_performance_change_preference(), GNUNET_ATS_performance_give_feedback(), GNUNET_CONSENSUS_create(), GNUNET_CONSENSUS_insert(), GNUNET_DATASTORE_put(), GNUNET_DATASTORE_remove(), GNUNET_DHT_put(), GNUNET_DNS_request_answer(), GNUNET_FS_indexing_send_list(), GNUNET_GNS_lookup(), GNUNET_IDENTITY_create(), GNUNET_IDENTITY_delete(), GNUNET_IDENTITY_ego_lookup(), GNUNET_IDENTITY_ego_lookup_by_suffix(), GNUNET_IDENTITY_get(), GNUNET_IDENTITY_rename(), GNUNET_IDENTITY_set(), GNUNET_NAMECACHE_block_cache(), GNUNET_NAMESTORE_records_lookup(), GNUNET_NAMESTORE_records_store(), GNUNET_NAT_AUTO_autoconfig_start(), GNUNET_NAT_request_reversal(), GNUNET_NAT_stun_handle_packet(), GNUNET_RECLAIM_attribute_delete(), GNUNET_RECLAIM_attribute_store(), GNUNET_RECLAIM_ticket_issue(), GNUNET_RPS_seed_ids(), GNUNET_SCALARPRODUCT_accept_computation(), GNUNET_SCALARPRODUCT_start_computation(), GNUNET_SECRETSHARING_create_session(), GNUNET_SECRETSHARING_decrypt(), GNUNET_SET_add_element(), GNUNET_SET_remove_element(), GNUNET_TESTBED_barrier_cancel(), GNUNET_TESTBED_barrier_init_(), GNUNET_TESTBED_barrier_wait(), GNUNET_TESTBED_controller_connect(), GNUNET_TESTBED_forward_operation_msg_(), GNUNET_TESTBED_queue_message_(), GNUNET_TRANSPORT_address_to_string(), GNUNET_TRANSPORT_application_validate(), GNUNET_TRANSPORT_communicator_notify(), GNUNET_TRANSPORT_communicator_receive(), GNUNET_TRANSPORT_TESTING_send(), GNUNET_TRANSPORT_TESTING_transport_communicator_open_queue(), GNUNET_TRANSPORT_TESTING_transport_communicator_send(), GSC_CLIENTS_deliver_message(), GSC_KX_encrypt_and_transmit(), GSF_pending_request_get_message_(), GST_send_operation_fail_msg(), handle_add_host(), handle_backchannel_encapsulation(), handle_cadet_audio_message(), handle_client_audio_message(), handle_data(), handle_datastore_reply(), handle_list(), handle_lookup_block_it(), handle_p2p_reply(), handle_peer_get_config(), handle_raw_message(), handle_record_lookup(), handle_search_result(), handle_slave_get_config(), handle_start_message(), handle_union_p2p_demand(), handle_zone_to_name_it(), hash_for_index_cb(), icmp_from_helper(), keygen_round2_conclude(), notify_client(), notify_clients_stun_change(), notify_monitor(), opstart_manage_service(), opstart_peer_create(), opstart_peer_reconfigure(), path_info_iterator(), PEERSTORE_create_record_mq_envelope(), process_dns_result(), process_requests(), queue_send_msg(), read_stdio(), reconnect(), return_agpl(), reversal_callback(), route_packet(), schedule_transmit_search_request(), search_reconnect(), send_add_address(), send_add_address_message(), send_add_queue(), send_alices_cryptodata_message(), send_bloomfilter(), send_client_element(), send_client_removed_element(), send_client_reply(), send_client_status_msg(), send_controller_link_response(), send_create(), send_full_element_iterator(), send_get(), send_get_known_results(), send_ibf(), send_intermediate_response(), send_lookup_response(), send_missing_full_elements_iter(), send_msg(), send_pull_reply(), send_remaining_elements(), send_reply(), send_request(), send_request_to_client(), send_result_code(), send_stream_peers(), send_to_client_iter(), send_view(), suggest_to_connect(), tcp_from_helper(), transmit(), transmit_address_to_client(), transmit_bobs_cryptodata_message(), transmit_bobs_cryptodata_message_multipart(), transmit_call_audio(), transmit_client_response(), transmit_content(), transmit_get(), transmit_item(), transmit_phone_audio(), transmit_req_addr(), transmit_set(), transmit_status(), transmit_watch(), udp_from_helper(), and union_accept().

◆ GNUNET_MQ_msg

#define GNUNET_MQ_msg	(	mvar,
		type
	)	GNUNET_MQ_msg_extra (mvar, 0, type)

Allocate a GNUNET_MQ_Envelope.

The contained message will already have the type and size field set.

Parameters

mvar	variable to store the allocated message in; must have a header field; can be NULL
type	type of the message

Returns: the allocated envelope

Definition at line 67 of file gnunet_mq_lib.h.

Referenced by add_to_tc(), addr_cb(), attr_iter_finished(), attr_store_cont(), clean_up_channel(), client_request_complete_alice(), client_send_response(), comm_schedule_send(), core_mq_send_impl(), core_send_connect_info(), cores_send_disconnect_info(), create_internal(), create_loc_uri(), decrypt_conclude(), do_blacklist_check(), do_flood(), do_peer_connect(), do_plugin_connect(), fail_intersection_operation(), fail_union_operation(), finish_cmc_handling(), GAS_handle_address_destroyed(), GAS_handle_reservation_request(), GAS_scheduling_transmit_address_suggestion(), GCC_destroy_without_tunnel(), get_all_peers_iterator(), get_all_tunnels_iterator(), GNUNET_ARM_request_service_list(), GNUNET_ATS_address_destroy(), GNUNET_ATS_address_update(), GNUNET_ATS_connectivity_suggest_cancel(), GNUNET_ATS_performance_list_addresses(), GNUNET_ATS_reserve_bandwidth(), GNUNET_ATS_TEST_traffic_handle_ping(), GNUNET_CADET_channel_create(), GNUNET_CADET_channel_destroy(), GNUNET_CADET_close_port(), GNUNET_CADET_receive_done(), GNUNET_CONVERSATION_call_resume(), GNUNET_CONVERSATION_call_suspend(), GNUNET_CONVERSATION_caller_hang_up(), GNUNET_CONVERSATION_caller_pick_up(), GNUNET_CONVERSATION_caller_resume(), GNUNET_CONVERSATION_caller_suspend(), GNUNET_DATASTORE_disconnect(), GNUNET_DATASTORE_get_for_replication(), GNUNET_DATASTORE_get_key(), GNUNET_DATASTORE_get_zero_anonymity(), GNUNET_DATASTORE_release_reserve(), GNUNET_DATASTORE_reserve(), GNUNET_DHT_get_stop(), GNUNET_DHT_monitor_stop(), GNUNET_DNS_request_drop(), GNUNET_DNS_request_forward(), GNUNET_FS_get_indexed_files(), GNUNET_FS_indexing_send_list(), GNUNET_NAMECACHE_lookup_block(), GNUNET_NAMESTORE_zone_iteration_start(), GNUNET_NAMESTORE_zone_iteration_stop(), GNUNET_NAMESTORE_zone_iterator_next(), GNUNET_NAMESTORE_zone_monitor_next(), GNUNET_NAMESTORE_zone_to_name(), GNUNET_PEERSTORE_watch(), GNUNET_PEERSTORE_watch_cancel(), GNUNET_RECLAIM_get_attributes_next(), GNUNET_RECLAIM_get_attributes_start(), GNUNET_RECLAIM_get_attributes_stop(), GNUNET_RECLAIM_ticket_consume(), GNUNET_RECLAIM_ticket_iteration_next(), GNUNET_RECLAIM_ticket_iteration_start(), GNUNET_RECLAIM_ticket_iteration_stop(), GNUNET_RECLAIM_ticket_revoke(), GNUNET_REVOCATION_query(), GNUNET_REVOCATION_revoke(), GNUNET_RPS_stream_request(), GNUNET_RPS_sub_start(), GNUNET_RPS_sub_stop(), GNUNET_RPS_view_request(), GNUNET_SET_accept(), GNUNET_SET_operation_cancel(), GNUNET_TRANSPORT_application_suggest_cancel(), GNUNET_TRANSPORT_core_disconnect(), GNUNET_TRANSPORT_core_get_mq(), GNUNET_TRANSPORT_manipulation_set(), GSC_bind(), GSC_CLIENTS_notify_client_about_neighbour(), GSC_CLIENTS_solicit_request(), GSC_handle_remote_channel_destroy(), GSC_KX_handle_client_monitor_peers(), GSF_block_peer_migration_(), GST_send_operation_success_msg(), handle_add_host(), handle_block_cache(), handle_cadet_hangup_message(), handle_cadet_pickup_message(), handle_cadet_resume_message(), handle_cadet_ring_message(), handle_cadet_suspend_message(), handle_channel_created(), handle_client_accept(), handle_client_address_to_string(), handle_client_call_message(), handle_client_copy_lazy_prepare(), handle_client_hangup_message(), handle_client_init(), handle_client_loc_sign(), handle_client_monitor_peers(), handle_client_pickup_message(), handle_client_resume_message(), handle_client_suspend_message(), handle_client_unindex(), handle_create_queue(), handle_disconnect(), handle_get(), handle_get_all(), handle_get_peers(), handle_gns_response(), handle_info_tunnels(), handle_iter_element(), handle_lookup_block(), handle_notify(), handle_peer_create(), handle_peer_start(), handle_peer_stop(), handle_ping(), handle_query(), handle_query_message(), handle_request(), handle_revoke_message(), handle_show_path(), handle_test(), handle_zone_to_name(), hash_for_index_val(), listen_connect(), monitor_sync(), notify_change(), open_port_cb(), opstart_overlay_connect(), opstart_peer_destroy(), opstart_peer_start(), opstart_peer_stop(), opstart_shutdown_peers(), plugin_session_info_cb(), prepare_client_end_notification(), reconnect(), reconnect_arm(), reconnect_arm_monitor(), reconnect_phone(), record_iterator(), retry_entry(), revoke_result_cb(), rewatch_it(), route_message(), schedule_action(), send_ack(), send_ack_to_client(), send_broken(), send_broken_without_mqm(), send_client_done(), send_client_done_and_destroy(), send_create_ack(), send_del_address(), send_del_queue(), send_delete_response(), send_echo(), send_element_count(), send_end_msg(), send_ic_request(), send_kx(), send_kx_auth(), send_monitor_start(), send_overlay_connect_success_msg(), send_p2p_done(), send_request(), send_start_monitor(), send_store_response(), send_ticket_result(), signal_index_ok(), signal_result(), test_nat_punched(), ticket_iter_cb(), transmit_address_to_client(), transmit_bobs_cryptodata_message(), transmit_item(), transmit_pending(), transmit_suggestion(), unindex_finish(), and zone_iteration_done_client_continue().

◆ GNUNET_MQ_msg_header

#define GNUNET_MQ_msg_header ( type ) GNUNET_MQ_msg_ (NULL, sizeof(struct GNUNET_MessageHeader), type)

Allocate a GNUNET_MQ_Envelope, where the message only consists of a header.

The allocated message will already have the type and size field set.

Parameters

type	type of the message

Definition at line 76 of file gnunet_mq_lib.h.

Referenced by cancel_stream(), check_peer_online(), decode_and_send(), GNUNET_CONSENSUS_conclude(), GNUNET_RPS_view_request_cancel(), GNUNET_SET_copy_lazy(), GNUNET_SET_iterate(), handle_union_p2p_full_done(), handle_union_p2p_strata_estimator(), maybe_finish(), send_client_element(), send_full_set(), send_pull_request(), send_push(), and send_to_client_iter().

◆ GNUNET_MQ_msg_header_extra

#define GNUNET_MQ_msg_header_extra	(	mh,
		esize,
		type
	)	GNUNET_MQ_msg_ (&mh, (esize) + sizeof(struct GNUNET_MessageHeader), type)

Allocate a GNUNET_MQ_Envelope, where the message only consists of a header and extra space.

The allocated message will already have the type and size field set.

Parameters

mh	pointer that will changed to point at to the allocated message header
esize	extra space to allocate after the message header
type	type of the message

Definition at line 88 of file gnunet_mq_lib.h.

Referenced by handle_union_p2p_offer(), and send_offers_iterator().

◆ GNUNET_MQ_msg_nested_mh

#define GNUNET_MQ_msg_nested_mh	(	mvar,
		type,
		mh
	)

Value:

({                                                                          \
    struct GNUNET_MQ_Envelope *_ev;                                           \
    _ev = GNUNET_MQ_msg_nested_mh_ ((struct GNUNET_MessageHeader **) &(mvar), \
                                    sizeof(*(mvar)),                         \
                                    (type),                                   \
                                    (mh));                                    \
    (void) (mvar)->header;  /* type check */                                   \
    _ev;                                                                      \
  })

Allocate a GNUNET_MQ_Envelope, and append a payload message after the given message struct.

Parameters

mvar	pointer to a message struct, will be changed to point at the newly allocated message, whose size is 'sizeof(*mvar) + ntohs (mh->size)'
type	message type of the allocated message, has no effect on the nested message
mh	message to nest

Returns: a newly allocated 'struct GNUNET_MQ_Envelope *'

Definition at line 102 of file gnunet_mq_lib.h.

Referenced by cadet_mq_send_impl(), core_mq_send_impl(), GNUNET_SET_prepare(), handle_incoming_msg(), intersection_evaluate(), mq_send_impl(), and union_evaluate().

◆ GNUNET_MQ_extract_nested_mh

#define GNUNET_MQ_extract_nested_mh ( var )

Value:

GNUNET_MQ_extract_nested_mh_ ((struct GNUNET_MessageHeader *) (var), \

sizeof(*(var)))

GNUNET_MQ_extract_nested_mh_

const struct GNUNET_MessageHeader * GNUNET_MQ_extract_nested_mh_(const struct GNUNET_MessageHeader *mh, uint16_t base_size)

Implementation of the #GNUNET_MQ_extract_nexted_mh macro.

Definition: mq.c:881

GNUNET_MessageHeader

Header for all communications.

Definition: gnunet_common.h:260

Return a pointer to the message at the end of the given message.

Parameters

var	pointer to a message struct, the type of the expression determines the base size, the space after the base size is the nested message

Returns: a 'struct GNUNET_MessageHeader *' that points at the nested message of the given message, or NULL if the given message in var does not have any space after the message struct

Definition at line 122 of file gnunet_mq_lib.h.

Referenced by check_incoming_msg(), check_request(), handle_client_evaluate(), handle_incoming_msg(), and handle_request().

◆ GNUNET_MQ_handler_end

#define GNUNET_MQ_handler_end ( )

Value:

{                             \
    NULL, NULL, NULL, 0, 0      \
  }

End-marker for the handlers array.

Definition at line 514 of file gnunet_mq_lib.h.

Referenced by advertise_dns_exit(), client_connect_cb(), client_disconnect_cb(), client_request_complete_alice(), connect_check_run(), connect_task(), core_connect_adapter(), create_channel(), create_internal(), create_loc_uri(), demultiplex_with_cmc(), disconnect_cb(), do_connect(), do_peer_connect(), do_plugin_connect(), do_reconnect(), GCO_init(), GCT_create_tunnel(), GDS_NEIGHBOURS_init(), get_cadet(), get_channel(), GNUNET_CONSENSUS_create(), GNUNET_CONVERSATION_call_start(), GNUNET_FS_get_indexed_files(), GNUNET_IDENTITY_ego_lookup(), GNUNET_IDENTITY_ego_lookup_by_suffix(), GNUNET_NAT_AUTO_autoconfig_start(), GNUNET_REVOCATION_query(), GNUNET_REVOCATION_revoke(), GNUNET_SCALARPRODUCT_accept_computation(), GNUNET_SCALARPRODUCT_start_computation(), GNUNET_SECRETSHARING_create_session(), GNUNET_SECRETSHARING_decrypt(), GNUNET_TESTBED_barrier_wait(), GNUNET_TESTBED_controller_connect(), GNUNET_TRANSPORT_address_to_string(), GSC_KX_init(), GSF_cadet_start_server(), GST_barriers_init(), handle_bob_client_message(), handle_client_call_message(), handle_client_evaluate(), handle_client_listen(), handle_client_register_message(), hash_for_index_cb(), listen_connect(), logger_run(), main(), main_init(), new_sub(), reconnect(), reconnect_arm(), reconnect_arm_monitor(), reconnect_phone(), reconnect_task(), reset_cadet(), run(), search_reconnect(), store_service(), testbed_run(), transport_connect_adapter(), try_connect(), try_open_exit(), try_reconnect(), and unindex_finish().

◆ GNUNET_MQ_hd_fixed_size

#define GNUNET_MQ_hd_fixed_size	(	name,
		code,
		str,
		ctx
	)

Value:

({                                                                    \
    void (*_cb)(void *cls, const str *msg) = &handle_ ## name;           \
    ((struct GNUNET_MQ_MessageHandler){ NULL,                            \
                                        (GNUNET_MQ_MessageCallback) _cb, \
                                        (ctx),                           \
                                        (code),                          \
                                        sizeof(str) });                  \
  })

Definition at line 548 of file gnunet_mq_lib.h.

Referenced by client_connect_cb(), client_disconnect_cb(), client_request_complete_alice(), core_connect_adapter(), create_internal(), create_loc_uri(), demultiplex_with_cmc(), do_peer_connect(), do_plugin_connect(), GCO_init(), GCT_create_tunnel(), get_channel(), GNUNET_CONSENSUS_create(), GNUNET_CONVERSATION_call_start(), GNUNET_FS_get_indexed_files(), GNUNET_REVOCATION_query(), GNUNET_REVOCATION_revoke(), GNUNET_SECRETSHARING_decrypt(), GNUNET_TESTBED_controller_connect(), GSC_KX_init(), GSF_cadet_start_server(), handle_bob_client_message(), handle_client_call_message(), handle_client_evaluate(), handle_client_listen(), handle_client_register_message(), hash_for_index_cb(), main(), main_init(), new_sub(), reconnect(), reconnect_arm(), reconnect_phone(), run(), testbed_run(), transport_communicator_start(), transport_connect_adapter(), try_connect(), try_reconnect(), and unindex_finish().

◆ GNUNET_MQ_hd_var_size

#define GNUNET_MQ_hd_var_size	(	name,
		code,
		str,
		ctx
	)

Value:

__extension__ ({                                                            \
    int (*_mv)(void *cls, const str *msg) = &check_ ## name;                  \
    void (*_cb)(void *cls, const str *msg) = &handle_ ## name;                \
    ((struct GNUNET_MQ_MessageHandler){ (GNUNET_MQ_MessageValidationCallback) \
                                        _mv,                                \
                                        (GNUNET_MQ_MessageCallback) _cb,      \
                                        (ctx),                                \
                                        (code),                               \
                                        sizeof(str) });                       \
  })

Definition at line 599 of file gnunet_mq_lib.h.

Referenced by advertise_dns_exit(), client_connect_cb(), client_disconnect_cb(), client_request_complete_alice(), connect_check_run(), connect_task(), create_channel(), create_internal(), demultiplex_with_cmc(), disconnect_cb(), do_connect(), do_peer_connect(), do_plugin_connect(), do_reconnect(), GCO_init(), GCT_create_tunnel(), GDS_NEIGHBOURS_init(), get_cadet(), get_channel(), GNUNET_CONSENSUS_create(), GNUNET_CONVERSATION_call_start(), GNUNET_FS_get_indexed_files(), GNUNET_IDENTITY_ego_lookup(), GNUNET_IDENTITY_ego_lookup_by_suffix(), GNUNET_NAT_AUTO_autoconfig_start(), GNUNET_SCALARPRODUCT_accept_computation(), GNUNET_SCALARPRODUCT_start_computation(), GNUNET_SECRETSHARING_create_session(), GNUNET_TESTBED_barrier_wait(), GNUNET_TESTBED_controller_connect(), GNUNET_TRANSPORT_address_to_string(), GSC_KX_init(), GST_barriers_init(), handle_bob_client_message(), handle_client_call_message(), handle_client_evaluate(), handle_client_listen(), handle_client_register_message(), hash_for_index_cb(), listen_connect(), logger_run(), main(), main_init(), new_sub(), reconnect(), reconnect_arm(), reconnect_arm_monitor(), reconnect_phone(), reconnect_task(), reset_cadet(), run(), search_reconnect(), store_service(), testbed_run(), transport_communicator_start(), try_connect(), try_open_exit(), and try_reconnect().

◆ GNUNET_MQ_check_zero_termination

#define GNUNET_MQ_check_zero_termination ( m )

Value:

{                                                               \
    const char *str = (const char *) &m[1];                       \
    const struct GNUNET_MessageHeader *hdr =                      \
      (const struct GNUNET_MessageHeader *) m;                    \
    uint16_t slen = ntohs (hdr->size) - sizeof(*m);              \
    if ((0 == slen) || (memchr (str, 0, slen) != &str[slen - 1])) \
    {                                                             \
      GNUNET_break (0);                                           \
      return GNUNET_NO;                                           \
    }                                                             \
  }

Insert code for a "check_" function that verifies that a given variable-length message received over the network is followed by a 0-terminated string.

If the message m is not followed by a 0-terminated string, an error is logged and the function is returned with GNUNET_NO.

Parameters

an	IPC message with proper type to determine the size, starting with a `struct GNUNET_MessageHeader`

Definition at line 622 of file gnunet_mq_lib.h.

Referenced by check_add_address(), check_add_queue_message(), check_announce(), check_client_index_start(), check_communicator_available(), check_create_queue(), check_get(), check_identity_result_code(), check_lookup(), check_lookup_by_suffix_message(), check_lookup_message(), check_monitor_data(), check_record_lookup(), check_request_hello_validation(), check_start(), and check_stop().

◆ GNUNET_MQ_check_boxed_message

#define GNUNET_MQ_check_boxed_message ( m )

Value:

{                                                      \
    const struct GNUNET_MessageHeader *inbox =           \
      (const struct GNUNET_MessageHeader *) &m[1];       \
    const struct GNUNET_MessageHeader *hdr =             \
      (const struct GNUNET_MessageHeader *) m;           \
    uint16_t slen = ntohs (hdr->size) - sizeof(*m);     \
    if ((slen < sizeof(struct GNUNET_MessageHeader)) || \
        (slen != ntohs (inbox->size)))                   \
    {                                                    \
      GNUNET_break (0);                                  \
      return GNUNET_NO;                                  \
    }                                                    \
  }

Insert code for a "check_" function that verifies that a given variable-length message received over the network is followed by another variable-length message that fits exactly with the given size.

If the message m is not followed by another struct GNUNET_MessageHeader with a size that adds up to the total size, an error is logged and the function is returned with GNUNET_NO.

Parameters

an	IPC message with proper type to determine the size, starting with a `struct GNUNET_MessageHeader`

Definition at line 648 of file gnunet_mq_lib.h.

Referenced by check_backchannel_incoming(), check_incoming_msg(), check_reliability_box(), and check_send_msg().

Typedef Documentation

◆ GNUNET_MQ_MessageCallback

typedef void(* GNUNET_MQ_MessageCallback) (void *cls, const struct GNUNET_MessageHeader *msg)

Called when a message has been received.

Parameters

cls	closure
msg	the received message

Definition at line 308 of file gnunet_mq_lib.h.

◆ GNUNET_MQ_MessageValidationCallback

typedef int(* GNUNET_MQ_MessageValidationCallback) (void *cls, const struct GNUNET_MessageHeader *msg)

Called when a message needs to be validated.

Parameters

cls	closure
msg	the received message

Returns: GNUNET_OK if the message is well-formed, GNUNET_SYSERR if not

Definition at line 321 of file gnunet_mq_lib.h.

◆ GNUNET_MQ_SendImpl

typedef void(* GNUNET_MQ_SendImpl) (struct GNUNET_MQ_Handle *mq, const struct GNUNET_MessageHeader *msg, void *impl_state)

Signature of functions implementing the sending functionality of a message queue.

Parameters

mq	the message queue
msg	the message to send
impl_state	state of the implementation

Definition at line 334 of file gnunet_mq_lib.h.

◆ GNUNET_MQ_DestroyImpl

typedef void(* GNUNET_MQ_DestroyImpl) (struct GNUNET_MQ_Handle *mq, void *impl_state)

Signature of functions implementing the destruction of a message queue.

Implementations must not free mq, but should take care of impl_state.

Parameters

mq	the message queue to destroy
impl_state	state of the implementation

Definition at line 348 of file gnunet_mq_lib.h.

◆ GNUNET_MQ_CancelImpl

typedef void(* GNUNET_MQ_CancelImpl) (struct GNUNET_MQ_Handle *mq, void *impl_state)

Implementation function that cancels the currently sent message.

Parameters

mq	message queue
impl_state	state specific to the implementation

Definition at line 358 of file gnunet_mq_lib.h.

◆ GNUNET_MQ_ErrorHandler

typedef void(* GNUNET_MQ_ErrorHandler) (void *cls, enum GNUNET_MQ_Error error)

Generic error handler, called with the appropriate error code and the same closure specified at the creation of the message queue.

Not every message queue implementation supports an error handler.

Parameters

cls	closure
error	error code

Definition at line 371 of file gnunet_mq_lib.h.

Enumeration Type Documentation

◆ GNUNET_MQ_Error

enum GNUNET_MQ_Error

Error codes for the queue.

Enumerator
GNUNET_MQ_ERROR_READ	Failed to read message from the network. FIXME: Likely not properly distinguished from TIMEOUT case in the code!
GNUNET_MQ_ERROR_WRITE	FIXME: document!
GNUNET_MQ_ERROR_TIMEOUT	FIXME: document!
GNUNET_MQ_ERROR_MALFORMED	We received a message that was malformed and thus could not be passed to its handler.
GNUNET_MQ_ERROR_NO_MATCH	We received a message for which we have no matching handler.

Definition at line 191 of file gnunet_mq_lib.h.

 {
   GNUNET_MQ_ERROR_READ = 1,
 
   GNUNET_MQ_ERROR_WRITE = 2,
 
   GNUNET_MQ_ERROR_TIMEOUT = 4,
 
   GNUNET_MQ_ERROR_MALFORMED = 8,
 
   GNUNET_MQ_ERROR_NO_MATCH = 16
 };

◆ GNUNET_MQ_PriorityPreferences

enum GNUNET_MQ_PriorityPreferences

Per envelope preferences and priorities.

Enumerator
GNUNET_MQ_PRIO_BACKGROUND	Lowest priority, i.e. background traffic (i.e. NSE, FS). This is the default!
GNUNET_MQ_PRIO_BEST_EFFORT	Best-effort traffic (i.e. CADET relay, DHT)
GNUNET_MQ_PRIO_URGENT	Urgent traffic (local peer, i.e. Conversation).
GNUNET_MQ_PRIO_CRITICAL_CONTROL	Highest priority, control traffic (i.e. CORE/CADET KX).
GNUNET_MQ_PRIORITY_MASK	Bit mask to apply to extract the priority bits.
GNUNET_MQ_PREF_UNRELIABLE	Flag to indicate that unreliable delivery is acceptable. This means TRANSPORT will not attempt to receive an acknowledgment. CORE will just pass this flag through. CADET will use unreliable delivery if this flag is set. Note that even without this flag, messages may be lost by TRANSPORT and CORE. Thus, how "strong" the semantics of reliable delivery are depends on the layer!
GNUNET_MQ_PREF_LOW_LATENCY	Flag to indicate that low latency is important. This flag must generally not be used in combination with #GNUNET_MQ_PREF_CORKING_ALLOWED as it would be a contradiction. When this flags is set, the envelope may skip forward in the queue (depending on priority) and also TRANSPORT should attempt to pick a communicator with particularly low latency.
GNUNET_MQ_PREF_CORK_ALLOWED	Flag to indicate that CORKing is acceptable. This allows the receiver to delay transmission in hope of combining this message with other messages into a larger transmission with less per-message overhead.
GNUNET_MQ_PREF_GOODPUT	Flag to indicate that high bandwidth is desired. This flag indicates that the method chosen for transmission should focus on overall goodput. It rarely makes sense to combine this flag with GNUNET_MQ_PREF_LOW_LATENCY.
GNUNET_MQ_PREF_OUT_OF_ORDER	Flag to indicate that out-of-order delivery is OK.

Definition at line 227 of file gnunet_mq_lib.h.

 {
   GNUNET_MQ_PRIO_BACKGROUND = 0,
 
   GNUNET_MQ_PRIO_BEST_EFFORT = 1,
 
   GNUNET_MQ_PRIO_URGENT = 2,
 
   GNUNET_MQ_PRIO_CRITICAL_CONTROL = 3,
 
   GNUNET_MQ_PRIORITY_MASK = 3,
 
   GNUNET_MQ_PREF_UNRELIABLE = 16,
 
   GNUNET_MQ_PREF_LOW_LATENCY = 32,
 
   GNUNET_MQ_PREF_CORK_ALLOWED = 64,
 
   GNUNET_MQ_PREF_GOODPUT = 128,
 
   GNUNET_MQ_PREF_OUT_OF_ORDER = 256,
 };

◆ GNUNET_MQ_PreferenceKind

enum GNUNET_MQ_PreferenceKind

Enum defining all known preference categories.

Deprecated:: will be replaced by enum GNUNET_MQ_PriorityPreference

Enumerator
GNUNET_MQ_PREFERENCE_NONE	No preference was expressed.
GNUNET_MQ_PREFERENCE_BANDWIDTH	The preferred transmission for this envelope focuses on maximizing bandwidth.
GNUNET_MQ_PREFERENCE_LATENCY	The preferred transmission for this envelope foces on minimizing latency.
GNUNET_MQ_PREFERENCE_RELIABILITY	The preferred transmission for this envelope foces on reliability.

Definition at line 1065 of file gnunet_mq_lib.h.

 {
   GNUNET_MQ_PREFERENCE_NONE = 0,
 
   GNUNET_MQ_PREFERENCE_BANDWIDTH = 1,
 
   GNUNET_MQ_PREFERENCE_LATENCY = 2,
 
   GNUNET_MQ_PREFERENCE_RELIABILITY = 3
 
 #define GNUNET_MQ_PREFERENCE_COUNT 4
 };

Function Documentation

◆ GNUNET_MQ_extract_nested_mh_()

const struct GNUNET_MessageHeader* GNUNET_MQ_extract_nested_mh_	(	const struct GNUNET_MessageHeader *	mh,
		uint16_t	base_size
	)

Implementation of the #GNUNET_MQ_extract_nexted_mh macro.

Parameters

mh	message header to extract nested message header from
base_size	size of the message before the nested message's header appears

Returns: pointer to the nested message, does not copy the message OR NULL in case of a malformed message.

Definition at line 881 of file mq.c.

References GNUNET_assert, GNUNET_break_op, and GNUNET_MessageHeader::size.

 {
   uint16_t whole_size;
   uint16_t nested_size;
   const struct GNUNET_MessageHeader *nested_msg;
 
   whole_size = ntohs (mh->size);
   GNUNET_assert (whole_size >= base_size);
   nested_size = whole_size - base_size;
   if (0 == nested_size)
     return NULL;
   if (nested_size < sizeof(struct GNUNET_MessageHeader))
   {
     GNUNET_break_op (0);
     return NULL;
   }
   nested_msg = (const struct GNUNET_MessageHeader *) ((char *) mh + base_size);
   if (ntohs (nested_msg->size) != nested_size)
   {
     GNUNET_break_op (0);
     return NULL;
   }
   return nested_msg;
 }

◆ GNUNET_MQ_env_get_msg()

const struct GNUNET_MessageHeader* GNUNET_MQ_env_get_msg ( const struct GNUNET_MQ_Envelope * env )

Obtain message contained in envelope.

Parameters

env	the envelope

Returns: message contained in the envelope

Definition at line 1080 of file mq.c.

References GNUNET_MQ_Envelope::mh.

Referenced by do_send(), mqm_execute(), and route_message().

 {
   return env->mh;
 }

Here is the caller graph for this function:

◆ GNUNET_MQ_env_next()

const struct GNUNET_MQ_Envelope* GNUNET_MQ_env_next ( const struct GNUNET_MQ_Envelope * env )

Return next envelope in queue.

Parameters

env	a queued envelope

Returns: next one, or NULL

Definition at line 1093 of file mq.c.

References GNUNET_MQ_Envelope::next.

Referenced by route_message().

 {
   return env->next;
 }

Here is the caller graph for this function:

◆ GNUNET_MQ_msg_nested_mh_()

struct GNUNET_MQ_Envelope* GNUNET_MQ_msg_nested_mh_	(	struct GNUNET_MessageHeader **	mhp,
		uint16_t	base_size,
		uint16_t	type,
		const struct GNUNET_MessageHeader *	nested_mh
	)

Implementation of the GNUNET_MQ_msg_nested_mh macro.

Parameters

mhp	pointer to the message header pointer that will be changed to allocate at the newly allocated space for the message.
base_size	size of the data before the nested message
type	type of the message in the envelope
nested_mh	the message to append to the message after base_size

Definition at line 675 of file mq.c.

References GNUNET_memcpy, GNUNET_MQ_msg_(), GNUNET_MQ_Envelope::mh, size, and GNUNET_MessageHeader::size.

 {
   struct GNUNET_MQ_Envelope *mqm;
   uint16_t size;
 
   if (NULL == nested_mh)
     return GNUNET_MQ_msg_ (mhp, base_size, type);
 
   size = base_size + ntohs (nested_mh->size);
 
   /* check for uint16_t overflow */
   if (size < base_size)
     return NULL;
 
   mqm = GNUNET_MQ_msg_ (mhp, size, type);
   GNUNET_memcpy ((char *) mqm->mh + base_size,
                  nested_mh,
                  ntohs (nested_mh->size));
 
   return mqm;
 }

Here is the call graph for this function:

◆ GNUNET_MQ_dll_insert_head()

void GNUNET_MQ_dll_insert_head	(	struct GNUNET_MQ_Envelope **	env_head,
		struct GNUNET_MQ_Envelope **	env_tail,
		struct GNUNET_MQ_Envelope *	env
	)

Insert env into the envelope DLL starting at env_head Note that env must not be in any MQ while this function is used with DLLs defined outside of the MQ module.

This is just in case some application needs to also manage a FIFO of envelopes independent of MQ itself and wants to re-use the pointers internal to env. Use with caution.

Parameters

Definition at line 1153 of file mq.c.

References GNUNET_CONTAINER_DLL_insert.

Referenced by route_message().

 {
   GNUNET_CONTAINER_DLL_insert (*env_head, *env_tail, env);
 }

Here is the caller graph for this function:

◆ GNUNET_MQ_dll_insert_tail()

void GNUNET_MQ_dll_insert_tail	(	struct GNUNET_MQ_Envelope **	env_head,
		struct GNUNET_MQ_Envelope **	env_tail,
		struct GNUNET_MQ_Envelope *	env
	)

Insert env into the envelope DLL starting at env_head Note that env must not be in any MQ while this function is used with DLLs defined outside of the MQ module.

This is just in case some application needs to also manage a FIFO of envelopes independent of MQ itself and wants to re-use the pointers internal to env. Use with caution.

Parameters

Definition at line 1174 of file mq.c.

References GNUNET_CONTAINER_DLL_insert_tail.

Referenced by route_message().

 {
   GNUNET_CONTAINER_DLL_insert_tail (*env_head, *env_tail, env);
 }

Here is the caller graph for this function:

◆ GNUNET_MQ_dll_remove()

void GNUNET_MQ_dll_remove	(	struct GNUNET_MQ_Envelope **	env_head,
		struct GNUNET_MQ_Envelope **	env_tail,
		struct GNUNET_MQ_Envelope *	env
	)

Remove env from the envelope DLL starting at env_head.

Note that env must not be in any MQ while this function is used with DLLs defined outside of the MQ module. This is just in case some application needs to also manage a FIFO of envelopes independent of MQ itself and wants to re-use the pointers internal to env. Use with caution.

Parameters

Definition at line 1195 of file mq.c.

References GNUNET_CONTAINER_DLL_remove.

Referenced by dir_ready_cb(), and discard_buffer().

 {
   GNUNET_CONTAINER_DLL_remove (*env_head, *env_tail, env);
 }

Here is the caller graph for this function:

◆ GNUNET_MQ_copy_handlers()

struct GNUNET_MQ_MessageHandler* GNUNET_MQ_copy_handlers ( const struct GNUNET_MQ_MessageHandler * handlers )

Copy an array of handlers.

Useful if the array has been delared in local memory and needs to be persisted for future use.

Parameters

handlers Array of handlers to be copied.

Returns: A newly allocated array of handlers. Needs to be freed with GNUNET_free.

Useful if the array has been delared in local memory and needs to be persisted for future use.

Parameters

handlers Array of handlers to be copied. Can be NULL (nothing done).

Returns: A newly allocated array of handlers. Needs to be freed with GNUNET_free.

Definition at line 1214 of file mq.c.

References GNUNET_memcpy, GNUNET_MQ_count_handlers(), and GNUNET_new_array.

Referenced by GNUNET_CADET_open_port(), GNUNET_CADET_TEST_ruN(), GNUNET_CORE_connect(), GNUNET_MQ_queue_for_callbacks(), and GNUNET_SERVICE_run_().

 {
   struct GNUNET_MQ_MessageHandler *copy;
   unsigned int count;
 
   if (NULL == handlers)
     return NULL;
 
   count = GNUNET_MQ_count_handlers (handlers);
   copy = GNUNET_new_array (count + 1, struct GNUNET_MQ_MessageHandler);
   GNUNET_memcpy (copy,
                  handlers,
                  count * sizeof(struct GNUNET_MQ_MessageHandler));
   return copy;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_MQ_copy_handlers2()

struct GNUNET_MQ_MessageHandler* GNUNET_MQ_copy_handlers2	(	const struct GNUNET_MQ_MessageHandler *	handlers,
		GNUNET_MQ_MessageCallback	agpl_handler,
		void *	agpl_cls
	)

Copy an array of handlers, appending AGPL handler.

Useful if the array has been delared in local memory and needs to be persisted for future use.

Parameters

handlers	Array of handlers to be copied. Can be NULL (nothing done).
agpl_handler	function to call for AGPL handling
agpl_cls	closure for agpl_handler

Returns: A newly allocated array of handlers. Needs to be freed with GNUNET_free.

Definition at line 1244 of file mq.c.

References GNUNET_MQ_MessageHandler::cb, GNUNET_MQ_MessageHandler::cls, GNUNET_MQ_MessageHandler::expected_size, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_REQUEST_AGPL, GNUNET_MQ_count_handlers(), GNUNET_new_array, GNUNET_MQ_MessageHandler::mv, and GNUNET_MQ_MessageHandler::type.

Referenced by GNUNET_SERVICE_start().

 {
   struct GNUNET_MQ_MessageHandler *copy;
   unsigned int count;
 
   if (NULL == handlers)
     return NULL;
   count = GNUNET_MQ_count_handlers (handlers);
   copy = GNUNET_new_array (count + 2, struct GNUNET_MQ_MessageHandler);
   GNUNET_memcpy (copy,
                  handlers,
                  count * sizeof(struct GNUNET_MQ_MessageHandler));
   copy[count].mv = NULL;
   copy[count].cb = agpl_handler;
   copy[count].cls = agpl_cls;
   copy[count].type = GNUNET_MESSAGE_TYPE_REQUEST_AGPL;
   copy[count].expected_size = sizeof(struct GNUNET_MessageHeader);
   return copy;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_MQ_count_handlers()

unsigned int GNUNET_MQ_count_handlers ( const struct GNUNET_MQ_MessageHandler * handlers )

Count the handlers in a handler array.

Parameters

handlers Array of handlers to be counted.

Returns: The number of handlers in the array.

Definition at line 1274 of file mq.c.

References GNUNET_MQ_MessageHandler::cb.

Referenced by GNUNET_CORE_connect(), GNUNET_MQ_copy_handlers(), and GNUNET_MQ_copy_handlers2().

 {
   unsigned int i;
 
   if (NULL == handlers)
     return 0;
 
   for (i = 0; NULL != handlers[i].cb; i++)
     ;
 
   return i;
 }

Here is the caller graph for this function:

◆ GNUNET_MQ_handle_message()

int GNUNET_MQ_handle_message	(	const struct GNUNET_MQ_MessageHandler *	handlers,
		const struct GNUNET_MessageHeader *	mh
	)

Call the message message handler that was registered for the type of the given message in the given handlers list.

This function is indended to be used for the implementation of message queues.

Parameters

handlers	a set of handlers
mh	message to dispatch

Returns: GNUNET_OK on success, GNUNET_NO if no handler matched, GNUNET_SYSERR if message was rejected by check function

Definition at line 229 of file mq.c.

References GNUNET_MQ_MessageHandler::cb, GNUNET_MQ_MessageHandler::cls, done(), GNUNET_MQ_MessageHandler::expected_size, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, GNUNET_YES, LOG, GNUNET_MQ_MessageHandler::mv, GNUNET_MessageHeader::size, GNUNET_MessageHeader::type, and GNUNET_MQ_MessageHandler::type.

Referenced by demultiplex_with_cmc(), and GNUNET_MQ_inject_message().

 {
   const struct GNUNET_MQ_MessageHandler *handler;
   int handled = GNUNET_NO;
   uint16_t msize = ntohs (mh->size);
   uint16_t mtype = ntohs (mh->type);
 
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Received message of type %u and size %u\n",
        mtype,
        msize);
 
   if (NULL == handlers)
     goto done;
   for (handler = handlers; NULL != handler->cb; handler++)
   {
     if (handler->type == mtype)
     {
       handled = GNUNET_YES;
       if ((handler->expected_size > msize) ||
           ((handler->expected_size != msize) && (NULL == handler->mv)))
       {
         /* Too small, or not an exact size and
            no 'mv' handler to check rest */
         LOG (GNUNET_ERROR_TYPE_ERROR,
              "Received malformed message of type %u\n",
              (unsigned int) handler->type);
         return GNUNET_SYSERR;
       }
       if ((NULL == handler->mv) ||
           (GNUNET_OK == handler->mv (handler->cls, mh)))
       {
         /* message well-formed, pass to handler */
         handler->cb (handler->cls, mh);
       }
       else
       {
         /* Message rejected by check routine */
         LOG (GNUNET_ERROR_TYPE_ERROR,
              "Received malformed message of type %u\n",
              (unsigned int) handler->type);
         return GNUNET_SYSERR;
       }
       break;
     }
   }
 done:
   if (GNUNET_NO == handled)
   {
     LOG (GNUNET_ERROR_TYPE_INFO,
          "No handler for message of type %u and size %u\n",
          mtype,
          msize);
     return GNUNET_NO;
   }
   return GNUNET_OK;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_MQ_msg_()

struct GNUNET_MQ_Envelope* GNUNET_MQ_msg_	(	struct GNUNET_MessageHeader **	mhp,
		uint16_t	size,
		uint16_t	type
	)

Create a new envelope.

Parameters

mhp	message header to store the allocated message header in, can be NULL
size	size of the message to allocate
type	type of the message, will be set in the allocated message

Returns: the allocated MQ message

Definition at line 632 of file mq.c.

References GNUNET_malloc, GNUNET_MQ_Envelope::mh, GNUNET_MessageHeader::size, and GNUNET_MessageHeader::type.

Referenced by GNUNET_MQ_msg_nested_mh_().

 {
   struct GNUNET_MQ_Envelope *ev;
 
   ev = GNUNET_malloc (size + sizeof(struct GNUNET_MQ_Envelope));
   ev->mh = (struct GNUNET_MessageHeader *) &ev[1];
   ev->mh->size = htons (size);
   ev->mh->type = htons (type);
   if (NULL != mhp)
     *mhp = ev->mh;
   return ev;
 }

Here is the caller graph for this function:

◆ GNUNET_MQ_msg_copy()

struct GNUNET_MQ_Envelope* GNUNET_MQ_msg_copy ( const struct GNUNET_MessageHeader * hdr )

Create a new envelope by copying an existing message.

Parameters

hdr	header of the message to copy

Returns: envelope containing hdr

Definition at line 653 of file mq.c.

References GNUNET_malloc, GNUNET_memcpy, GNUNET_MQ_Envelope::mh, size, and GNUNET_MessageHeader::size.

Referenced by do_connect(), GNUNET_MQ_env_copy(), GNUNET_notification_context_broadcast(), GNUNET_PEERINFO_add_peer(), GNUNET_TRANSPORT_offer_hello(), GST_clients_broadcast_peer_notification(), GST_forwarded_operation_reply_relay(), handle_barrier_status(), handle_send_msg(), handle_start(), notify_client(), plugin_session_info_cb(), route_message(), schedule_next_hello(), send_key(), send_peer_information(), send_ping(), transmit_task_cb(), and unicast().

 {
   struct GNUNET_MQ_Envelope *mqm;
   uint16_t size = ntohs (hdr->size);
 
   mqm = GNUNET_malloc (sizeof(*mqm) + size);
   mqm->mh = (struct GNUNET_MessageHeader *) &mqm[1];
   GNUNET_memcpy (mqm->mh, hdr, size);
   return mqm;
 }

Here is the caller graph for this function:

◆ GNUNET_MQ_discard()

void GNUNET_MQ_discard ( struct GNUNET_MQ_Envelope * ev )

Discard the message queue message, free all allocated resources.

Must be called in the event that a message is created but should not actually be sent.

Parameters

mqm	the message to discard

Definition at line 321 of file mq.c.

References GNUNET_assert, GNUNET_free, and GNUNET_MQ_Envelope::parent_queue.

Referenced by abort_all_requests(), broadcast_status(), cadet_mq_cancel_impl(), core_mq_cancel_impl(), destroy_channel(), discard_buffer(), disconnect_and_free_peer_entry(), free_channel_client(), free_it(), free_op(), free_qe(), free_queue_entry(), free_ze(), GCCH_handle_channel_plaintext_data(), GCP_request_mq_cancel(), GCP_send_ooo(), GCP_set_mq(), GCT_send_cancel(), GNUNET_ABD_request_cancel(), GNUNET_GNS_lookup_cancel(), GNUNET_MQ_destroy(), GSF_peer_disconnect_handler(), handle_dns_response(), handle_result(), make_queue_entry(), mqm_execute(), send_client_element(), send_to_channel(), and set_operation_destroy().

 {
   GNUNET_assert (NULL == ev->parent_queue);
   GNUNET_free (ev);
 }

Here is the caller graph for this function:

◆ GNUNET_MQ_get_current_envelope()

struct GNUNET_MQ_Envelope* GNUNET_MQ_get_current_envelope ( struct GNUNET_MQ_Handle * mq )

Function to obtain the current envelope from within GNUNET_MQ_SendImpl implementations.

Parameters

mq	message queue to interrogate

Returns: the current envelope

Definition at line 974 of file mq.c.

References GNUNET_MQ_Handle::current_envelope.

Referenced by cadet_mq_send_impl(), core_mq_send_impl(), and mq_send_impl().

 {
   return mq->current_envelope;
 }

Here is the caller graph for this function:

◆ GNUNET_MQ_env_copy()

struct GNUNET_MQ_Envelope* GNUNET_MQ_env_copy ( struct GNUNET_MQ_Envelope * env )

Function to copy an envelope.

The envelope must not yet be in any queue or have any options or callbacks set.

Parameters

env	envelope to copy

Returns: copy of env

Definition at line 414 of file mq.c.

References GNUNET_assert, GNUNET_MQ_msg_copy(), GNUNET_NO, GNUNET_MQ_Envelope::have_custom_options, GNUNET_MQ_Envelope::mh, GNUNET_MQ_Envelope::next, GNUNET_MQ_Envelope::parent_queue, and GNUNET_MQ_Envelope::sent_cb.

Referenced by cadet_channel_end_cb(), and dns_pre_request_handler().

 {
   GNUNET_assert (NULL == env->next);
   GNUNET_assert (NULL == env->parent_queue);
   GNUNET_assert (NULL == env->sent_cb);
   GNUNET_assert (GNUNET_NO == env->have_custom_options);
   return GNUNET_MQ_msg_copy (env->mh);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_MQ_get_last_envelope()

struct GNUNET_MQ_Envelope* GNUNET_MQ_get_last_envelope ( struct GNUNET_MQ_Handle * mq )

Function to obtain the last envelope in the queue.

Parameters

mq	message queue to interrogate

Returns: the last envelope in the queue

Definition at line 987 of file mq.c.

References GNUNET_MQ_Handle::current_envelope, and GNUNET_MQ_Handle::envelope_tail.

 {
   if (NULL != mq->envelope_tail)
     return mq->envelope_tail;
 
   return mq->current_envelope;
 }

◆ GNUNET_MQ_env_set_options()

void GNUNET_MQ_env_set_options	(	struct GNUNET_MQ_Envelope *	env,
		enum GNUNET_MQ_PriorityPreferences	pp
	)

Set application-specific options for this envelope.

Overrides the options set for the queue with GNUNET_MQ_set_options() for this message only.

Parameters

env	message to set options for
pp	priority and preferences to set for env

Set application-specific options for this envelope.

Overrides the options set for the queue with GNUNET_MQ_set_options() for this message only.

Parameters

env	message to set options for
pp	priorities and preferences to apply

Definition at line 1005 of file mq.c.

References GNUNET_YES, GNUNET_MQ_Envelope::have_custom_options, and GNUNET_MQ_Envelope::priority.

Referenced by adv_transmit(), client_request_complete_alice(), route_message(), send_to_channel(), and transmit_pending().

 {
   env->priority = pp;
   env->have_custom_options = GNUNET_YES;
 }

Here is the caller graph for this function:

◆ GNUNET_MQ_env_get_options()

enum GNUNET_MQ_PriorityPreferences GNUNET_MQ_env_get_options ( struct GNUNET_MQ_Envelope * env )

Get performance preferences set for this envelope.

Parameters

env	message to set options for

Returns: priority and preferences to use

Get performance preferences set for this envelope.

Parameters

env	message to set options for

Returns: priorities and preferences to apply for env

Definition at line 1020 of file mq.c.

References GNUNET_YES, GNUNET_MQ_Envelope::have_custom_options, mq, GNUNET_MQ_Envelope::parent_queue, GNUNET_MQ_Envelope::priority, and GNUNET_MQ_Handle::priority.

Referenced by cadet_mq_send_impl(), core_mq_send_impl(), mq_send_impl(), and route_message().

 {
   struct GNUNET_MQ_Handle *mq = env->parent_queue;
 
   if (GNUNET_YES == env->have_custom_options)
     return env->priority;
   if (NULL == mq)
     return 0;
   return mq->priority;
 }

Here is the caller graph for this function:

◆ GNUNET_MQ_env_combine_options()

enum GNUNET_MQ_PriorityPreferences GNUNET_MQ_env_combine_options	(	enum GNUNET_MQ_PriorityPreferences	p1,
		enum GNUNET_MQ_PriorityPreferences	p2
	)

Combine performance preferences set for different envelopes that are being combined into one larger envelope.

Parameters

p1	one set of preferences
p2	second set of preferences

Returns: combined priority and preferences to use

Definition at line 1041 of file mq.c.

References GNUNET_MAX, GNUNET_MQ_PREF_CORK_ALLOWED, GNUNET_MQ_PREF_GOODPUT, GNUNET_MQ_PREF_LOW_LATENCY, GNUNET_MQ_PREF_OUT_OF_ORDER, GNUNET_MQ_PREF_UNRELIABLE, GNUNET_MQ_PRIORITY_MASK, and ret.

 {
   enum GNUNET_MQ_PriorityPreferences ret;
 
   ret = GNUNET_MAX (p1 & GNUNET_MQ_PRIORITY_MASK, p2 & GNUNET_MQ_PRIORITY_MASK);
   ret |= ((p1 & GNUNET_MQ_PREF_UNRELIABLE) & (p2 & GNUNET_MQ_PREF_UNRELIABLE));
   ret |=
     ((p1 & GNUNET_MQ_PREF_LOW_LATENCY) | (p2 & GNUNET_MQ_PREF_LOW_LATENCY));
   ret |=
     ((p1 & GNUNET_MQ_PREF_CORK_ALLOWED) & (p2 & GNUNET_MQ_PREF_CORK_ALLOWED));
   ret |= ((p1 & GNUNET_MQ_PREF_GOODPUT) & (p2 & GNUNET_MQ_PREF_GOODPUT));
   ret |=
     ((p1 & GNUNET_MQ_PREF_OUT_OF_ORDER) & (p2 & GNUNET_MQ_PREF_OUT_OF_ORDER));
   return ret;
 }

◆ GNUNET_MQ_unsent_head()

struct GNUNET_MQ_Envelope* GNUNET_MQ_unsent_head ( struct GNUNET_MQ_Handle * mq )

Remove the first envelope that has not yet been sent from the message queue and return it.

Parameters

mq	queue to remove envelope from

Returns: NULL if queue is empty (or has no envelope that is not under transmission)

Definition at line 394 of file mq.c.

References env, GNUNET_MQ_Handle::envelope_head, GNUNET_MQ_Handle::envelope_tail, GNUNET_CONTAINER_DLL_remove, GNUNET_MQ_Envelope::parent_queue, and GNUNET_MQ_Handle::queue_length.

Referenced by send_to_channel().

 {
   struct GNUNET_MQ_Envelope *env;
 
   env = mq->envelope_head;
   GNUNET_CONTAINER_DLL_remove (mq->envelope_head, mq->envelope_tail, env);
   mq->queue_length--;
   env->parent_queue = NULL;
   return env;
 }

Here is the caller graph for this function:

◆ GNUNET_MQ_set_options()

void GNUNET_MQ_set_options	(	struct GNUNET_MQ_Handle *	mq,
		enum GNUNET_MQ_PriorityPreferences	pp
	)

Set application-specific options for this queue.

Parameters

mq	message queue to set options for
pp	priority and preferences to use by default

Set application-specific options for this queue.

Parameters

mq	message queue to set options for
pp	priorities and preferences to apply

Definition at line 1066 of file mq.c.

References GNUNET_MQ_Handle::priority.

Referenced by connect_notify(), and handle_core_connect().

 {
   mq->priority = pp;
 }

Here is the caller graph for this function:

◆ GNUNET_MQ_get_length()

unsigned int GNUNET_MQ_get_length ( struct GNUNET_MQ_Handle * mq )

Obtain the current length of the message queue.

Parameters

mq	queue to inspect

Returns: number of queued, non-transmitted messages

Definition at line 335 of file mq.c.

References GNUNET_YES, GNUNET_MQ_Handle::in_flight, and GNUNET_MQ_Handle::queue_length.

Referenced by continue_writing(), GCP_send(), GCP_send_ooo(), GDS_NEIGHBOURS_handle_get(), GDS_NEIGHBOURS_handle_put(), GDS_NEIGHBOURS_handle_reply(), GNUNET_notification_context_broadcast(), GNUNET_STATISTICS_destroy(), GNUNET_TRANSPORT_communicator_receive(), GSC_CLIENTS_deliver_message(), GSC_NEIGHBOURS_get_queue_length(), handle_p2p_get(), schedule_action(), send_to_channel(), transmit_pending(), and unicast().

 {
   if (GNUNET_YES != mq->in_flight)
   {
     return mq->queue_length;
   }
   return mq->queue_length - 1;
 }

Here is the caller graph for this function:

◆ GNUNET_MQ_send()

void GNUNET_MQ_send	(	struct GNUNET_MQ_Handle *	mq,
		struct GNUNET_MQ_Envelope *	ev
	)

Send a message with the given message queue.

May only be called once per message.

Parameters

mq	message queue
ev	the envelope with the message to send.

Definition at line 353 of file mq.c.

References GNUNET_MQ_Handle::current_envelope, GNUNET_MQ_Handle::envelope_head, GNUNET_MQ_Handle::envelope_tail, GNUNET_assert, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_MQ_Handle::impl_state, LOG, GNUNET_MQ_Envelope::mh, mq, GNUNET_MQ_Envelope::parent_queue, GNUNET_MQ_Handle::queue_length, GNUNET_MQ_Handle::send_impl, GNUNET_MQ_Handle::send_task, and GNUNET_MessageHeader::type.

 {
   GNUNET_assert (NULL != mq);
   GNUNET_assert (NULL == ev->parent_queue);
 
   mq->queue_length++;
   if (mq->queue_length >= 10000)
   {
     /* This would seem like a bug... */
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 "MQ with %u entries extended by message of type %u (FC broken?)\n",
                 (unsigned int) mq->queue_length,
                 (unsigned int) ntohs (ev->mh->type));
   }
   ev->parent_queue = mq;
   /* is the implementation busy? queue it! */
   if ((NULL != mq->current_envelope) || (NULL != mq->send_task))
   {
     GNUNET_CONTAINER_DLL_insert_tail (mq->envelope_head, mq->envelope_tail, ev);
     return;
   }
   GNUNET_assert (NULL == mq->envelope_head);
   mq->current_envelope = ev;
 
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "sending message of type %u, queue empty (MQ: %p)\n",
        ntohs (ev->mh->type),
        mq);
 
   mq->send_impl (mq, ev->mh, mq->impl_state);
 }

◆ GNUNET_MQ_send_copy()

void GNUNET_MQ_send_copy	(	struct GNUNET_MQ_Handle *	mq,
		const struct GNUNET_MQ_Envelope *	ev
	)

Send a copy of a message with the given message queue.

Can be called repeatedly on the same envelope.

Parameters

mq	message queue
ev	the envelope with the message to send.

Definition at line 432 of file mq.c.

References env, GNUNET_malloc, GNUNET_memcpy, GNUNET_MQ_send(), GNUNET_MQ_Envelope::mh, GNUNET_MQ_Envelope::sent_cb, GNUNET_MQ_Envelope::sent_cls, and GNUNET_MessageHeader::size.

Referenced by GNUNET_ABD_collect(), GNUNET_ABD_verify(), GNUNET_GNS_lookup(), GNUNET_RECLAIM_attribute_delete(), GNUNET_RECLAIM_attribute_store(), GNUNET_RECLAIM_ticket_consume(), GNUNET_RECLAIM_ticket_issue(), and reconnect().

 {
   struct GNUNET_MQ_Envelope *env;
   uint16_t msize;
 
   msize = ntohs (ev->mh->size);
   env = GNUNET_malloc (sizeof(struct GNUNET_MQ_Envelope) + msize);
   env->mh = (struct GNUNET_MessageHeader *) &env[1];
   env->sent_cb = ev->sent_cb;
   env->sent_cls = ev->sent_cls;
   GNUNET_memcpy (&env[1], ev->mh, msize);
   GNUNET_MQ_send (mq, env);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_MQ_send_cancel()

void GNUNET_MQ_send_cancel ( struct GNUNET_MQ_Envelope * ev )

Cancel sending the message.

Message must have been sent with GNUNET_MQ_send before. May not be called after the notify sent callback has been called

Parameters

ev	queued envelope to cancel

Definition at line 916 of file mq.c.

Referenced by GSF_push_stop_(), handle_client_audio_message(), mq_cancel_impl(), neighbour_delete(), and shutdown_task().

 {
   struct GNUNET_MQ_Handle *mq = ev->parent_queue;
 
   GNUNET_assert (NULL != mq);
   GNUNET_assert (NULL != mq->cancel_impl);
 
   mq->evacuate_called = GNUNET_NO;
 
   if (mq->current_envelope == ev)
   {
     /* complex case, we already started with transmitting
        the message using the callbacks. */
     GNUNET_assert (GNUNET_NO == mq->in_flight);
     GNUNET_assert (0 < mq->queue_length);
     mq->queue_length--;
     mq->cancel_impl (mq, mq->impl_state);
     /* continue sending the next message, if any */
     mq->current_envelope = mq->envelope_head;
     if (NULL != mq->current_envelope)
     {
       GNUNET_CONTAINER_DLL_remove (mq->envelope_head,
                                    mq->envelope_tail,
                                    mq->current_envelope);
 
       LOG (GNUNET_ERROR_TYPE_DEBUG,
            "sending canceled message of type %u queue\n",
            ntohs (ev->mh->type));
 
       mq->send_impl (mq, mq->current_envelope->mh, mq->impl_state);
     }
   }
   else
   {
     /* simple case, message is still waiting in the queue */
     GNUNET_CONTAINER_DLL_remove (mq->envelope_head, mq->envelope_tail, ev);
     GNUNET_assert (0 < mq->queue_length);
     mq->queue_length--;
   }
 
   if (GNUNET_YES != mq->evacuate_called)
   {
     ev->parent_queue = NULL;
     ev->mh = NULL;
     /* also frees ev */
     GNUNET_free (ev);
   }
 }

Here is the caller graph for this function:

◆ GNUNET_MQ_assoc_add()

uint32_t GNUNET_MQ_assoc_add	(	struct GNUNET_MQ_Handle *	mq,
		void *	assoc_data
	)

Associate the assoc_data in mq with a unique request id.

Parameters

mq	message queue, id will be unique for the queue
assoc_data	to associate

Associate the assoc_data in mq with a unique request id.

Parameters

mq	message queue, id will be unique for the queue
assoc_data	to associate

Definition at line 708 of file mq.c.

References GNUNET_MQ_Handle::assoc_id, GNUNET_MQ_Handle::assoc_map, GNUNET_assert, GNUNET_CONTAINER_multihashmap32_create(), GNUNET_CONTAINER_multihashmap32_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_OK, and id.

Referenced by GNUNET_SET_commit().

 {
   uint32_t id;
 
   if (NULL == mq->assoc_map)
   {
     mq->assoc_map = GNUNET_CONTAINER_multihashmap32_create (8);
     mq->assoc_id = 1;
   }
   id = mq->assoc_id++;
   GNUNET_assert (GNUNET_OK ==
                  GNUNET_CONTAINER_multihashmap32_put (
                    mq->assoc_map,
                    id,
                    assoc_data,
                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
   return id;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_MQ_assoc_get()

void* GNUNET_MQ_assoc_get	(	struct GNUNET_MQ_Handle *	mq,
		uint32_t	request_id
	)

Get the data associated with a request_id in a queue.

Parameters

mq	the message queue with the association
request_id	the request id we are interested in

Returns: the associated data

Definition at line 736 of file mq.c.

References GNUNET_MQ_Handle::assoc_map, and GNUNET_CONTAINER_multihashmap32_get().

Referenced by handle_result().

 {
   if (NULL == mq->assoc_map)
     return NULL;
   return GNUNET_CONTAINER_multihashmap32_get (mq->assoc_map, request_id);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_MQ_assoc_remove()

void* GNUNET_MQ_assoc_remove	(	struct GNUNET_MQ_Handle *	mq,
		uint32_t	request_id
	)

Remove the association for a request_id.

Parameters

mq	the message queue with the association
request_id	the request id we want to remove

Returns: the associated data

Definition at line 752 of file mq.c.

References GNUNET_MQ_Handle::assoc_map, GNUNET_CONTAINER_multihashmap32_get(), and GNUNET_CONTAINER_multihashmap32_remove_all().

Referenced by handle_result(), and set_operation_destroy().

 {
   void *val;
 
   if (NULL == mq->assoc_map)
     return NULL;
   val = GNUNET_CONTAINER_multihashmap32_get (mq->assoc_map, request_id);
   GNUNET_CONTAINER_multihashmap32_remove_all (mq->assoc_map, request_id);
   return val;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_MQ_queue_for_callbacks()

struct GNUNET_MQ_Handle* GNUNET_MQ_queue_for_callbacks	(	GNUNET_MQ_SendImpl	send,
		GNUNET_MQ_DestroyImpl	destroy,
		GNUNET_MQ_CancelImpl	cancel,
		void *	impl_state,
		const struct GNUNET_MQ_MessageHandler *	handlers,
		GNUNET_MQ_ErrorHandler	error_handler,
		void *	error_handler_cls
	)

Create a message queue for the specified handlers.

Parameters

send	function the implements sending messages
destroy	function that implements destroying the queue
cancel	function that implements canceling a message
impl_state	for the queue, passed to send, destroy and cancel
handlers	array of message handlers
error_handler	handler for read and write errors
cls	closure for message handlers and error handler

Returns: a new message queue

Parameters

send	function the implements sending messages
destroy	function that implements destroying the queue
cancel	function that implements canceling a message
impl_state	for the queue, passed to 'send' and 'destroy'
handlers	array of message handlers
error_handler	handler for read and write errors
error_handler_cls	closure for error_handler

Returns: a new message queue

Definition at line 552 of file mq.c.

References GNUNET_MQ_Handle::cancel_impl, destroy(), GNUNET_MQ_Handle::destroy_impl, GNUNET_MQ_Handle::error_handler, error_handler(), GNUNET_MQ_Handle::error_handler_cls, GNUNET_MQ_copy_handlers(), GNUNET_new, GNUNET_MQ_Handle::handlers, GNUNET_MQ_Handle::impl_state, mq, and GNUNET_MQ_Handle::send_impl.

Referenced by boot_queue(), connect_peer(), GCT_create_tunnel(), GNUNET_CADET_channel_create(), GNUNET_CLIENT_connect(), handle_channel_created(), handle_connect(), setup_queue(), setup_receiver_mq(), and start_client().

 {
   struct GNUNET_MQ_Handle *mq;
 
   mq = GNUNET_new (struct GNUNET_MQ_Handle);
   mq->send_impl = send;
   mq->destroy_impl = destroy;
   mq->cancel_impl = cancel;
   mq->handlers = GNUNET_MQ_copy_handlers (handlers);
   mq->error_handler = error_handler;
   mq->error_handler_cls = error_handler_cls;
   mq->impl_state = impl_state;
 
   return mq;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_MQ_set_handlers_closure()

void GNUNET_MQ_set_handlers_closure	(	struct GNUNET_MQ_Handle *	mq,
		void *	handlers_cls
	)

Change the closure argument in all of the handlers of the mq.

Parameters

mq	to modify
handlers_cls	new closure to use

Definition at line 583 of file mq.c.

References GNUNET_MQ_MessageHandler::cb, GNUNET_MQ_MessageHandler::cls, and GNUNET_MQ_Handle::handlers.

Referenced by connect_peer(), GNUNET_CADET_channel_create(), handle_channel_created(), handle_connect(), and start_client().

 {
   if (NULL == mq->handlers)
     return;
   for (unsigned int i = 0; NULL != mq->handlers[i].cb; i++)
     mq->handlers[i].cls = handlers_cls;
 }

Here is the caller graph for this function:

◆ GNUNET_MQ_notify_sent()

void GNUNET_MQ_notify_sent	(	struct GNUNET_MQ_Envelope *	ev,
		GNUNET_SCHEDULER_TaskCallback	cb,
		void *	cb_cls
	)

Call a callback once the envelope has been sent, that is, sending it can not be canceled anymore.

There can be only one notify sent callback per envelope.

Parameters

ev	message to call the notify callback for
cb	the notify callback
cb_cls	closure for the callback

Definition at line 774 of file mq.c.

References GNUNET_assert, GNUNET_MQ_Envelope::sent_cb, and GNUNET_MQ_Envelope::sent_cls.

Referenced by check_peer_online(), comm_schedule_send(), dispatch_buffer(), do_send(), GCP_request_mq_cancel(), GCP_send(), GCP_send_ooo(), GNUNET_ATS_TEST_traffic_handle_ping(), GNUNET_CONSENSUS_insert(), GNUNET_DATASTORE_disconnect(), GNUNET_DHT_put(), GNUNET_DHT_put_cancel(), GNUNET_PEERINFO_add_peer(), GNUNET_PEERSTORE_store(), GNUNET_SET_add_element(), GNUNET_SET_remove_element(), GNUNET_TRANSPORT_offer_hello(), GNUNET_TRANSPORT_TESTING_send(), handle_client_audio_message(), handle_client_hangup_message(), handle_datastore_reply(), handle_raw_message(), handle_send_msg(), mq_send_impl(), read_stdio(), reconnect(), schedule_action(), schedule_peer_transmission(), send_message(), send_msg(), send_p2p_done(), send_remaining_elements(), transmit_bobs_cryptodata_message(), transmit_bobs_cryptodata_message_multipart(), transmit_content(), transmit_get(), transmit_pending(), transmit_set(), and transmit_watch().

 {
   /* allow setting *OR* clearing callback */
   GNUNET_assert ((NULL == ev->sent_cb) || (NULL == cb));
   ev->sent_cb = cb;
   ev->sent_cls = cb_cls;
 }

Here is the caller graph for this function:

◆ GNUNET_MQ_destroy()

void GNUNET_MQ_destroy ( struct GNUNET_MQ_Handle * mq )

Destroy the message queue.

Parameters

mq	message queue to destroy

Definition at line 824 of file mq.c.

 {
   struct GNUNET_MQ_DestroyNotificationHandle *dnh;
 
   if (NULL != mq->destroy_impl)
   {
     mq->destroy_impl (mq, mq->impl_state);
   }
   if (NULL != mq->send_task)
   {
     GNUNET_SCHEDULER_cancel (mq->send_task);
     mq->send_task = NULL;
   }
   while (NULL != mq->envelope_head)
   {
     struct GNUNET_MQ_Envelope *ev;
 
     ev = mq->envelope_head;
     ev->parent_queue = NULL;
     GNUNET_CONTAINER_DLL_remove (mq->envelope_head, mq->envelope_tail, ev);
     GNUNET_assert (0 < mq->queue_length);
     mq->queue_length--;
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "MQ destroy drops message of type %u\n",
          ntohs (ev->mh->type));
     GNUNET_MQ_discard (ev);
   }
   if (NULL != mq->current_envelope)
   {
     /* we can only discard envelopes that
      * are not queued! */
     mq->current_envelope->parent_queue = NULL;
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "MQ destroy drops current message of type %u\n",
          ntohs (mq->current_envelope->mh->type));
     GNUNET_MQ_discard (mq->current_envelope);
     mq->current_envelope = NULL;
     GNUNET_assert (0 < mq->queue_length);
     mq->queue_length--;
   }
   GNUNET_assert (0 == mq->queue_length);
   while (NULL != (dnh = mq->dnh_head))
   {
     dnh->cb (dnh->cb_cls);
     GNUNET_MQ_destroy_notify_cancel (dnh);
   }
   if (NULL != mq->assoc_map)
   {
     GNUNET_CONTAINER_multihashmap32_destroy (mq->assoc_map);
     mq->assoc_map = NULL;
   }
   GNUNET_free_non_null (mq->handlers);
   GNUNET_free (mq);
 }

Here is the call graph for this function:

◆ GNUNET_MQ_destroy_notify()

struct GNUNET_MQ_DestroyNotificationHandle* GNUNET_MQ_destroy_notify	(	struct GNUNET_MQ_Handle *	mq,
		GNUNET_SCHEDULER_TaskCallback	cb,
		void *	cb_cls
	)

Register function to be called whenever mq is being destroyed.

Parameters

mq	message queue to watch
cb	function to call on mq destruction
cb_cls	closure for cb

Returns: handle for GNUNET_MQ_destroy_notify_cancel().

Definition at line 1109 of file mq.c.

References GNUNET_MQ_DestroyNotificationHandle::cb, GNUNET_MQ_DestroyNotificationHandle::cb_cls, GNUNET_MQ_Handle::dnh_head, GNUNET_MQ_Handle::dnh_tail, GNUNET_CONTAINER_DLL_insert, GNUNET_new, mq, and GNUNET_MQ_DestroyNotificationHandle::mq.

Referenced by GNUNET_notification_context_add().

 {
   struct GNUNET_MQ_DestroyNotificationHandle *dnh;
 
   dnh = GNUNET_new (struct GNUNET_MQ_DestroyNotificationHandle);
   dnh->mq = mq;
   dnh->cb = cb;
   dnh->cb_cls = cb_cls;
   GNUNET_CONTAINER_DLL_insert (mq->dnh_head, mq->dnh_tail, dnh);
   return dnh;
 }

Here is the caller graph for this function:

◆ GNUNET_MQ_destroy_notify_cancel()

void GNUNET_MQ_destroy_notify_cancel ( struct GNUNET_MQ_DestroyNotificationHandle * dnh )

Cancel registration from GNUNET_MQ_destroy_notify().

Parameters

dnh	handle for registration to cancel

Definition at line 1130 of file mq.c.

References GNUNET_MQ_Handle::dnh_head, GNUNET_MQ_Handle::dnh_tail, GNUNET_CONTAINER_DLL_remove, GNUNET_free, mq, and GNUNET_MQ_DestroyNotificationHandle::mq.

Referenced by GNUNET_MQ_destroy(), and GNUNET_notification_context_destroy().

 {
   struct GNUNET_MQ_Handle *mq = dnh->mq;
 
   GNUNET_CONTAINER_DLL_remove (mq->dnh_head, mq->dnh_tail, dnh);
   GNUNET_free (dnh);
 }

Here is the caller graph for this function:

◆ GNUNET_MQ_inject_message()

void GNUNET_MQ_inject_message	(	struct GNUNET_MQ_Handle *	mq,
		const struct GNUNET_MessageHeader *	mh
	)

Call the message message handler that was registered for the type of the given message in the given message queue.

This function is indended to be used for the implementation of message queues.

Parameters

mq	message queue with the handlers
mh	message to dispatch

Definition at line 202 of file mq.c.

References GNUNET_MQ_ERROR_MALFORMED, GNUNET_MQ_handle_message(), GNUNET_MQ_inject_error(), GNUNET_SYSERR, GNUNET_MQ_Handle::handlers, and ret.

Referenced by handle_decrypted(), handle_local_data(), handle_notify_inbound(), handle_recv(), recv_message(), and service_client_mst_cb().

 {
   int ret;
 
   ret = GNUNET_MQ_handle_message (mq->handlers, mh);
   if (GNUNET_SYSERR == ret)
   {
     GNUNET_MQ_inject_error (mq, GNUNET_MQ_ERROR_MALFORMED);
     return;
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_MQ_inject_error()

void GNUNET_MQ_inject_error	(	struct GNUNET_MQ_Handle *	mq,
		enum GNUNET_MQ_Error	error
	)

Call the error handler of a message queue with the given error code.

If there is no error handler, log a warning.

This function is intended to be used for the implementation of message queues.

Parameters

mq	message queue
error	the error type

If there is no error handler, log a warning.

This function is intended to be used by the implementation of message queues.

Parameters

mq	message queue
error	the error type

Definition at line 300 of file mq.c.

References GNUNET_MQ_Handle::error_handler, GNUNET_MQ_Handle::error_handler_cls, GNUNET_ERROR_TYPE_WARNING, and LOG.

Referenced by do_send(), GNUNET_MQ_inject_message(), receive_ready(), and transmit_ready().

 {
   if (NULL == mq->error_handler)
   {
     LOG (GNUNET_ERROR_TYPE_WARNING,
          "Got error %d, but no handler installed\n",
          (int) error);
     return;
   }
   mq->error_handler (mq->error_handler_cls, error);
 }

Here is the caller graph for this function:

◆ GNUNET_MQ_impl_send_continue()

void GNUNET_MQ_impl_send_continue ( struct GNUNET_MQ_Handle * mq )

Call the send implementation for the next queued message, if any.

Calls the send notification for the current message unless GNUNET_MQ_impl_send_in_flight was called for this envelope.

Only useful for implementing message queues, results in undefined behavior if not used carefully.

Parameters

mq	message queue to send the next message with

Only useful for implementing message queues, results in undefined behavior if not used carefully.

Parameters

mq	message queue to send the next message with

Definition at line 486 of file mq.c.

References GNUNET_MQ_Handle::current_envelope, GNUNET_assert, GNUNET_free, GNUNET_NO, GNUNET_SCHEDULER_add_now(), impl_send_continue(), GNUNET_MQ_Handle::in_flight, GNUNET_MQ_Envelope::parent_queue, GNUNET_MQ_Handle::queue_length, GNUNET_MQ_Handle::send_task, GNUNET_MQ_Envelope::sent_cb, and GNUNET_MQ_Envelope::sent_cls.

Referenced by cadet_mq_send_impl(), cadet_mq_send_now(), core_mq_send_impl(), do_send(), handle_send_ready(), mq_send(), mq_send_impl(), notify_send_done(), notify_send_done_fin(), queue_write(), select_write_cb(), and transmit_ready().

 {
   struct GNUNET_MQ_Envelope *current_envelope;
   GNUNET_SCHEDULER_TaskCallback cb;
 
   GNUNET_assert (0 < mq->queue_length);
   mq->queue_length--;
   mq->in_flight = GNUNET_NO;
   current_envelope = mq->current_envelope;
   current_envelope->parent_queue = NULL;
   mq->current_envelope = NULL;
   GNUNET_assert (NULL == mq->send_task);
   mq->send_task = GNUNET_SCHEDULER_add_now (&impl_send_continue, mq);
   if (NULL != (cb = current_envelope->sent_cb))
   {
     current_envelope->sent_cb = NULL;
     cb (current_envelope->sent_cls);
   }
   GNUNET_free (current_envelope);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_MQ_impl_send_in_flight()

void GNUNET_MQ_impl_send_in_flight ( struct GNUNET_MQ_Handle * mq )

Call the send notification for the current message, but do not try to send the next message until #gnunet_mq_impl_send_continue is called.

Only useful for implementing message queues, results in undefined behavior if not used carefully.

Parameters

mq	message queue to send the next message with

Call the send notification for the current message, but do not try to send the next message until #gnunet_mq_impl_send_continue is called.

Only useful for implementing message queues, results in undefined behavior if not used carefully.

Parameters

mq	message queue to send the next message with

Definition at line 519 of file mq.c.

References GNUNET_MQ_Handle::current_envelope, GNUNET_assert, GNUNET_YES, GNUNET_MQ_Handle::in_flight, GNUNET_MQ_Envelope::parent_queue, GNUNET_MQ_Envelope::sent_cb, and GNUNET_MQ_Envelope::sent_cls.

Referenced by do_send(), notify_send_done(), and transmit_ready().

 {
   struct GNUNET_MQ_Envelope *current_envelope;
   GNUNET_SCHEDULER_TaskCallback cb;
 
   mq->in_flight = GNUNET_YES;
   /* call is only valid if we're actually currently sending
    * a message */
   current_envelope = mq->current_envelope;
   GNUNET_assert (NULL != current_envelope);
   /* can't call cancel from now on anymore */
   current_envelope->parent_queue = NULL;
   if (NULL != (cb = current_envelope->sent_cb))
   {
     current_envelope->sent_cb = NULL;
     cb (current_envelope->sent_cls);
   }
 }

Here is the caller graph for this function:

◆ GNUNET_MQ_impl_state()

void* GNUNET_MQ_impl_state ( struct GNUNET_MQ_Handle * mq )

Get the implementation state associated with the message queue.

While the GNUNET_MQ_Impl* callbacks receive the implementation state, continuations that are scheduled by the implementation function often only have one closure argument, with this function it is possible to get at the implementation state when only passing the struct GNUNET_MQ_Handle as closure.

Parameters

mq	message queue with the current message

Returns: message to send, never NULL

While the GNUNET_MQ_Impl* callbacks receive the implementation state, continuations that are scheduled by the implementation function often only have one closure argument, with this function it is possible to get at the implementation state when only passing the GNUNET_MQ_Handle as closure.

Parameters

mq	message queue with the current message

Returns: message to send, never NULL

Definition at line 625 of file mq.c.

References GNUNET_MQ_Handle::impl_state.

 {
   return mq->impl_state;
 }

◆ GNUNET_MQ_impl_current()

const struct GNUNET_MessageHeader* GNUNET_MQ_impl_current ( struct GNUNET_MQ_Handle * mq )

Get the message that should currently be sent.

Fails if there is no current message. Only useful for implementing message queues, results in undefined behavior if not used carefully.

Parameters

mq	message queue with the current message

Returns: message to send, never NULL

Definition at line 602 of file mq.c.

References GNUNET_MQ_Handle::current_envelope, GNUNET_assert, and GNUNET_MQ_Envelope::mh.

 {
   GNUNET_assert (NULL != mq->current_envelope);
   GNUNET_assert (NULL != mq->current_envelope->mh);
   return mq->current_envelope->mh;
 }

◆ GNUNET_MQ_preference_to_string()

const char* GNUNET_MQ_preference_to_string ( enum GNUNET_MQ_PreferenceKind type )

Convert an enum GNUNET_MQ_PreferenceType to a string.

Parameters

type	the preference type

Returns: a string or NULL if invalid

Deprecated:: will be replaced by enum GNUNET_MQ_PriorityPreference

Parameters

type	the preference type

Returns: a string or NULL if invalid

Definition at line 1295 of file mq.c.

References GNUNET_MQ_PREFERENCE_BANDWIDTH, GNUNET_MQ_PREFERENCE_LATENCY, GNUNET_MQ_PREFERENCE_NONE, and GNUNET_MQ_PREFERENCE_RELIABILITY.

 {
   switch (type)
   {
   case GNUNET_MQ_PREFERENCE_NONE:
     return "NONE";
 
   case GNUNET_MQ_PREFERENCE_BANDWIDTH:
     return "BANDWIDTH";
 
   case GNUNET_MQ_PREFERENCE_LATENCY:
     return "LATENCY";
 
   case GNUNET_MQ_PREFERENCE_RELIABILITY:
     return "RELIABILITY";
   }
   ;
   return NULL;
 }

◆ GNUNET_notification_context_create()

struct GNUNET_NotificationContext* GNUNET_notification_context_create ( unsigned int queue_length )

Create a new notification context.

Parameters

queue_length maximum number of messages to keep in the notification queue; optional messages are dropped if the queue gets longer than this number of messages

Returns: handle to the notification context

Definition at line 121 of file nc.c.

References GNUNET_new, SubscriberList::nc, and GNUNET_NotificationContext::queue_length.

Referenced by GAS_performance_init(), GSC_KX_init(), and run().

 {
   struct GNUNET_NotificationContext *nc;
 
   nc = GNUNET_new (struct GNUNET_NotificationContext);
   nc->queue_length = queue_length;
   return nc;
 }

Here is the caller graph for this function:

◆ GNUNET_notification_context_destroy()

void GNUNET_notification_context_destroy ( struct GNUNET_NotificationContext * nc )

Destroy the context, force disconnect for all subscribers.

Parameters

nc	context to destroy.

Definition at line 137 of file nc.c.

References GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_MQ_destroy_notify_cancel(), SubscriberList::mq_nh, GNUNET_NotificationContext::subscribers_head, and GNUNET_NotificationContext::subscribers_tail.

Referenced by cleanup_task(), do_shutdown(), GAS_performance_done(), GSC_KX_done(), and shutdown_task().

 {
   struct SubscriberList *pos;
 
   while (NULL != (pos = nc->subscribers_head))
   {
     GNUNET_CONTAINER_DLL_remove (nc->subscribers_head,
                                  nc->subscribers_tail,
                                  pos);
     GNUNET_MQ_destroy_notify_cancel (pos->mq_nh);
     GNUNET_free (pos);
   }
   GNUNET_free (nc);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_notification_context_add()

void GNUNET_notification_context_add	(	struct GNUNET_NotificationContext *	nc,
		struct GNUNET_MQ_Handle *	mq
	)

Add a subscriber to the notification context.

Parameters

nc	context to modify
mq	message queue add

Definition at line 160 of file nc.c.

References GNUNET_CONTAINER_DLL_insert, GNUNET_MQ_destroy_notify(), GNUNET_new, handle_mq_destroy(), SubscriberList::mq, SubscriberList::mq_nh, SubscriberList::nc, SubscriberList::next, GNUNET_NotificationContext::subscribers_head, and GNUNET_NotificationContext::subscribers_tail.

Referenced by client_connect_cb(), GAS_performance_add_client(), GSC_KX_handle_client_monitor_peers(), handle_client_monitor_plugins(), handle_monitor(), handle_monitor_start(), handle_notify(), handle_start(), and handle_start_message().

 {
   struct SubscriberList *cl;
 
   for (cl = nc->subscribers_head; NULL != cl; cl = cl->next)
     if (cl->mq == mq)
       return;
   /* already present */
   cl = GNUNET_new (struct SubscriberList);
   GNUNET_CONTAINER_DLL_insert (nc->subscribers_head,
                                nc->subscribers_tail,
                                cl);
   cl->nc = nc;
   cl->mq = mq;
   cl->mq_nh = GNUNET_MQ_destroy_notify (cl->mq,
                                         &handle_mq_destroy,
                                         cl);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_notification_context_broadcast()

void GNUNET_notification_context_broadcast	(	struct GNUNET_NotificationContext *	nc,
		const struct GNUNET_MessageHeader *	msg,
		int	can_drop
	)

Send a message to all subscribers of this context.

Parameters

nc	context to modify
msg	message to send
can_drop	can this message be dropped due to queue length limitations

Definition at line 189 of file nc.c.

References env, GNUNET_MQ_get_length(), GNUNET_MQ_msg_copy(), GNUNET_MQ_send(), GNUNET_YES, SubscriberList::mq, SubscriberList::next, GNUNET_NotificationContext::queue_length, and GNUNET_NotificationContext::subscribers_head.

Referenced by broadcast_status(), monitor_notify_all(), notify_all(), notify_client(), notify_listeners(), plugin_session_info_cb(), and update_network_size_estimate().

 {
   struct SubscriberList *pos;
   struct GNUNET_MQ_Envelope *env;
 
   for (pos = nc->subscribers_head; NULL != pos; pos = pos->next)
   {
     if ((GNUNET_YES == can_drop) &&
         (GNUNET_MQ_get_length (pos->mq) > nc->queue_length))
       continue;
     env = GNUNET_MQ_msg_copy (msg);
     GNUNET_MQ_send (pos->mq,
                     env);
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_notification_context_get_size()

unsigned int GNUNET_notification_context_get_size ( struct GNUNET_NotificationContext * nc )

Return active number of subscribers in this context.

Parameters

nc	context to query

Returns: number of current subscribers

Definition at line 215 of file nc.c.

References SubscriberList::next, and GNUNET_NotificationContext::subscribers_head.

Referenced by plugin_session_info_cb().

 {
   unsigned int num;
   struct SubscriberList *pos;
 
   num = 0;
   for (pos = nc->subscribers_head; NULL != pos; pos = pos->next)
     num++;
   return num;
 }

Here is the caller graph for this function:

Variable Documentation

◆ mv

GNUNET_MQ_MessageValidationCallback GNUNET_MQ_MessageHandler::mv

Callback to validate a message of the specified type.

The closure given to mv will be this struct (not ctx). Using NULL means only size-validation using expected_size. In this case, expected_size must be non-zero.

Definition at line 482 of file gnunet_mq_lib.h.

Referenced by GNUNET_MQ_copy_handlers2(), and GNUNET_MQ_handle_message().

◆ cb

GNUNET_MQ_MessageCallback GNUNET_MQ_MessageHandler::cb

Callback, called every time a new message of the specified type has been receied.

The closure given to mv will be this struct (not ctx).

Definition at line 489 of file gnunet_mq_lib.h.

Referenced by GNUNET_MQ_copy_handlers2(), GNUNET_MQ_count_handlers(), GNUNET_MQ_handle_message(), GNUNET_MQ_set_handlers_closure(), GNUNET_TRANSPORT_core_connect(), GNUNET_TRANSPORT_core_get_mq(), and GNUNET_TRANSPORT_TESTING_start_peer().

◆ cls

void* GNUNET_MQ_MessageHandler::cls

Closure for mv and cb.

Definition at line 494 of file gnunet_mq_lib.h.

Referenced by GNUNET_MQ_copy_handlers2(), GNUNET_MQ_handle_message(), and GNUNET_MQ_set_handlers_closure().

◆ type

uint16_t GNUNET_MQ_MessageHandler::type

Type of the message this handler covers, in host byte order.

Definition at line 499 of file gnunet_mq_lib.h.

Referenced by GNUNET_MQ_copy_handlers2(), GNUNET_MQ_handle_message(), and reconnect().

◆ expected_size

uint16_t GNUNET_MQ_MessageHandler::expected_size

Expected size of messages of this type.

Minimum size of the message if mv is non-NULL. Messages of the given type will be discarded (and the connection closed with an error reported to the application) if they do not have the right size.

Definition at line 507 of file gnunet_mq_lib.h.

Referenced by GNUNET_MQ_copy_handlers2(), and GNUNET_MQ_handle_message().

Data Structures

Macros

Typedefs

Enumerations

Functions

Variables

will return a `struct GNUNET_MQ_MessageHandler`

will return a `struct

Detailed Description

Macro Definition Documentation

◆ GNUNET_MQ_msg_extra

◆ GNUNET_MQ_msg

◆ GNUNET_MQ_msg_header

◆ GNUNET_MQ_msg_header_extra

◆ GNUNET_MQ_msg_nested_mh

◆ GNUNET_MQ_extract_nested_mh

◆ GNUNET_MQ_handler_end

◆ GNUNET_MQ_hd_fixed_size

◆ GNUNET_MQ_hd_var_size

◆ GNUNET_MQ_check_zero_termination

◆ GNUNET_MQ_check_boxed_message

Typedef Documentation

◆ GNUNET_MQ_MessageCallback

◆ GNUNET_MQ_MessageValidationCallback

◆ GNUNET_MQ_SendImpl

◆ GNUNET_MQ_DestroyImpl

◆ GNUNET_MQ_CancelImpl

◆ GNUNET_MQ_ErrorHandler

Enumeration Type Documentation

◆ GNUNET_MQ_Error

◆ GNUNET_MQ_PriorityPreferences

◆ GNUNET_MQ_PreferenceKind

Function Documentation

◆ GNUNET_MQ_extract_nested_mh_()

◆ GNUNET_MQ_env_get_msg()

◆ GNUNET_MQ_env_next()

◆ GNUNET_MQ_msg_nested_mh_()

◆ GNUNET_MQ_dll_insert_head()

◆ GNUNET_MQ_dll_insert_tail()

◆ GNUNET_MQ_dll_remove()

◆ GNUNET_MQ_copy_handlers()

◆ GNUNET_MQ_copy_handlers2()

◆ GNUNET_MQ_count_handlers()

◆ GNUNET_MQ_handle_message()

◆ GNUNET_MQ_msg_()

◆ GNUNET_MQ_msg_copy()

◆ GNUNET_MQ_discard()

◆ GNUNET_MQ_get_current_envelope()

◆ GNUNET_MQ_env_copy()

◆ GNUNET_MQ_get_last_envelope()

◆ GNUNET_MQ_env_set_options()

◆ GNUNET_MQ_env_get_options()

◆ GNUNET_MQ_env_combine_options()

◆ GNUNET_MQ_unsent_head()

◆ GNUNET_MQ_set_options()

◆ GNUNET_MQ_get_length()

◆ GNUNET_MQ_send()

◆ GNUNET_MQ_send_copy()

◆ GNUNET_MQ_send_cancel()

◆ GNUNET_MQ_assoc_add()

◆ GNUNET_MQ_assoc_get()

◆ GNUNET_MQ_assoc_remove()

◆ GNUNET_MQ_queue_for_callbacks()

◆ GNUNET_MQ_set_handlers_closure()

◆ GNUNET_MQ_notify_sent()

◆ GNUNET_MQ_destroy()

◆ GNUNET_MQ_destroy_notify()

◆ GNUNET_MQ_destroy_notify_cancel()

◆ GNUNET_MQ_inject_message()

◆ GNUNET_MQ_inject_error()

◆ GNUNET_MQ_impl_send_continue()

◆ GNUNET_MQ_impl_send_in_flight()

◆ GNUNET_MQ_impl_state()

◆ GNUNET_MQ_impl_current()

◆ GNUNET_MQ_preference_to_string()

◆ GNUNET_notification_context_create()

◆ GNUNET_notification_context_destroy()

◆ GNUNET_notification_context_add()

◆ GNUNET_notification_context_broadcast()

◆ GNUNET_notification_context_get_size()