X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Ftransport%2Fgnunet-service-transport_clients.c;h=7ce455f7d3174af5732f7d148273c0c80036b803;hb=6d754e6c89fda8cb0da00c4152ffc6dcc707e6ce;hp=a3254998d7c7243f1eba4073cea1d15b60943edd;hpb=71100696bec461d248b481e280a9ee64f9c8f6e4;p=oweals%2Fgnunet.git diff --git a/src/transport/gnunet-service-transport_clients.c b/src/transport/gnunet-service-transport_clients.c index a3254998d..7ce455f7d 100644 --- a/src/transport/gnunet-service-transport_clients.c +++ b/src/transport/gnunet-service-transport_clients.c @@ -108,6 +108,11 @@ struct TransportClient * Length of the list of messages pending for this client. */ unsigned int message_count; + + /** + * Is this client interested in payload messages? + */ + int send_payload; }; @@ -158,7 +163,9 @@ setup_client (struct GNUNET_SERVER_Client *client) tc = GNUNET_malloc (sizeof (struct TransportClient)); tc->client = client; - GNUNET_CONTAINER_DLL_insert (clients_head, clients_tail, tc); +#if DEBUG_TRANSPORT + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Client %X connected\n", tc); +#endif return tc; } @@ -228,7 +235,7 @@ transmit_to_client_callback (void *cls, size_t size, void *buf) /** * Queue the given message for transmission to the given client * - * @param client target of the message + * @param tc target of the message * @param msg message to transmit * @param may_drop GNUNET_YES if the message can be dropped */ @@ -317,30 +324,32 @@ client_disconnect_notification (void *cls, struct GNUNET_SERVER_Client *client) * @param peer identity of the neighbour * @param ats performance data * @param ats_count number of entries in ats (excluding 0-termination) + * @param address the address */ static void notify_client_about_neighbour (void *cls, const struct GNUNET_PeerIdentity *peer, - const struct GNUNET_TRANSPORT_ATS_Information - *ats, uint32_t ats_count) + const struct GNUNET_ATS_Information *ats, + uint32_t ats_count, + const struct GNUNET_HELLO_Address *address) { struct TransportClient *tc = cls; struct ConnectInfoMessage *cim; - size_t size; - - size = + struct GNUNET_ATS_Information *ap; + size_t size = sizeof (struct ConnectInfoMessage) + - ats_count * sizeof (struct GNUNET_TRANSPORT_ATS_Information); + ats_count * sizeof (struct GNUNET_ATS_Information); + char buf[size]; + GNUNET_assert (size < GNUNET_SERVER_MAX_MESSAGE_SIZE); - cim = GNUNET_malloc (size); + cim = (struct ConnectInfoMessage *) buf; cim->header.size = htons (size); cim->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT); cim->ats_count = htonl (ats_count); cim->id = *peer; - memcpy (&cim->ats, ats, - ats_count * sizeof (struct GNUNET_TRANSPORT_ATS_Information)); + ap = (struct GNUNET_ATS_Information *) &cim[1]; + memcpy (ap, ats, ats_count * sizeof (struct GNUNET_ATS_Information)); unicast (tc, &cim->header, GNUNET_NO); - GNUNET_free (cim); } @@ -359,6 +368,7 @@ clients_handle_start (void *cls, struct GNUNET_SERVER_Client *client, { const struct StartMessage *start; struct TransportClient *tc; + uint32_t options; tc = lookup_client (client); @@ -383,7 +393,8 @@ clients_handle_start (void *cls, struct GNUNET_SERVER_Client *client, return; } start = (const struct StartMessage *) message; - if ((GNUNET_NO != ntohl (start->do_check)) && + options = ntohl (start->options); + if ((0 != (1 & options)) && (0 != memcmp (&start->self, &GST_my_identity, sizeof (struct GNUNET_PeerIdentity)))) @@ -397,9 +408,10 @@ clients_handle_start (void *cls, struct GNUNET_SERVER_Client *client, return; } tc = setup_client (client); - + tc->send_payload = (0 != (2 & options)); unicast (tc, GST_hello_get (), GNUNET_NO); GST_neighbours_iterate (¬ify_client_about_neighbour, tc); + GNUNET_CONTAINER_DLL_insert (clients_head, clients_tail, tc); GNUNET_SERVER_receive_done (client, GNUNET_OK); } @@ -482,12 +494,12 @@ clients_handle_send (void *cls, struct GNUNET_SERVER_Client *client, tc = lookup_client (client); if (NULL == tc) - { - /* client asked for transmission before 'START' */ - GNUNET_break (0); - GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); - return; - } + { + /* client asked for transmission before 'START' */ + GNUNET_break (0); + GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); + return; + } size = ntohs (message->size); if (size < @@ -533,7 +545,7 @@ clients_handle_send (void *cls, struct GNUNET_SERVER_Client *client, GNUNET_SERVER_receive_done (client, GNUNET_OK); stcc = GNUNET_malloc (sizeof (struct SendTransmitContinuationContext)); stcc->target = obm->peer; - stcc->client = client; // !!!! + stcc->client = client; GNUNET_SERVER_client_keep (client); GST_neighbours_send (&obm->peer, obmm, msize, GNUNET_TIME_relative_ntoh (obm->timeout), @@ -589,55 +601,27 @@ clients_handle_request_connect (void *cls, struct GNUNET_SERVER_Client *client, } -/** - * Client asked for a quota change for a particular peer. Process the request. - * - * @param cls unused - * @param client the client - * @param message the quota changing message - */ -static void -clients_handle_set_quota (void *cls, struct GNUNET_SERVER_Client *client, - const struct GNUNET_MessageHeader *message) -{ - const struct QuotaSetMessage *qsm; - - qsm = (const struct QuotaSetMessage *) message; - GNUNET_STATISTICS_update (GST_stats, - gettext_noop ("# SET QUOTA messages received"), 1, - GNUNET_NO); -#if DEBUG_TRANSPORT - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Received `%s' request (new quota %u) from client for peer `%4s'\n", - "SET_QUOTA", (unsigned int) ntohl (qsm->quota.value__), - GNUNET_i2s (&qsm->peer)); -#endif - GST_neighbours_set_incoming_quota (&qsm->peer, qsm->quota); - GNUNET_SERVER_receive_done (client, GNUNET_OK); -} - - /** * Take the given address and append it to the set of results sent back to * the client. * * @param cls the transmission context used ('struct GNUNET_SERVER_TransmitContext*') - * @param address the resolved name, NULL to indicate the last response + * @param buf text to transmit */ static void -transmit_address_to_client (void *cls, const char *address) +transmit_address_to_client (void *cls, const char *buf) { struct GNUNET_SERVER_TransmitContext *tc = cls; - if (NULL == address) + if (NULL == buf) { GNUNET_SERVER_transmit_context_append_data (tc, NULL, 0, - GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_REPLY); + GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_TO_STRING_REPLY); GNUNET_SERVER_transmit_context_run (tc, GNUNET_TIME_UNIT_FOREVER_REL); return; } - GNUNET_SERVER_transmit_context_append_data (tc, address, strlen (address) + 1, - GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_REPLY); + GNUNET_SERVER_transmit_context_append_data (tc, buf, strlen (buf) + 1, + GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_TO_STRING_REPLY); } @@ -649,8 +633,9 @@ transmit_address_to_client (void *cls, const char *address) * @param message the resolution request */ static void -clients_handle_address_lookup (void *cls, struct GNUNET_SERVER_Client *client, - const struct GNUNET_MessageHeader *message) +clients_handle_address_to_string (void *cls, + struct GNUNET_SERVER_Client *client, + const struct GNUNET_MessageHeader *message) { const struct AddressLookupMessage *alum; struct GNUNET_TRANSPORT_PluginFunctions *papi; @@ -670,7 +655,7 @@ clients_handle_address_lookup (void *cls, struct GNUNET_SERVER_Client *client, return; } alum = (const struct AddressLookupMessage *) message; - address_len = ntohl (alum->addrlen); + address_len = ntohs (alum->addrlen); if (size <= sizeof (struct AddressLookupMessage) + address_len) { GNUNET_break (0); @@ -687,13 +672,13 @@ clients_handle_address_lookup (void *cls, struct GNUNET_SERVER_Client *client, return; } rtimeout = GNUNET_TIME_relative_ntoh (alum->timeout); - numeric = ntohl (alum->numeric_only); + numeric = ntohs (alum->numeric_only); tc = GNUNET_SERVER_transmit_context_create (client); papi = GST_plugins_find (plugin_name); if (NULL == papi) { GNUNET_SERVER_transmit_context_append_data (tc, NULL, 0, - GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_REPLY); + GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_TO_STRING_REPLY); GNUNET_SERVER_transmit_context_run (tc, rtimeout); return; } @@ -704,101 +689,57 @@ clients_handle_address_lookup (void *cls, struct GNUNET_SERVER_Client *client, } -/** - * Send an address to the client. - * - * @param cls our 'struct GNUNET_SERVER_TransmitContext' (for sending) - * @param public_key public key for the peer, never NULL - * @param target peer this change is about, never NULL - * @param valid_until until what time do we consider the address valid? - * @param validation_block is FOREVER if the address is for an unsupported plugin (from PEERINFO) - * is ZERO if the address is considered valid (no validation needed) - * is a time in the future if we're currently denying re-validation - * @param plugin_name name of the plugin - * @param plugin_address binary address - * @param plugin_address_len length of address - */ -static void -send_address_to_client (void *cls, - const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded - *public_key, const struct GNUNET_PeerIdentity *target, - struct GNUNET_TIME_Absolute valid_until, - struct GNUNET_TIME_Absolute validation_block, - const char *plugin_name, const void *plugin_address, - size_t plugin_address_len) -{ - struct GNUNET_SERVER_TransmitContext *tc = cls; - char *addr_buf; - - /* FIXME: move to a binary format!!! */ - GNUNET_asprintf (&addr_buf, "%s --- %s, %s", - GST_plugins_a2s (plugin_name, plugin_address, - plugin_address_len), - (GNUNET_YES == - GST_neighbours_test_connected (target)) ? "CONNECTED" : - "DISCONNECTED", - (GNUNET_TIME_absolute_get_remaining (valid_until).rel_value > - 0) ? "VALIDATED" : "UNVALIDATED"); - transmit_address_to_client (tc, addr_buf); - GNUNET_free (addr_buf); -} - - -/** - * Client asked to obtain information about a peer's addresses. - * Process the request. - * FIXME: use better name! - * - * @param cls unused - * @param client the client - * @param message the peer address information request - */ -static void -clients_handle_peer_address_lookup (void *cls, - struct GNUNET_SERVER_Client *client, - const struct GNUNET_MessageHeader *message) -{ - const struct PeerAddressLookupMessage *peer_address_lookup; - struct GNUNET_SERVER_TransmitContext *tc; - - peer_address_lookup = (const struct PeerAddressLookupMessage *) message; - GNUNET_break (ntohl (peer_address_lookup->reserved) == 0); - tc = GNUNET_SERVER_transmit_context_create (client); - GST_validation_get_addresses (&peer_address_lookup->peer, - &send_address_to_client, tc); - GNUNET_SERVER_transmit_context_append_data (tc, NULL, 0, - GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_REPLY); - GNUNET_SERVER_transmit_context_run (tc, GNUNET_TIME_UNIT_FOREVER_REL); -} - - /** * Output the active address of connected neighbours to the given client. * * @param cls the 'struct GNUNET_SERVER_TransmitContext' for transmission to the client - * @param neighbour identity of the neighbour + * @param peer identity of the neighbour * @param ats performance data * @param ats_count number of entries in ats (excluding 0-termination) + * @param address the address */ static void -output_addresses (void *cls, const struct GNUNET_PeerIdentity *neighbour, - const struct GNUNET_TRANSPORT_ATS_Information *ats, - uint32_t ats_count) +output_address (void *cls, const struct GNUNET_PeerIdentity *peer, + const struct GNUNET_ATS_Information *ats, uint32_t ats_count, + const struct GNUNET_HELLO_Address *address) { struct GNUNET_SERVER_TransmitContext *tc = cls; - char *addr_buf; + struct AddressIterateResponseMessage *msg; + size_t size; + size_t tlen; + size_t alen; + char *addr; - /* FIXME: move to a binary format!!! */ - GNUNET_asprintf (&addr_buf, "%s: %s", GNUNET_i2s (neighbour), - GST_plugins_a2s ("FIXME", NULL, 0)); - transmit_address_to_client (tc, addr_buf); - GNUNET_free (addr_buf); + tlen = strlen (address->transport_name) + 1; + alen = address->address_length; + size = (sizeof (struct AddressIterateResponseMessage) + alen + tlen); + { + char buf[size]; + + msg = (struct AddressIterateResponseMessage *) buf; + msg->reserved = htonl (0); + msg->peer = *peer; + msg->addrlen = htonl (alen); + msg->pluginlen = htonl (tlen); + addr = (char *) &msg[1]; + memcpy (addr, address->address, alen); + memcpy (&addr[alen], address->transport_name, tlen); + GNUNET_SERVER_transmit_context_append_data (tc, + &buf[sizeof + (struct + GNUNET_MessageHeader)], + size - + sizeof (struct + GNUNET_MessageHeader), + GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_ITERATE_RESPONSE); + } } /** - * Client asked to obtain information about all actively used addresses. - * Process the request. FIXME: use better name! + * Client asked to obtain information about all actively used addresses + * of connected peers + * Process the request. * * @param cls unused * @param client the client @@ -808,13 +749,47 @@ static void clients_handle_address_iterate (void *cls, struct GNUNET_SERVER_Client *client, const struct GNUNET_MessageHeader *message) { + static struct GNUNET_PeerIdentity all_zeros; struct GNUNET_SERVER_TransmitContext *tc; + struct AddressIterateMessage *msg; + struct GNUNET_HELLO_Address *address; + if (ntohs (message->type) != GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_ITERATE) + { + GNUNET_break (0); + GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); + return; + } + if (ntohs (message->size) != sizeof (struct AddressIterateMessage)) + { + GNUNET_break (0); + GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); + return; + } + msg = (struct AddressIterateMessage *) message; + if (GNUNET_YES != ntohl (msg->one_shot)) + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "Address monitoring not implemented\n"); + GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); + return; + } GNUNET_SERVER_disable_receive_done_warning (client); tc = GNUNET_SERVER_transmit_context_create (client); - GST_neighbours_iterate (&output_addresses, tc); + if (0 == memcmp (&msg->peer, &all_zeros, sizeof (struct GNUNET_PeerIdentity))) + { + /* iterate over all neighbours */ + GST_neighbours_iterate (&output_address, tc); + } + else + { + /* just return one neighbour */ + address = GST_neighbour_get_current_address (&msg->peer); + if (address != NULL) + output_address (tc, &msg->peer, NULL, 0, address); + } GNUNET_SERVER_transmit_context_append_data (tc, NULL, 0, - GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_REPLY); + GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_ITERATE_RESPONSE); GNUNET_SERVER_transmit_context_run (tc, GNUNET_TIME_UNIT_FOREVER_REL); } @@ -837,16 +812,11 @@ GST_clients_start (struct GNUNET_SERVER_Handle *server) {&clients_handle_request_connect, NULL, GNUNET_MESSAGE_TYPE_TRANSPORT_REQUEST_CONNECT, sizeof (struct TransportRequestConnectMessage)}, - {&clients_handle_set_quota, NULL, - GNUNET_MESSAGE_TYPE_TRANSPORT_SET_QUOTA, sizeof (struct QuotaSetMessage)}, - {&clients_handle_address_lookup, NULL, - GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_LOOKUP, 0}, - {&clients_handle_peer_address_lookup, NULL, - GNUNET_MESSAGE_TYPE_TRANSPORT_PEER_ADDRESS_LOOKUP, - sizeof (struct PeerAddressLookupMessage)}, + {&clients_handle_address_to_string, NULL, + GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_TO_STRING, 0}, {&clients_handle_address_iterate, NULL, GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_ITERATE, - sizeof (struct GNUNET_MessageHeader)}, + sizeof (struct AddressIterateMessage)}, {&GST_blacklist_handle_init, NULL, GNUNET_MESSAGE_TYPE_TRANSPORT_BLACKLIST_INIT, sizeof (struct GNUNET_MessageHeader)}, @@ -875,7 +845,7 @@ GST_clients_stop () * Broadcast the given message to all of our clients. * * @param msg message to broadcast - * @param may_drop GNUNET_YES if the message can be dropped + * @param may_drop GNUNET_YES if the message can be dropped / is payload */ void GST_clients_broadcast (const struct GNUNET_MessageHeader *msg, int may_drop) @@ -883,7 +853,11 @@ GST_clients_broadcast (const struct GNUNET_MessageHeader *msg, int may_drop) struct TransportClient *tc; for (tc = clients_head; tc != NULL; tc = tc->next) + { + if ((GNUNET_YES == may_drop) && (GNUNET_YES != tc->send_payload)) + continue; /* skip, this client does not care about payload */ unicast (tc, msg, may_drop); + } } @@ -902,10 +876,7 @@ GST_clients_unicast (struct GNUNET_SERVER_Client *client, tc = lookup_client (client); if (NULL == tc) - { - GNUNET_break (0); - return; - } + return; /* client got disconnected in the meantime, drop message */ unicast (tc, msg, may_drop); }