/**
* Callback: called when a node is removed from the backend.
*
* Removes all references to the node from the frontend.
*/
static void
nodes_gui_node_removed(const struct nid *node_id)
{
if (GUI_PROPERTY(gui_debug) >= 5)
g_debug("%s(%s)", G_STRFUNC, nid_to_string(node_id));
nodes_gui_remove_node(node_id);
}
/**
* Callback: called when a node is added from the backend.
*
* Adds the node to the gui.
*/
static void
nodes_gui_node_added(const struct nid *node_id)
{
gnet_node_info_t info;
if (GUI_PROPERTY(gui_debug) >= 5)
g_debug("%s(%s)", G_STRFUNC, nid_to_string(node_id));
guc_node_fill_info(node_id, &info);
nodes_gui_add_node(&info);
guc_node_clear_info(&info);
}
/**
* Callback: called when a node is added from the backend.
*
* Adds the node to the gui.
*/
static void
nodes_gui_node_added(const struct nid *node_id)
{
gnet_node_info_t *info;
if (GUI_PROPERTY(gui_debug) >= 5)
g_debug("nodes_gui_node_added(%s)\n", nid_to_string(node_id));
info = guc_node_get_info(node_id);
if (info) {
nodes_gui_add_node(info);
guc_node_free_info(info);
}
}
/**
* RPC callback.
*
* @param type DHT_RPC_REPLY or DHT_RPC_TIMEOUT
* @param kn the replying node
* @param function the type of message we got (0 on TIMEOUT)
* @param payload the payload we got
* @param len the length of the payload
* @param arg user-defined callback parameter
*/
static void
revent_rpc_cb(
enum dht_rpc_ret type,
const knode_t *kn,
const gnutella_node_t *unused_n,
kda_msg_t function,
const char *payload, size_t len, void *arg)
{
struct revent_rpc_info *rpi = arg;
struct revent_ops *ops;
void *obj;
(void) unused_n;
knode_check(kn);
rpi_check(rpi);
ops = rpi->ops;
/*
* It is possible that whilst the RPC was in transit, the operation was
* terminated. Therefore, we need to ensure that the recorded user is
* still alive.
*/
obj = (*ops->is_alive)(rpi->rid);
if (NULL == obj) {
if (*ops->debug > 2)
g_debug("DHT %s[%s] late RPC %s from %s",
ops->name, nid_to_string(&rpi->rid),
type == DHT_RPC_TIMEOUT ? "timeout" : "reply",
knode_to_string(kn));
goto cleanup;
}
/*
* Let them know we're about to handle the RPC.
*/
if (*ops->debug > 2)
g_debug("DHT %s[%s] handling %s for RPC issued %s%u to %s",
ops->name, nid_to_string(&rpi->rid),
type == DHT_RPC_TIMEOUT ? "timeout" : "reply",
ops->udata_name, rpi->udata, knode_to_string(kn));
if (ops->handling_rpc)
(*ops->handling_rpc)(obj, type, kn, rpi->udata);
/*
* Handle reply.
*/
if (type == DHT_RPC_TIMEOUT) {
if (rpi->pmi != NULL) /* Message not processed by UDP queue yet */
rpi->pmi->rpc_done = TRUE;
} else {
g_assert(NULL == rpi->pmi); /* Since message has been sent */
if (!(*ops->handle_reply)(obj, kn, function, payload, len, rpi->udata))
goto cleanup;
}
/*
* Allow next iteration to proceed.
*/
if (ops->iterate)
(*ops->iterate)(obj, type, rpi->udata);
cleanup:
revent_rpi_free(rpi);
}
/**
* Free routine for our extended message blocks.
*/
static void
revent_pmsg_free(pmsg_t *mb, void *arg)
{
struct revent_pmsg_info *pmi = arg;
struct revent_ops *ops;
void *obj;
pmi_check(pmi);
g_assert(pmsg_is_extended(mb));
ops = pmi->ops;
/*
* It is possible that whilst the message was in the message queue,
* the operation was terminated. Therefore, we need to ensure that the
* recorded user is still alive.
*/
obj = (*ops->is_alive)(pmi->rid);
if (NULL == obj) {
if (*ops->debug > 2)
g_debug("DHT %s[%s] late UDP message %s",
ops->name, nid_to_string(&pmi->rid),
pmsg_was_sent(mb) ? "sending" : "dropping");
goto cleanup;
}
/*
* Signal message freeing, so that user structure can decrement the
* amount of pending messsages if necessary.
*/
if (ops->freeing_msg)
(*ops->freeing_msg)(obj);
/*
* If the RPC callback triggered before the UDP message queue could
* process the message on the way out, then we don't need to do anything
* as the RPC is already dead and has been processed as such...
*/
if (pmi->rpc_done)
goto cleanup;
pmi->rpi->pmi = NULL; /* Break x-ref as message was processed */
if (pmsg_was_sent(mb)) {
knode_t *kn = pmi->kn;
/*
* Message was successfully sent from the queue.
*/
kn->last_sent = tm_time();
if (ops->msg_sent)
(*ops->msg_sent)(obj, mb);
if (*ops->debug > 4)
g_debug("DHT %s[%s] sent %s (%d bytes) to %s, RTT=%u",
ops->name, nid_to_string(&pmi->rid),
kmsg_infostr(pmsg_phys_base(mb)),
pmsg_written_size(mb), knode_to_string(kn), kn->rtt);
} else {
knode_t *kn = pmi->kn;
guid_t *muid;
if (*ops->debug > 2)
g_debug("DHT %s[%s] message %s%u to %s dropped by UDP queue",
ops->name, nid_to_string(&pmi->rid),
ops->udata_name, pmi->rpi->udata,
knode_to_string(kn));
/*
* Message was not sent and dropped by the queue.
*/
if (ops->msg_dropped)
(*ops->msg_dropped)(obj, kn, mb);
/*
* Cancel the RPC, since the message was never sent out...
* The MUID is at the start of the message.
*/
g_assert(pmsg_written_size(mb) > GUID_RAW_SIZE);
muid = cast_to_guid_ptr(pmsg_phys_base(mb));
dht_rpc_cancel(muid);
if (ops->rpc_cancelled)
(*ops->rpc_cancelled)(obj, pmi->rpi->udata);
revent_rpi_free(pmi->rpi); /* Cancel does not invoke RPC callback */
}
cleanup:
revent_pmi_free(pmi);
}
