connecting peers fully implemented ... time for PIIZZA!
[oweals/gnunet.git] / src / transport / transport-testing.c
1 /*
2      This file is part of GNUnet.
3      (C) 2006, 2009 Christian Grothoff (and other contributing authors)
4
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 2, or (at your
8      option) any later version.
9
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.
14
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.
19 */
20
21 /**
22  * @file transport_testing.c
23  * @brief testing lib for transport service
24  *
25  * @author Matthias Wachs
26  */
27
28 #include "transport-testing.h"
29
30 struct ConnectingContext
31 {
32   struct PeerContext * p1;
33   struct PeerContext * p2;
34   GNUNET_SCHEDULER_TaskIdentifier tct;
35   GNUNET_TRANSPORT_TESTING_connect_cb cb;
36   void * cb_cls;
37
38   struct GNUNET_TRANSPORT_Handle *th_p1;
39   struct GNUNET_TRANSPORT_Handle *th_p2;
40   int c;
41 };
42
43 static void
44 exchange_hello_last (void *cls,
45                      const struct GNUNET_MessageHeader *message);
46 static void
47 exchange_hello (void *cls,
48                      const struct GNUNET_MessageHeader *message);
49
50 static void
51 notify_connect_internal (void *cls,
52                 const struct GNUNET_PeerIdentity *peer,
53                 const struct GNUNET_TRANSPORT_ATS_Information *ats,
54                 uint32_t ats_count)
55 {
56   struct ConnectingContext * cc = cls;
57 //  /void * cb_cls = cc->cb_cls;
58
59   GNUNET_assert(cc != NULL);
60   cc->c++;
61
62   if (cc->c == 2)
63   {
64      /* clean up */
65     GNUNET_TRANSPORT_get_hello_cancel (cc->th_p2, &exchange_hello_last, cc);
66     GNUNET_TRANSPORT_get_hello_cancel (cc->th_p1, &exchange_hello, cc);
67
68     if (cc->tct != GNUNET_SCHEDULER_NO_TASK)
69       GNUNET_SCHEDULER_cancel(cc->tct);
70
71     cc->tct = GNUNET_SCHEDULER_NO_TASK;
72
73     GNUNET_TRANSPORT_disconnect( cc->th_p1);
74     GNUNET_TRANSPORT_disconnect( cc->th_p2);
75
76     if (cc->cb != NULL)
77       cc->cb (cc->p1, cc->p2, cc->cb_cls);
78
79     GNUNET_free(cc);
80   }
81
82 }
83
84 static void
85 notify_connect (void *cls,
86                 const struct GNUNET_PeerIdentity *peer,
87                 const struct GNUNET_TRANSPORT_ATS_Information *ats,
88                 uint32_t ats_count)
89 {
90   struct PeerContext * p = cls;
91   if (p == NULL)
92     return;
93   if (p->nc != NULL)
94     p->nc (p->cb_cls, peer, ats, ats_count);
95 }
96
97 static void
98 notify_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer)
99 {
100   struct PeerContext * p = cls;
101   if (p == NULL)
102     return;
103   if (p->nd != NULL)
104     p->nd (p->cb_cls, peer);
105 }
106
107 static void
108 notify_receive (void *cls,
109                 const struct GNUNET_PeerIdentity *peer,
110                 const struct GNUNET_MessageHeader *message,
111                 const struct GNUNET_TRANSPORT_ATS_Information *ats,
112                 uint32_t ats_count)
113 {
114   struct PeerContext * p = cls;
115   if (p == NULL)
116     return;
117   if (p->rec != NULL)
118     p->rec (p->cb_cls, peer, message, ats, ats_count);
119 }
120
121
122 static void
123 exchange_hello_last (void *cls,
124                      const struct GNUNET_MessageHeader *message)
125 {
126   struct ConnectingContext * cc = cls;
127   struct PeerContext *me = cc->p2;
128   //struct PeerContext *p1 = cc->p1;
129
130   GNUNET_assert (message != NULL);
131   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
132               "Exchanging HELLO of size %d with peer (%s)!\n",
133               (int) GNUNET_HELLO_size((const struct GNUNET_HELLO_Message *)message),
134               GNUNET_i2s (&me->id));
135   GNUNET_assert (GNUNET_OK ==
136                  GNUNET_HELLO_get_id ((const struct GNUNET_HELLO_Message *)
137                                       message, &me->id));
138   GNUNET_TRANSPORT_offer_hello (cc->th_p1, message, NULL, NULL);
139 }
140
141
142 static void
143 exchange_hello (void *cls,
144                 const struct GNUNET_MessageHeader *message)
145 {
146   struct ConnectingContext * cc = cls;
147   struct PeerContext *me = cc->p1;
148   //struct PeerContext *p2 = cc->p2;
149
150   GNUNET_assert (message != NULL);
151   GNUNET_assert (GNUNET_OK ==
152                  GNUNET_HELLO_get_id ((const struct GNUNET_HELLO_Message *)
153                                       message, &me->id));
154   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
155               "Exchanging HELLO of size %d from peer %s!\n",
156               (int) GNUNET_HELLO_size((const struct GNUNET_HELLO_Message *)message),
157               GNUNET_i2s (&me->id));
158   GNUNET_TRANSPORT_offer_hello (cc->th_p2, message, NULL, NULL);
159 }
160
161 static void
162 try_connect (void *cls,
163              const struct GNUNET_SCHEDULER_TaskContext *tc)
164 {
165   struct ConnectingContext * cc = cls;
166   struct PeerContext *p1 = cc->p1;
167   struct PeerContext *p2 = cc->p2;
168
169   cc->tct = GNUNET_SCHEDULER_NO_TASK;
170   if ( (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
171     return;
172
173   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
174               "Asking peers to connect...\n");
175   /* FIXME: 'pX.id' may still be all-zeros here... */
176   GNUNET_TRANSPORT_try_connect (cc->th_p1,
177                                 &p2->id);
178   GNUNET_TRANSPORT_try_connect (cc->th_p2,
179                                 &p1->id);
180
181   cc->tct = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
182                                       &try_connect,
183                                       cc);
184 }
185
186 struct PeerContext *
187 GNUNET_TRANSPORT_TESTING_start_peer (const char * cfgname,
188     GNUNET_TRANSPORT_ReceiveCallback rec,
189     GNUNET_TRANSPORT_NotifyConnect nc,
190     GNUNET_TRANSPORT_NotifyDisconnect nd,
191     void * cb_cls)
192 {
193   struct PeerContext * p = GNUNET_malloc (sizeof (struct PeerContext));
194
195   p->cfg = GNUNET_CONFIGURATION_create ();
196
197   GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
198   if (GNUNET_CONFIGURATION_have_value (p->cfg,"PATHS", "SERVICEHOME"))
199       GNUNET_CONFIGURATION_get_value_string (p->cfg, "PATHS", "SERVICEHOME", &p->servicehome);
200   if (NULL != p->servicehome)
201     GNUNET_DISK_directory_remove (p->servicehome);
202   p->arm_proc = GNUNET_OS_start_process (NULL, NULL, "gnunet-service-arm",
203                                         "gnunet-service-arm",
204                                         "-c", cfgname,
205 #if VERBOSE_PEERS
206                                         "-L", "DEBUG",
207 #else
208                                         "-L", "ERROR",
209 #endif
210                                         NULL);
211   p->nc = nc;
212   p->nd = nd;
213   p->rec = rec;
214   p->cb_cls = cb_cls;
215
216   p->th = GNUNET_TRANSPORT_connect(p->cfg, NULL,
217                             p,
218                             &notify_receive,
219                             &notify_connect,
220                             &notify_disconnect);
221   GNUNET_assert (p->th != NULL);
222   return p;
223 }
224
225 void
226 GNUNET_TRANSPORT_TESTING_stop_peer (struct PeerContext * p)
227 {
228   if (p->th != NULL)
229     GNUNET_TRANSPORT_disconnect(p->th);
230
231   if (NULL != p->arm_proc)
232     {
233       if (0 != GNUNET_OS_process_kill (p->arm_proc, SIGTERM))
234         GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
235       GNUNET_OS_process_wait (p->arm_proc);
236       GNUNET_OS_process_close (p->arm_proc);
237       p->arm_proc = NULL;
238     }
239   GNUNET_CONFIGURATION_destroy (p->cfg);
240   if (p->servicehome != NULL)
241     {
242     GNUNET_DISK_directory_remove (p->servicehome);
243     GNUNET_free(p->servicehome);
244     }
245   GNUNET_free (p);
246 }
247
248 void
249 GNUNET_TRANSPORT_TESTING_connect_peers (struct PeerContext * p1,
250                                         struct PeerContext * p2,
251                                         GNUNET_TRANSPORT_TESTING_connect_cb cb,
252                                         void * cls)
253 {
254   struct ConnectingContext * cc = GNUNET_malloc (sizeof (struct ConnectingContext));
255
256   GNUNET_assert (p1 != NULL);
257   GNUNET_assert (p2 != NULL);
258
259   cc->p1 = p1;
260   cc->p2 = p2;
261
262   cc->cb = cb;
263   cc->cb_cls = cls;
264
265   cc->th_p1 = GNUNET_TRANSPORT_connect(cc->p1->cfg, NULL,
266                             cc,
267                             NULL,
268                             &notify_connect_internal,
269                             NULL);
270
271   cc->th_p2 = GNUNET_TRANSPORT_connect(cc->p2->cfg, NULL,
272                             cc,
273                             NULL,
274                             &notify_connect_internal,
275                             NULL);
276
277   GNUNET_assert (cc->th_p1 != NULL);
278   GNUNET_assert (cc->th_p2 != NULL);
279
280   GNUNET_TRANSPORT_get_hello (cc->th_p1, &exchange_hello, cc);
281   GNUNET_TRANSPORT_get_hello (cc->th_p2, &exchange_hello_last, cc);
282
283   cc->tct = GNUNET_SCHEDULER_add_now (&try_connect, cc);
284 }
285
286
287
288 /* end of transport_testing.h */