/**
* Context for the address lookup.
*/
-struct GNUNET_TRANSPORT_PeerAddressLookupContext
+struct GNUNET_TRANSPORT_PeerIterateContext
{
/**
- * Function to call with the human-readable address.
+ * Function to call with the binary address.
*/
- GNUNET_TRANSPORT_AddressLookUpCallback cb;
+ GNUNET_TRANSPORT_PeerIterateCallback cb;
/**
* Closure for cb.
struct GNUNET_TIME_Absolute timeout;
};
+
/**
* Function called with responses from the service.
*
peer_address_response_processor (void *cls,
const struct GNUNET_MessageHeader *msg)
{
- struct GNUNET_TRANSPORT_PeerAddressLookupContext *pal_ctx = cls;
- struct AddressIterateResponseMessage *air_msg = (struct AddressIterateResponseMessage *) &msg[1];
- const struct GNUNET_HELLO_Address *address;
+ struct GNUNET_TRANSPORT_PeerIterateContext *pal_ctx = cls;
+ struct AddressIterateResponseMessage *air_msg;
+ struct GNUNET_HELLO_Address *address;
+ const char *addr;
+ const char *transport_name;
uint16_t size;
- if (air_msg == NULL)
+ size_t alen;
+ size_t tlen;
+
+ if (msg == NULL)
{
- pal_ctx->cb (pal_ctx->cb_cls, NULL);
- GNUNET_CLIENT_disconnect (pal_ctx->client, GNUNET_NO);
- GNUNET_free (pal_ctx);
+ pal_ctx->cb (pal_ctx->cb_cls, NULL, NULL);
+ GNUNET_TRANSPORT_peer_get_active_addresses_cancel (pal_ctx);
return;
}
size = ntohs (msg->size);
- GNUNET_break (ntohs (msg->type) == GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_ITERATE_RESPONSE);
+ GNUNET_break (ntohs (msg->type) ==
+ GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_ITERATE_RESPONSE);
if (size == sizeof (struct GNUNET_MessageHeader))
{
/* done! */
- pal_ctx->cb (pal_ctx->cb_cls, NULL );
- GNUNET_CLIENT_disconnect (pal_ctx->client, GNUNET_NO);
- GNUNET_free (pal_ctx);
+ pal_ctx->cb (pal_ctx->cb_cls, NULL, NULL);
+ GNUNET_TRANSPORT_peer_get_active_addresses_cancel (pal_ctx);
return;
}
- size_t tlen = ntohl(air_msg->pluginlen);
- size_t alen = ntohl(air_msg->addrlen);
-
- if (size != sizeof (struct GNUNET_MessageHeader) + sizeof (struct AddressIterateResponseMessage) + tlen + alen)
+ if ((size <
+ sizeof (struct GNUNET_MessageHeader) +
+ sizeof (struct AddressIterateResponseMessage)) ||
+ (ntohs (msg->type) !=
+ GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_ITERATE_RESPONSE))
{
- GNUNET_break_op (0);
- pal_ctx->cb (pal_ctx->cb_cls, NULL );
- GNUNET_CLIENT_disconnect (pal_ctx->client, GNUNET_NO);
- GNUNET_free (pal_ctx);
+ GNUNET_break (0);
+ pal_ctx->cb (pal_ctx->cb_cls, NULL, NULL);
+ GNUNET_TRANSPORT_peer_get_active_addresses_cancel (pal_ctx);
return;
}
- char * addr = (char *) &air_msg[1];
- char * transport_name = &addr[alen];
+ air_msg = (struct AddressIterateResponseMessage *) msg;
+ tlen = ntohl (air_msg->pluginlen);
+ alen = ntohl (air_msg->addrlen);
- if (transport_name[tlen] != '\0')
+ if (size != sizeof (struct AddressIterateResponseMessage) + tlen + alen)
{
- GNUNET_break_op (0);
- pal_ctx->cb (pal_ctx->cb_cls, NULL );
- GNUNET_CLIENT_disconnect (pal_ctx->client, GNUNET_NO);
- GNUNET_free (pal_ctx);
+ GNUNET_break (0);
+ pal_ctx->cb (pal_ctx->cb_cls, NULL, NULL);
+ GNUNET_TRANSPORT_peer_get_active_addresses_cancel (pal_ctx);
return;
}
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "peer %s transport_name: %s\n",GNUNET_i2s(&air_msg->peer), transport_name);
+ addr = (const char *) &air_msg[1];
+ transport_name = &addr[alen];
- address = GNUNET_HELLO_address_allocate(&air_msg->peer, transport_name, addr, alen);
+ if (transport_name[tlen - 1] != '\0')
+ {
+ GNUNET_break_op (0);
+ pal_ctx->cb (pal_ctx->cb_cls, NULL, NULL);
+ GNUNET_TRANSPORT_peer_get_active_addresses_cancel (pal_ctx);
+ return;
+ }
/* expect more replies */
- GNUNET_CLIENT_receive (pal_ctx->client, &peer_address_response_processor, pal_ctx,
+ GNUNET_CLIENT_receive (pal_ctx->client, &peer_address_response_processor,
+ pal_ctx,
GNUNET_TIME_absolute_get_remaining (pal_ctx->timeout));
- pal_ctx->cb (pal_ctx->cb_cls, address);
+ /* notify client */
+ address =
+ GNUNET_HELLO_address_allocate (&air_msg->peer, transport_name, addr,
+ alen);
+ pal_ctx->cb (pal_ctx->cb_cls, &air_msg->peer, address);
+ GNUNET_HELLO_address_free (address);
}
/**
- * Return all the known addresses for a peer.
+ * Return all the known addresses for a specific peer or all peers.
+ * Returns continously all address if one_shot is set to GNUNET_NO
+ *
+ * CHANGE: Returns the address(es) that we are currently using for this
+ * peer. Upon completion, the 'AddressLookUpCallback' is called one more
+ * time with 'NULL' for the address and the peer. After this, the operation must no
+ * longer be explicitly cancelled.
*
* @param cfg configuration to use
- * @param peer peer identity to look up the addresses of
+ * @param peer peer identity to look up the addresses of, CHANGE: allow NULL for all (connected) peers
+ * @param one_shot GNUNET_YES to return the current state and then end (with NULL+NULL),
+ * GNUNET_NO to monitor the set of addresses used (continuously, must be explicitly cancelled)
* @param timeout how long is the lookup allowed to take at most
* @param peer_address_callback function to call with the results
* @param peer_address_callback_cls closure for peer_address_callback
- * @return handle to cancel the operation, NULL on error
*/
-struct GNUNET_TRANSPORT_PeerAddressLookupContext *
-GNUNET_TRANSPORT_peer_get_active_addresses (const struct GNUNET_CONFIGURATION_Handle *cfg,
- const struct GNUNET_PeerIdentity *peer,
- int one_shot,
+struct GNUNET_TRANSPORT_PeerIterateContext *
+GNUNET_TRANSPORT_peer_get_active_addresses (const struct
+ GNUNET_CONFIGURATION_Handle *cfg,
+ const struct GNUNET_PeerIdentity
+ *peer, int one_shot,
struct GNUNET_TIME_Relative timeout,
- GNUNET_TRANSPORT_AddressLookUpCallback peer_address_callback,
+ GNUNET_TRANSPORT_PeerIterateCallback
+ peer_address_callback,
void *peer_address_callback_cls)
{
- struct GNUNET_TRANSPORT_PeerAddressLookupContext *pal_ctx;
+ struct GNUNET_TRANSPORT_PeerIterateContext *pal_ctx;
struct AddressIterateMessage msg;
struct GNUNET_CLIENT_Connection *client;
struct GNUNET_TIME_Absolute abs_timeout;
- client = GNUNET_CLIENT_connect ("transport", cfg);
- if (client == NULL)
+ if (GNUNET_YES != one_shot)
{
- peer_address_callback (peer_address_callback_cls, NULL);
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ "Address monitoring not implemented\n");
return NULL;
}
-
+ client = GNUNET_CLIENT_connect ("transport", cfg);
+ if (client == NULL)
+ return NULL;
abs_timeout = GNUNET_TIME_relative_to_absolute (timeout);
-
msg.header.size = htons (sizeof (struct AddressIterateMessage));
msg.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_ITERATE);
+ msg.one_shot = htonl (one_shot);
msg.timeout = GNUNET_TIME_absolute_hton (abs_timeout);
if (peer == NULL)
- memset (&msg.peer, 0 , sizeof (struct GNUNET_PeerIdentity));
+ memset (&msg.peer, 0, sizeof (struct GNUNET_PeerIdentity));
else
- memcpy (&msg.peer, peer , sizeof (struct GNUNET_PeerIdentity));
-
- pal_ctx = GNUNET_malloc (sizeof (struct GNUNET_TRANSPORT_PeerAddressLookupContext));
+ msg.peer = *peer;
+ pal_ctx = GNUNET_malloc (sizeof (struct GNUNET_TRANSPORT_PeerIterateContext));
pal_ctx->cb = peer_address_callback;
pal_ctx->cb_cls = peer_address_callback_cls;
pal_ctx->timeout = abs_timeout;
*/
void
GNUNET_TRANSPORT_peer_get_active_addresses_cancel (struct
- GNUNET_TRANSPORT_PeerAddressLookupContext
- *alc)
+ GNUNET_TRANSPORT_PeerIterateContext
+ *alc)
{
GNUNET_CLIENT_disconnect (alc->client, GNUNET_NO);
GNUNET_free (alc);
}
-/**
- * Return all the known addresses for all peers.
- *
- * @param cfg configuration to use
- * @param timeout how long is the lookup allowed to take at most
- * @param peer_address_callback function to call with the results
- * @param peer_address_callback_cls closure for peer_address_callback
- */
-void
-GNUNET_TRANSPORT_address_iterate (const struct GNUNET_CONFIGURATION_Handle *cfg,
- struct GNUNET_TIME_Relative timeout,
- GNUNET_TRANSPORT_AddressLookUpCallback
- peer_address_callback,
- void *peer_address_callback_cls)
-{
- GNUNET_TRANSPORT_peer_get_active_addresses (cfg,
- NULL,
- GNUNET_YES,
- timeout,
- peer_address_callback,
- peer_address_callback_cls);
-}
/* end of transport_api_peer_address_lookup.c */