/**
* Monitor callback
*/
- GNUNET_MESH_MonitorCB monitor_cb;
+ GNUNET_MESH_TunnelsCB tunnels_cb;
/**
* Monitor callback closure.
*/
- void *monitor_cls;
+ void *tunnels_cls;
+
+ /**
+ * Tunnel callback.
+ */
+ GNUNET_MESH_TunnelCB tunnel_cb;
+
+ /**
+ * Tunnel callback closure.
+ */
+ void *tunnel_cls;
+
+ /**
+ * All the peer in the tunnel so far.
+ */
+ struct GNUNET_PeerIdentity *peers;
+
+ /**
+ * How many peers we have in this tunnel so far.
+ */
+ unsigned int tunnel_npeers;
#if DEBUG_ACK
unsigned int acks_sent;
/**
- * Process a local monitor reply, pass info to the user.
+ * Process a local reply about info on all tunnels, pass info to the user.
*
* @param h Mesh handle.
* @param message Message itself.
*/
static void
-process_monitor (struct GNUNET_MESH_Handle *h,
- const struct GNUNET_MessageHeader *message)
+process_get_tunnels (struct GNUNET_MESH_Handle *h,
+ const struct GNUNET_MessageHeader *message)
{
struct GNUNET_MESH_LocalMonitor *msg;
uint32_t npeers;
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Monitor messasge received\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Get Tunnels messasge received\n");
- if (NULL == h->monitor_cb)
+ if (NULL == h->tunnels_cb)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, " ignored\n");
return;
msg = (struct GNUNET_MESH_LocalMonitor *) message;
npeers = ntohl (msg->npeers);
- if (ntohs (message->size) !=
+ if (ntohs (message->size) !=
(sizeof (struct GNUNET_MESH_LocalMonitor) +
npeers * sizeof (struct GNUNET_PeerIdentity)))
{
GNUNET_break_op (0);
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "Monitor message: size %hu - expected %u (%u peers)\n",
+ "Get tunnels message: size %hu - expected %u (%u peers)\n",
ntohs (message->size),
sizeof (struct GNUNET_MESH_LocalMonitor) +
npeers * sizeof (struct GNUNET_PeerIdentity),
npeers);
return;
}
- h->monitor_cb (h->monitor_cls,
+ h->tunnels_cb (h->tunnels_cls,
&msg->owner,
ntohl (msg->tunnel_id),
(struct GNUNET_PeerIdentity *) &msg[1],
}
+
+/**
+ * Process a local monitor_tunnel reply, pass info to the user.
+ *
+ * @param h Mesh handle.
+ * @param message Message itself.
+ */
+static void
+process_show_tunnel (struct GNUNET_MESH_Handle *h,
+ const struct GNUNET_MessageHeader *message)
+{
+ struct GNUNET_MESH_LocalMonitor *msg;
+ struct GNUNET_PeerIdentity *new_peers;
+ uint32_t *new_parents;
+ size_t esize;
+ uint32_t npeers;
+ unsigned int i;
+
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Show Tunnel messasge received\n");
+
+ if (NULL == h->tunnel_cb)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, " ignored\n");
+ return;
+ }
+
+ /* Verify message sanity */
+ msg = (struct GNUNET_MESH_LocalMonitor *) message;
+ npeers = ntohl (msg->npeers);
+ esize = sizeof (struct GNUNET_MESH_LocalMonitor);
+ esize += npeers * (sizeof (struct GNUNET_PeerIdentity) + sizeof (uint32_t));
+ if (ntohs (message->size) != esize)
+ {
+ GNUNET_break_op (0);
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ "Show tunnel message: size %hu - expected %u (%u peers)\n",
+ ntohs (message->size),
+ esize,
+ npeers);
+
+ h->tunnel_cb (h->tunnel_cls, NULL, NULL);
+ h->tunnel_cb = NULL;
+ h->tunnel_cls = NULL;
+ h->tunnel_npeers = 0;
+ GNUNET_free_non_null (h->peers);
+ h->peers = NULL;
+
+ return;
+ }
+
+ new_peers = (struct GNUNET_PeerIdentity *) &msg[1];
+ new_parents = (uint32_t *) &new_peers[npeers];
+
+ h->peers = GNUNET_realloc (h->peers, h->tunnel_npeers + npeers);
+ memcpy (&h->peers[h->tunnel_npeers],
+ new_peers,
+ npeers * sizeof (struct GNUNET_PeerIdentity));
+ h->tunnel_npeers += npeers;
+ for (i = 0; i < npeers; i++)
+ h->tunnel_cb (h->tunnel_cls,
+ &new_peers[i],
+ &h->peers[new_parents[i]]);
+}
+
+
/**
* Function to process all messages received from the service
*
case GNUNET_MESSAGE_TYPE_MESH_LOCAL_ACK:
process_ack (h, msg);
break;
- case GNUNET_MESSAGE_TYPE_MESH_LOCAL_MONITOR:
- process_monitor (h, msg);
+ case GNUNET_MESSAGE_TYPE_MESH_LOCAL_INFO_TUNNELS:
+ process_get_tunnels (h, msg);
+ break;
+ case GNUNET_MESSAGE_TYPE_MESH_LOCAL_INFO_TUNNEL:
+ process_show_tunnel (h, msg);
break;
default:
/* We shouldn't get any other packages, log and ignore */
LOG (GNUNET_ERROR_TYPE_WARNING,
- "unsolicited message form service (type %hu)\n",
- ntohs (msg->type));
+ "unsolicited message form service (type %s)\n",
+ GNUNET_MESH_DEBUG_M2S (ntohs (msg->type)));
}
LOG (GNUNET_ERROR_TYPE_DEBUG, "message processed\n");
if (GNUNET_YES == h->in_receive)
h->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
/* count handlers and apps, calculate size */
- for (h->n_applications = 0; stypes[h->n_applications]; h->n_applications++) ;
- for (h->n_handlers = 0; handlers[h->n_handlers].type; h->n_handlers++) ;
+ for (h->n_applications = 0;
+ stypes && stypes[h->n_applications];
+ h->n_applications++) ;
+ for (h->n_handlers = 0;
+ handlers && handlers[h->n_handlers].type;
+ h->n_handlers++) ;
send_connect (h);
LOG (GNUNET_ERROR_TYPE_DEBUG, "GNUNET_MESH_connect() END\n");
return h;
{
case GNUNET_MESSAGE_TYPE_MESH_LOCAL_CONNECT:
case GNUNET_MESSAGE_TYPE_MESH_LOCAL_TUNNEL_DESTROY:
- case GNUNET_MESSAGE_TYPE_MESH_LOCAL_MONITOR:
+ case GNUNET_MESSAGE_TYPE_MESH_LOCAL_INFO_TUNNELS:
+ case GNUNET_MESSAGE_TYPE_MESH_LOCAL_INFO_TUNNEL:
break;
default:
GNUNET_break (0);
unsigned int compression_characters)
{
struct GNUNET_MESH_RegexAnnounce *msg;
+ size_t payload;
size_t len;
size_t msgsize;
+ size_t offset;
+ char buffer[UINT16_MAX];
len = strlen (regex);
- msgsize = sizeof(struct GNUNET_MESH_RegexAnnounce) + len;
- GNUNET_assert (UINT16_MAX > msgsize);
-
+ payload = UINT16_MAX - sizeof(struct GNUNET_MESH_RegexAnnounce);
+ msg = (struct GNUNET_MESH_RegexAnnounce *) buffer;
+ msg->header.type = htons (GNUNET_MESSAGE_TYPE_MESH_LOCAL_ANNOUNCE_REGEX);
+ msg->compression_characters = htons (compression_characters);
+ offset = 0;
+ do
{
- char buffer[msgsize];
+ msgsize = (len - offset > payload) ? payload : len - offset;
+ memcpy (&msg[1], ®ex[offset], msgsize);
+ offset += msgsize;
+ msgsize += sizeof(struct GNUNET_MESH_RegexAnnounce);
- msg = (struct GNUNET_MESH_RegexAnnounce *) buffer;
msg->header.size = htons (msgsize);
- msg->header.type = htons (GNUNET_MESSAGE_TYPE_MESH_LOCAL_ANNOUNCE_REGEX);
- msg->compression_characters = htons (compression_characters);
- memcpy (&msg[1], regex, len);
+ msg->last = htons (offset >= len);
- send_packet(h, &msg->header, NULL);
- }
+ send_packet (h, &msg->header, NULL);
+ } while (len > offset);
}
/**
send_packet (h, &msg.header, NULL);
}
+
/**
* Request that a peer should be added to the tunnel. The existing
* connect handler will be called ONCE with either success or failure.
* This function should NOT be called again with the same peer before the
* connect handler is called.
+ * FIXME: I think the above documentation is false. I think it should
+ * read: "The connect handler will be called once the peer was actually
+ * successfully added to the multicast group. This function should
+ * not be called twice for the same peer (unless, of course,
+ * the peer was removed using GNUNET_MESH_peer_Request_connect_del in
+ * the meantime).
*
* @param tunnel handle to existing tunnel
* @param peer peer to add
msg.tunnel_id = htonl (tunnel->tid);
msg.peer = *peer;
send_packet (tunnel->mesh, &msg.header, tunnel);
-
- return;
}
/**
* Request information about the running mesh peer.
+ * The callback will be called for every tunnel known to the service,
+ * listing all active peers that blong to the tunnel.
+ *
+ * If called again on the same handle, it will overwrite the previous
+ * callback and cls. To retrieve the cls, monitor_cancel must be
+ * called first.
+ *
+ * WARNING: unstable API, likely to change in the future!
*
* @param h Handle to the mesh peer.
* @param callback Function to call with the requested data.
- * @param monitor_cls Closure for @c callback.
+ * @param callback_cls Closure for @c callback.
*/
void
-GNUNET_MESH_monitor (struct GNUNET_MESH_Handle *h,
- GNUNET_MESH_MonitorCB callback,
- void *monitor_cls)
+GNUNET_MESH_get_tunnels (struct GNUNET_MESH_Handle *h,
+ GNUNET_MESH_TunnelsCB callback,
+ void *callback_cls)
{
struct GNUNET_MessageHeader msg;
msg.size = htons (sizeof (msg));
- msg.type = htons (GNUNET_MESSAGE_TYPE_MESH_LOCAL_MONITOR);
+ msg.type = htons (GNUNET_MESSAGE_TYPE_MESH_LOCAL_INFO_TUNNELS);
send_packet (h, &msg, NULL);
- h->monitor_cb = callback;
- h->monitor_cls = monitor_cls;
+ h->tunnels_cb = callback;
+ h->tunnels_cls = callback_cls;
return;
}
* @return Closure given to GNUNET_MESH_monitor, if any.
*/
void *
-GNUNET_MESH_monitor_cancel (struct GNUNET_MESH_Handle *h)
+GNUNET_MESH_get_tunnels_cancel (struct GNUNET_MESH_Handle *h)
{
void *cls;
- cls = h->monitor_cls;
- h->monitor_cb = NULL;
- h->monitor_cls = NULL;
+ cls = h->tunnels_cls;
+ h->tunnels_cb = NULL;
+ h->tunnels_cls = NULL;
return cls;
}
+/**
+ * Request information about a specific tunnel of the running mesh peer.
+ *
+ * WARNING: unstable API, likely to change in the future!
+ *
+ * @param h Handle to the mesh peer.
+ * @param initiator ID of the owner of the tunnel.
+ * @param tunnel_number Tunnel number.
+ * @param callback Function to call with the requested data.
+ * @param callback_cls Closure for @c callback.
+ */
+void
+GNUNET_MESH_show_tunnel (struct GNUNET_MESH_Handle *h,
+ struct GNUNET_PeerIdentity *initiator,
+ unsigned int tunnel_number,
+ GNUNET_MESH_TunnelCB callback,
+ void *callback_cls)
+{
+ struct GNUNET_MESH_LocalMonitor msg;
+
+ msg.header.size = htons (sizeof (msg));
+ msg.header.type = htons (GNUNET_MESSAGE_TYPE_MESH_LOCAL_INFO_TUNNEL);
+ msg.npeers = htonl (0);
+ msg.owner = *initiator;
+ msg.tunnel_id = htonl (tunnel_number);
+ msg.reserved = 0;
+ send_packet (h, &msg.header, NULL);
+ h->tunnel_cb = callback;
+ h->tunnel_cls = callback_cls;
+
+ return;
+}
+
+
/**
* Transition API for tunnel ctx management
*/
projects / oweals / gnunet.git / blobdiff