gnunet-android

gnunet_protocols.h (93205B)

---

 /*
      This file is part of GNUnet.
      Copyright (C) 2001--2024 GNUnet e.V.
 
      GNUnet is free software: you can redistribute it and/or modify it
      under the terms of the GNU Affero General Public License as published
      by the Free Software Foundation, either version 3 of the License,
      or (at your option) any later version.
 
      GNUnet is distributed in the hope that it will be useful, but
      WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      Affero General Public License for more details.
 
      You should have received a copy of the GNU Affero General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
      SPDX-License-Identifier: AGPL3.0-or-later
  */
 
 /**
  * @addtogroup libgnunetutil
  * Multi-function utilities library for GNUnet programs
  * @{
  *
  * @author Christian Grothoff
  * @author Tobias Frisch
  *
  * @file
  * Constants for network protocols
  *
  * @defgroup protocols  Network protocol definitions
  * Types of messages used in GNUnet.
  *
  * @see [Documentation](https://gnunet.org/ipc)
  *
  * @{
  */
 
 /*******************************************************************************
  * TODO: we need a way to register message types centrally (via some webpage).
  * For now: unofficial extensions should start at 48k, internal extensions
  * defined here should leave some room (4-10 additional messages to the previous
  * extension).
  ******************************************************************************/
 
 #ifndef GNUNET_PROTOCOLS_H
 #define GNUNET_PROTOCOLS_H
 
 #ifdef __cplusplus
 extern "C" {
 #if 0 /* keep Emacsens' auto-indent happy */
 }
 #endif
 #endif
 
 /*******************************************************************************
 * Deprecated
 * *****************************************************************************/
 
 /**
  * Test if service is online.
  *
  * @deprecated!
  */
 #define GNUNET_MESSAGE_TYPE_TEST 0
 
 /*******************************************************************************
 * AGPL source code download
 * *****************************************************************************/
 
 /**
  * Message to request source code link.
  */
 #define GNUNET_MESSAGE_TYPE_REQUEST_AGPL 1
 
 /**
  * Source code link.
  */
 #define GNUNET_MESSAGE_TYPE_RESPONSE_AGPL 2
 
 /*******************************************************************************
  * RESOLVER message types
  ******************************************************************************/
 
 /**
  * Request DNS resolution.
  */
 #define GNUNET_MESSAGE_TYPE_RESOLVER_REQUEST 4
 
 /**
  * Response to a DNS resolution request.
  */
 #define GNUNET_MESSAGE_TYPE_RESOLVER_RESPONSE 5
 
 /*******************************************************************************
  * UTIL message types
  ******************************************************************************/
 
 /**
  * Dummy messages for testing / benchmarking.
  */
 #define GNUNET_MESSAGE_TYPE_DUMMY 6
 
 /**
  * Another dummy messages for testing / benchmarking.
  */
 #define GNUNET_MESSAGE_TYPE_DUMMY2 7
 
 
 /*******************************************************************************
  * ARM message types
  ******************************************************************************/
 
 /**
  * Request to ARM to start a service.
  */
 #define GNUNET_MESSAGE_TYPE_ARM_START 8
 
 /**
  * Request to ARM to stop a service.
  */
 #define GNUNET_MESSAGE_TYPE_ARM_STOP 9
 
 /**
  * Response from ARM.
  */
 #define GNUNET_MESSAGE_TYPE_ARM_RESULT 10
 
 /**
  * Status update from ARM.
  */
 #define GNUNET_MESSAGE_TYPE_ARM_STATUS 11
 
 /**
  * Request to ARM to list all currently running services
  */
 #define GNUNET_MESSAGE_TYPE_ARM_LIST 12
 
 /**
  * Response from ARM for listing currently running services
  */
 #define GNUNET_MESSAGE_TYPE_ARM_LIST_RESULT 13
 
 /**
  * Request to ARM to notify client of service status changes
  */
 #define GNUNET_MESSAGE_TYPE_ARM_MONITOR 14
 
 /**
  * Test if ARM service is online.
  */
 #define GNUNET_MESSAGE_TYPE_ARM_TEST 15
 
 /*******************************************************************************
  * HELLO message types
  ******************************************************************************/
 
 /**
  * Latest HELLO messages used for communicating peer addresses.
  * Managed by libgnunethello.
  */
 #define GNUNET_MESSAGE_TYPE_HELLO_URI 16
 
 /**
  * HELLO message with friend only flag used for communicating peer addresses.
  * Managed by libgnunethello.
  */
 
 #define GNUNET_MESSAGE_TYPE_HELLO 17
 
 /*******************************************************************************
  * FRAGMENTATION message types
  ******************************************************************************/
 
 /**
  * FRAGMENT of a larger message.
  * Managed by libgnunetfragment.
  */
 #define GNUNET_MESSAGE_TYPE_FRAGMENT 18
 
 /**
  * Acknowledgement of a FRAGMENT of a larger message.
  * Managed by libgnunetfragment.
  */
 #define GNUNET_MESSAGE_TYPE_FRAGMENT_ACK 19
 
 /*******************************************************************************
  * Transport-WLAN message types
  ******************************************************************************/
 
 /**
  * Type of data messages from the plugin to the gnunet-wlan-helper
  */
 #define GNUNET_MESSAGE_TYPE_WLAN_DATA_TO_HELPER 39
 
 /**
  * Type of data messages from the gnunet-wlan-helper to the plugin
  */
 #define GNUNET_MESSAGE_TYPE_WLAN_DATA_FROM_HELPER 40
 
 /**
  * Control message between the gnunet-wlan-helper and the daemon (with the MAC).
  */
 #define GNUNET_MESSAGE_TYPE_WLAN_HELPER_CONTROL 41
 
 /**
  * Type of messages for advertisement over wlan
  */
 #define GNUNET_MESSAGE_TYPE_WLAN_ADVERTISEMENT 42
 
 /**
  * Type of messages for data over the wlan
  */
 #define GNUNET_MESSAGE_TYPE_WLAN_DATA 43
 
 
 /*******************************************************************************
  * Transport-DV message types
  ******************************************************************************/
 
 /**
  * DV service to DV Plugin message, when a message is
  * unwrapped by the DV service and handed to the plugin
  * for processing
  */
 #define GNUNET_MESSAGE_TYPE_DV_RECV 44
 
 /**
  * DV Plugin to DV service message, indicating a message
  * should be sent out.
  */
 #define GNUNET_MESSAGE_TYPE_DV_SEND 45
 
 /**
  * DV service to DV api message, containing a confirmation
  * or failure of a DV_SEND message.
  */
 #define GNUNET_MESSAGE_TYPE_DV_SEND_ACK 46
 
 /**
  * P2P DV message encapsulating some real message
  */
 #define GNUNET_MESSAGE_TYPE_DV_ROUTE 47
 
 /**
  * DV Plugin to DV service message, indicating
  * startup.
  */
 #define GNUNET_MESSAGE_TYPE_DV_START 48
 
 /**
  * P2P DV message telling plugin that a peer connected
  */
 #define GNUNET_MESSAGE_TYPE_DV_CONNECT 49
 
 /**
  * P2P DV message telling plugin that a peer disconnected
  */
 #define GNUNET_MESSAGE_TYPE_DV_DISCONNECT 50
 
 /**
  * P2P DV message telling plugin that a message transmission failed (negative
  * ACK)
  */
 #define GNUNET_MESSAGE_TYPE_DV_SEND_NACK 51
 
 /**
  * P2P DV message telling plugin that our distance to a peer changed
  */
 #define GNUNET_MESSAGE_TYPE_DV_DISTANCE_CHANGED 52
 
 /**
  * DV message box for boxing multiple messages.
  */
 #define GNUNET_MESSAGE_TYPE_DV_BOX 53
 
 
 /**
  * Experimental message type.
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_XU_MESSAGE 55
 
 
 /*******************************************************************************
  * Transport-UDP message types
  ******************************************************************************/
 
 /**
  * Normal UDP message type.
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_MESSAGE 56
 
 /**
  * UDP ACK.
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_ACK 57
 
 /*******************************************************************************
  * Transport-TCP message types
  ******************************************************************************/
 
 /**
  * TCP NAT probe message, send from NAT'd peer to
  * other peer to establish bi-directional communication
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_TCP_NAT_PROBE 60
 
 /**
  * Welcome message between TCP transports.
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_TCP_WELCOME 61
 
 /**
  * Message to force transport to update bandwidth assignment (LEGACY)
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_ATS 62
 
 /*******************************************************************************
  * NAT message types
  ******************************************************************************/
 
 /**
  * Message to ask NAT server to perform traversal test
  */
 #define GNUNET_MESSAGE_TYPE_NAT_TEST 63
 
 /*******************************************************************************
  * CORE message types
  ******************************************************************************/
 
 /**
  * Initial setup message from core client to core.
  */
 #define GNUNET_MESSAGE_TYPE_CORE_INIT 64
 
 /**
  * Response from core to core client to INIT message.
  */
 #define GNUNET_MESSAGE_TYPE_CORE_INIT_REPLY 65
 
 /**
  * Notify clients about new peer-to-peer connections (triggered
  * after key exchange).
  */
 #define GNUNET_MESSAGE_TYPE_CORE_NOTIFY_CONNECT 67
 
 /**
  * Notify clients about peer disconnecting.
  */
 #define GNUNET_MESSAGE_TYPE_CORE_NOTIFY_DISCONNECT 68
 
 /**
  * Notify clients about peer status change.
  */
 #define GNUNET_MESSAGE_TYPE_CORE_NOTIFY_STATUS_CHANGE 69
 
 /**
  * Notify clients about incoming P2P messages.
  */
 #define GNUNET_MESSAGE_TYPE_CORE_NOTIFY_INBOUND 70
 
 /**
  * Notify clients about outgoing P2P transmissions.
  */
 #define GNUNET_MESSAGE_TYPE_CORE_NOTIFY_OUTBOUND 71
 
 /**
  * Request from client to transmit message.
  */
 #define GNUNET_MESSAGE_TYPE_CORE_SEND_REQUEST 74
 
 /**
  * Confirmation from core that message can now be sent
  */
 #define GNUNET_MESSAGE_TYPE_CORE_SEND_READY 75
 
 /**
  * Client with message to transmit (after SEND_READY confirmation
  * was received).
  */
 #define GNUNET_MESSAGE_TYPE_CORE_SEND 76
 
 /**
  * Request for connection monitoring from CORE service.
  */
 #define GNUNET_MESSAGE_TYPE_CORE_MONITOR_PEERS 78
 
 /**
  * Reply for monitor by CORE service.
  */
 #define GNUNET_MESSAGE_TYPE_CORE_MONITOR_NOTIFY 79
 
 /**
  * Encapsulation for an encrypted message between peers.
  */
 #define GNUNET_MESSAGE_TYPE_CORE_ENCRYPTED_MESSAGE 82
 
 /**
  * Check that other peer is alive (challenge).
  */
 #define GNUNET_MESSAGE_TYPE_CORE_PING 83
 
 /**
  * Confirmation that other peer is alive.
  */
 #define GNUNET_MESSAGE_TYPE_CORE_PONG 84
 
 /**
  * Request by the other peer to terminate the connection.
  */
 #define GNUNET_MESSAGE_TYPE_CORE_HANGUP 85
 
 /**
  * gzip-compressed type map of the sender
  */
 #define GNUNET_MESSAGE_TYPE_CORE_COMPRESSED_TYPE_MAP 86
 
 /**
  * uncompressed type map of the sender
  */
 #define GNUNET_MESSAGE_TYPE_CORE_BINARY_TYPE_MAP 87
 
 /**
  * Session key exchange between peers.
  */
 #define GNUNET_MESSAGE_TYPE_CORE_EPHEMERAL_KEY 88
 
 /**
  * Other peer confirms having received the type map
  */
 #define GNUNET_MESSAGE_TYPE_CORE_CONFIRM_TYPE_MAP 89
 
 
 /*******************************************************************************
  * DATASTORE message types
  ******************************************************************************/
 
 /**
  * Message sent by datastore client on join.
  */
 #define GNUNET_MESSAGE_TYPE_DATASTORE_RESERVE 92
 
 /**
  * Message sent by datastore client on join.
  */
 #define GNUNET_MESSAGE_TYPE_DATASTORE_RELEASE_RESERVE 93
 
 /**
  * Message sent by datastore to client informing about status
  * processing a request
  * (in response to RESERVE, RELEASE_RESERVE, PUT, UPDATE and REMOVE requests).
  */
 #define GNUNET_MESSAGE_TYPE_DATASTORE_STATUS 94
 
 /**
  * Message sent by datastore client to store data.
  */
 #define GNUNET_MESSAGE_TYPE_DATASTORE_PUT 95
 
 /**
  * Message sent by datastore client to get data.
  */
 #define GNUNET_MESSAGE_TYPE_DATASTORE_GET 97
 
 /**
  * Message sent by datastore client to get random data.
  */
 #define GNUNET_MESSAGE_TYPE_DATASTORE_GET_REPLICATION 98
 
 /**
  * Message sent by datastore client to get random data.
  */
 #define GNUNET_MESSAGE_TYPE_DATASTORE_GET_ZERO_ANONYMITY 99
 
 /**
  * Message sent by datastore to client providing requested data
  * (in response to GET or GET_RANDOM request).
  */
 #define GNUNET_MESSAGE_TYPE_DATASTORE_DATA 100
 
 /**
  * Message sent by datastore to client signaling end of matching data.
  * This message will also be sent for "GET_RANDOM", even though
  * "GET_RANDOM" returns at most one data item.
  */
 #define GNUNET_MESSAGE_TYPE_DATASTORE_DATA_END 101
 
 /**
  * Message sent by datastore client to remove data.
  */
 #define GNUNET_MESSAGE_TYPE_DATASTORE_REMOVE 102
 
 /**
  * Message sent by datastore client to drop the database.
  */
 #define GNUNET_MESSAGE_TYPE_DATASTORE_DROP 103
 
 /**
  * Message sent by datastore client to get data by key.
  */
 #define GNUNET_MESSAGE_TYPE_DATASTORE_GET_KEY 104
 
 
 /*******************************************************************************
  * FS message types
  ******************************************************************************/
 
 /**
  * Message sent by fs client to request LOC signature.
  */
 #define GNUNET_MESSAGE_TYPE_FS_REQUEST_LOC_SIGN 126
 
 /**
  * Reply sent by fs service with LOC signature.
  */
 #define GNUNET_MESSAGE_TYPE_FS_REQUEST_LOC_SIGNATURE 127
 
 /**
  * Message sent by fs client to start indexing.
  */
 #define GNUNET_MESSAGE_TYPE_FS_INDEX_START 128
 
 /**
  * Affirmative response to a request for start indexing.
  */
 #define GNUNET_MESSAGE_TYPE_FS_INDEX_START_OK 129
 
 /**
  * Response to a request for start indexing that
  * refuses.
  */
 #define GNUNET_MESSAGE_TYPE_FS_INDEX_START_FAILED 130
 
 /**
  * Request from client for list of indexed files.
  */
 #define GNUNET_MESSAGE_TYPE_FS_INDEX_LIST_GET 131
 
 /**
  * Reply to client with an indexed file name.
  */
 #define GNUNET_MESSAGE_TYPE_FS_INDEX_LIST_ENTRY 132
 
 /**
  * Reply to client indicating end of list.
  */
 #define GNUNET_MESSAGE_TYPE_FS_INDEX_LIST_END 133
 
 /**
  * Request from client to unindex a file.
  */
 #define GNUNET_MESSAGE_TYPE_FS_UNINDEX 134
 
 /**
  * Reply to client indicating unindex receipt.
  */
 #define GNUNET_MESSAGE_TYPE_FS_UNINDEX_OK 135
 
 /**
  * Client asks FS service to start a (keyword) search.
  */
 #define GNUNET_MESSAGE_TYPE_FS_START_SEARCH 136
 
 /**
  * P2P request for content (one FS to another).
  */
 #define GNUNET_MESSAGE_TYPE_FS_GET 137
 
 /**
  * P2P response with content or active migration of content.  Also
  * used between the service and clients (in response to
  * #GNUNET_MESSAGE_TYPE_FS_START_SEARCH).
  */
 #define GNUNET_MESSAGE_TYPE_FS_PUT 138
 
 /**
  * Peer asks us to stop migrating content towards it for a while.
  */
 #define GNUNET_MESSAGE_TYPE_FS_MIGRATION_STOP 139
 
 /**
  * P2P request for content (one FS to another via a cadet).
  */
 #define GNUNET_MESSAGE_TYPE_FS_CADET_QUERY 140
 
 /**
  * P2P answer for content (one FS to another via a cadet).
  */
 #define GNUNET_MESSAGE_TYPE_FS_CADET_REPLY 141
 
 
 /*******************************************************************************
  * DHT message types
  ******************************************************************************/
 /**
  * Client wants to store item in DHT.
  */
 #define GNUNET_MESSAGE_TYPE_DHT_CLIENT_PUT 142
 
 /**
  * Client wants to lookup item in DHT.
  */
 #define GNUNET_MESSAGE_TYPE_DHT_CLIENT_GET 143
 
 /**
  * Client wants to stop search in DHT.
  */
 #define GNUNET_MESSAGE_TYPE_DHT_CLIENT_GET_STOP 144
 
 /**
  * Service returns result to client.
  */
 #define GNUNET_MESSAGE_TYPE_DHT_CLIENT_RESULT 145
 
 /**
  * Peer is storing data in DHT.
  */
 #define GNUNET_MESSAGE_TYPE_DHT_P2P_PUT 146
 
 /**
  * Peer tries to find data in DHT.
  */
 #define GNUNET_MESSAGE_TYPE_DHT_P2P_GET 147
 
 /**
  * Data is returned to peer from DHT.
  */
 #define GNUNET_MESSAGE_TYPE_DHT_P2P_RESULT 148
 
 /**
  * Receive information about transiting GETs
  */
 #define GNUNET_MESSAGE_TYPE_DHT_MONITOR_GET 149
 
 /**
  * Receive information about transiting GET responses
  */
 #define GNUNET_MESSAGE_TYPE_DHT_MONITOR_GET_RESP 150
 
 /**
  * Receive information about transiting PUTs
  */
 #define GNUNET_MESSAGE_TYPE_DHT_MONITOR_PUT 151
 
 /**
  * Receive information about transiting PUT responses (TODO)
  */
 #define GNUNET_MESSAGE_TYPE_DHT_MONITOR_PUT_RESP 152
 
 /**
  * Request information about transiting messages
  */
 #define GNUNET_MESSAGE_TYPE_DHT_MONITOR_START 153
 
 /**
  * Stop information about transiting messages
  */
 #define GNUNET_MESSAGE_TYPE_DHT_MONITOR_STOP 154
 
 /**
  * Certain results are already known to the client, filter those.
  */
 #define GNUNET_MESSAGE_TYPE_DHT_CLIENT_GET_RESULTS_KNOWN 156
 
 /**
  * HELLO advertising a neighbours addresses.
  */
 #define GNUNET_MESSAGE_TYPE_DHT_P2P_HELLO 157
 
 /**
  * Encapsulation of DHT messages in CORE service.
  */
 #define GNUNET_MESSAGE_TYPE_DHT_CORE 158
 
 /**
  * HELLO URL send between client and service (in
  * either direction).
  */
 #define GNUNET_MESSAGE_TYPE_DHT_CLIENT_HELLO_URL 159
 
 /**
  * Client requests DHT service's HELLO URL.
  */
 #define GNUNET_MESSAGE_TYPE_DHT_CLIENT_HELLO_GET 161
 
 
 /*******************************************************************************
  * HOSTLIST message types
  ******************************************************************************/
 
 /**
  * Hostlist advertisement message
  */
 #define GNUNET_MESSAGE_TYPE_HOSTLIST_ADVERTISEMENT 160
 
 
 /*******************************************************************************
  * STATISTICS message types
  ******************************************************************************/
 
 /**
  * Set a statistical value.
  */
 #define GNUNET_MESSAGE_TYPE_STATISTICS_SET 168
 
 /**
  * Get a statistical value(s).
  */
 #define GNUNET_MESSAGE_TYPE_STATISTICS_GET 169
 
 /**
  * Response to a STATISTICS_GET message (with value).
  */
 #define GNUNET_MESSAGE_TYPE_STATISTICS_VALUE 170
 
 /**
  * Response to a STATISTICS_GET message (end of value stream).
  */
 #define GNUNET_MESSAGE_TYPE_STATISTICS_END 171
 
 /**
  * Watch changes to a statistical value.  Message format is the same
  * as for GET, except that the subsystem and entry name must be given.
  */
 #define GNUNET_MESSAGE_TYPE_STATISTICS_WATCH 172
 
 /**
  * Changes to a watched value.
  */
 #define GNUNET_MESSAGE_TYPE_STATISTICS_WATCH_VALUE 173
 
 /**
  * Client is done sending service requests and will now disconnect.
  */
 #define GNUNET_MESSAGE_TYPE_STATISTICS_DISCONNECT 174
 
 /**
  * Service confirms disconnect and that it is done processing
  * all requests from the client.
  */
 #define GNUNET_MESSAGE_TYPE_STATISTICS_DISCONNECT_CONFIRM 175
 
 /*******************************************************************************
  * VPN message types
  ******************************************************************************/
 
 /**
  * Type of messages between the gnunet-vpn-helper and the daemon
  */
 #define GNUNET_MESSAGE_TYPE_VPN_HELPER 185
 
 /**
  * Type of messages containing an ICMP packet for a service.
  */
 #define GNUNET_MESSAGE_TYPE_VPN_ICMP_TO_SERVICE 190
 
 /**
  * Type of messages containing an ICMP packet for the Internet.
  */
 #define GNUNET_MESSAGE_TYPE_VPN_ICMP_TO_INTERNET 191
 
 /**
  * Type of messages containing an ICMP packet for the VPN
  */
 #define GNUNET_MESSAGE_TYPE_VPN_ICMP_TO_VPN 192
 
 /**
  * Type of messages containing an DNS request for a DNS exit service.
  */
 #define GNUNET_MESSAGE_TYPE_VPN_DNS_TO_INTERNET 193
 
 /**
  * Type of messages containing an DNS reply from a DNS exit service.
  */
 #define GNUNET_MESSAGE_TYPE_VPN_DNS_FROM_INTERNET 194
 
 /**
  * Type of messages containing an TCP packet for a service.
  */
 #define GNUNET_MESSAGE_TYPE_VPN_TCP_TO_SERVICE_START 195
 
 /**
  * Type of messages containing an TCP packet for the Internet.
  */
 #define GNUNET_MESSAGE_TYPE_VPN_TCP_TO_INTERNET_START 196
 
 /**
  * Type of messages containing an TCP packet of an established connection.
  */
 #define GNUNET_MESSAGE_TYPE_VPN_TCP_DATA_TO_EXIT 197
 
 /**
  * Type of messages containing an TCP packet of an established connection.
  */
 #define GNUNET_MESSAGE_TYPE_VPN_TCP_DATA_TO_VPN 198
 
 /**
  * Type of messages containing an UDP packet for a service.
  */
 #define GNUNET_MESSAGE_TYPE_VPN_UDP_TO_SERVICE 199
 
 /**
  * Type of messages containing an UDP packet for the Internet.
  */
 #define GNUNET_MESSAGE_TYPE_VPN_UDP_TO_INTERNET 200
 
 /**
  * Type of messages containing an UDP packet from a remote host
  */
 #define GNUNET_MESSAGE_TYPE_VPN_UDP_REPLY 201
 
 
 /**
  * Client asks VPN service to setup an IP to redirect traffic
  * via an exit node to some global IP address.
  */
 #define GNUNET_MESSAGE_TYPE_VPN_CLIENT_REDIRECT_TO_IP 202
 
 /**
  * Client asks VPN service to setup an IP to redirect traffic
  * to some peer offering a service.
  */
 #define GNUNET_MESSAGE_TYPE_VPN_CLIENT_REDIRECT_TO_SERVICE 203
 
 /**
  * VPN service responds to client with an IP to use for the
  * requested redirection.
  */
 #define GNUNET_MESSAGE_TYPE_VPN_CLIENT_USE_IP 204
 
 
 /*******************************************************************************
  * VPN-DNS message types
  ******************************************************************************/
 
 
 /**
  * Initial message from client to DNS service for registration.
  */
 #define GNUNET_MESSAGE_TYPE_DNS_CLIENT_INIT 211
 
 /**
  * Type of messages between the gnunet-helper-dns and the service
  */
 #define GNUNET_MESSAGE_TYPE_DNS_CLIENT_REQUEST 212
 
 /**
  * Type of messages between the gnunet-helper-dns and the service
  */
 #define GNUNET_MESSAGE_TYPE_DNS_CLIENT_RESPONSE 213
 
 /**
  * Type of messages between the gnunet-helper-dns and the service
  */
 #define GNUNET_MESSAGE_TYPE_DNS_HELPER 214
 
 
 /*******************************************************************************
  * CHAT message types START
  ******************************************************************************/
 
 /**
  * Message sent from client to join a chat room.
  */
 #define GNUNET_MESSAGE_TYPE_CHAT_JOIN_REQUEST 300
 
 /**
  * Message sent to client to indicate joining of another room member.
  */
 #define GNUNET_MESSAGE_TYPE_CHAT_JOIN_NOTIFICATION 301
 
 /**
  * Message sent to client to indicate leaving of another room member.
  */
 #define GNUNET_MESSAGE_TYPE_CHAT_LEAVE_NOTIFICATION 302
 
 /**
  * Notification sent by service to client indicating that we've received a chat
  * message.
  */
 #define GNUNET_MESSAGE_TYPE_CHAT_MESSAGE_NOTIFICATION 303
 
 /**
  * Request sent by client to transmit a chat message to another room members.
  */
 #define GNUNET_MESSAGE_TYPE_CHAT_TRANSMIT_REQUEST 304
 
 /**
  * Receipt sent from a message receiver to the service to confirm delivery of
  * a chat message.
  */
 #define GNUNET_MESSAGE_TYPE_CHAT_CONFIRMATION_RECEIPT 305
 
 /**
  * Notification sent from the service to the original sender
  * to acknowledge delivery of a chat message.
  */
 #define GNUNET_MESSAGE_TYPE_CHAT_CONFIRMATION_NOTIFICATION 306
 
 /**
  * P2P message sent to indicate joining of another room member.
  */
 #define GNUNET_MESSAGE_TYPE_CHAT_P2P_JOIN_NOTIFICATION 307
 
 /**
  * P2P message sent to indicate leaving of another room member.
  */
 #define GNUNET_MESSAGE_TYPE_CHAT_P2P_LEAVE_NOTIFICATION 308
 
 /**
  * P2P message sent to a newly connected peer to request its known clients in
  * order to synchronize room members.
  */
 #define GNUNET_MESSAGE_TYPE_CHAT_P2P_SYNC_REQUEST 309
 
 /**
  * Notification sent from one peer to another to indicate that we have received
  * a chat message.
  */
 #define GNUNET_MESSAGE_TYPE_CHAT_P2P_MESSAGE_NOTIFICATION 310
 
 /**
  * P2P receipt confirming delivery of a chat message.
  */
 #define GNUNET_MESSAGE_TYPE_CHAT_P2P_CONFIRMATION_RECEIPT 311
 
 
 /*******************************************************************************
  * NSE (network size estimation) message types
  ******************************************************************************/
 
 /**
  * client->service message indicating start
  */
 #define GNUNET_MESSAGE_TYPE_NSE_START 321
 
 /**
  * P2P message sent from nearest peer
  */
 #define GNUNET_MESSAGE_TYPE_NSE_P2P_FLOOD 322
 
 /**
  * service->client message indicating
  */
 #define GNUNET_MESSAGE_TYPE_NSE_ESTIMATE 323
 
 
 /*******************************************************************************
  * PEERINFO message types
  ******************************************************************************/
 
 /**
  * Request update and listing of a peer.
  */
 #define GNUNET_MESSAGE_TYPE_PEERINFO_GET 330
 
 /**
  * Request update and listing of all peers.
  */
 #define GNUNET_MESSAGE_TYPE_PEERINFO_GET_ALL 331
 
 /**
  * Information about one of the peers.
  */
 #define GNUNET_MESSAGE_TYPE_PEERINFO_INFO 332
 
 /**
  * End of information about other peers.
  */
 #define GNUNET_MESSAGE_TYPE_PEERINFO_INFO_END 333
 
 /**
  * Start notifying this client about all changes to
  * the known peers until it disconnects.
  */
 #define GNUNET_MESSAGE_TYPE_PEERINFO_NOTIFY 334
 
 /*******************************************************************************
  * ATS message types
  ******************************************************************************/
 
 /**
  * Type of the 'struct ClientStartMessage' sent by clients to ATS to
  * identify the type of the client.
  */
 #define GNUNET_MESSAGE_TYPE_ATS_START 340
 
 /**
  * Type of the 'struct RequestAddressMessage' sent by clients to ATS
  * to request an address to help connect.
  */
 #define GNUNET_MESSAGE_TYPE_ATS_REQUEST_ADDRESS 341
 
 /**
  * Type of the 'struct RequestAddressMessage' sent by clients to ATS
  * to request an address to help connect.
  */
 #define GNUNET_MESSAGE_TYPE_ATS_REQUEST_ADDRESS_CANCEL 342
 
 /**
  * Type of the 'struct AddressUpdateMessage' sent by clients to ATS
  * to inform ATS about performance changes.
  */
 #define GNUNET_MESSAGE_TYPE_ATS_ADDRESS_UPDATE 343
 
 /**
  * Type of the 'struct AddressDestroyedMessage' sent by clients to ATS
  * to inform ATS about an address being unavailable.
  */
 #define GNUNET_MESSAGE_TYPE_ATS_ADDRESS_DESTROYED 344
 
 /**
  * Type of the 'struct AddressSuggestionMessage' sent by ATS to clients
  * to suggest switching to a different address.
  */
 #define GNUNET_MESSAGE_TYPE_ATS_ADDRESS_SUGGESTION 345
 
 /**
  * Type of the 'struct PeerInformationMessage' sent by ATS to clients
  * to inform about QoS for a particular connection.
  */
 #define GNUNET_MESSAGE_TYPE_ATS_PEER_INFORMATION 346
 
 /**
  * Type of the 'struct ReservationRequestMessage' sent by clients to ATS
  * to ask for inbound bandwidth reservations.
  */
 #define GNUNET_MESSAGE_TYPE_ATS_RESERVATION_REQUEST 347
 
 /**
  * Type of the 'struct ReservationResultMessage' sent by ATS to clients
  * in response to a reservation request.
  */
 #define GNUNET_MESSAGE_TYPE_ATS_RESERVATION_RESULT 348
 
 /**
  * Type of the 'struct ChangePreferenceMessage' sent by clients to ATS
  * to ask for allocation preference changes.
  */
 #define GNUNET_MESSAGE_TYPE_ATS_PREFERENCE_CHANGE 349
 
 /**
  * Type of the 'struct SessionReleaseMessage' sent by ATS to client
  * to confirm that a session ID was destroyed.
  */
 #define GNUNET_MESSAGE_TYPE_ATS_SESSION_RELEASE 350
 
 /**
  * Type of the 'struct AddressUpdateMessage' sent by client to ATS
  * to add a new address
  */
 #define GNUNET_MESSAGE_TYPE_ATS_ADDRESS_ADD 353
 
 /**
  * Type of the 'struct AddressListRequestMessage' sent by client to ATS
  * to request information about addresses
  */
 #define GNUNET_MESSAGE_TYPE_ATS_ADDRESSLIST_REQUEST 354
 
 /**
  * Type of the 'struct AddressListResponseMessage' sent by ATS to client
  * with information about addresses
  */
 #define GNUNET_MESSAGE_TYPE_ATS_ADDRESSLIST_RESPONSE 355
 
 /**
  * Type of the 'struct ChangePreferenceMessage' sent by clients to ATS
  * to ask for allocation preference changes.
  */
 #define GNUNET_MESSAGE_TYPE_ATS_PREFERENCE_FEEDBACK 356
 
 
 /*******************************************************************************
  * TRANSPORT message types
  ******************************************************************************/
 
 /**
  * Message from the core saying that the transport
  * server should start giving it messages.  This
  * should automatically trigger the transmission of
  * a HELLO message.
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_START 360
 
 /**
  * Message from TRANSPORT notifying about a
  * client that connected to us.
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT 361
 
 /**
  * Message from TRANSPORT notifying about a
  * client that disconnected from us.
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_DISCONNECT 362
 
 /**
  * Request to TRANSPORT to transmit a message.
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_SEND 363
 
 /**
  * Confirmation from TRANSPORT that message for transmission has been
  * queued (and that the next message to this peer can now be passed to
  * the service).  Note that this confirmation does NOT imply that the
  * message was fully transmitted.
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_OK 364
 
 /**
  * Message from TRANSPORT notifying about a
  * message that was received.
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_RECV 365
 
 /**
  * Message telling transport to limit its receive rate.
  * (FIXME: was the above comment ever accurate?)
  *
  * Note: dead in TNG, replaced by RECV_OK!
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_SET_QUOTA 366
 
 /**
  * Message telling transport to limit its receive rate.
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_RECV_OK 366
 
 /**
  * Request to look addresses of peers in server.
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_TO_STRING 367
 
 /**
  * Response to the address lookup request.
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_TO_STRING_REPLY 368
 
 /**
  * Register a client that wants to do blacklisting.
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_BLACKLIST_INIT 369
 
 /**
  * Query to a blacklisting client (is this peer blacklisted)?
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_BLACKLIST_QUERY 370
 
 /**
  * Reply from blacklisting client (answer to blacklist query).
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_BLACKLIST_REPLY 371
 
 /**
  * Transport PING message
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_PING 372
 
 /**
  * Transport PONG message
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_PONG 373
 
 /**
  * Transport SYN message exchanged between transport services to
  * indicate that a session should be marked as 'connected'.
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_SYN 375
 
 /**
  * Transport SYN_ACK message exchanged between transport services to
  * indicate that a SYN message was accepted
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_SYN_ACK 376
 
 /**
  * Transport ACK message exchanged between transport services to
  * indicate that a SYN_ACK message was accepted
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_ACK 377
 
 /**
  * Transport DISCONNECT message exchanged between transport services to
  * indicate that a connection should be dropped.
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_DISCONNECT 378
 
 /**
  * Message exchanged between transport services to
  * indicate that the sender should limit its transmission
  * rate to the indicated quota.
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_QUOTA 379
 
 /**
  * Request to monitor addresses used by a peer or all peers.
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PEER_REQUEST 380
 
 /**
  * Message send by a peer to notify the other to keep the session alive
  * and measure latency in a regular interval
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_KEEPALIVE 381
 
 /**
  * Response to a #GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_KEEPALIVE message to
  * measure latency in a regular interval
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_KEEPALIVE_RESPONSE 382
 
 /**
  * Response to #GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PEER_REQUEST
  * request to iterate over all known addresses.
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PEER_RESPONSE 383
 
 /**
  * Message send by a peer to notify the other to keep the session alive.
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_BROADCAST_BEACON 384
 
 /**
  * Message containing traffic metrics for transport service
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_TRAFFIC_METRIC 385
 
 /**
  * Request to start monitoring the connection state of plugins.
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PLUGIN_START 388
 
 /**
  * Monitoring event about the connection state of plugins,
  * generated in response to a subscription initiated via
  * #GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PLUGIN_START
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PLUGIN_EVENT 389
 
 /**
  * Monitoring event notifying client that the initial iteration
  * is now completed and we are in sync with the state of the subsystem.
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PLUGIN_SYNC 390
 
 /**
  * Response to #GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PEER_RESPONSE_END
  * terminating list of replies.
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PEER_RESPONSE_END 391
 
 
 /*******************************************************************************
  * FS-PUBLISH-HELPER IPC Messages
  ******************************************************************************/
 
 /**
  * Progress information from the helper: found a file
  */
 #define GNUNET_MESSAGE_TYPE_FS_PUBLISH_HELPER_PROGRESS_FILE 420
 
 /**
  * Progress information from the helper: found a directory
  */
 #define GNUNET_MESSAGE_TYPE_FS_PUBLISH_HELPER_PROGRESS_DIRECTORY 421
 
 /**
  * Error signal from the helper.
  */
 #define GNUNET_MESSAGE_TYPE_FS_PUBLISH_HELPER_ERROR 422
 
 /**
  * Signal that helper skipped a file.
  */
 #define GNUNET_MESSAGE_TYPE_FS_PUBLISH_HELPER_SKIP_FILE 423
 
 /**
  * Signal that helper is done scanning the directory tree.
  */
 #define GNUNET_MESSAGE_TYPE_FS_PUBLISH_HELPER_COUNTING_DONE 424
 
 /**
  * Extracted meta data from the helper.
  */
 #define GNUNET_MESSAGE_TYPE_FS_PUBLISH_HELPER_META_DATA 425
 
 /**
  * Signal that helper is done.
  */
 #define GNUNET_MESSAGE_TYPE_FS_PUBLISH_HELPER_FINISHED 426
 
 
 /*******************************************************************************
  * NAMECACHE message types
  ******************************************************************************/
 
 /**
  * Client to service: lookup block
  */
 #define GNUNET_MESSAGE_TYPE_NAMECACHE_LOOKUP_BLOCK 431
 
 /**
  * Service to client: result of block lookup
  */
 #define GNUNET_MESSAGE_TYPE_NAMECACHE_LOOKUP_BLOCK_RESPONSE 432
 
 /**
  * Client to service: cache a block
  */
 #define GNUNET_MESSAGE_TYPE_NAMECACHE_BLOCK_CACHE 433
 
 /**
  * Service to client: result of block cache request
  */
 #define GNUNET_MESSAGE_TYPE_NAMECACHE_BLOCK_CACHE_RESPONSE 434
 
 /*******************************************************************************
  * NAMESTORE message types
  ******************************************************************************/
 
 /**
  * Client to service: store records (as authority)
  */
 #define GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_STORE 435
 
 /**
  * Service to client: result of store operation.
  */
 #define GNUNET_MESSAGE_TYPE_NAMESTORE_GENERIC_RESPONSE 436
 
 /**
  * Client to service: lookup label
  */
 #define GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP 437
 
 /**
  * Service to client: lookup label
  */
 #define GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP_RESPONSE 438
 
 /**
  * Client to service: "reverse" lookup for zone name based on zone key
  */
 #define GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME 439
 
 /**
  * Service to client: result of zone-to-name lookup.
  */
 #define GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME_RESPONSE 440
 
 /**
  * Client to service: start monitoring (yields sequence of
  * "ZONE_ITERATION_RESPONSES" --- forever).
  */
 #define GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_START 441
 
 /**
  * Service to client: you're now in sync.
  */
 #define GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_SYNC 442
 
 /**
  * Service to client: here is a (plaintext) record you requested.
  */
 #define GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT 443
 
 /**
  * Client to service: I am now ready for the next (set of) monitor
  * events. Monitoring equivlaent of
  * #GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_NEXT.
  */
 #define GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_NEXT 444
 
 /**
  * Client to service: please start iteration; receives
  * "GNUNET_MESSAGE_TYPE_NAMESTORE_LOOKUP_NAME_RESPONSE" messages in return.
  */
 #define GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_START 445
 
 /**
  * Client to service: next record(s) in iteration please.
  */
 #define GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_NEXT 447
 
 /**
  * Client to service: stop iterating.
  */
 #define GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_STOP 448
 
 /**
  * Service to client: end of list of results
  */
 #define GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT_END 449
 
 
 /*******************************************************************************
  * LOCKMANAGER message types
  ******************************************************************************/
 
 /**
  * Message to acquire Lock
  */
 #define GNUNET_MESSAGE_TYPE_LOCKMANAGER_ACQUIRE 450
 
 /**
  * Message to release lock
  */
 #define GNUNET_MESSAGE_TYPE_LOCKMANAGER_RELEASE 451
 
 /**
  * SUCCESS reply from lockmanager
  */
 #define GNUNET_MESSAGE_TYPE_LOCKMANAGER_SUCCESS 452
 
 /*******************************************************************************
  * TESTBED message types
  ******************************************************************************/
 
 /**
  * Initial message from a client to a testing control service
  */
 #define GNUNET_MESSAGE_TYPE_TESTBED_INIT 460
 
 /**
  * Message to add host
  */
 #define GNUNET_MESSAGE_TYPE_TESTBED_ADD_HOST 461
 
 /**
  * Message to signal that a add host succeeded
  */
 #define GNUNET_MESSAGE_TYPE_TESTBED_ADD_HOST_SUCCESS 462
 
 /**
  * Message to link delegated controller to slave controller
  */
 #define GNUNET_MESSAGE_TYPE_TESTBED_LINK_CONTROLLERS 463
 
 /**
  * Message to create a peer at a host
  */
 #define GNUNET_MESSAGE_TYPE_TESTBED_CREATE_PEER 464
 
 /**
  * Message to reconfigure a peer
  */
 #define GNUNET_MESSAGE_TYPE_TESTBED_RECONFIGURE_PEER 465
 
 /**
  * Message to start a peer at a host
  */
 #define GNUNET_MESSAGE_TYPE_TESTBED_START_PEER 466
 
 /**
  * Message to stop a peer at a host
  */
 #define GNUNET_MESSAGE_TYPE_TESTBED_STOP_PEER 467
 
 /**
  * Message to destroy a peer
  */
 #define GNUNET_MESSAGE_TYPE_TESTBED_DESTROY_PEER 468
 
 /**
  * Configure underlay link message
  */
 #define GNUNET_MESSAGE_TYPE_TESTBED_CONFIGURE_UNDERLAY_LINK 469
 
 /**
  * Message to connect peers in a overlay
  */
 #define GNUNET_MESSAGE_TYPE_TESTBED_OVERLAY_CONNECT 470
 
 /**
  * Message for peer events
  */
 #define GNUNET_MESSAGE_TYPE_TESTBED_PEER_EVENT 471
 
 /**
  * Message for peer connect events
  */
 #define GNUNET_MESSAGE_TYPE_TESTBED_PEER_CONNECT_EVENT 472
 
 /**
  * Message for operation events
  */
 #define GNUNET_MESSAGE_TYPE_TESTBED_OPERATION_FAIL_EVENT 473
 
 /**
  * Message to signal successful peer creation
  */
 #define GNUNET_MESSAGE_TYPE_TESTBED_CREATE_PEER_SUCCESS 474
 
 /**
  * Message to signal a generic operation has been successful
  */
 #define GNUNET_MESSAGE_TYPE_TESTBED_GENERIC_OPERATION_SUCCESS 475
 
 /**
  * Message to get a peer's information
  */
 #define GNUNET_MESSAGE_TYPE_TESTBED_GET_PEER_INFORMATION 476
 
 /**
  * Message containing the peer's information
  */
 #define GNUNET_MESSAGE_TYPE_TESTBED_PEER_INFORMATION 477
 
 /**
  * Message to request a controller to make one of its peer to connect to another
  * peer using the contained HELLO
  */
 #define GNUNET_MESSAGE_TYPE_TESTBED_REMOTE_OVERLAY_CONNECT 478
 
 /**
  * Message to request configuration of a slave controller
  */
 #define GNUNET_MESSAGE_TYPE_TESTBED_GET_SLAVE_CONFIGURATION 479
 
 /**
  * Message which contains the configuration of slave controller
  */
 #define GNUNET_MESSAGE_TYPE_TESTBED_SLAVE_CONFIGURATION 480
 
 /**
  * Message to signal the result of #GNUNET_MESSAGE_TYPE_TESTBED_LINK_CONTROLLERS
  * request
  */
 #define GNUNET_MESSAGE_TYPE_TESTBED_LINK_CONTROLLERS_RESULT 481
 
 /**
  * A controller receiving this message floods it to its directly-connected
  * sub-controllers and then stops and destroys all peers
  */
 #define GNUNET_MESSAGE_TYPE_TESTBED_SHUTDOWN_PEERS 482
 
 /**
  * Message to start/stop a service of a peer
  */
 #define GNUNET_MESSAGE_TYPE_TESTBED_MANAGE_PEER_SERVICE 483
 
 /**
  * Message to initialise a barrier.  Messages of these type are flooded to all
  * sub-controllers
  */
 #define GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_INIT 484
 
 /**
  * Message to cancel a barrier.  This message is flooded to all sub-controllers
  */
 #define GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_CANCEL 485
 
 /**
  * Message for signalling status of a barrier
  */
 #define GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_STATUS 486
 
 /**
  * Message sent by a peer when it has reached a barrier and is waiting for it to
  * be crossed
  */
 #define GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_WAIT 487
 
 /**
  * Not really a message, but for careful checks on the testbed messages; Should
  * always be the maximum and never be used to send messages with this type
  */
 #define GNUNET_MESSAGE_TYPE_TESTBED_MAX 488
 
 /**
  * The initialization message towards gnunet-testbed-helper
  */
 #define GNUNET_MESSAGE_TYPE_TESTBED_HELPER_INIT 495
 
 /**
  * The reply message from gnunet-testbed-helper
  */
 #define GNUNET_MESSAGE_TYPE_TESTBED_HELPER_REPLY 496
 
 
 /******************************************************************************
  * GNS.
  *****************************************************************************/
 
 /**
  * Client would like to resolve a name.
  */
 #define GNUNET_MESSAGE_TYPE_GNS_LOOKUP 500
 
 /**
  * Service response to name resolution request from client.
  */
 #define GNUNET_MESSAGE_TYPE_GNS_LOOKUP_RESULT 501
 
 /**
  * Reverse lookup
  */
 #define GNUNET_MESSAGE_TYPE_GNS_REVERSE_LOOKUP 503
 
 /**
  * Response to reverse lookup
  */
 #define GNUNET_MESSAGE_TYPE_GNS_REVERSE_LOOKUP_RESULT 504
 
 
 /*******************************************************************************
  * CONSENSUS message types
  ******************************************************************************/
 
 /**
  * Join a consensus session. Sent by client to service as first message.
  */
 #define GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_JOIN 520
 
 /**
  * Insert an element. Sent by client to service.
  */
 #define GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_INSERT 521
 
 /**
  * Begin accepting new elements from other participants.
  * Sent by client to service.
  */
 #define GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_BEGIN 522
 
 /**
  * Sent by service when a new element is added.
  */
 #define GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_RECEIVED_ELEMENT 523
 
 /**
  * Sent by client to service in order to start the consensus conclusion.
  */
 #define GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_CONCLUDE 524
 
 /**
  * Sent by service to client in order to signal a completed consensus
  * conclusion. Last message sent in a consensus session.
  */
 #define GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_CONCLUDE_DONE 525
 
 
 /* message types 526-539 reserved for consensus client/service messages */
 
 
 /**
  * Sent by client to service, telling whether a received element should
  * be accepted and propagated further or not.
  */
 #define GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_ACK 540
 
 /**
  * Strata estimator.
  */
 #define GNUNET_MESSAGE_TYPE_CONSENSUS_P2P_DELTA_ESTIMATE 541
 
 /**
  * IBF containing all elements of a peer.
  */
 #define GNUNET_MESSAGE_TYPE_CONSENSUS_P2P_DIFFERENCE_DIGEST 542
 
 /**
  * One or more elements that are sent from peer to peer.
  */
 #define GNUNET_MESSAGE_TYPE_CONSENSUS_P2P_ELEMENTS 543
 
 /**
  * Elements, and requests for further elements
  */
 #define GNUNET_MESSAGE_TYPE_CONSENSUS_P2P_ELEMENTS_REQUEST 544
 
 /**
  * Elements that a peer reports to be missing at the remote peer.
  */
 #define GNUNET_MESSAGE_TYPE_CONSENSUS_P2P_ELEMENTS_REPORT 545
 
 /**
  * Provide context for a consensus round.
  */
 #define GNUNET_MESSAGE_TYPE_CONSENSUS_P2P_ROUND_CONTEXT 547
 
 
 /*******************************************************************************
  * SETU message types
  ******************************************************************************/
 
 
 /**
  * Cancel a set operation
  */
 #define GNUNET_MESSAGE_TYPE_SETU_CANCEL 550
 
 /**
  * Add element to set
  */
 #define GNUNET_MESSAGE_TYPE_SETU_ADD 551
 
 /**
  * Create a new local set
  */
 #define GNUNET_MESSAGE_TYPE_SETU_CREATE 552
 
 /**
  * Handle result message from operation
  */
 #define GNUNET_MESSAGE_TYPE_SETU_RESULT 553
 
 /**
  * Evaluate a set operation
  */
 #define GNUNET_MESSAGE_TYPE_SETU_EVALUATE 554
 
 /**
  * Listen for operation requests
  */
 #define GNUNET_MESSAGE_TYPE_SETU_LISTEN 555
 
 /**
  * Reject a set request.
  */
 #define GNUNET_MESSAGE_TYPE_SETU_REJECT 556
 
 /**
  * Accept an incoming set request
  */
 #define GNUNET_MESSAGE_TYPE_SETU_ACCEPT 557
 
 /**
  * Notify the client of an incoming request from a remote peer
  */
 #define GNUNET_MESSAGE_TYPE_SETU_REQUEST 558
 
 
 /**
  * Demand the whole element from the other
  * peer, given only the hash code.
  */
 #define GNUNET_MESSAGE_TYPE_SETU_P2P_REQUEST_FULL 559
 
 /**
  * Demand the whole element from the other
  * peer, given only the hash code.
  */
 #define GNUNET_MESSAGE_TYPE_SETU_P2P_DEMAND 560
 
 /**
  * Tell the other peer to send us a list of
  * hashes that match an IBF key.
  */
 #define GNUNET_MESSAGE_TYPE_SETU_P2P_INQUIRY 561
 
 /**
  * Tell the other peer which hashes match a
  * given IBF key.
  */
 #define GNUNET_MESSAGE_TYPE_SETU_P2P_OFFER 562
 
 /**
  * Request a set union operation from a remote peer.
  */
 #define GNUNET_MESSAGE_TYPE_SETU_P2P_OPERATION_REQUEST 563
 
 /**
  * Strata estimator.
  */
 #define GNUNET_MESSAGE_TYPE_SETU_P2P_SE 564
 
 /**
  * Invertible bloom filter.
  */
 #define GNUNET_MESSAGE_TYPE_SETU_P2P_IBF 565
 
 /**
  * Actual set elements.
  */
 #define GNUNET_MESSAGE_TYPE_SETU_P2P_ELEMENTS 566
 
 /**
  * Set operation is done.
  */
 #define GNUNET_MESSAGE_TYPE_SETU_P2P_DONE 568
 
 /**
  * Compressed strata estimator.
  */
 #define GNUNET_MESSAGE_TYPE_SETU_P2P_SEC 569
 
 /**
  * Request all missing elements from the other peer,
  * based on their sets and the elements we previously sent
  * with #GNUNET_MESSAGE_TYPE_SET_P2P_ELEMENTS.
  */
 #define GNUNET_MESSAGE_TYPE_SETU_P2P_FULL_DONE 570
 
 /**
  * Send a set element, not as response to a demand but because
  * we're sending the full set.
  */
 #define GNUNET_MESSAGE_TYPE_SETU_P2P_FULL_ELEMENT 571
 
 /**
  * Request all missing elements from the other peer,
  * based on their sets and the elements we previously sent
  * with #GNUNET_MESSAGE_TYPE_SET_P2P_ELEMENTS.
  */
 #define GNUNET_MESSAGE_TYPE_SETU_P2P_OVER 572
 
 /**
  * Signals other peer that all elements are sent.
  */
 
 #define GNUNET_MESSAGE_TYPE_SETU_P2P_SEND_FULL 710
 
 
 /*******************************************************************************
  * SETI message types
  ******************************************************************************/
 
 
 /**
  * Cancel a set operation
  */
 #define GNUNET_MESSAGE_TYPE_SETI_CANCEL 580
 
 /**
  * Add element to set.
  */
 #define GNUNET_MESSAGE_TYPE_SETI_ADD 581
 
 /**
  * Create a new local set
  */
 #define GNUNET_MESSAGE_TYPE_SETI_CREATE 582
 
 /**
  * Handle result message from operation
  */
 #define GNUNET_MESSAGE_TYPE_SETI_RESULT 583
 
 /**
  * Evaluate a set operation
  */
 #define GNUNET_MESSAGE_TYPE_SETI_EVALUATE 584
 
 /**
  * Listen for operation requests
  */
 #define GNUNET_MESSAGE_TYPE_SETI_LISTEN 585
 
 /**
  * Reject a set request.
  */
 #define GNUNET_MESSAGE_TYPE_SETI_REJECT 586
 
 /**
  * Accept an incoming set request
  */
 #define GNUNET_MESSAGE_TYPE_SETI_ACCEPT 587
 
 /**
  * Notify the client of an incoming request from a remote peer
  */
 #define GNUNET_MESSAGE_TYPE_SETI_REQUEST 588
 
 /**
  * Information about the element count for intersection
  */
 #define GNUNET_MESSAGE_TYPE_SETI_P2P_ELEMENT_INFO 591
 
 /**
  * Bloom filter message for intersection exchange started by Bob.
  */
 #define GNUNET_MESSAGE_TYPE_SETI_P2P_BF 592
 
 /**
  * Intersection operation is done.
  */
 #define GNUNET_MESSAGE_TYPE_SETI_P2P_DONE 593
 
 /**
  * Request to begin set intersection operation.
  */
 #define GNUNET_MESSAGE_TYPE_SETI_P2P_OPERATION_REQUEST 594
 
 
 /*******************************************************************************
  * SET message types
  ******************************************************************************/
 
 
 /**
  * Demand the whole element from the other
  * peer, given only the hash code.
  */
 #define GNUNET_MESSAGE_TYPE_SET_UNION_P2P_REQUEST_FULL 565
 
 /**
  * Demand the whole element from the other
  * peer, given only the hash code.
  */
 #define GNUNET_MESSAGE_TYPE_SET_UNION_P2P_DEMAND 566
 
 /**
  * Tell the other peer to send us a list of
  * hashes that match an IBF key.
  */
 #define GNUNET_MESSAGE_TYPE_SET_UNION_P2P_INQUIRY 567
 
 /**
  * Tell the other peer which hashes match a
  * given IBF key.
  */
 #define GNUNET_MESSAGE_TYPE_SET_UNION_P2P_OFFER 568
 
 /**
  * Reject a set request.
  */
 #define GNUNET_MESSAGE_TYPE_SET_REJECT 569
 
 /**
  * Cancel a set operation
  */
 #define GNUNET_MESSAGE_TYPE_SET_CANCEL 570
 
 /**
  * Acknowledge result from iteration
  */
 #define GNUNET_MESSAGE_TYPE_SET_ITER_ACK 571
 
 /**
  * Create an empty set
  */
 #define GNUNET_MESSAGE_TYPE_SET_RESULT 572
 
 /**
  * Add element to set
  */
 #define GNUNET_MESSAGE_TYPE_SET_ADD 573
 
 /**
  * Remove element from set
  */
 #define GNUNET_MESSAGE_TYPE_SET_REMOVE 574
 
 /**
  * Listen for operation requests
  */
 #define GNUNET_MESSAGE_TYPE_SET_LISTEN 575
 
 /**
  * Accept a set request
  */
 #define GNUNET_MESSAGE_TYPE_SET_ACCEPT 576
 
 /**
  * Evaluate a set operation
  */
 #define GNUNET_MESSAGE_TYPE_SET_EVALUATE 577
 
 /**
  * Start a set operation with the given set
  */
 #define GNUNET_MESSAGE_TYPE_SET_CONCLUDE 578
 
 /**
  * Notify the client of a request from a remote peer
  */
 #define GNUNET_MESSAGE_TYPE_SET_REQUEST 579
 
 /**
  * Create a new local set
  */
 #define GNUNET_MESSAGE_TYPE_SET_CREATE 580
 
 /**
  * Request a set operation from a remote peer.
  */
 #define GNUNET_MESSAGE_TYPE_SET_P2P_OPERATION_REQUEST 581
 
 /**
  * Strata estimator.
  */
 #define GNUNET_MESSAGE_TYPE_SET_UNION_P2P_SE 582
 
 /**
  * Invertible bloom filter.
  */
 #define GNUNET_MESSAGE_TYPE_SET_UNION_P2P_IBF 583
 
 /**
  * Actual set elements.
  */
 #define GNUNET_MESSAGE_TYPE_SET_P2P_ELEMENTS 584
 
 /**
  * Set operation is done.
  */
 #define GNUNET_MESSAGE_TYPE_SET_UNION_P2P_DONE 586
 
 /**
  * Start iteration over set elements.
  */
 #define GNUNET_MESSAGE_TYPE_SET_ITER_REQUEST 587
 
 /**
  * Element result for the iterating client.
  */
 #define GNUNET_MESSAGE_TYPE_SET_ITER_ELEMENT 588
 
 /**
  * Iteration end marker for the client.
  */
 #define GNUNET_MESSAGE_TYPE_SET_ITER_DONE 589
 
 /**
  * Compressed strata estimator.
  */
 #define GNUNET_MESSAGE_TYPE_SET_UNION_P2P_SEC 590
 
 /**
  * Information about the element count for intersection
  */
 #define GNUNET_MESSAGE_TYPE_SET_INTERSECTION_P2P_ELEMENT_INFO 591
 
 /**
  * Bloom filter message for intersection exchange started by Bob.
  */
 #define GNUNET_MESSAGE_TYPE_SET_INTERSECTION_P2P_BF 592
 
 /**
  * Intersection operation is done.
  */
 #define GNUNET_MESSAGE_TYPE_SET_INTERSECTION_P2P_DONE 593
 
 /**
  * Ask the set service to prepare a copy of a set.
  */
 #define GNUNET_MESSAGE_TYPE_SET_COPY_LAZY_PREPARE 594
 
 /**
  * Give the client an ID for connecting to the set's copy.
  */
 #define GNUNET_MESSAGE_TYPE_SET_COPY_LAZY_RESPONSE 595
 
 /**
  * Sent by the client to the server to connect to an existing,
  * lazily copied set.
  */
 #define GNUNET_MESSAGE_TYPE_SET_COPY_LAZY_CONNECT 596
 
 /**
  * Request all missing elements from the other peer,
  * based on their sets and the elements we previously sent
  * with #GNUNET_MESSAGE_TYPE_SET_P2P_ELEMENTS.
  */
 #define GNUNET_MESSAGE_TYPE_SET_UNION_P2P_FULL_DONE 597
 
 /**
  * Send a set element, not as response to a demand but because
  * we're sending the full set.
  */
 #define GNUNET_MESSAGE_TYPE_SET_UNION_P2P_FULL_ELEMENT 598
 
 /**
  * Request all missing elements from the other peer,
  * based on their sets and the elements we previously sent
  * with #GNUNET_MESSAGE_TYPE_SET_P2P_ELEMENTS.
  */
 #define GNUNET_MESSAGE_TYPE_SET_UNION_P2P_OVER 599
 
 
 /*******************************************************************************
  * TESTBED LOGGER message types
  ******************************************************************************/
 
 /**
  * Message for TESTBED LOGGER
  */
 #define GNUNET_MESSAGE_TYPE_TESTBED_LOGGER_MSG 600
 
 /**
  * Message for TESTBED LOGGER acknowledgement
  */
 #define GNUNET_MESSAGE_TYPE_TESTBED_LOGGER_ACK 601
 
 
 /**
  * Advertise regex capability.
  */
 #define GNUNET_MESSAGE_TYPE_REGEX_ANNOUNCE 620
 
 /**
  * Search for peer with matching capability.
  */
 #define GNUNET_MESSAGE_TYPE_REGEX_SEARCH 621
 
 /**
  * Result in response to regex search.
  */
 #define GNUNET_MESSAGE_TYPE_REGEX_RESULT 622
 
 /*******************************************************************************
  * IDENTITY message types
  ******************************************************************************/
 
 /**
  * First message send from identity client to service (to subscribe to
  * updates).
  */
 #define GNUNET_MESSAGE_TYPE_IDENTITY_START 624
 
 /**
  * Generic response from identity service with success and/or error message.
  */
 #define GNUNET_MESSAGE_TYPE_IDENTITY_RESULT_CODE 625
 
 /**
  * Update about identity status from service to clients.
  */
 #define GNUNET_MESSAGE_TYPE_IDENTITY_UPDATE 626
 
 /**
  * 627 and 628 unused
  */
 
 /**
  * Create new identity (client->service).
  */
 #define GNUNET_MESSAGE_TYPE_IDENTITY_CREATE 629
 
 /**
  * Rename existing identity (client->service).
  */
 #define GNUNET_MESSAGE_TYPE_IDENTITY_RENAME 630
 
 /**
  * Delete identity (client->service).
  */
 #define GNUNET_MESSAGE_TYPE_IDENTITY_DELETE 631
 
 /**
  * First message send from identity client to service to
  * lookup a single ego.  The service will respond with a
  * #GNUNET_MESSAGE_TYPE_IDENTITY_UPDATE message if the ego
  * exists, or a #GNUNET_MESSAGE_TYPE_IDENTITY_RESULT_CODE if not.
  */
 #define GNUNET_MESSAGE_TYPE_IDENTITY_LOOKUP 632
 
 /**
  * First message send from identity client to service to lookup a
  * single ego matching the given suffix (longest match).  The service
  * will respond with a #GNUNET_MESSAGE_TYPE_IDENTITY_UPDATE message if
  * the ego exists, or a #GNUNET_MESSAGE_TYPE_IDENTITY_RESULT_CODE if
  * not.
  */
 #define GNUNET_MESSAGE_TYPE_IDENTITY_LOOKUP_BY_SUFFIX 633
 
 
 /*******************************************************************************
  * REVOCATION message types
  ******************************************************************************/
 
 /**
  * Client to service: was this key revoked?
  */
 #define GNUNET_MESSAGE_TYPE_REVOCATION_QUERY 636
 
 /**
  * Service to client: answer if key was revoked!
  */
 #define GNUNET_MESSAGE_TYPE_REVOCATION_QUERY_RESPONSE 637
 
 /**
  * Client to service OR peer-to-peer: revoke this key!
  */
 #define GNUNET_MESSAGE_TYPE_REVOCATION_REVOKE 638
 
 /**
  * Service to client: revocation confirmed
  */
 #define GNUNET_MESSAGE_TYPE_REVOCATION_REVOKE_RESPONSE 639
 
 
 /*******************************************************************************
  * SCALARPRODUCT message types
  ******************************************************************************/
 
 /**
  * Client -> Alice
  */
 #define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_TO_ALICE 640
 
 /**
  * Client -> Bob
  */
 #define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_TO_BOB 641
 
 /**
  * Client -> Alice multipart
  */
 #define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_MULTIPART_ALICE 642
 
 /**
  * Client -> Bob multipart
  */
 #define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_MULTIPART_BOB 643
 
 /**
  * Alice -> Bob session initialization
  */
 #define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_SESSION_INITIALIZATION 644
 
 /**
  * Alice -> Bob SP crypto-data (after intersection)
  */
 #define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ALICE_CRYPTODATA 645
 
 /**
  * Bob -> Alice SP crypto-data
  */
 #define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_BOB_CRYPTODATA 647
 
 /**
  * Bob -> Alice SP crypto-data multipart
  */
 #define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_BOB_CRYPTODATA_MULTIPART 648
 
 /**
  * Alice/Bob -> Client Result
  */
 #define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_RESULT 649
 
 /**
  * Alice -> Bob ECC session initialization
  */
 #define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_SESSION_INITIALIZATION 650
 
 /**
  * Alice -> Bob ECC crypto data
  */
 #define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_ALICE_CRYPTODATA 651
 
 /**
  * Bob -> Alice ECC crypto data
  */
 #define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_BOB_CRYPTODATA 652
 
 
 /*******************************************************************************
  * PSYCSTORE message types
  ******************************************************************************/
 
 /**
  * Store a membership event.
  */
 #define GNUNET_MESSAGE_TYPE_PSYCSTORE_MEMBERSHIP_STORE 660
 
 /**
  * Test for membership of a member at a particular point in time.
  */
 #define GNUNET_MESSAGE_TYPE_PSYCSTORE_MEMBERSHIP_TEST 661
 
 #define GNUNET_MESSAGE_TYPE_PSYCSTORE_FRAGMENT_STORE 662
 
 #define GNUNET_MESSAGE_TYPE_PSYCSTORE_FRAGMENT_GET 663
 
 #define GNUNET_MESSAGE_TYPE_PSYCSTORE_MESSAGE_GET 664
 
 #define GNUNET_MESSAGE_TYPE_PSYCSTORE_MESSAGE_GET_FRAGMENT 665
 
 #define GNUNET_MESSAGE_TYPE_PSYCSTORE_COUNTERS_GET 666
 
 /* 657 */
 
 #define GNUNET_MESSAGE_TYPE_PSYCSTORE_STATE_MODIFY 668
 
 #define GNUNET_MESSAGE_TYPE_PSYCSTORE_STATE_SYNC 669
 
 #define GNUNET_MESSAGE_TYPE_PSYCSTORE_STATE_RESET 670
 
 #define GNUNET_MESSAGE_TYPE_PSYCSTORE_STATE_HASH_UPDATE 671
 
 #define GNUNET_MESSAGE_TYPE_PSYCSTORE_STATE_GET 672
 
 #define GNUNET_MESSAGE_TYPE_PSYCSTORE_STATE_GET_PREFIX 673
 
 /**
  * Generic response from PSYCstore service with success and/or error message.
  */
 #define GNUNET_MESSAGE_TYPE_PSYCSTORE_RESULT_CODE 674
 
 #define GNUNET_MESSAGE_TYPE_PSYCSTORE_RESULT_FRAGMENT 675
 
 #define GNUNET_MESSAGE_TYPE_PSYCSTORE_RESULT_COUNTERS 676
 
 #define GNUNET_MESSAGE_TYPE_PSYCSTORE_RESULT_STATE 677
 
 
 /*******************************************************************************
  * PSYC message types
  ******************************************************************************/
 
 /**
  * C: client
  * S: service
  * M: multicast
  */
 
 /** S->C: result of an operation */
 #define GNUNET_MESSAGE_TYPE_PSYC_RESULT_CODE 680
 
 /** C->S: request to start a channel as a master */
 #define GNUNET_MESSAGE_TYPE_PSYC_MASTER_START 681
 
 /** S->C: master start acknowledgement */
 #define GNUNET_MESSAGE_TYPE_PSYC_MASTER_START_ACK 682
 
 /** C->S: request to join a channel as a slave */
 #define GNUNET_MESSAGE_TYPE_PSYC_SLAVE_JOIN 683
 
 /** S->C: slave join acknowledgement */
 #define GNUNET_MESSAGE_TYPE_PSYC_SLAVE_JOIN_ACK 684
 
 /** C->S: request to part from a channel */
 #define GNUNET_MESSAGE_TYPE_PSYC_PART_REQUEST 685
 
 /** S->C: acknowledgement that a slave of master parted from a channel */
 #define GNUNET_MESSAGE_TYPE_PSYC_PART_ACK 686
 
 /** M->S->C: incoming join request from multicast */
 #define GNUNET_MESSAGE_TYPE_PSYC_JOIN_REQUEST 687
 
 /** C->S->M: decision about a join request */
 #define GNUNET_MESSAGE_TYPE_PSYC_JOIN_DECISION 688
 
 
 /** C->S: request to add/remove channel slave in the membership database. */
 #define GNUNET_MESSAGE_TYPE_PSYC_CHANNEL_MEMBERSHIP_STORE 689
 
 /* 690 */
 
 /** S<--C: PSYC message which contains one or more message parts. */
 #define GNUNET_MESSAGE_TYPE_PSYC_MESSAGE 691
 
 /** M<->S<->C: PSYC message which contains a header and one or more message
  * parts. */
 #define GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_HEADER \
         692 // FIXME: start using this where appropriate
 
 /** Message part: method */
 #define GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_METHOD 693
 
 /** Message part: modifier */
 #define GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_MODIFIER 694
 
 /** Message part: modifier continuation */
 #define GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_MOD_CONT 695
 
 /** Message part: data */
 #define GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_DATA 696
 
 /** Message part: end of message */
 #define GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_END 697
 
 /** Message part: message cancelled */
 #define GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_CANCEL 698
 
 /** S->C: message acknowledgement */
 #define GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_ACK 699
 
 /* 700 */
 
 /** C->S: request channel history replay from PSYCstore. */
 #define GNUNET_MESSAGE_TYPE_PSYC_HISTORY_REPLAY 701
 
 /** S->C: result for a channel history request */
 #define GNUNET_MESSAGE_TYPE_PSYC_HISTORY_RESULT 702
 
 
 /** C->S: request best matching state variable from PSYCstore. */
 #define GNUNET_MESSAGE_TYPE_PSYC_STATE_GET 703
 
 /** C->S: request state variables with a given prefix from PSYCstore. */
 #define GNUNET_MESSAGE_TYPE_PSYC_STATE_GET_PREFIX 704
 
 /** S->C: result for a state request. */
 #define GNUNET_MESSAGE_TYPE_PSYC_STATE_RESULT 705
 
 
 /*******************************************************************************
  * CONVERSATION message types
  ******************************************************************************/
 
 /**
  * Message to transmit the audio between helper and speaker/microphone library.
  */
 #define GNUNET_MESSAGE_TYPE_CONVERSATION_AUDIO 730
 
 /**
  * Client -> Server message to register a phone.
  */
 #define GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_REGISTER 731
 
 /**
  * Client -> Server message to reject/hangup a call
  */
 #define GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_PICK_UP 732
 
 /**
  * Client -> Server message to reject/hangup a call
  */
 #define GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_HANG_UP 733
 
 /**
  * Client <- Server message to indicate a ringing phone
  */
 #define GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_CALL 734
 
 /**
  * Client <- Server message to indicate a ringing phone
  */
 #define GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RING 735
 
 /**
  * Client <-> Server message to suspend connection.
  */
 #define GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_SUSPEND 736
 
 /**
  * Client <-> Server message to resume connection.
  */
 #define GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RESUME 737
 
 /**
  * Service -> Client message to notify that phone was picked up.
  */
 #define GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_PICKED_UP 738
 
 /**
  * Client <-> Server message to send audio data.
  */
 #define GNUNET_MESSAGE_TYPE_CONVERSATION_CS_AUDIO 739
 
 /**
  * Cadet: call initiation
  */
 #define GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_RING 740
 
 /**
  * Cadet: hang up / refuse call
  */
 #define GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_HANG_UP 741
 
 /**
  * Cadet: pick up phone (establish audio channel)
  */
 #define GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_PICK_UP 742
 
 /**
  * Cadet: phone suspended.
  */
 #define GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_SUSPEND 743
 
 /**
  * Cadet: phone resumed.
  */
 #define GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_RESUME 744
 
 /**
  * Cadet: audio data
  */
 #define GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_AUDIO 745
 
 
 /*******************************************************************************
  * MULTICAST message types
  ******************************************************************************/
 
 /**
  * C: client
  * S: service
  * T: cadet
  */
 
 /**
  * C->S: Start the origin.
  */
 #define GNUNET_MESSAGE_TYPE_MULTICAST_ORIGIN_START 750
 
 /**
  * C->S: Join group as a member.
  */
 #define GNUNET_MESSAGE_TYPE_MULTICAST_MEMBER_JOIN 751
 
 /**
  * C<--S<->T: A peer wants to join the group.
  *
  * Unicast message to the origin or another group member.
  */
 #define GNUNET_MESSAGE_TYPE_MULTICAST_JOIN_REQUEST 752
 
 /**
  * C<->S<->T: Response to a join request.
  *
  * Unicast message from a group member to the peer wanting to join.
  */
 #define GNUNET_MESSAGE_TYPE_MULTICAST_JOIN_DECISION 753
 
 /**
  * A peer wants to part the group.
  */
 #define GNUNET_MESSAGE_TYPE_MULTICAST_PART_REQUEST 754
 
 /**
  * Acknowledgement sent in response to a part request.
  *
  * Unicast message from a group member to the peer wanting to part.
  */
 #define GNUNET_MESSAGE_TYPE_MULTICAST_PART_ACK 755
 
 // FIXME: this is never used!
 /**
  * Group terminated.
  */
 #define GNUNET_MESSAGE_TYPE_MULTICAST_GROUP_END 756
 
 /**
  * C<->S<->T: Multicast message from the origin to all members.
  */
 #define GNUNET_MESSAGE_TYPE_MULTICAST_MESSAGE 757
 
 /**
  * C<->S<->T: Unicast request from a group member to the origin.
  */
 #define GNUNET_MESSAGE_TYPE_MULTICAST_REQUEST 758
 
 /**
  * C->S: Acknowledgement of a message or request fragment for the client.
  */
 #define GNUNET_MESSAGE_TYPE_MULTICAST_FRAGMENT_ACK 759
 
 /**
  * C<->S<->T: Replay request from a group member to another member.
  */
 #define GNUNET_MESSAGE_TYPE_MULTICAST_REPLAY_REQUEST 760
 
 /**
  * C<->S<->T: Replay response from a group member to another member.
  */
 #define GNUNET_MESSAGE_TYPE_MULTICAST_REPLAY_RESPONSE 761
 
 /**
  * C<->S: End of replay response.
  */
 #define GNUNET_MESSAGE_TYPE_MULTICAST_REPLAY_RESPONSE_END 762
 
 
 /*******************************************************************************
  * SECRETSHARING message types
  ******************************************************************************/
 
 
 /**
  * Establish a new session.
  */
 #define GNUNET_MESSAGE_TYPE_SECRETSHARING_CLIENT_GENERATE 780
 
 /**
  * Request the decryption of a ciphertext.
  */
 #define GNUNET_MESSAGE_TYPE_SECRETSHARING_CLIENT_DECRYPT 781
 
 /**
  * The service succeeded in decrypting a ciphertext.
  */
 #define GNUNET_MESSAGE_TYPE_SECRETSHARING_CLIENT_DECRYPT_DONE 782
 
 /**
  * The cryptosystem has been established.
  * Contains the peer's share.
  */
 #define GNUNET_MESSAGE_TYPE_SECRETSHARING_CLIENT_SECRET_READY 783
 
 
 /*******************************************************************************
  * PEERSTORE message types
  ******************************************************************************/
 
 /**
  * Store request message
  */
 #define GNUNET_MESSAGE_TYPE_PEERSTORE_STORE 820
 
 /**
  * Iteration request (see also 828, 829)
  */
 #define GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE_START 821
 
 /**
  * Record result message
  */
 #define GNUNET_MESSAGE_TYPE_PEERSTORE_RECORD 822
 
 /**
  * Iteration end message
  */
 #define GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE_END 823
 
 /**
  * Monitor request
  */
 #define GNUNET_MESSAGE_TYPE_PEERSTORE_MONITOR_START 824
 
 /**
  * Monitor sync
  */
 #define GNUNET_MESSAGE_TYPE_PEERSTORE_MONITOR_SYNC 825
 
 /**
  * Monitor next request
  */
 #define GNUNET_MESSAGE_TYPE_PEERSTORE_MONITOR_NEXT 826
 
 /**
  * Store result message
  */
 #define GNUNET_MESSAGE_TYPE_PEERSTORE_STORE_RESULT 827
 
 /**
  * Iteration request (see also 821, 829)
  */
 #define GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE_NEXT 828
 
 /**
  * Iteration request (see also 821, 828)
  */
 #define GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE_STOP 829
 
 /*******************************************************************************
  * SOCIAL message types
  ******************************************************************************/
 
 /**
  * C: client
  * S: service
  * P: PSYC
  */
 
 /** S->C: result of an operation */
 #define GNUNET_MESSAGE_TYPE_SOCIAL_RESULT_CODE 840
 
 /** C->S: request to enter a place as the host */
 #define GNUNET_MESSAGE_TYPE_SOCIAL_HOST_ENTER 841
 
 /** S->C: host enter acknowledgement */
 #define GNUNET_MESSAGE_TYPE_SOCIAL_HOST_ENTER_ACK 842
 
 /** C->S: request to enter a place as a guest */
 #define GNUNET_MESSAGE_TYPE_SOCIAL_GUEST_ENTER 843
 
 /** C->S: request to enter a place as a guest, using a GNS address */
 #define GNUNET_MESSAGE_TYPE_SOCIAL_GUEST_ENTER_BY_NAME 844
 
 /** S->C: guest enter acknowledgement */
 #define GNUNET_MESSAGE_TYPE_SOCIAL_GUEST_ENTER_ACK 845
 
 /** P->S->C: incoming entry request from PSYC */
 #define GNUNET_MESSAGE_TYPE_SOCIAL_ENTRY_REQUEST 846
 
 /** C->S->P: decision about an entry request */
 #define GNUNET_MESSAGE_TYPE_SOCIAL_ENTRY_DECISION 847
 
 /** C->S: request to leave a place */
 #define GNUNET_MESSAGE_TYPE_SOCIAL_PLACE_LEAVE 848
 
 /** S->C: place leave acknowledgement */
 #define GNUNET_MESSAGE_TYPE_SOCIAL_PLACE_LEAVE_ACK 849
 
 /** C->S: add place to GNS zone */
 #define GNUNET_MESSAGE_TYPE_SOCIAL_ZONE_ADD_PLACE 850
 
 /** C->S: add nym to GNS zone */
 #define GNUNET_MESSAGE_TYPE_SOCIAL_ZONE_ADD_NYM 851
 
 /** C->S: connect application */
 #define GNUNET_MESSAGE_TYPE_SOCIAL_APP_CONNECT 852
 
 /** C->S: detach a place from application */
 #define GNUNET_MESSAGE_TYPE_SOCIAL_APP_DETACH 853
 
 /** S->C: notify about an existing ego */
 #define GNUNET_MESSAGE_TYPE_SOCIAL_APP_EGO 854
 
 /** S->C: end of ego list */
 #define GNUNET_MESSAGE_TYPE_SOCIAL_APP_EGO_END 855
 
 /** S->C: notify about an existing place */
 #define GNUNET_MESSAGE_TYPE_SOCIAL_APP_PLACE 856
 
 /** S->C: end of place list */
 #define GNUNET_MESSAGE_TYPE_SOCIAL_APP_PLACE_END 857
 
 /** C->S: set message processing flags */
 #define GNUNET_MESSAGE_TYPE_SOCIAL_MSG_PROC_SET 858
 
 /** C->S: clear message processing flags */
 #define GNUNET_MESSAGE_TYPE_SOCIAL_MSG_PROC_CLEAR 859
 
 /*******************************************************************************
  * X-VINE DHT messages
  ******************************************************************************/
 
 /**
  * Trail setup request is received by a peer.
  */
 #define GNUNET_MESSAGE_TYPE_XDHT_P2P_TRAIL_SETUP 880
 
 /**
  * Trail to a particular peer is returned to this peer.
  */
 #define GNUNET_MESSAGE_TYPE_XDHT_P2P_TRAIL_SETUP_RESULT 881
 
 /**
  * Verify if your immediate successor is still your immediate successor.
  */
 #define GNUNET_MESSAGE_TYPE_XDHT_P2P_VERIFY_SUCCESSOR 882
 
 /**
  * Notify your new immediate successor that you are its new predecessor.
  */
 #define GNUNET_MESSAGE_TYPE_XDHT_P2P_NOTIFY_NEW_SUCCESSOR 883
 
 /**
  * Message which contains the immediate predecessor of requested successor
  */
 #define GNUNET_MESSAGE_TYPE_XDHT_P2P_VERIFY_SUCCESSOR_RESULT 884
 
 /**
  * Message which contains the get result.
  */
 #define GNUNET_MESSAGE_TYPE_XDHT_P2P_GET_RESULT 885
 
 /**
  * Trail Rejection Message.
  */
 #define GNUNET_MESSAGE_TYPE_XDHT_P2P_TRAIL_SETUP_REJECTION 886
 
 /**
  * Trail Tear down Message.
  */
 #define GNUNET_MESSAGE_TYPE_XDHT_P2P_TRAIL_TEARDOWN 887
 
 /**
  * Routing table add message.
  */
 #define GNUNET_MESSAGE_TYPE_XDHT_P2P_ADD_TRAIL 888
 
 /**
  * Peer is storing the data in DHT.
  */
 #define GNUNET_MESSAGE_TYPE_XDHT_P2P_PUT 890
 
 /**
  * Peer tries to find data in DHT.
  */
 #define GNUNET_MESSAGE_TYPE_XDHT_P2P_GET 891
 
 /**
  * Send back peer that considers you are its successor, a confirmation
  * that you got the notify successor message.
  */
 #define GNUNET_MESSAGE_TYPE_XDHT_P2P_NOTIFY_SUCCESSOR_CONFIRMATION 892
 
 
 /*******************************************************************************
  * Whanau DHT messages
  ******************************************************************************/
 
 
 /**
  * This message contains the query for performing a random walk
  */
 #define GNUNET_MESSAGE_TYPE_WDHT_RANDOM_WALK 910
 
 /**
  * This message contains the result of a random walk
  */
 #define GNUNET_MESSAGE_TYPE_WDHT_RANDOM_WALK_RESPONSE 911
 
 /**
  * This message contains a notification for the death of a trail
  */
 #define GNUNET_MESSAGE_TYPE_WDHT_TRAIL_DESTROY 912
 
 /**
  * This message are used to route a query to a peer
  */
 #define GNUNET_MESSAGE_TYPE_WDHT_TRAIL_ROUTE 913
 
 /**
  * This message contains the query to transfer successor values.
  */
 #define GNUNET_MESSAGE_TYPE_WDHT_SUCCESSOR_FIND 914
 
 /**
  * Message which contains the get query
  */
 #define GNUNET_MESSAGE_TYPE_WDHT_GET 915
 
 /**
  * Message which contains the "put", a response to
  * #GNUNET_MESSAGE_TYPE_WDHT_SUCCESSOR_FIND.
  */
 #define GNUNET_MESSAGE_TYPE_WDHT_PUT 916
 
 /**
  * Message which contains the get result, a response
  * to #GNUNET_MESSAGE_TYPE_WDHT_GET.
  */
 #define GNUNET_MESSAGE_TYPE_WDHT_GET_RESULT 917
 
 
 /*******************************************************************************
  * RPS messages
  ******************************************************************************/
 
 /* P2P Messages */
 
 /**
  * RPS check liveliness message to check liveliness of other peer
  */
 #define GNUNET_MESSAGE_TYPE_RPS_PP_CHECK_LIVE 950
 
 /**
  * RPS PUSH message to push own ID to another peer
  */
 #define GNUNET_MESSAGE_TYPE_RPS_PP_PUSH 951
 
 /**
  * RPS PULL REQUEST message to request the local view of another peer
  */
 #define GNUNET_MESSAGE_TYPE_RPS_PP_PULL_REQUEST 952
 
 /**
  * RPS PULL REPLY message which contains the view of the other peer
  */
 #define GNUNET_MESSAGE_TYPE_RPS_PP_PULL_REPLY 953
 
 
 /* Client-Service Messages */
 
 
 /**
  * RPS CS SEED Message for the Client to seed peers into rps
  */
 #define GNUNET_MESSAGE_TYPE_RPS_CS_SEED 954
 
 #ifndef ENABLE_MALICIOUS
 #define ENABLE_MALICIOUS 0
 #endif
 
 #if ENABLE_MALICIOUS
 /**
  * Turn RPS service malicious
  */
 #define GNUNET_MESSAGE_TYPE_RPS_ACT_MALICIOUS 955
 
 #endif /* ENABLE_MALICIOUS */
 
 /**
  * RPS client-service message to start a sub sampler
  */
 #define GNUNET_MESSAGE_TYPE_RPS_CS_SUB_START 956
 
 /**
  * RPS client-service message to stop a sub sampler
  */
 #define GNUNET_MESSAGE_TYPE_RPS_CS_SUB_STOP 957
 
 /* Debugging API continues at 1130 */
 
 /******************************************************************************/
 
 
 /**************************************************
  *
  * IDENTITY PROVIDER MESSAGE TYPES
  */
 #define GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_STORE 961
 
 #define GNUNET_MESSAGE_TYPE_RECLAIM_SUCCESS_RESPONSE 962
 
 #define GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_ITERATION_START 963
 
 #define GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_ITERATION_STOP 964
 
 #define GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_ITERATION_NEXT 965
 
 #define GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_RESULT 966
 
 #define GNUNET_MESSAGE_TYPE_RECLAIM_ISSUE_TICKET 967
 
 #define GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_RESULT 968
 
 #define GNUNET_MESSAGE_TYPE_RECLAIM_REVOKE_TICKET 969
 
 #define GNUNET_MESSAGE_TYPE_RECLAIM_REVOKE_TICKET_RESULT 970
 
 #define GNUNET_MESSAGE_TYPE_RECLAIM_CONSUME_TICKET 971
 
 #define GNUNET_MESSAGE_TYPE_RECLAIM_CONSUME_TICKET_RESULT 972
 
 #define GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_ITERATION_START 973
 
 #define GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_ITERATION_STOP 974
 
 #define GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_ITERATION_NEXT 975
 
 #define GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_DELETE 976
 
 #define GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_STORE 977
 
 #define GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_DELETE 978
 
 #define GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_RESULT 979
 
 #define GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_ITERATION_START 980
 
 #define GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_ITERATION_STOP 981
 
 #define GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_ITERATION_NEXT 982
 
 
 /**************************************************
  *
  * ABD MESSAGE TYPES
  */
 #define GNUNET_MESSAGE_TYPE_ABD_VERIFY 991
 
 #define GNUNET_MESSAGE_TYPE_ABD_VERIFY_RESULT 992
 
 #define GNUNET_MESSAGE_TYPE_ABD_COLLECT 993
 
 #define GNUNET_MESSAGE_TYPE_ABD_COLLECT_RESULT 994
 
 #define GNUNET_MESSAGE_TYPE_ABD_INTERMEDIATE_RESULT 995
 
 /******************************************************************************/
 
 
 /******************************************************************************/
 /***********************************  CADET  **********************************/
 /******************************************************************************/
 /* CADET: message types 1000-1059
  * 1000-1009 Connection-level Messages
  * 1010-1019 Channel-level Messages
  * 1020-1029 Local Client-Service
  * 1030-1049 Local Service Monitoring
  * 1050-1059 Application Data
  */
 
 /********************************  Connection  ********************************/
 
 /**
  * Request the creation of a connection
  */
 #define GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE 1000
 
 /**
  * Send origin an ACK that the connection is complete
  */
 #define GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE_ACK 1001
 
 /**
  * Notify that a connection is no longer valid
  */
 #define GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN 1002
 
 /**
  * Request the destruction of a connection
  */
 #define GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY 1003
 
 /**
  * At some point, the route will spontaneously change TODO
  */
 #define GNUNET_MESSAGE_TYPE_CADET_CONNECTION_PATH_CHANGED_UNIMPLEMENTED 1004
 
 /**
  * Hop-by-hop, connection dependent ACK.
  *
  * @deprecated
  */
 #define GNUNET_MESSAGE_TYPE_CADET_CONNECTION_HOP_BY_HOP_ENCRYPTED_ACK 1005
 
 /**
  * We do not bother with ACKs for
  * #GNUNET_MESSAGE_TYPE_CADET_TUNNEL_ENCRYPTED messages, but we instead
  * poll for one if we got nothing for a while and start to be worried.
  *
  * @deprecated
  */
 #define GNUNET_MESSAGE_TYPE_CADET_TUNNEL_ENCRYPTED_POLL 1006
 
 /**
  * Axolotl key exchange.
  */
 #define GNUNET_MESSAGE_TYPE_CADET_TUNNEL_KX 1007
 
 /**
  * Axolotl encrypted data.
  */
 #define GNUNET_MESSAGE_TYPE_CADET_TUNNEL_ENCRYPTED 1008
 
 /**
  * Axolotl key exchange response with authentication.
  */
 #define GNUNET_MESSAGE_TYPE_CADET_TUNNEL_KX_AUTH 1009
 
 
 /**********************************  Channel  *********************************/
 
 /**
  * Payload data (inside an encrypted tunnel).
  */
 #define GNUNET_MESSAGE_TYPE_CADET_CHANNEL_APP_DATA 1010
 
 /**
  * Confirm payload data end-to-end.
  */
 #define GNUNET_MESSAGE_TYPE_CADET_CHANNEL_APP_DATA_ACK 1011
 
 /**
  * Announce connection is still alive (direction sensitive).
  */
 #define GNUNET_MESSAGE_TYPE_CADET_CHANNEL_KEEPALIVE 1012
 
 /**
  * Ask the cadet service to create a new channel.
  */
 #define GNUNET_MESSAGE_TYPE_CADET_CHANNEL_OPEN 1013
 
 /**
  * Ask the cadet service to destroy a channel.
  */
 #define GNUNET_MESSAGE_TYPE_CADET_CHANNEL_DESTROY 1014
 
 /**
  * Confirm the creation of a channel
  */
 #define GNUNET_MESSAGE_TYPE_CADET_CHANNEL_OPEN_ACK 1015
 
 /**
  * Reject the creation of a channel
  *
  * @deprecated
  */
 #define GNUNET_MESSAGE_TYPE_CADET_CHANNEL_OPEN_NACK_DEPRECATED 1016
 
 /***********************************  Local  **********************************/
 
 /**
  * Payload client <-> service
  */
 #define GNUNET_MESSAGE_TYPE_CADET_LOCAL_DATA 1020
 
 /**
  * Local ACK for data.
  */
 #define GNUNET_MESSAGE_TYPE_CADET_LOCAL_ACK 1021
 
 /**
  * Start listening on a port.
  */
 #define GNUNET_MESSAGE_TYPE_CADET_LOCAL_PORT_OPEN 1022
 
 /**
  * Stop listening on a port.
  */
 #define GNUNET_MESSAGE_TYPE_CADET_LOCAL_PORT_CLOSE 1023
 
 /**
  * Ask the cadet service to create a new channel.
  */
 #define GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_CREATE 1024
 
 /**
  * Tell client that a channel was destroyed.
  */
 #define GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_DESTROY 1025
 
 /**********************************  Monitor  *********************************/
 
 
 /**
  * Local information about all channels of service.
  */
 #define GNUNET_MESSAGE_TYPE_CADET_LOCAL_REQUEST_INFO_CHANNEL 1030
 
 /**
  * Local information of service about a specific channel.
  */
 #define GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_CHANNEL 1031
 
 /**
  * End of local information of service about channels.
  */
 #define GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_CHANNEL_END 1032
 
 /**
  * Request local information about all peers known to the service.
  */
 #define GNUNET_MESSAGE_TYPE_CADET_LOCAL_REQUEST_INFO_PEERS 1033
 
 /**
  * Local information about all peers known to the service.
  */
 #define GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PEERS 1034
 
 /**
  * End of local information about all peers known to the service.
  */
 #define GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PEERS_END 1035
 
 /**
  * Request local information of service about paths to specific peer.
  */
 #define GNUNET_MESSAGE_TYPE_CADET_LOCAL_REQUEST_INFO_PATH 1036
 
 /**
  * Local information of service about a specific path.
  */
 #define GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PATH 1037
 
 /**
  * End of local information of service about a specific path.
  */
 #define GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PATH_END 1038
 
 /**
  * Request local information about all tunnels of service.
  */
 #define GNUNET_MESSAGE_TYPE_CADET_LOCAL_REQUEST_INFO_TUNNELS 1039
 
 /**
  * Local information about all tunnels of service.
  */
 #define GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNELS 1040
 
 /**
  * End of local information about all tunnels of service.
  */
 #define GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNELS_END 1041
 
 /**
  * Request to drop a message of type X to peer y.
  */
 #define GNUNET_MESSAGE_TYPE_CADET_DROP_CADET_MESSAGE 1042
 
 
 /********************************  Application  *******************************/
 
 /**
  * Traffic (net-cat style) used by the Command Line Interface.
  */
 #define GNUNET_MESSAGE_TYPE_CADET_CLI 1059
 
 /******************************************************************************/
 
 
 /******************************************************************************/
 /*************************************  NAT  **********************************/
 /******************************************************************************/
 
 /**
  * Message to ask NAT service to register a client.
  */
 #define GNUNET_MESSAGE_TYPE_NAT_REGISTER 1060
 
 /**
  * Message to ask NAT service to handle a STUN packet.
  */
 #define GNUNET_MESSAGE_TYPE_NAT_HANDLE_STUN 1061
 
 /**
  * Message to ask NAT service to request connection reversal.
  */
 #define GNUNET_MESSAGE_TYPE_NAT_REQUEST_CONNECTION_REVERSAL 1062
 
 /**
  * Message to from NAT service notifying us that connection reversal
  * was requested by another peer.
  */
 #define GNUNET_MESSAGE_TYPE_NAT_CONNECTION_REVERSAL_REQUESTED 1063
 
 /**
  * Message to from NAT service notifying us that one of our
  * addresses changed.
  */
 #define GNUNET_MESSAGE_TYPE_NAT_ADDRESS_CHANGE 1064
 
 /**
  * Message to ask NAT service to notify all clients about a new global address.
  */
 #define GNUNET_MESSAGE_TYPE_NAT_ADD_GLOBAL_ADDRESS 1065
 
 /**
  * Message to ask NAT service to request autoconfiguration.
  */
 #define GNUNET_MESSAGE_TYPE_NAT_AUTO_REQUEST_CFG 1067
 
 /**
  * Message from NAT service with the autoconfiguration result.
  */
 #define GNUNET_MESSAGE_TYPE_NAT_AUTO_CFG_RESULT 1068
 
 
 /* 1080-1109 reserved for TMCG (Heiko Stamer, see gnunet-developers, January
  * 2017) */
 
 
 /******************************************************************************/
 /***********************************  AUCTION  ********************************/
 /******************************************************************************/
 
 /**
  * Client wants to create a new auction.
  */
 #define GNUNET_MESSAGE_TYPE_AUCTION_CLIENT_CREATE 1110
 
 /**
  * Client wants to join an existing auction.
  */
 #define GNUNET_MESSAGE_TYPE_AUCTION_CLIENT_JOIN 1111
 
 /**
  * Service reports the auction outcome to the client.
  */
 #define GNUNET_MESSAGE_TYPE_AUCTION_CLIENT_OUTCOME 1112
 
 
 /******************************************************************************/
 /*********************************  RPS DEBUG  ********************************/
 /******************************************************************************/
 
 /**
  * @brief Request updates of the view
  */
 #define GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_VIEW_REQUEST 1130
 
 /**
  * @brief Send update of the view
  */
 #define GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_VIEW_REPLY 1131
 
 /**
  * @brief Cancel getting updates of the view
  */
 #define GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_VIEW_CANCEL 1132
 
 
 /**
  * @brief Request biased input stream
  */
 #define GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_STREAM_REQUEST 1133
 
 /**
  * @brief Send peer of biased stream
  */
 #define GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_STREAM_REPLY 1134
 
 /**
  * @brief Cancel getting biased stream
  */
 #define GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_STREAM_CANCEL 1135
 
 
 /*******************************************************
    NEW (TNG) Transport service
  ******************************************************* */
 
 /**
  * @brief inform transport to add an address of this peer
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_ADD_ADDRESS 1200
 
 /**
  * @brief inform transport to delete an address of this peer
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_DEL_ADDRESS 1201
 
 /**
  * @brief inform transport about an incoming message
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_INCOMING_MSG 1202
 
 /**
  * @brief transport acknowledges processing an incoming message
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_INCOMING_MSG_ACK 1203
 
 /**
  * @brief inform transport that a queue was setup to talk to some peer
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_SETUP 1204
 
 /**
  * @brief inform transport that a queue was torn down
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_TEARDOWN 1205
 
 /**
  * @brief transport tells communicator it wants a queue
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_CREATE 1206
 
 /**
  * Response from communicator: will try to create queue.
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_CREATE_OK 1207
 
 /**
  * Response from communicator: address bogus, will not try to create queue.
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_CREATE_FAIL 1208
 
 /**
  * @brief transport tells communicator it wants to transmit
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_MSG 1209
 
 /**
  * @brief communicator tells transports that message was sent
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_MSG_ACK 1210
 
 /**
  * Message sent to indicate to the transport which address
  * prefix is supported by a communicator.
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_NEW_COMMUNICATOR 1211
 
 /**
  * Tell transport that it should assist with exchanging a
  * message between communicators.  Usually used when
  * communciators are uni-directional and need an alternative
  * back-channel.
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_COMMUNICATOR_BACKCHANNEL 1212
 
 /**
  * Message type used between transport services when they
  * internally forward communicator backchannel messages.
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_BACKCHANNEL_ENCAPSULATION 1213
 
 /**
  * Type of a fragment of a CORE message created by transport to adjust
  * message length to a queue's MTU.
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_FRAGMENT 1214
 
 /**
  * Wrapper around non-fragmented CORE message used to measure RTT
  * and ensure reliability.
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_RELIABILITY_BOX 1216
 
 /**
  * Confirmation for a #GNUNET_MESSAGE_TYPE_TRANSPORT_RELIABILITY_BOX.
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_RELIABILITY_ACK 1217
 
 /**
  * Message sent for topology discovery at transport level.
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_DV_LEARN 1218
 
 /**
  * Source-routed transport message based DV information gathered.
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_DV_BOX 1219
 
 /**
  * Transport signalling incoming backchannel message to a communicator.
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_COMMUNICATOR_BACKCHANNEL_INCOMING 1220
 
 /**
  * Transport signalling incoming backchannel message to a communicator.
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_FLOW_CONTROL 1221
 
 /**
  * @brief inform transport that a queue was updated
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_UPDATE 1222
 
 /**
  * Message sent to indicate to the transport that a monitor
  * wants to observe certain events.
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_START 1250
 
 /**
  * Message sent to indicate to a monitor about events.
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_DATA 1251
 
 /**
  * Message sent to indicate to a monitor that a one-shot
  * iteration over events is done.
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_END 1252
 
 /**
  * Burst message we send to another peer for hole punching.
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_START_BURST 1253
 
 /**
  * Burst message we send to another peer for hole punching.
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_BURST_FINISHED 1254
 
 /**
  * Message exchanged between communicators to confirm
  * successful KX (and address validation).
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_COMMUNICATOR_KX_CONFIRMATION 1275
 
 /**
  * Message exchanged between communicators to exchange
  * flow control (FC) limits and acknowledgemets.
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_COMMUNICATOR_FC_LIMITS 1276
 
 /**
  * Type of the 'struct ExpressPreferenceMessage' send by clients to TRANSPORT
  * to establish bandwidth preference.
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_SUGGEST 1300
 
 /**
  * Type of the 'struct ExpressPreferenceMessage' send by clients to TRANSPORT
  * to abandon bandwidth preference.
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_SUGGEST_CANCEL 1301
 
 /**
  * Type of the 'struct RequestHelloValidationMessage' send by clients to
  * TRANSPORT to trigger validation of addresses.
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_REQUEST_HELLO_VALIDATION 1302
 
 
 /**
  * P2P message: transport requests confirmation that an address works.
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_VALIDATION_CHALLENGE 1303
 
 /**
  * P2P message: transport proves that an address worked.
  */
 #define GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_VALIDATION_RESPONSE 1304
 
 
 /* ************** NEW (NG) ATS Messages ************* */
 /* NOTE: it is not clear ATS will survive in TNG      */
 
 /**
  * Type of the 'struct ExpressPreferenceMessage' send by clients to ATS
  * to establish bandwidth preference.
  */
 #define GNUNET_MESSAGE_TYPE_ATS_SUGGEST 1400
 
 /**
  * Type of the 'struct ExpressPreferenceMessage' send by clients to ATS
  * to abandon bandwidth preference.
  */
 #define GNUNET_MESSAGE_TYPE_ATS_SUGGEST_CANCEL 1401
 
 
 /**
  * Type of the 'struct SessionAddMessage' send by transport clients to ATS
  * to ask ATS to allocate resources to a session.
  */
 #define GNUNET_MESSAGE_TYPE_ATS_SESSION_ADD 1402
 
 /**
  * Type of the 'struct SessionAddMessage' send by transport clients to ATS
  * to inform ATS about a session where resources are consumed but allocation
  * is impossible (unidirectional).
  */
 #define GNUNET_MESSAGE_TYPE_ATS_SESSION_ADD_INBOUND_ONLY 1403
 
 /**
  * Type of the 'struct SessionUpdateMessage' send by transport clients to ATS
  * to inform ATS about property changes of a session.
  */
 #define GNUNET_MESSAGE_TYPE_ATS_SESSION_UPDATE 1404
 
 /**
  * Type of the 'struct SessionDelMessage' send by transport clients to ATS
  * to tell ATS that a session is no longer available.
  */
 #define GNUNET_MESSAGE_TYPE_ATS_SESSION_DEL 1405
 
 /**
  * Type of the 'struct SessionAllocationMessage' send by ATS to the
  * transport to tell it about resources to allocate to the session.
  */
 #define GNUNET_MESSAGE_TYPE_ATS_SESSION_ALLOCATION 1406
 
 
 /**
  * TCP communicator rekey message.
  */
 #define GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_REKEY 1450
 
 /**
  * TCP communicator payload box
  */
 #define GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_BOX 1451
 
 /**
  * TCP communicator end of stream.
  */
 #define GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_FINISH 1452
 
 /**
  * TCP communicator confirmation ack.
  */
 #define GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_CONFIRMATION_ACK 1453
 
 /**
  * UDP KX acknowledgement.
  */
 #define GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_ACK 1460
 
 /**
  * UDP communicator padding.
  */
 #define GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_PAD 1461
 
 /**
  * UDP Rekey.
  */
 #define GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_REKEY 1462
 
 /**
  * Next available: 1500
  */
 #define GNUNET_MESSAGE_TYPE_RECLAIM_REFERENCE_DELETE 1500
 
 #define GNUNET_MESSAGE_TYPE_RECLAIM_REFERENCE_RESULT 1501
 
 
 /*********************************************************************************/
 /**********************************  MESSENGER  **********************************/
 /*********************************************************************************/
 /* MESSENGER: message types 1600-1629
  * 1600-1609 Connection-level Messages
  * 1610-1619 Room-level Messages
  */
 
 /*********************************  Connection  **********************************/
 
 #define GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_CREATE 1600
 
 #define GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_DESTROY 1601
 
 #define GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_MEMBER_ID 1602
 
 /************************************  Room  *************************************/
 
 #define GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_OPEN 1610
 
 #define GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_ENTRY 1611
 
 #define GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_CLOSE 1612
 
 #define GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_SEND_MESSAGE 1614
 
 #define GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_RECV_MESSAGE 1615
 
 #define GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_GET_MESSAGE 1616
 
 #define GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_SYNC 1617
 
 #define GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_LINK 1618
 
 /*********************************************************************************/
 
 /*********************************************************************************/
 /**********************************  Cmd Testing  **********************************/
 /*********************************************************************************/
 
 /**
  * The initialization message towards gnunet-cmds-helper
  */
 #define GNUNET_MESSAGE_TYPE_CMDS_HELPER_INIT 1700
 
 /**
  * The reply message from gnunet-cmds-helper
  */
 #define GNUNET_MESSAGE_TYPE_CMDS_HELPER_REPLY 1701
 
 #define GNUNET_MESSAGE_TYPE_CMDS_HELPER_PEER_STARTED 1702
 
 #define GNUNET_MESSAGE_TYPE_CMDS_HELPER_ALL_PEERS_STARTED 1703
 
 #define GNUNET_MESSAGE_TYPE_CMDS_HELPER_LOCAL_TEST_PREPARED 1704
 
 #define GNUNET_MESSAGE_TYPE_CMDS_HELPER_ALL_LOCAL_TESTS_PREPARED 1705
 
 #define GNUNET_MESSAGE_TYPE_CMDS_HELPER_LOCAL_FINISHED 1706
 
 #define GNUNET_MESSAGE_TYPE_CMDS_HELPER_BARRIER_REACHED 1707
 
 #define GNUNET_MESSAGE_TYPE_CMDS_HELPER_BARRIER_ATTACH 1708
 
 #define GNUNET_MESSAGE_TYPE_CMDS_HELPER_BARRIER_CROSSABLE 1709
 
 #define GNUNET_MESSAGE_TYPE_CMDS_HELPER_BARRIER_ATTACHED 1710
 
 /*********************************************************************************/
 
 /*********************************************************************************/
 /**********************************  NAMESTORE (cont.)  **************************/
 /*********************************************************************************/
 /* NAMESTORE: message types 1750-1800
  */
 
 /**
  * Message type for start of record edit with advisory lock
  */
 #define GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_SET_EDIT 1750
 
 /**
  * Return record set to edit with previous editor hint/advisory lock
  */
 #define GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_SET_EDIT_RESPONSE 1751
 
 /**
  * Message type for cancellation/reset of editor hint/advisory lock
  */
 #define GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_SET_EDIT_CANCEL 1752
 
 /*********************************************************************************/
 
 /*********************************************************************************/
 /**********************************  UTIL (cont.)  **************************/
 /*********************************************************************************/
 /* NAMESTORE: message types 1801-1810
  */
 
 /**
  * Message exchanged between peers for burst synchronisation.
  */
 #define GNUNET_TYPE_BURST_SYNC 1801
 
 
 /**
  * Type used to match 'all' message types.
  */
 #define GNUNET_MESSAGE_TYPE_ALL 65535
 
 
 #if 0 /* keep Emacsens' auto-indent happy */
 {
 #endif
 #ifdef __cplusplus
 }
 #endif
 
 /* ifndef GNUNET_PROTOCOLS_H */
 #endif
 
 /** @} */ /* end of group protocols */
 
 /** @} */ /* end of group addition */
 
 /* end of gnunet_protocols.h */