2 This file is part of GNUnet.
3 (C) 2009, 2010 Christian Grothoff (and other contributing authors)
5 GNUnet is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published
7 by the Free Software Foundation; either version 3, or (at your
8 option) any later version.
10 GNUnet is distributed in the hope that it will be useful, but
11 WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with GNUnet; see the file COPYING. If not, write to the
17 Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18 Boston, MA 02111-1307, USA.
22 * @file mesh/mesh_api.c
23 * @brief mesh service; API for the Mesh. This is used to talk to arbitrary peers
24 * as of 2011-01Jan-06 this is a mockup.
25 * @author Philipp Tölke
28 #include <gnunet_constants.h>
29 #include <gnunet_mesh_service.h>
30 #include <gnunet_core_service.h>
31 #include <gnunet_container_lib.h>
32 #include <gnunet_applications.h>
36 uint32_t id GNUNET_PACKED;
37 struct GNUNET_PeerIdentity initiator;
38 struct GNUNET_PeerIdentity target;
41 static uint32_t current_id = 0;
45 struct GNUNET_MessageHeader hdr;
47 /* followed by another GNUNET_MessageHeader */
53 GNUNET_CONNECTION_TransmitReadyNotify notify;
54 struct GNUNET_MESH_Tunnel *tunnel;
57 struct GNUNET_MESH_Tunnel
59 /* The other peer this tunnel leads to; just unicast for the moment! */
60 struct GNUNET_PeerIdentity peer;
64 /* The handlers and cls for outbound tunnels. Are NULL for inbound tunnels. */
65 GNUNET_MESH_TunnelDisconnectHandler disconnect_handler;
66 GNUNET_MESH_TunnelConnectHandler connect_handler;
69 struct GNUNET_MESH_Handle *handle;
71 /* The application-type requested for this tunnel. Is only needed for pending
74 uint16_t application_type;
76 struct GNUNET_MESH_TransmitHandle *notify_handle;
78 /* The context of the receive-function. */
81 /* A list, usable by application-code (for queues) */
85 /* A pointer, usable by application-code */
89 struct tunnel_list_element
91 struct GNUNET_MESH_Tunnel tunnel;
92 struct tunnel_list_element *next, *prev;
97 struct tunnel_list_element *head, *tail;
100 struct type_list_element
102 GNUNET_MESH_ApplicationType type;
103 struct type_list_element *next, *prev;
106 struct peer_list_element
108 struct GNUNET_PeerIdentity peer;
110 /* list of application-types */
111 struct type_list_element *type_head, *type_tail;
113 struct GNUNET_TRANSPORT_ATS_Information atsi;
114 struct peer_list_element *next, *prev;
116 /* The handle that sends the hellos to this peer */
117 struct GNUNET_CORE_TransmitHandle *hello;
119 GNUNET_SCHEDULER_TaskIdentifier sched;
121 struct GNUNET_MESH_Handle *handle;
126 struct peer_list_element *head, *tail;
129 struct GNUNET_MESH_Handle
131 struct GNUNET_CORE_Handle *core;
132 struct GNUNET_MESH_MessageHandler *handlers;
133 struct GNUNET_PeerIdentity myself;
134 unsigned int connected_to_core;
135 struct peer_list connected_peers;
136 struct tunnel_list established_tunnels;
137 struct tunnel_list pending_tunnels;
138 struct tunnel_list pending_by_type_tunnels;
140 GNUNET_MESH_TunnelEndHandler *cleaner;
141 size_t hello_message_size;
142 uint16_t *hello_message;
146 send_end_connect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
148 if ((tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
151 struct GNUNET_MESH_Tunnel *tunnel = cls;
153 tunnel->connect_handler (tunnel->handler_cls, NULL, NULL);
157 send_self_connect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
159 if ((tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
162 struct GNUNET_MESH_Tunnel *tunnel = cls;
164 tunnel->connect_handler (tunnel->handler_cls, &tunnel->handle->myself, NULL);
165 GNUNET_SCHEDULER_add_now (send_end_connect, tunnel);
169 call_connect_handler (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
171 if ((tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
174 struct GNUNET_MESH_Tunnel *tunnel = cls;
176 tunnel->connect_handler (tunnel->handler_cls, &tunnel->peer, NULL);
177 GNUNET_SCHEDULER_add_now (send_end_connect, tunnel);
181 core_startup (void *cls, struct GNUNET_CORE_Handle *core
182 __attribute__ ((unused)),
183 const struct GNUNET_PeerIdentity *my_identity,
184 const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *publicKey
185 __attribute__ ((unused)))
187 struct GNUNET_MESH_Handle *handle = cls;
189 memcpy (&handle->myself, my_identity, sizeof (struct GNUNET_PeerIdentity));
190 handle->connected_to_core = GNUNET_YES;
194 send_hello_message (void *cls, size_t size, void *buf)
199 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending hello\n");
201 struct peer_list_element *element = cls;
202 struct GNUNET_MESH_Handle *handle = element->handle;
203 element->hello = NULL;
204 struct GNUNET_MessageHeader *hdr = buf;
207 sizeof (struct GNUNET_MessageHeader) + handle->hello_message_size;
212 hdr->type = htons (GNUNET_MESSAGE_TYPE_MESH_HELLO);
213 hdr->size = htons (size);
215 memcpy (hdr + 1, handle->hello_message, handle->hello_message_size);
219 void schedule_hello_message(void* cls, const struct GNUNET_SCHEDULER_TaskContext* tctx)
221 struct peer_list_element *element = cls;
222 element->sched = GNUNET_SCHEDULER_NO_TASK;
224 if ((tctx->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
227 if (element->hello == NULL)
228 element->hello = GNUNET_CORE_notify_transmit_ready (element->handle->core, GNUNET_NO, 42,
229 GNUNET_TIME_UNIT_SECONDS, &element->peer,
230 sizeof (struct GNUNET_MessageHeader) +
231 element->handle->hello_message_size,
232 &send_hello_message, element);
234 element->sched = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_MINUTES, schedule_hello_message, cls);
239 * Core calls this if we are connected to a new peer.
241 * The peer is added to the connected_peers-list.
245 core_connect (void *cls, const struct GNUNET_PeerIdentity *peer,
246 const struct GNUNET_TRANSPORT_ATS_Information *atsi)
248 struct GNUNET_MESH_Handle *handle = cls;
250 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
251 "Core tells us we are connected to peer %s\n", GNUNET_i2s (peer));
253 /* put the new peer into the list of connected peers */
254 struct peer_list_element *element =
255 GNUNET_malloc (sizeof (struct peer_list_element));
256 memcpy (&element->peer, peer, sizeof (struct GNUNET_PeerIdentity));
257 element->handle = handle;
259 /* Send a hello to this peer */
260 element->sched = GNUNET_SCHEDULER_add_now(schedule_hello_message, element);
263 memcpy (&element->atsi, atsi,
264 sizeof (struct GNUNET_TRANSPORT_ATS_Information));
266 GNUNET_CONTAINER_DLL_insert_after (handle->connected_peers.head,
267 handle->connected_peers.tail,
268 handle->connected_peers.tail, element);
270 struct tunnel_list_element *tunnel = handle->pending_tunnels.head;
272 while (tunnel != NULL)
275 memcmp (&tunnel->tunnel.peer, peer,
276 sizeof (struct GNUNET_PeerIdentity)))
278 struct tunnel_list_element *next = tunnel->next;
280 GNUNET_CONTAINER_DLL_remove (handle->pending_tunnels.head,
281 handle->pending_tunnels.tail, tunnel);
282 GNUNET_CONTAINER_DLL_insert_after (handle->established_tunnels.head,
283 handle->established_tunnels.tail,
284 handle->established_tunnels.tail,
286 tunnel->tunnel.connect_handler (tunnel->tunnel.handler_cls, peer, atsi);
287 GNUNET_SCHEDULER_add_now (send_end_connect, tunnel);
291 tunnel = tunnel->next;
296 * Core calls this if we disconnect a peer
298 * Remove this peer from the list of connected peers
299 * Close all tunnels this peer belongs to
302 core_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer)
304 struct GNUNET_MESH_Handle *handle = cls;
306 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
307 "Core tells us we are no longer connected to peer %s\n",
310 struct peer_list_element *element = handle->connected_peers.head;
312 while (element != NULL)
314 if (0 == memcmp (&element->peer, peer, sizeof (struct GNUNET_PeerIdentity)))
316 element = element->next;
320 GNUNET_CONTAINER_DLL_remove (handle->connected_peers.head,
321 handle->connected_peers.tail, element);
322 while (element->type_head != NULL)
324 struct type_list_element *tail = element->type_tail;
326 GNUNET_CONTAINER_DLL_remove (element->type_head, element->type_tail,
330 GNUNET_CORE_notify_transmit_ready_cancel(element->hello);
331 GNUNET_SCHEDULER_cancel(element->sched);
332 GNUNET_free (element);
335 struct tunnel_list_element *telement = handle->established_tunnels.head;
337 while (telement != NULL)
340 memcmp (&telement->tunnel.peer, peer,
341 sizeof (struct GNUNET_PeerIdentity)))
343 /* disconnect tunnels */
344 /* outbound tunnels */
345 if (telement->tunnel.connect_handler != NULL &&
346 NULL != telement->tunnel.disconnect_handler)
347 telement->tunnel.disconnect_handler (telement->tunnel.handler_cls,
349 /* inbound tunnels */
350 else if (NULL != handle->cleaner)
351 handle->cleaner (handle->cls, &telement->tunnel, &telement->tunnel.ctx);
353 struct tunnel_list_element *next = telement->next;
355 GNUNET_CONTAINER_DLL_remove (handle->established_tunnels.head,
356 handle->established_tunnels.tail, telement);
357 GNUNET_free (telement);
362 telement = telement->next;
368 * Receive a message from core.
369 * This is a hello-message, containing the application-types the other peer can receive
372 receive_hello (void *cls, const struct GNUNET_PeerIdentity *other,
373 const struct GNUNET_MessageHeader *message,
374 const struct GNUNET_TRANSPORT_ATS_Information *atsi)
376 struct GNUNET_MESH_Handle *handle = cls;
377 uint16_t *num = (uint16_t *) (message + 1);
378 GNUNET_MESH_ApplicationType *ports =
379 (GNUNET_MESH_ApplicationType *) (num + 1);
382 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
383 "The peer %s tells us he supports %d application-types.\n",
384 GNUNET_i2s (other), ntohs (*num));
386 struct peer_list_element *element = handle->connected_peers.head;
388 while (element != NULL)
391 memcmp (&element->peer, other, sizeof (struct GNUNET_PeerIdentity)))
393 element = element->next;
396 GNUNET_assert (NULL != element);
398 for (i = 0; i < ntohs (*num); i++)
400 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
401 "The peer %s newly supports the application-type %d\n",
402 GNUNET_i2s (other), ntohs (ports[i]));
403 if (GNUNET_APPLICATION_TYPE_END == ntohs (ports[i]))
405 struct type_list_element *new_type = GNUNET_malloc (sizeof *new_type);
407 new_type->type = (GNUNET_MESH_ApplicationType) ntohs (ports[i]);
408 GNUNET_CONTAINER_DLL_insert (element->type_head, element->type_tail,
412 struct type_list_element *type;
414 for (type = element->type_head; type != NULL; type = type->next)
416 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
417 "The peer %s supports the application-type %d\n",
418 GNUNET_i2s (other), type->type);
421 struct tunnel_list_element *tunnel = handle->pending_by_type_tunnels.head;
423 while (tunnel != NULL)
425 struct tunnel_list_element *next = tunnel->next;
427 for (i = 0; i < ntohs (*num); i++)
429 if (ntohs (ports[i]) == tunnel->tunnel.application_type)
431 GNUNET_CONTAINER_DLL_remove (handle->pending_by_type_tunnels.head,
432 handle->pending_by_type_tunnels.tail,
434 GNUNET_CONTAINER_DLL_insert_after (handle->established_tunnels.head,
435 handle->established_tunnels.tail,
436 handle->established_tunnels.tail,
438 memcpy (&tunnel->tunnel.peer, other,
439 sizeof (struct GNUNET_PeerIdentity));
440 tunnel->tunnel.connect_handler (tunnel->tunnel.handler_cls,
441 &tunnel->tunnel.peer, atsi);
442 GNUNET_SCHEDULER_add_now (send_end_connect, tunnel);
446 if (ntohs (ports[i]) == tunnel->tunnel.application_type)
449 tunnel = tunnel->next;
455 * Receive a message from core.
458 core_receive (void *cls, const struct GNUNET_PeerIdentity *other,
459 const struct GNUNET_MessageHeader *message,
460 const struct GNUNET_TRANSPORT_ATS_Information *atsi)
462 struct GNUNET_MESH_Handle *handle = cls;
463 struct tunnel_message *tmessage = (struct tunnel_message *) message;
464 struct GNUNET_MessageHeader *rmessage =
465 (struct GNUNET_MessageHeader *) (tmessage + 1);
467 struct GNUNET_MESH_MessageHandler *handler;
469 for (handler = handle->handlers; handler->callback != NULL; handler++)
471 if ((ntohs (rmessage->type) == handler->type) &&
472 ((handler->expected_size == 0) ||
473 (handler->expected_size == ntohs (rmessage->size))))
479 /* handler->callback handles this message */
481 /* If no handler was found, drop the message but keep the channel open */
482 if (handler->callback == NULL)
484 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
485 "Received message of type %d from peer %s; dropping it.\n",
486 ntohs (rmessage->type), GNUNET_i2s (other));
490 struct tunnel_list_element *tunnel = handle->established_tunnels.head;
492 while (tunnel != NULL)
494 if (tunnel->tunnel.id.id == tmessage->id.id &&
496 memcmp (&tmessage->id.initiator, &tunnel->tunnel.id.initiator,
497 sizeof (struct GNUNET_PeerIdentity))) &&
499 memcmp (&tmessage->id.target, &tunnel->tunnel.id.target,
500 sizeof (struct GNUNET_PeerIdentity))))
502 tunnel = tunnel->next;
505 /* if no tunnel was found: create a new inbound tunnel */
508 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
509 "New inbound tunnel from peer %s; first message has type %d.\n",
510 GNUNET_i2s (other), ntohs (rmessage->type));
511 tunnel = GNUNET_malloc (sizeof (struct tunnel_list_element));
512 tunnel->tunnel.connect_handler = NULL;
513 tunnel->tunnel.disconnect_handler = NULL;
514 tunnel->tunnel.handler_cls = NULL;
515 tunnel->tunnel.ctx = NULL;
516 tunnel->tunnel.handle = handle;
517 memcpy (&tunnel->tunnel.peer, other, sizeof (struct GNUNET_PeerIdentity));
518 memcpy (&tunnel->tunnel.id, &tmessage->id, sizeof (struct tunnel_id));
520 GNUNET_CONTAINER_DLL_insert_after (handle->established_tunnels.head,
521 handle->established_tunnels.tail,
522 handle->established_tunnels.tail,
526 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
527 "Inbound message from peer %s; type %d.\n", GNUNET_i2s (other),
528 ntohs (rmessage->type));
530 return handler->callback (handle->cls, &tunnel->tunnel, &tunnel->tunnel.ctx,
531 other, rmessage, atsi);
534 struct GNUNET_MESH_Tunnel *
535 GNUNET_MESH_peer_request_connect_by_type (struct GNUNET_MESH_Handle *handle,
536 struct GNUNET_TIME_Relative timeout,
537 GNUNET_MESH_ApplicationType
539 GNUNET_MESH_TunnelConnectHandler
541 GNUNET_MESH_TunnelDisconnectHandler
542 disconnect_handler, void *handler_cls)
544 /* Look in the list of connected peers */
545 struct peer_list_element *element = handle->connected_peers.head;
547 while (element != NULL)
549 struct type_list_element *i;
551 for (i = element->type_head; i != NULL; i = i->next)
552 if (application_type == i->type)
553 return GNUNET_MESH_peer_request_connect_all (handle, timeout, 1,
558 element = element->next;
561 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Trying to connect by tupe %d.\n",
564 /* Put into pending list */
565 struct tunnel_list_element *tunnel =
566 GNUNET_malloc (sizeof (struct tunnel_list_element));
568 tunnel->tunnel.connect_handler = connect_handler;
569 tunnel->tunnel.disconnect_handler = disconnect_handler;
570 tunnel->tunnel.handler_cls = handler_cls;
571 tunnel->tunnel.ctx = NULL;
572 tunnel->tunnel.handle = handle;
573 memcpy (&tunnel->tunnel.id.initiator, &handle->myself,
574 sizeof (struct GNUNET_PeerIdentity));
575 tunnel->tunnel.id.id = current_id++;
576 tunnel->tunnel.application_type = application_type;
578 GNUNET_CONTAINER_DLL_insert_after (handle->pending_by_type_tunnels.head,
579 handle->pending_by_type_tunnels.tail,
580 handle->pending_by_type_tunnels.tail,
582 return &tunnel->tunnel;
587 struct GNUNET_MESH_Tunnel *
588 GNUNET_MESH_peer_request_connect_all (struct GNUNET_MESH_Handle *handle,
589 struct GNUNET_TIME_Relative timeout,
590 unsigned int num_peers,
591 const struct GNUNET_PeerIdentity *peers,
592 GNUNET_MESH_TunnelConnectHandler
594 GNUNET_MESH_TunnelDisconnectHandler
595 disconnect_handler, void *handler_cls)
600 struct tunnel_list_element *tunnel =
601 GNUNET_malloc (sizeof (struct tunnel_list_element));
603 tunnel->tunnel.connect_handler = connect_handler;
604 tunnel->tunnel.disconnect_handler = disconnect_handler;
605 tunnel->tunnel.handler_cls = handler_cls;
606 tunnel->tunnel.ctx = NULL;
607 tunnel->tunnel.handle = handle;
608 memcpy (&tunnel->tunnel.id.initiator, &handle->myself,
609 sizeof (struct GNUNET_PeerIdentity));
610 memcpy (&tunnel->tunnel.id.target, peers,
611 sizeof (struct GNUNET_PeerIdentity));
612 tunnel->tunnel.id.id = current_id++;
613 memcpy (&tunnel->tunnel.peer, peers, sizeof (struct GNUNET_PeerIdentity));
615 struct peer_list_element *element = handle->connected_peers.head;
617 while (element != NULL)
620 memcmp (&element->peer, peers, sizeof (struct GNUNET_PeerIdentity)))
622 element = element->next;
627 /* we are connected to this peer */
628 GNUNET_CONTAINER_DLL_insert_after (handle->established_tunnels.head,
629 handle->established_tunnels.tail,
630 handle->established_tunnels.tail,
632 GNUNET_SCHEDULER_add_now (call_connect_handler, tunnel);
635 memcmp (peers, &handle->myself, sizeof (struct GNUNET_PeerIdentity)))
637 /* we are the peer */
638 GNUNET_CONTAINER_DLL_insert_after (handle->established_tunnels.head,
639 handle->established_tunnels.tail,
640 handle->established_tunnels.tail,
642 GNUNET_SCHEDULER_add_now (send_self_connect, tunnel);
646 /* we are not connected to this peer */
647 GNUNET_CONTAINER_DLL_insert_after (handle->pending_tunnels.head,
648 handle->pending_tunnels.tail,
649 handle->pending_tunnels.tail, tunnel);
650 (void) GNUNET_CORE_peer_request_connect (handle->core, peers, NULL, NULL);
653 return &tunnel->tunnel;
656 const struct GNUNET_PeerIdentity *
657 GNUNET_MESH_get_peer (const struct GNUNET_MESH_Tunnel *tunnel)
659 return &tunnel->peer;
663 core_notify (void *cls, size_t size, void *buf)
665 struct notify_cls *ncls = cls;
666 struct GNUNET_MESH_Tunnel *tunnel = ncls->tunnel;
668 tunnel->notify_handle = NULL;
669 struct tunnel_message *message = buf;
670 void *cbuf = (void *) &message[1];
672 GNUNET_assert (NULL != ncls->notify);
675 ncls->notify (ncls->notify_cls, size - sizeof (struct tunnel_message),
683 sent += sizeof (struct tunnel_message);
685 message->hdr.type = htons (GNUNET_MESSAGE_TYPE_MESH);
686 message->hdr.size = htons (sent);
687 memcpy (&message->id, &tunnel->id, sizeof (struct tunnel_id));
693 * Ask the mesh to call "notify" once it is ready to transmit the
694 * given number of bytes to the specified "target". If we are not yet
695 * connected to the specified peer, a call to this function will cause
696 * us to try to establish a connection.
698 * @param tunnel tunnel to use for transmission
699 * @param cork is corking allowed for this transmission?
700 * @param priority how important is the message?
701 * @param maxdelay how long can the message wait?
702 * @param target destination for the message, NULL for multicast to all tunnel targets
703 * @param notify_size how many bytes of buffer space does notify want?
704 * @param notify function to call when buffer space is available;
705 * will be called with NULL on timeout or if the overall queue
706 * for this peer is larger than queue_size and this is currently
707 * the message with the lowest priority
708 * @param notify_cls closure for notify
709 * @return non-NULL if the notify callback was queued,
710 * NULL if we can not even queue the request (insufficient
711 * memory); if NULL is returned, "notify" will NOT be called.
713 struct GNUNET_MESH_TransmitHandle *
714 GNUNET_MESH_notify_transmit_ready (struct GNUNET_MESH_Tunnel *tunnel, int cork,
716 struct GNUNET_TIME_Relative maxdelay,
717 const struct GNUNET_PeerIdentity *target
718 __attribute__ ((unused)), size_t notify_size,
719 GNUNET_CONNECTION_TransmitReadyNotify notify,
722 if (NULL != tunnel->notify_handle)
728 struct notify_cls *cls = GNUNET_malloc (sizeof (struct notify_cls));
730 cls->notify_cls = notify_cls;
731 GNUNET_assert (NULL != notify);
732 cls->notify = notify;
733 cls->tunnel = tunnel;
735 tunnel->notify_handle =
736 (struct GNUNET_MESH_TransmitHandle *)
737 GNUNET_CORE_notify_transmit_ready (tunnel->handle->core, cork, priority,
738 maxdelay, &tunnel->peer,
740 sizeof (struct tunnel_message),
741 &core_notify, (void *) cls);
743 return tunnel->notify_handle;
747 GNUNET_MESH_notify_transmit_ready_cancel (struct GNUNET_MESH_TransmitHandle *th)
749 GNUNET_CORE_notify_transmit_ready_cancel ((struct GNUNET_CORE_TransmitHandle
754 GNUNET_MESH_tunnel_set_head (struct GNUNET_MESH_Tunnel *tunnel, void *head)
756 tunnel->app_head = head;
760 GNUNET_MESH_tunnel_set_tail (struct GNUNET_MESH_Tunnel *tunnel, void *tail)
762 tunnel->app_tail = tail;
766 GNUNET_MESH_tunnel_get_head (struct GNUNET_MESH_Tunnel *tunnel)
768 return tunnel->app_head;
772 GNUNET_MESH_tunnel_get_tail (struct GNUNET_MESH_Tunnel *tunnel)
774 return tunnel->app_head;
778 GNUNET_MESH_tunnel_set_data (struct GNUNET_MESH_Tunnel *tunnel, void *data)
780 tunnel->app_data = data;
784 GNUNET_MESH_tunnel_get_data (struct GNUNET_MESH_Tunnel *tunnel)
786 return tunnel->app_data;
791 build_hello_message (struct GNUNET_MESH_Handle *handle,
792 const GNUNET_MESH_ApplicationType *stypes)
795 const GNUNET_MESH_ApplicationType *t;
797 for (t = stypes; *t != GNUNET_APPLICATION_TYPE_END; t++, num++) ;
799 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "I can handle %d app-types.\n", num);
801 handle->hello_message_size = sizeof (uint16_t) + /* For the number of types */
802 num * sizeof (GNUNET_MESH_ApplicationType); /* For the types */
804 uint16_t *nums = GNUNET_malloc (handle->hello_message_size);
805 GNUNET_MESH_ApplicationType *types =
806 (GNUNET_MESH_ApplicationType *) (nums + 1);
812 for (i = 0; i < num; i++)
814 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "I can handle the app-type %d\n",
816 types[i] = htons (stypes[i]);
819 handle->hello_message = nums;
823 struct GNUNET_MESH_Handle *
824 GNUNET_MESH_connect (const struct GNUNET_CONFIGURATION_Handle *cfg, void *cls,
825 GNUNET_MESH_TunnelEndHandler cleaner,
826 const struct GNUNET_MESH_MessageHandler *handlers,
827 const GNUNET_MESH_ApplicationType *stypes)
829 struct GNUNET_MESH_Handle *ret =
830 GNUNET_malloc (sizeof (struct GNUNET_MESH_Handle));
832 ret->connected_to_core = GNUNET_NO;
833 ret->connected_peers.head = NULL;
834 ret->connected_peers.tail = NULL;
835 ret->cleaner = cleaner;
838 const struct GNUNET_MESH_MessageHandler *it;
839 unsigned int len = 1;
841 for (it = handlers; it->callback != NULL; it++)
847 GNUNET_malloc (len * sizeof (struct GNUNET_MESH_MessageHandler));
848 memset (ret->handlers, 0, len * sizeof (struct GNUNET_MESH_MessageHandler));
849 memcpy (ret->handlers, handlers,
850 len * sizeof (struct GNUNET_MESH_MessageHandler));
852 build_hello_message (ret, stypes);
854 static const struct GNUNET_CORE_MessageHandler core_handlers[] = {
855 {&core_receive, GNUNET_MESSAGE_TYPE_MESH, 0},
856 {&receive_hello, GNUNET_MESSAGE_TYPE_MESH_HELLO, 0},
861 GNUNET_CORE_connect (cfg, 42, ret, &core_startup, &core_connect,
862 &core_disconnect, NULL, NULL, GNUNET_NO, NULL,
863 GNUNET_NO, core_handlers);
868 GNUNET_MESH_disconnect (struct GNUNET_MESH_Handle *handle)
870 GNUNET_free (handle->handlers);
871 GNUNET_free (handle->hello_message);
872 GNUNET_CORE_disconnect (handle->core);
874 struct peer_list_element *element = handle->connected_peers.head;
876 while (element != NULL)
878 struct peer_list_element *next = element->next;
880 while (element->type_head != NULL)
882 struct type_list_element *tail = element->type_tail;
884 GNUNET_CONTAINER_DLL_remove (element->type_head, element->type_tail,
888 GNUNET_CORE_notify_transmit_ready_cancel(element->hello);
889 GNUNET_SCHEDULER_cancel(element->sched);
890 GNUNET_free (element);
894 struct tunnel_list_element *tunnel = handle->pending_tunnels.head;
896 while (tunnel != NULL)
898 struct tunnel_list_element *next = tunnel->next;
900 GNUNET_free (tunnel);
903 tunnel = handle->established_tunnels.head;;
904 while (tunnel != NULL)
906 struct tunnel_list_element *next = tunnel->next;
908 GNUNET_free (tunnel);
912 GNUNET_free (handle);
915 /* end of mesh_api.c */