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;
119 struct peer_list_element *head, *tail;
122 struct GNUNET_MESH_Handle
124 struct GNUNET_CORE_Handle *core;
125 struct GNUNET_MESH_MessageHandler *handlers;
126 struct GNUNET_PeerIdentity myself;
127 unsigned int connected_to_core;
128 struct peer_list connected_peers;
129 struct tunnel_list established_tunnels;
130 struct tunnel_list pending_tunnels;
131 struct tunnel_list pending_by_type_tunnels;
133 GNUNET_MESH_TunnelEndHandler *cleaner;
134 size_t hello_message_size;
135 uint16_t *hello_message;
139 send_end_connect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
141 if ((tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
144 struct GNUNET_MESH_Tunnel *tunnel = cls;
146 tunnel->connect_handler (tunnel->handler_cls, NULL, NULL);
150 send_self_connect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
152 if ((tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
155 struct GNUNET_MESH_Tunnel *tunnel = cls;
157 tunnel->connect_handler (tunnel->handler_cls, &tunnel->handle->myself, NULL);
158 GNUNET_SCHEDULER_add_now (send_end_connect, tunnel);
162 call_connect_handler (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
164 if ((tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
167 struct GNUNET_MESH_Tunnel *tunnel = cls;
169 tunnel->connect_handler (tunnel->handler_cls, &tunnel->peer, NULL);
170 GNUNET_SCHEDULER_add_now (send_end_connect, tunnel);
174 core_startup (void *cls,
175 struct GNUNET_CORE_Handle *core __attribute__ ((unused)),
176 const struct GNUNET_PeerIdentity *my_identity,
177 const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *publicKey
178 __attribute__ ((unused)))
180 struct GNUNET_MESH_Handle *handle = cls;
182 memcpy (&handle->myself, my_identity, sizeof (struct GNUNET_PeerIdentity));
183 handle->connected_to_core = GNUNET_YES;
187 send_hello_message (void *cls, size_t size, void *buf)
192 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending hello\n");
194 struct GNUNET_MESH_Handle *handle = cls;
195 struct GNUNET_MessageHeader *hdr = buf;
198 sizeof (struct GNUNET_MessageHeader) + handle->hello_message_size;
203 hdr->type = htons (GNUNET_MESSAGE_TYPE_MESH_HELLO);
204 hdr->size = htons (size);
206 memcpy (hdr + 1, handle->hello_message, handle->hello_message_size);
212 * Core calls this if we are connected to a new peer.
214 * The peer is added to the connected_peers-list.
218 core_connect (void *cls,
219 const struct GNUNET_PeerIdentity *peer,
220 const struct GNUNET_TRANSPORT_ATS_Information *atsi)
222 struct GNUNET_MESH_Handle *handle = cls;
224 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
225 "Core tells us we are connected to peer %s\n", GNUNET_i2s (peer));
227 /* Send a hello to this peer */
228 GNUNET_CORE_notify_transmit_ready (handle->core,
231 GNUNET_TIME_UNIT_SECONDS,
233 sizeof (struct GNUNET_MessageHeader) +
234 handle->hello_message_size,
235 &send_hello_message, cls);
237 /* put the new peer into the list of connected peers */
238 struct peer_list_element *element =
239 GNUNET_malloc (sizeof (struct peer_list_element));
240 memcpy (&element->peer, peer, sizeof (struct GNUNET_PeerIdentity));
243 memcpy (&element->atsi, atsi,
244 sizeof (struct GNUNET_TRANSPORT_ATS_Information));
246 GNUNET_CONTAINER_DLL_insert_after (handle->connected_peers.head,
247 handle->connected_peers.tail,
248 handle->connected_peers.tail, element);
250 struct tunnel_list_element *tunnel = handle->pending_tunnels.head;
252 while (tunnel != NULL)
255 memcmp (&tunnel->tunnel.peer, peer,
256 sizeof (struct GNUNET_PeerIdentity)))
258 struct tunnel_list_element *next = tunnel->next;
260 GNUNET_CONTAINER_DLL_remove (handle->pending_tunnels.head,
261 handle->pending_tunnels.tail, tunnel);
262 GNUNET_CONTAINER_DLL_insert_after (handle->established_tunnels.head,
263 handle->established_tunnels.tail,
264 handle->established_tunnels.tail,
266 tunnel->tunnel.connect_handler (tunnel->tunnel.handler_cls, peer, atsi);
267 GNUNET_SCHEDULER_add_now (send_end_connect, tunnel);
271 tunnel = tunnel->next;
276 * Core calls this if we disconnect a peer
278 * Remove this peer from the list of connected peers
279 * Close all tunnels this peer belongs to
282 core_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer)
284 struct GNUNET_MESH_Handle *handle = cls;
286 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
287 "Core tells us we are no longer connected to peer %s\n",
290 struct peer_list_element *element = handle->connected_peers.head;
292 while (element != NULL)
294 if (0 == memcmp (&element->peer, peer, sizeof (struct GNUNET_PeerIdentity)))
296 element = element->next;
300 GNUNET_CONTAINER_DLL_remove (handle->connected_peers.head,
301 handle->connected_peers.tail, element);
302 while (element->type_head != NULL)
304 struct type_list_element *tail = element->type_tail;
306 GNUNET_CONTAINER_DLL_remove (element->type_head, element->type_tail,
310 GNUNET_free (element);
313 struct tunnel_list_element *telement = handle->established_tunnels.head;
315 while (telement != NULL)
318 memcmp (&telement->tunnel.peer, peer,
319 sizeof (struct GNUNET_PeerIdentity)))
321 /* disconnect tunnels */
322 /* outbound tunnels */
323 if (telement->tunnel.connect_handler != NULL &&
324 NULL != telement->tunnel.disconnect_handler)
325 telement->tunnel.disconnect_handler (telement->tunnel.handler_cls,
327 /* inbound tunnels */
328 else if (NULL != handle->cleaner)
329 handle->cleaner (handle->cls, &telement->tunnel, &telement->tunnel.ctx);
331 struct tunnel_list_element *next = telement->next;
333 GNUNET_CONTAINER_DLL_remove (handle->established_tunnels.head,
334 handle->established_tunnels.tail, telement);
335 GNUNET_free (telement);
340 telement = telement->next;
346 * Receive a message from core.
347 * This is a hello-message, containing the application-types the other peer can receive
350 receive_hello (void *cls,
351 const struct GNUNET_PeerIdentity *other,
352 const struct GNUNET_MessageHeader *message,
353 const struct GNUNET_TRANSPORT_ATS_Information *atsi)
355 struct GNUNET_MESH_Handle *handle = cls;
356 uint16_t *num = (uint16_t *) (message + 1);
357 GNUNET_MESH_ApplicationType *ports =
358 (GNUNET_MESH_ApplicationType *) (num + 1);
361 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
362 "The peer %s tells us he supports %d application-types.\n",
363 GNUNET_i2s (other), ntohs (*num));
365 struct peer_list_element *element = handle->connected_peers.head;
367 while (element != NULL)
370 memcmp (&element->peer, other, sizeof (struct GNUNET_PeerIdentity)))
372 element = element->next;
375 GNUNET_assert (NULL != element);
377 for (i = 0; i < ntohs (*num); i++)
379 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
380 "The peer %s newly supports the application-type %d\n",
381 GNUNET_i2s (other), ntohs (ports[i]));
382 if (GNUNET_APPLICATION_TYPE_END == ntohs (ports[i]))
384 struct type_list_element *new_type = GNUNET_malloc (sizeof *new_type);
386 new_type->type = (GNUNET_MESH_ApplicationType) ntohs (ports[i]);
387 GNUNET_CONTAINER_DLL_insert (element->type_head, element->type_tail,
391 struct type_list_element *type;
393 for (type = element->type_head; type != NULL; type = type->next)
395 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
396 "The peer %s supports the application-type %d\n",
397 GNUNET_i2s (other), type->type);
400 struct tunnel_list_element *tunnel = handle->pending_by_type_tunnels.head;
402 while (tunnel != NULL)
404 struct tunnel_list_element *next = tunnel->next;
406 for (i = 0; i < ntohs (*num); i++)
408 if (ntohs (ports[i]) == tunnel->tunnel.application_type)
410 GNUNET_CONTAINER_DLL_remove (handle->pending_by_type_tunnels.head,
411 handle->pending_by_type_tunnels.tail,
413 GNUNET_CONTAINER_DLL_insert_after (handle->established_tunnels.head,
414 handle->established_tunnels.tail,
415 handle->established_tunnels.tail,
417 memcpy (&tunnel->tunnel.peer, other,
418 sizeof (struct GNUNET_PeerIdentity));
419 tunnel->tunnel.connect_handler (tunnel->tunnel.handler_cls,
420 &tunnel->tunnel.peer, atsi);
421 GNUNET_SCHEDULER_add_now (send_end_connect, tunnel);
425 if (ntohs (ports[i]) == tunnel->tunnel.application_type)
428 tunnel = tunnel->next;
434 * Receive a message from core.
437 core_receive (void *cls,
438 const struct GNUNET_PeerIdentity *other,
439 const struct GNUNET_MessageHeader *message,
440 const struct GNUNET_TRANSPORT_ATS_Information *atsi)
442 struct GNUNET_MESH_Handle *handle = cls;
443 struct tunnel_message *tmessage = (struct tunnel_message *) message;
444 struct GNUNET_MessageHeader *rmessage =
445 (struct GNUNET_MessageHeader *) (tmessage + 1);
447 struct GNUNET_MESH_MessageHandler *handler;
449 for (handler = handle->handlers; handler->callback != NULL; handler++)
451 if ((ntohs (rmessage->type) == handler->type)
452 && ((handler->expected_size == 0)
453 || (handler->expected_size == ntohs (rmessage->size))))
459 /* handler->callback handles this message */
461 /* If no handler was found, drop the message but keep the channel open */
462 if (handler->callback == NULL)
464 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
465 "Received message of type %d from peer %s; dropping it.\n",
466 ntohs (rmessage->type), GNUNET_i2s (other));
470 struct tunnel_list_element *tunnel = handle->established_tunnels.head;
472 while (tunnel != NULL)
474 if (tunnel->tunnel.id.id == tmessage->id.id &&
476 memcmp (&tmessage->id.initiator, &tunnel->tunnel.id.initiator,
477 sizeof (struct GNUNET_PeerIdentity)))
479 memcmp (&tmessage->id.target, &tunnel->tunnel.id.target,
480 sizeof (struct GNUNET_PeerIdentity))))
482 tunnel = tunnel->next;
485 /* if no tunnel was found: create a new inbound tunnel */
488 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
489 "New inbound tunnel from peer %s; first message has type %d.\n",
490 GNUNET_i2s (other), ntohs (rmessage->type));
491 tunnel = GNUNET_malloc (sizeof (struct tunnel_list_element));
492 tunnel->tunnel.connect_handler = NULL;
493 tunnel->tunnel.disconnect_handler = NULL;
494 tunnel->tunnel.handler_cls = NULL;
495 tunnel->tunnel.ctx = NULL;
496 tunnel->tunnel.handle = handle;
497 memcpy (&tunnel->tunnel.peer, other, sizeof (struct GNUNET_PeerIdentity));
498 memcpy (&tunnel->tunnel.id, &tmessage->id, sizeof (struct tunnel_id));
500 GNUNET_CONTAINER_DLL_insert_after (handle->established_tunnels.head,
501 handle->established_tunnels.tail,
502 handle->established_tunnels.tail,
506 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
507 "Inbound message from peer %s; type %d.\n", GNUNET_i2s (other),
508 ntohs (rmessage->type));
510 return handler->callback (handle->cls, &tunnel->tunnel,
511 &tunnel->tunnel.ctx, other, rmessage, atsi);
514 struct GNUNET_MESH_Tunnel *
515 GNUNET_MESH_peer_request_connect_by_type (struct GNUNET_MESH_Handle *handle,
516 struct GNUNET_TIME_Relative timeout,
517 GNUNET_MESH_ApplicationType
519 GNUNET_MESH_TunnelConnectHandler
521 GNUNET_MESH_TunnelDisconnectHandler
522 disconnect_handler, void *handler_cls)
524 /* Look in the list of connected peers */
525 struct peer_list_element *element = handle->connected_peers.head;
527 while (element != NULL)
529 struct type_list_element *i;
531 for (i = element->type_head; i != NULL; i = i->next)
532 if (application_type == i->type)
533 return GNUNET_MESH_peer_request_connect_all (handle, timeout, 1,
538 element = element->next;
541 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Trying to connect by tupe %d.\n",
544 /* Put into pending list */
545 struct tunnel_list_element *tunnel =
546 GNUNET_malloc (sizeof (struct tunnel_list_element));
548 tunnel->tunnel.connect_handler = connect_handler;
549 tunnel->tunnel.disconnect_handler = disconnect_handler;
550 tunnel->tunnel.handler_cls = handler_cls;
551 tunnel->tunnel.ctx = NULL;
552 tunnel->tunnel.handle = handle;
553 memcpy (&tunnel->tunnel.id.initiator, &handle->myself,
554 sizeof (struct GNUNET_PeerIdentity));
555 tunnel->tunnel.id.id = current_id++;
556 tunnel->tunnel.application_type = application_type;
558 GNUNET_CONTAINER_DLL_insert_after (handle->pending_by_type_tunnels.head,
559 handle->pending_by_type_tunnels.tail,
560 handle->pending_by_type_tunnels.tail,
562 return &tunnel->tunnel;
567 struct GNUNET_MESH_Tunnel *
568 GNUNET_MESH_peer_request_connect_all (struct GNUNET_MESH_Handle *handle,
569 struct GNUNET_TIME_Relative timeout,
570 unsigned int num_peers,
571 const struct GNUNET_PeerIdentity *peers,
572 GNUNET_MESH_TunnelConnectHandler
574 GNUNET_MESH_TunnelDisconnectHandler
575 disconnect_handler, void *handler_cls)
580 struct tunnel_list_element *tunnel =
581 GNUNET_malloc (sizeof (struct tunnel_list_element));
583 tunnel->tunnel.connect_handler = connect_handler;
584 tunnel->tunnel.disconnect_handler = disconnect_handler;
585 tunnel->tunnel.handler_cls = handler_cls;
586 tunnel->tunnel.ctx = NULL;
587 tunnel->tunnel.handle = handle;
588 memcpy (&tunnel->tunnel.id.initiator, &handle->myself,
589 sizeof (struct GNUNET_PeerIdentity));
590 memcpy (&tunnel->tunnel.id.target, peers,
591 sizeof (struct GNUNET_PeerIdentity));
592 tunnel->tunnel.id.id = current_id++;
593 memcpy (&tunnel->tunnel.peer, peers, sizeof (struct GNUNET_PeerIdentity));
595 struct peer_list_element *element = handle->connected_peers.head;
597 while (element != NULL)
600 memcmp (&element->peer, peers, sizeof (struct GNUNET_PeerIdentity)))
602 element = element->next;
607 /* we are connected to this peer */
608 GNUNET_CONTAINER_DLL_insert_after (handle->established_tunnels.head,
609 handle->established_tunnels.tail,
610 handle->established_tunnels.tail,
612 GNUNET_SCHEDULER_add_now (call_connect_handler, tunnel);
615 memcmp (peers, &handle->myself, sizeof (struct GNUNET_PeerIdentity)))
617 /* we are the peer */
618 GNUNET_CONTAINER_DLL_insert_after (handle->established_tunnels.head,
619 handle->established_tunnels.tail,
620 handle->established_tunnels.tail,
622 GNUNET_SCHEDULER_add_now (send_self_connect, tunnel);
626 /* we are not connected to this peer */
627 GNUNET_CONTAINER_DLL_insert_after (handle->pending_tunnels.head,
628 handle->pending_tunnels.tail,
629 handle->pending_tunnels.tail, tunnel);
630 (void) GNUNET_CORE_peer_request_connect (handle->core, peers, NULL, NULL);
633 return &tunnel->tunnel;
636 const struct GNUNET_PeerIdentity *
637 GNUNET_MESH_get_peer (const struct GNUNET_MESH_Tunnel *tunnel)
639 return &tunnel->peer;
643 core_notify (void *cls, size_t size, void *buf)
645 struct notify_cls *ncls = cls;
646 struct GNUNET_MESH_Tunnel *tunnel = ncls->tunnel;
648 tunnel->notify_handle = NULL;
649 struct tunnel_message *message = buf;
650 void *cbuf = (void *) &message[1];
652 GNUNET_assert (NULL != ncls->notify);
655 ncls->notify (ncls->notify_cls, size - sizeof (struct tunnel_message),
663 sent += sizeof (struct tunnel_message);
665 message->hdr.type = htons (GNUNET_MESSAGE_TYPE_MESH);
666 message->hdr.size = htons (sent);
667 memcpy (&message->id, &tunnel->id, sizeof (struct tunnel_id));
673 * Ask the mesh to call "notify" once it is ready to transmit the
674 * given number of bytes to the specified "target". If we are not yet
675 * connected to the specified peer, a call to this function will cause
676 * us to try to establish a connection.
678 * @param tunnel tunnel to use for transmission
679 * @param cork is corking allowed for this transmission?
680 * @param priority how important is the message?
681 * @param maxdelay how long can the message wait?
682 * @param target destination for the message, NULL for multicast to all tunnel targets
683 * @param notify_size how many bytes of buffer space does notify want?
684 * @param notify function to call when buffer space is available;
685 * will be called with NULL on timeout or if the overall queue
686 * for this peer is larger than queue_size and this is currently
687 * the message with the lowest priority
688 * @param notify_cls closure for notify
689 * @return non-NULL if the notify callback was queued,
690 * NULL if we can not even queue the request (insufficient
691 * memory); if NULL is returned, "notify" will NOT be called.
693 struct GNUNET_MESH_TransmitHandle *
694 GNUNET_MESH_notify_transmit_ready (struct
702 const struct GNUNET_PeerIdentity *target
703 __attribute__ ((unused)),
705 GNUNET_CONNECTION_TransmitReadyNotify
706 notify, void *notify_cls)
708 if (NULL != tunnel->notify_handle)
714 struct notify_cls *cls = GNUNET_malloc (sizeof (struct notify_cls));
716 cls->notify_cls = notify_cls;
717 GNUNET_assert (NULL != notify);
718 cls->notify = notify;
719 cls->tunnel = tunnel;
721 tunnel->notify_handle = (struct GNUNET_MESH_TransmitHandle *)
722 GNUNET_CORE_notify_transmit_ready (tunnel->handle->core, cork, priority,
723 maxdelay, &tunnel->peer,
725 sizeof (struct tunnel_message),
726 &core_notify, (void *) cls);
728 return tunnel->notify_handle;
732 GNUNET_MESH_notify_transmit_ready_cancel (struct GNUNET_MESH_TransmitHandle *th)
734 GNUNET_CORE_notify_transmit_ready_cancel ((struct GNUNET_CORE_TransmitHandle
739 GNUNET_MESH_tunnel_set_head (struct GNUNET_MESH_Tunnel *tunnel, void *head)
741 tunnel->app_head = head;
745 GNUNET_MESH_tunnel_set_tail (struct GNUNET_MESH_Tunnel *tunnel, void *tail)
747 tunnel->app_tail = tail;
751 GNUNET_MESH_tunnel_get_head (struct GNUNET_MESH_Tunnel *tunnel)
753 return tunnel->app_head;
757 GNUNET_MESH_tunnel_get_tail (struct GNUNET_MESH_Tunnel *tunnel)
759 return tunnel->app_head;
763 GNUNET_MESH_tunnel_set_data (struct GNUNET_MESH_Tunnel *tunnel, void *data)
765 tunnel->app_data = data;
769 GNUNET_MESH_tunnel_get_data (struct GNUNET_MESH_Tunnel *tunnel)
771 return tunnel->app_data;
776 build_hello_message (struct GNUNET_MESH_Handle *handle,
777 const GNUNET_MESH_ApplicationType *stypes)
780 const GNUNET_MESH_ApplicationType *t;
782 for (t = stypes; *t != GNUNET_APPLICATION_TYPE_END; t++, num++) ;
784 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "I can handle %d app-types.\n", num);
786 handle->hello_message_size = sizeof (uint16_t) + /* For the number of types */
787 num * sizeof (GNUNET_MESH_ApplicationType); /* For the types */
789 uint16_t *nums = GNUNET_malloc (handle->hello_message_size);
790 GNUNET_MESH_ApplicationType *types =
791 (GNUNET_MESH_ApplicationType *) (nums + 1);
797 for (i = 0; i < num; i++)
799 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "I can handle the app-type %d\n",
801 types[i] = htons (stypes[i]);
804 handle->hello_message = nums;
808 struct GNUNET_MESH_Handle *
809 GNUNET_MESH_connect (const struct
810 GNUNET_CONFIGURATION_Handle
812 GNUNET_MESH_TunnelEndHandler
814 const struct GNUNET_MESH_MessageHandler *handlers,
815 const GNUNET_MESH_ApplicationType *stypes)
817 struct GNUNET_MESH_Handle *ret =
818 GNUNET_malloc (sizeof (struct GNUNET_MESH_Handle));
820 ret->connected_to_core = GNUNET_NO;
821 ret->connected_peers.head = NULL;
822 ret->connected_peers.tail = NULL;
823 ret->cleaner = cleaner;
826 const struct GNUNET_MESH_MessageHandler *it;
827 unsigned int len = 1;
829 for (it = handlers; it->callback != NULL; it++)
835 GNUNET_malloc (len * sizeof (struct GNUNET_MESH_MessageHandler));
836 memset (ret->handlers, 0, len * sizeof (struct GNUNET_MESH_MessageHandler));
837 memcpy (ret->handlers, handlers,
838 len * sizeof (struct GNUNET_MESH_MessageHandler));
840 build_hello_message (ret, stypes);
842 static const struct GNUNET_CORE_MessageHandler core_handlers[] = {
843 {&core_receive, GNUNET_MESSAGE_TYPE_MESH, 0},
844 {&receive_hello, GNUNET_MESSAGE_TYPE_MESH_HELLO, 0},
848 ret->core = GNUNET_CORE_connect (cfg,
856 GNUNET_NO, NULL, GNUNET_NO, core_handlers);
861 GNUNET_MESH_disconnect (struct GNUNET_MESH_Handle *handle)
863 GNUNET_free (handle->handlers);
864 GNUNET_free (handle->hello_message);
865 GNUNET_CORE_disconnect (handle->core);
867 struct peer_list_element *element = handle->connected_peers.head;
869 while (element != NULL)
871 struct peer_list_element *next = element->next;
873 while (element->type_head != NULL)
875 struct type_list_element *tail = element->type_tail;
877 GNUNET_CONTAINER_DLL_remove (element->type_head, element->type_tail,
881 GNUNET_free (element);
885 struct tunnel_list_element *tunnel = handle->pending_tunnels.head;
887 while (tunnel != NULL)
889 struct tunnel_list_element *next = tunnel->next;
891 GNUNET_free (tunnel);
894 tunnel = handle->established_tunnels.head;;
895 while (tunnel != NULL)
897 struct tunnel_list_element *next = tunnel->next;
899 GNUNET_free (tunnel);
903 GNUNET_free (handle);
906 /* end of mesh_api.c */