#include "mesh.h"
#include "mesh_protocol.h"
-#define DEBUG GNUNET_YES
+#define MESH_API_DEBUG GNUNET_YES
+
+#define LOG(kind,...) GNUNET_log_from (kind, "mesh-api",__VA_ARGS__)
/******************************************************************************/
/************************ DATA STRUCTURES ****************************/
/**
* Send a connect packet to the service with the applications and types
* requested by the user.
- *
+ *
* @param h The mesh handle.
- *
+ *
*/
static void
send_connect (struct GNUNET_MESH_Handle *h)
for (napps = 0; napps < h->n_applications; napps++)
{
apps[napps] = htonl (h->applications[napps]);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "mesh: app %u\n",
- h->applications[napps]);
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "mesh: app %u\n", h->applications[napps]);
}
types = (uint16_t *) & apps[napps];
for (ntypes = 0; ntypes < h->n_handlers; ntypes++)
types[ntypes] = htons (h->message_handlers[ntypes].type);
msg->applications = htons (napps);
msg->types = htons (ntypes);
-#if DEBUG
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "mesh: Sending %lu bytes long message %d types and %d apps\n",
- ntohs (msg->header.size), ntypes, napps);
+#if MESH_API_DEBUG
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "mesh: Sending %lu bytes long message %d types and %d apps\n",
+ ntohs (msg->header.size), ntypes, napps);
#endif
send_packet (h, &msg->header);
}
struct GNUNET_MESH_Tunnel *t;
unsigned int i;
-#if DEBUG
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "mesh: *****************************\n");
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "mesh: ******* RECONNECT *******\n");
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "mesh: *****************************\n");
+#if MESH_API_DEBUG
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "mesh: *****************************\n");
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "mesh: ******* RECONNECT *******\n");
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "mesh: *****************************\n");
#endif
h->in_receive = GNUNET_NO;
/* disconnect */
GNUNET_TIME_relative_min (GNUNET_TIME_UNIT_HOURS,
GNUNET_TIME_relative_multiply
(h->reconnect_time, 2));
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "mesh: Next retry in %sms\n",
- GNUNET_TIME_relative_to_string(h->reconnect_time));
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "mesh: Next retry in %sms\n",
+ GNUNET_TIME_relative_to_string (h->reconnect_time));
GNUNET_break (0);
return GNUNET_NO;
}
{
h->reconnect_time = GNUNET_TIME_UNIT_MILLISECONDS;
}
- send_connect(h);
+ send_connect (h);
/* Rebuild all tunnels */
for (t = h->tunnels_head; NULL != t; t = t->next)
{
struct GNUNET_MESH_TunnelMessage tmsg;
struct GNUNET_MESH_PeerControl pmsg;
+ if (t->tid >= GNUNET_MESH_LOCAL_TUNNEL_ID_SERV)
+ {
+ /* Tunnel was created by service (incoming tunnel) */
+ /* TODO: Notify service of missing tunnel, to request
+ * creator to recreate path (find a path to him via DHT?)
+ */
+ continue;
+ }
tmsg.header.type = htons (GNUNET_MESSAGE_TYPE_MESH_LOCAL_TUNNEL_CREATE);
tmsg.header.size = htons (sizeof (struct GNUNET_MESH_TunnelMessage));
tmsg.tunnel_id = htonl (t->tid);
const struct GNUNET_MESH_TunnelNotification *msg)
{
struct GNUNET_MESH_Tunnel *t;
- struct GNUNET_TRANSPORT_ATS_Information atsi;
+ struct GNUNET_ATS_Information atsi;
MESH_TunnelNumber tid;
tid = ntohl (msg->tunnel_id);
- if (tid <= GNUNET_MESH_LOCAL_TUNNEL_ID_CLI)
+ if (tid < GNUNET_MESH_LOCAL_TUNNEL_ID_SERV)
{
GNUNET_break (0);
return;
if (NULL == t)
{
- GNUNET_break (0);
return;
}
if (0 == t->owner)
{
struct GNUNET_MESH_Tunnel *t;
struct GNUNET_MESH_Peer *p;
- struct GNUNET_TRANSPORT_ATS_Information atsi;
+ struct GNUNET_ATS_Information atsi;
GNUNET_PEER_Id id;
uint16_t size;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "mesh: processig peer event\n");
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "mesh: processig peer event\n");
size = ntohs (msg->header.size);
if (size != sizeof (struct GNUNET_MESH_PeerControl))
{
p = add_peer_to_tunnel (t, &msg->peer);
if (GNUNET_MESSAGE_TYPE_MESH_LOCAL_PEER_ADD == ntohs (msg->header.type))
{
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "mesh: adding peer\n");
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "mesh: adding peer\n");
if (NULL != t->connect_handler)
{
atsi.type = 0;
}
else
{
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "mesh: removing peer\n");
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "mesh: removing peer\n");
if (NULL != t->disconnect_handler && p->connected)
{
t->disconnect_handler (t->cls, &msg->peer);
remove_peer_from_tunnel (p);
GNUNET_free (p);
}
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "mesh: processing peer event END\n");
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "mesh: processing peer event END\n");
}
unsigned int i;
uint16_t type;
-
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "mesh: Got a data message!\n");
type = ntohs (message->type);
switch (type)
{
case GNUNET_MESSAGE_TYPE_MESH_UNICAST:
ucast = (struct GNUNET_MESH_Unicast *) message;
+
t = retrieve_tunnel (h, ntohl (ucast->tid));
payload = (struct GNUNET_MessageHeader *) &ucast[1];
peer = &ucast->oid;
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "mesh: on tunnel %s [%x]\n",
+ GNUNET_i2s (peer),
+ ntohl (ucast->tid));
break;
case GNUNET_MESSAGE_TYPE_MESH_MULTICAST:
mcast = (struct GNUNET_MESH_Multicast *) message;
handler = &h->message_handlers[i];
if (handler->type == type)
{
- struct GNUNET_TRANSPORT_ATS_Information atsi;
+ struct GNUNET_ATS_Information atsi;
atsi.type = 0;
atsi.value = 0;
if (GNUNET_OK !=
handler->callback (h->cls, t, &t->ctx, peer, payload, &atsi))
{
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "MESH: callback caused disconnection\n");
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "MESH: callback caused disconnection\n");
GNUNET_MESH_disconnect (h);
return;
}
-#if DEBUG
+#if MESH_API_DEBUG
else
{
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "MESH: callback completed successfully\n");
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "MESH: callback completed successfully\n");
}
#endif
reconnect (h);
return;
}
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "mesh: received a message type %hu from MESH\n",
- ntohs (msg->type));
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "mesh: received a message type %hu from MESH\n",
+ ntohs (msg->type));
switch (ntohs (msg->type))
{
/* Notify of a new incoming tunnel */
break;
/* We shouldn't get any other packages, log and ignore */
default:
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- "MESH: unsolicited message form service (type %d)\n",
- ntohs (msg->type));
+ LOG (GNUNET_ERROR_TYPE_WARNING,
+ "MESH: unsolicited message form service (type %d)\n",
+ ntohs (msg->type));
}
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "mesh: message processed\n");
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "mesh: message processed\n");
GNUNET_CLIENT_receive (h->client, &msg_received, h,
GNUNET_TIME_UNIT_FOREVER_REL);
}
size_t tsize;
size_t psize;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "mesh: Send packet() Buffer %u\n", size);
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "mesh: Send packet() Buffer %u\n", size);
h->th = NULL;
if ((0 == size) || (NULL == buf))
{
tsize = 0;
while ((NULL != (th = h->th_head)) && (size >= th->size))
{
-#if DEBUG
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "mesh: type: %u\n",
- ntohs (((struct GNUNET_MessageHeader *) &th[1])->type));
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "mesh: size: %u\n",
- ntohs (((struct GNUNET_MessageHeader *) &th[1])->size));
-#endif
if (NULL != th->notify)
{
- if (th->target == 0)
+ if (th->tunnel->tid >= GNUNET_MESH_LOCAL_TUNNEL_ID_SERV)
+ {
+ /* traffic to origin */
+ struct GNUNET_MESH_ToOrigin to;
+ struct GNUNET_MessageHeader *mh;
+
+ GNUNET_assert (size >= th->size);
+ mh = (struct GNUNET_MessageHeader *) &cbuf[sizeof (to)];
+ psize =
+ th->notify (th->notify_cls, size - sizeof (to), mh);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "mesh: to origin, type %u\n",
+ ntohs (mh->type));
+ if (psize > 0)
+ {
+ psize += sizeof (to);
+ GNUNET_assert (size >= psize);
+ to.header.size = htons (psize);
+ to.header.type = htons (GNUNET_MESSAGE_TYPE_MESH_TO_ORIGIN);
+ to.tid = htonl (th->tunnel->tid);
+ memset (&to.oid, 0, sizeof (struct GNUNET_PeerIdentity));
+ memset (&to.sender, 0, sizeof (struct GNUNET_PeerIdentity));
+ memcpy (cbuf, &to, sizeof (to));
+ }
+ }
+ else if (th->target == 0)
{
/* multicast */
struct GNUNET_MESH_Multicast mc;
+ struct GNUNET_MessageHeader *mh;
- GNUNET_assert (size >= sizeof (mc) + th->size);
+ GNUNET_assert (size >= th->size);
+ mh = (struct GNUNET_MessageHeader *) &cbuf[sizeof (mc)];
psize =
- th->notify (th->notify_cls, size - sizeof (mc), &cbuf[sizeof (mc)]);
+ th->notify (th->notify_cls, size - sizeof (mc), mh);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "mesh: multicast, type %u\n",
+ ntohs (mh->type));
if (psize > 0)
{
- mc.header.size = htons (sizeof (mc) + th->size);
+ psize += sizeof (mc);
+ GNUNET_assert (size >= psize);
+ mc.header.size = htons (psize);
mc.header.type = htons (GNUNET_MESSAGE_TYPE_MESH_MULTICAST);
mc.tid = htonl (th->tunnel->tid);
memset (&mc.oid, 0, sizeof (struct GNUNET_PeerIdentity));
memcpy (cbuf, &mc, sizeof (mc));
- psize = th->size + sizeof (mc);
}
}
else
{
/* unicast */
struct GNUNET_MESH_Unicast uc;
+ struct GNUNET_MessageHeader *mh;
- GNUNET_assert (size >= sizeof (uc) + th->size);
+ GNUNET_assert (size >= th->size);
+ mh = (struct GNUNET_MessageHeader *) &cbuf[sizeof (uc)];
psize =
- th->notify (th->notify_cls, size - sizeof (uc), &cbuf[sizeof (uc)]);
+ th->notify (th->notify_cls, size - sizeof (uc), mh);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "mesh: unicast, type %u\n",
+ ntohs (mh->type));
if (psize > 0)
{
- uc.header.size = htons (sizeof (uc) + th->size);
+ psize += sizeof (uc);
+ GNUNET_assert (size >= psize);
+ uc.header.size = htons (psize);
uc.header.type = htons (GNUNET_MESSAGE_TYPE_MESH_UNICAST);
uc.tid = htonl (th->tunnel->tid);
memset (&uc.oid, 0, sizeof (struct GNUNET_PeerIdentity));
GNUNET_PEER_resolve (th->target, &uc.destination);
memcpy (cbuf, &uc, sizeof (uc));
- psize = th->size + sizeof (uc);
}
}
}
size -= psize;
tsize += psize;
}
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "mesh: total size: %u\n", tsize);
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "mesh: total size: %u\n", tsize);
if (NULL != (th = h->th_head))
{
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "mesh: next size: %u\n", th->size);
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "mesh: next size: %u\n", th->size);
h->th =
GNUNET_CLIENT_notify_transmit_ready (h->client, th->size,
GNUNET_TIME_UNIT_FOREVER_REL,
GNUNET_YES, &send_callback, h);
}
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "mesh: Send packet() END\n");
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "mesh: Send packet() END\n");
if (GNUNET_NO == h->in_receive)
{
h->in_receive = GNUNET_YES;
{
struct GNUNET_MESH_Handle *h;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "mesh: GNUNET_MESH_connect()\n");
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "mesh: GNUNET_MESH_connect()\n");
h = GNUNET_malloc (sizeof (struct GNUNET_MESH_Handle));
h->cfg = cfg;
h->max_queue_size = queue_size;
/* 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++) ;
- send_connect(h);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "mesh: GNUNET_MESH_connect() END\n");
+ send_connect (h);
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "mesh: GNUNET_MESH_connect() END\n");
return h;
}
struct GNUNET_MESH_Tunnel *t;
struct GNUNET_MESH_TunnelMessage msg;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "mesh: Creating new tunnel\n");
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "mesh: Creating new tunnel\n");
t = create_tunnel (h, 0);
t->connect_handler = connect_handler;
t->disconnect_handler = disconnect_handler;
struct GNUNET_MESH_Handle *h;
struct GNUNET_MESH_TunnelMessage msg;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "mesh: Destroying tunnel\n");
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "mesh: Destroying tunnel\n");
h = tunnel->mesh;
if (0 != tunnel->owner)
{
if (tunnel->peers[i]->id == peer_id)
{
+ /* Peer already exists in tunnel */
GNUNET_PEER_change_rc (peer_id, -1);
GNUNET_break (0);
return;
uint32_t least_priority;
size_t overhead;
+#if MESH_API_DEBUG
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "mesh: mesh notify transmit ready called\n");
+ if (NULL != target)
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "mesh: target %s\n",
+ GNUNET_i2s (target));
+ else
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "mesh: target multicast\n");
+#endif
GNUNET_assert (NULL != notify);
if (tunnel->mesh->npackets >= tunnel->mesh->max_queue_size &&
tunnel->npackets > 0)
th->priority = priority;
th->timeout = GNUNET_TIME_relative_to_absolute (maxdelay);
th->target = GNUNET_PEER_intern (target);
- if (NULL == target)
+ if (tunnel->tid >= GNUNET_MESH_LOCAL_TUNNEL_ID_SERV)
+ overhead = sizeof (struct GNUNET_MESH_ToOrigin);
+ else if (NULL == target)
overhead = sizeof (struct GNUNET_MESH_Multicast);
else
overhead = sizeof (struct GNUNET_MESH_Unicast);
th->notify = notify;
th->notify_cls = notify_cls;
add_to_queue (tunnel->mesh, th);
+ if (NULL != tunnel->mesh->th)
+ return th;
+ tunnel->mesh->th =
+ GNUNET_CLIENT_notify_transmit_ready (tunnel->mesh->client,
+ th->size,
+ GNUNET_TIME_UNIT_FOREVER_REL,
+ GNUNET_YES,
+ &send_callback,
+ tunnel->mesh);
return th;
}
}
+/**
+ * Transition API for tunnel ctx management
+ */
+void
+GNUNET_MESH_tunnel_set_data (struct GNUNET_MESH_Tunnel *tunnel, void *data)
+{
+ tunnel->ctx = data;
+}
+
+/**
+ * Transition API for tunnel ctx management
+ */
+void *
+GNUNET_MESH_tunnel_get_data (struct GNUNET_MESH_Tunnel *tunnel)
+{
+ return tunnel->ctx;
+}
+
+
#if 0 /* keep Emacsens' auto-indent happy */
{
#endif