diff options
author | Matthias Wachs <wachs@net.in.tum.de> | 2011-10-27 19:14:50 +0000 |
---|---|---|
committer | Matthias Wachs <wachs@net.in.tum.de> | 2011-10-27 19:14:50 +0000 |
commit | 7961bd44ccf6e76aa8d82154381030f332f7fb6d (patch) | |
tree | 7539fc601a75814bb6b8332ac6677c5b128fe605 | |
parent | 535f25a46ffa5c535f1b01b87e14a42261580425 (diff) | |
download | gnunet-7961bd44ccf6e76aa8d82154381030f332f7fb6d.tar.gz gnunet-7961bd44ccf6e76aa8d82154381030f332f7fb6d.zip |
-rw-r--r-- | src/transport/gnunet-service-transport_3way.c | 580 | ||||
-rw-r--r-- | src/transport/gnunet-service-transport_neighbours_3way.c (renamed from src/transport/gnunet-service-transport_neighbours_fsm.c) | 0 | ||||
-rw-r--r-- | src/transport/gnunet-service-transport_neighbours_3way.h | 272 |
3 files changed, 852 insertions, 0 deletions
diff --git a/src/transport/gnunet-service-transport_3way.c b/src/transport/gnunet-service-transport_3way.c new file mode 100644 index 000000000..a24d6c1b1 --- /dev/null +++ b/src/transport/gnunet-service-transport_3way.c | |||
@@ -0,0 +1,580 @@ | |||
1 | /* | ||
2 | This file is part of GNUnet. | ||
3 | (C) 2010,2011 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 3, 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/gnunet-service-transport-new.c | ||
23 | * @brief | ||
24 | * @author Christian Grothoff | ||
25 | */ | ||
26 | #include "platform.h" | ||
27 | #include "gnunet_util_lib.h" | ||
28 | #include "gnunet_statistics_service.h" | ||
29 | #include "gnunet_transport_service.h" | ||
30 | #include "gnunet_peerinfo_service.h" | ||
31 | #include "gnunet_ats_service.h" | ||
32 | #include "gnunet-service-transport.h" | ||
33 | #include "gnunet-service-transport_blacklist.h" | ||
34 | #include "gnunet-service-transport_clients.h" | ||
35 | #include "gnunet-service-transport_hello.h" | ||
36 | #include "gnunet-service-transport_neighbours.h" | ||
37 | #include "gnunet-service-transport_plugins.h" | ||
38 | #include "gnunet-service-transport_validation.h" | ||
39 | #include "transport.h" | ||
40 | |||
41 | /* globals */ | ||
42 | |||
43 | /** | ||
44 | * Statistics handle. | ||
45 | */ | ||
46 | struct GNUNET_STATISTICS_Handle *GST_stats; | ||
47 | |||
48 | /** | ||
49 | * Configuration handle. | ||
50 | */ | ||
51 | const struct GNUNET_CONFIGURATION_Handle *GST_cfg; | ||
52 | |||
53 | /** | ||
54 | * Configuration handle. | ||
55 | */ | ||
56 | struct GNUNET_PeerIdentity GST_my_identity; | ||
57 | |||
58 | /** | ||
59 | * Handle to peerinfo service. | ||
60 | */ | ||
61 | struct GNUNET_PEERINFO_Handle *GST_peerinfo; | ||
62 | |||
63 | /** | ||
64 | * Our public key. | ||
65 | */ | ||
66 | struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded GST_my_public_key; | ||
67 | |||
68 | /** | ||
69 | * Our private key. | ||
70 | */ | ||
71 | struct GNUNET_CRYPTO_RsaPrivateKey *GST_my_private_key; | ||
72 | |||
73 | /** | ||
74 | * ATS handle. | ||
75 | */ | ||
76 | struct GNUNET_ATS_SchedulingHandle *GST_ats; | ||
77 | |||
78 | |||
79 | /** | ||
80 | * Transmit our HELLO message to the given (connected) neighbour. | ||
81 | * | ||
82 | * @param cls the 'HELLO' message | ||
83 | * @param target a connected neighbour | ||
84 | * @param ats performance information (unused) | ||
85 | * @param ats_count number of records in ats (unused) | ||
86 | * @param transport plugin | ||
87 | * @param addr address | ||
88 | * @param addrlen address length | ||
89 | */ | ||
90 | static void | ||
91 | transmit_our_hello (void *cls, const struct GNUNET_PeerIdentity *target, | ||
92 | const struct GNUNET_ATS_Information *ats, | ||
93 | uint32_t ats_count, | ||
94 | const char * transport, | ||
95 | const void * addr, | ||
96 | size_t addrlen) | ||
97 | { | ||
98 | const struct GNUNET_MessageHeader *hello = cls; | ||
99 | |||
100 | GST_neighbours_send (target, (const char *) hello, ntohs (hello->size), | ||
101 | GNUNET_CONSTANTS_HELLO_ADDRESS_EXPIRATION, NULL, NULL); | ||
102 | } | ||
103 | |||
104 | |||
105 | /** | ||
106 | * My HELLO has changed. Tell everyone who should know. | ||
107 | * | ||
108 | * @param cls unused | ||
109 | * @param hello new HELLO | ||
110 | */ | ||
111 | static void | ||
112 | process_hello_update (void *cls, const struct GNUNET_MessageHeader *hello) | ||
113 | { | ||
114 | GST_clients_broadcast (hello, GNUNET_NO); | ||
115 | GST_neighbours_iterate (&transmit_our_hello, (void *) hello); | ||
116 | } | ||
117 | |||
118 | |||
119 | |||
120 | /** | ||
121 | * We received some payload. Prepare to pass it on to our clients. | ||
122 | * | ||
123 | * @param peer (claimed) identity of the other peer | ||
124 | * @param message the message, NULL if we only care about | ||
125 | * learning about the delay until we should receive again -- FIXME! | ||
126 | * @param ats performance information | ||
127 | * @param ats_count number of records in ats | ||
128 | * @return how long the plugin should wait until receiving more data | ||
129 | */ | ||
130 | static struct GNUNET_TIME_Relative | ||
131 | process_payload (const struct GNUNET_PeerIdentity *peer, | ||
132 | const struct GNUNET_MessageHeader *message, | ||
133 | const struct GNUNET_ATS_Information *ats, | ||
134 | uint32_t ats_count) | ||
135 | { | ||
136 | struct GNUNET_TIME_Relative ret; | ||
137 | int do_forward; | ||
138 | struct InboundMessage *im; | ||
139 | size_t size = sizeof (struct InboundMessage) + ntohs (message->size) + sizeof (struct GNUNET_ATS_Information) * ats_count; | ||
140 | char buf[size]; | ||
141 | struct GNUNET_ATS_Information *ap; | ||
142 | |||
143 | ret = GNUNET_TIME_UNIT_ZERO; | ||
144 | do_forward = GNUNET_SYSERR; | ||
145 | ret = | ||
146 | GST_neighbours_calculate_receive_delay (peer, | ||
147 | (message == | ||
148 | NULL) ? 0 : | ||
149 | ntohs (message->size), | ||
150 | &do_forward); | ||
151 | |||
152 | im = (struct InboundMessage*) buf; | ||
153 | im->header.size = htons (size); | ||
154 | im->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_RECV); | ||
155 | im->ats_count = htonl (ats_count); | ||
156 | im->peer = *peer; | ||
157 | ap = (struct GNUNET_ATS_Information*) &im[1]; | ||
158 | memcpy (ap, ats, ats_count * sizeof (struct GNUNET_ATS_Information)); | ||
159 | memcpy (&ap[ats_count], message, ntohs (message->size)); | ||
160 | |||
161 | switch (do_forward) | ||
162 | { | ||
163 | case GNUNET_YES: | ||
164 | GST_clients_broadcast (&im->header, GNUNET_YES); | ||
165 | break; | ||
166 | case GNUNET_NO: | ||
167 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | ||
168 | _("Discarded %u bytes of type %u from %s: quota violated or no neighbour record!\n"), | ||
169 | ntohs (message->size), | ||
170 | ntohs (message->type), | ||
171 | GNUNET_i2s (peer)); | ||
172 | break; | ||
173 | case GNUNET_SYSERR: | ||
174 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | ||
175 | _("Discarded %u bytes of type %u from %s: connection is down!\n"), | ||
176 | ntohs (message->size), | ||
177 | ntohs (message->type), | ||
178 | GNUNET_i2s (peer)); | ||
179 | /* FIXME: store until connection is up? This is virtually always a SETKEY and a PING... */ | ||
180 | break; | ||
181 | default: | ||
182 | GNUNET_break (0); | ||
183 | break; | ||
184 | } | ||
185 | return ret; | ||
186 | } | ||
187 | |||
188 | |||
189 | /** | ||
190 | * Function called by the transport for each received message. | ||
191 | * This function should also be called with "NULL" for the | ||
192 | * message to signal that the other peer disconnected. | ||
193 | * | ||
194 | * @param cls closure, const char* with the name of the plugin we received the message from | ||
195 | * @param peer (claimed) identity of the other peer | ||
196 | * @param message the message, NULL if we only care about | ||
197 | * learning about the delay until we should receive again -- FIXME! | ||
198 | * @param ats performance information | ||
199 | * @param ats_count number of records in ats | ||
200 | * @param session identifier used for this session (NULL for plugins | ||
201 | * that do not offer bi-directional communication to the sender | ||
202 | * using the same "connection") | ||
203 | * @param sender_address binary address of the sender (if we established the | ||
204 | * connection or are otherwise sure of it; should be NULL | ||
205 | * for inbound TCP/UDP connections since it it not clear | ||
206 | * that we could establish ourselves a connection to that | ||
207 | * IP address and get the same system) | ||
208 | * @param sender_address_len number of bytes in sender_address | ||
209 | * @return how long the plugin should wait until receiving more data | ||
210 | * (plugins that do not support this, can ignore the return value) | ||
211 | */ | ||
212 | static struct GNUNET_TIME_Relative | ||
213 | plugin_env_receive_callback (void *cls, const struct GNUNET_PeerIdentity *peer, | ||
214 | const struct GNUNET_MessageHeader *message, | ||
215 | const struct GNUNET_ATS_Information *ats, | ||
216 | uint32_t ats_count, struct Session *session, | ||
217 | const char *sender_address, | ||
218 | uint16_t sender_address_len) | ||
219 | { | ||
220 | const char *plugin_name = cls; | ||
221 | struct GNUNET_TIME_Relative ret; | ||
222 | uint16_t type; | ||
223 | |||
224 | ret = GNUNET_TIME_UNIT_ZERO; | ||
225 | if (NULL == message) | ||
226 | goto end; | ||
227 | type = ntohs (message->type); | ||
228 | #if DEBUG_TRANSPORT | ||
229 | |||
230 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Received Message with type %u\n", type); | ||
231 | #endif | ||
232 | |||
233 | switch (type) | ||
234 | { | ||
235 | case GNUNET_MESSAGE_TYPE_HELLO: | ||
236 | GST_validation_handle_hello (message); | ||
237 | return ret; | ||
238 | case GNUNET_MESSAGE_TYPE_TRANSPORT_PING: | ||
239 | #if DEBUG_TRANSPORT | ||
240 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK, | ||
241 | "Processing `%s' from `%s'\n", "PING", | ||
242 | (sender_address != NULL) ? GST_plugins_a2s (plugin_name, | ||
243 | sender_address, | ||
244 | sender_address_len) | ||
245 | : "<inbound>"); | ||
246 | #endif | ||
247 | GST_validation_handle_ping (peer, message, plugin_name, session, | ||
248 | sender_address, sender_address_len); | ||
249 | break; | ||
250 | case GNUNET_MESSAGE_TYPE_TRANSPORT_PONG: | ||
251 | #if DEBUG_TRANSPORT | ||
252 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK, | ||
253 | "Processing `%s' from `%s'\n", "PONG", | ||
254 | (sender_address != NULL) ? GST_plugins_a2s (plugin_name, | ||
255 | sender_address, | ||
256 | sender_address_len) | ||
257 | : "<inbound>"); | ||
258 | #endif | ||
259 | GST_validation_handle_pong (peer, message); | ||
260 | break; | ||
261 | case GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_CONNECT: | ||
262 | GST_neighbours_handle_connect (message, | ||
263 | peer, | ||
264 | plugin_name, sender_address, sender_address_len, | ||
265 | session, ats, ats_count); | ||
266 | break; | ||
267 | case GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_CONNECT_ACK: | ||
268 | GST_neighbours_handle_connect_ack (message, | ||
269 | peer, | ||
270 | plugin_name, sender_address, sender_address_len, | ||
271 | session, ats, ats_count); | ||
272 | break; | ||
273 | case GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_ACK: | ||
274 | GST_neighbours_handle_ack (message, | ||
275 | peer, | ||
276 | plugin_name, sender_address, sender_address_len, | ||
277 | session, ats, ats_count); | ||
278 | break; | ||
279 | case GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_DISCONNECT: | ||
280 | GST_neighbours_handle_disconnect_message (peer, message); | ||
281 | break; | ||
282 | case GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_KEEPALIVE: | ||
283 | GST_neighbours_keepalive (peer); | ||
284 | break; | ||
285 | default: | ||
286 | /* should be payload */ | ||
287 | ret = process_payload (peer, | ||
288 | message, | ||
289 | ats, ats_count); | ||
290 | break; | ||
291 | } | ||
292 | end: | ||
293 | #if 1 | ||
294 | /* FIXME: this should not be needed, and not sure it's good to have it, but without | ||
295 | this connections seem to go extra-slow */ | ||
296 | GNUNET_ATS_address_update (GST_ats, peer, | ||
297 | plugin_name, sender_address, sender_address_len, | ||
298 | session, | ||
299 | ats, ats_count); | ||
300 | #endif | ||
301 | #if DEBUG_TRANSPORT | ||
302 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
303 | "Allowing receive from peer %s to continue in %llu ms\n", | ||
304 | GNUNET_i2s (peer), | ||
305 | (unsigned long long) ret.rel_value); | ||
306 | #endif | ||
307 | return ret; | ||
308 | } | ||
309 | |||
310 | |||
311 | /** | ||
312 | * Function that will be called for each address the transport | ||
313 | * is aware that it might be reachable under. Update our HELLO. | ||
314 | * | ||
315 | * @param cls name of the plugin (const char*) | ||
316 | * @param add_remove should the address added (YES) or removed (NO) from the | ||
317 | * set of valid addresses? | ||
318 | * @param addr one of the addresses of the host | ||
319 | * the specific address format depends on the transport | ||
320 | * @param addrlen length of the address | ||
321 | */ | ||
322 | static void | ||
323 | plugin_env_address_change_notification (void *cls, int add_remove, | ||
324 | const void *addr, size_t addrlen) | ||
325 | { | ||
326 | const char *plugin_name = cls; | ||
327 | |||
328 | GST_hello_modify_addresses (add_remove, plugin_name, addr, addrlen); | ||
329 | } | ||
330 | |||
331 | |||
332 | /** | ||
333 | * Function that will be called whenever the plugin internally | ||
334 | * cleans up a session pointer and hence the service needs to | ||
335 | * discard all of those sessions as well. Plugins that do not | ||
336 | * use sessions can simply omit calling this function and always | ||
337 | * use NULL wherever a session pointer is needed. This function | ||
338 | * should be called BEFORE a potential "TransmitContinuation" | ||
339 | * from the "TransmitFunction". | ||
340 | * | ||
341 | * @param cls closure | ||
342 | * @param peer which peer was the session for | ||
343 | * @param session which session is being destoyed | ||
344 | */ | ||
345 | static void | ||
346 | plugin_env_session_end (void *cls, const struct GNUNET_PeerIdentity *peer, | ||
347 | struct Session *session) | ||
348 | { | ||
349 | #if DEBUG_TRANSPORT | ||
350 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
351 | "Session %X to peer `%s' ended \n", | ||
352 | session, GNUNET_i2s (peer)); | ||
353 | #endif | ||
354 | if (NULL != session) | ||
355 | GNUNET_log_from (GNUNET_ERROR_TYPE_INFO | GNUNET_ERROR_TYPE_BULK, | ||
356 | "transport-ats", | ||
357 | "Telling ATS to destroy session %p from peer %s\n", | ||
358 | session, | ||
359 | GNUNET_i2s (peer)); | ||
360 | GNUNET_ATS_address_destroyed (GST_ats, peer, NULL, NULL, 0, session); | ||
361 | GST_neighbours_session_terminated (peer, session); | ||
362 | } | ||
363 | |||
364 | |||
365 | /** | ||
366 | * Function called by ATS to notify the callee that the | ||
367 | * assigned bandwidth or address for a given peer was changed. If the | ||
368 | * callback is called with address/bandwidth assignments of zero, the | ||
369 | * ATS disconnect function will still be called once the disconnect | ||
370 | * actually happened. | ||
371 | * | ||
372 | * @param cls closure | ||
373 | * @param peer identity of the peer | ||
374 | * @param plugin_name name of the transport plugin, NULL to disconnect | ||
375 | * @param session session to use (if available) | ||
376 | * @param plugin_addr address to use (if available) | ||
377 | * @param plugin_addr_len number of bytes in addr | ||
378 | * @param bandwidth_out assigned outbound bandwidth for the connection, 0 to disconnect from peer | ||
379 | * @param bandwidth_in assigned inbound bandwidth for the connection, 0 to disconnect from peer | ||
380 | */ | ||
381 | static void | ||
382 | ats_request_address_change (void *cls, const struct GNUNET_PeerIdentity *peer, | ||
383 | const char *plugin_name, | ||
384 | const void *plugin_addr, size_t plugin_addr_len, | ||
385 | struct Session *session, | ||
386 | struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out, | ||
387 | struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in, | ||
388 | const struct GNUNET_ATS_Information * ats, | ||
389 | uint32_t ats_count) | ||
390 | { | ||
391 | uint32_t bw_in = ntohl (bandwidth_in.value__); | ||
392 | uint32_t bw_out = ntohl (bandwidth_out.value__); | ||
393 | |||
394 | /* ATS tells me to disconnect from peer*/ | ||
395 | if ((bw_in == 0) && (bw_out == 0)) | ||
396 | { | ||
397 | #if DEBUG_TRANSPORT | ||
398 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
399 | "ATS tells me to disconnect from peer `%s'\n", | ||
400 | GNUNET_i2s (peer)); | ||
401 | #endif | ||
402 | GST_neighbours_force_disconnect(peer); | ||
403 | return; | ||
404 | } | ||
405 | /* will never return GNUNET_YES since connection is to be established */ | ||
406 | GST_neighbours_switch_to_address (peer, plugin_name, plugin_addr, | ||
407 | plugin_addr_len, session, ats, ats_count, | ||
408 | bandwidth_in, bandwidth_out); | ||
409 | } | ||
410 | |||
411 | |||
412 | /** | ||
413 | * Function called to notify transport users that another | ||
414 | * peer connected to us. | ||
415 | * | ||
416 | * @param cls closure | ||
417 | * @param peer the peer that connected | ||
418 | * @param ats performance data | ||
419 | * @param ats_count number of entries in ats | ||
420 | */ | ||
421 | static void | ||
422 | neighbours_connect_notification (void *cls, | ||
423 | const struct GNUNET_PeerIdentity *peer, | ||
424 | const struct GNUNET_ATS_Information | ||
425 | *ats, uint32_t ats_count) | ||
426 | { | ||
427 | size_t len = sizeof (struct ConnectInfoMessage) + | ||
428 | ats_count * sizeof (struct GNUNET_ATS_Information); | ||
429 | char buf[len]; | ||
430 | struct ConnectInfoMessage *connect_msg = (struct ConnectInfoMessage *) buf; | ||
431 | struct GNUNET_ATS_Information *ap; | ||
432 | |||
433 | connect_msg->header.size = htons (sizeof (buf)); | ||
434 | connect_msg->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT); | ||
435 | connect_msg->ats_count = htonl (ats_count); | ||
436 | connect_msg->id = *peer; | ||
437 | ap = (struct GNUNET_ATS_Information *) &connect_msg[1]; | ||
438 | memcpy (ap, ats, | ||
439 | ats_count * sizeof (struct GNUNET_ATS_Information)); | ||
440 | GST_clients_broadcast (&connect_msg->header, GNUNET_NO); | ||
441 | } | ||
442 | |||
443 | |||
444 | /** | ||
445 | * Function called to notify transport users that another | ||
446 | * peer disconnected from us. | ||
447 | * | ||
448 | * @param cls closure | ||
449 | * @param peer the peer that disconnected | ||
450 | */ | ||
451 | static void | ||
452 | neighbours_disconnect_notification (void *cls, | ||
453 | const struct GNUNET_PeerIdentity *peer) | ||
454 | { | ||
455 | struct DisconnectInfoMessage disconnect_msg; | ||
456 | |||
457 | disconnect_msg.header.size = htons (sizeof (struct DisconnectInfoMessage)); | ||
458 | disconnect_msg.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_DISCONNECT); | ||
459 | disconnect_msg.reserved = htonl (0); | ||
460 | disconnect_msg.peer = *peer; | ||
461 | GST_clients_broadcast (&disconnect_msg.header, GNUNET_NO); | ||
462 | } | ||
463 | |||
464 | |||
465 | /** | ||
466 | * Function called when the service shuts down. Unloads our plugins | ||
467 | * and cancels pending validations. | ||
468 | * | ||
469 | * @param cls closure, unused | ||
470 | * @param tc task context (unused) | ||
471 | */ | ||
472 | static void | ||
473 | shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | ||
474 | { | ||
475 | GST_validation_stop (); | ||
476 | GST_plugins_unload (); | ||
477 | GST_neighbours_stop (); | ||
478 | GNUNET_ATS_scheduling_done (GST_ats); | ||
479 | GST_ats = NULL; | ||
480 | GST_clients_stop (); | ||
481 | GST_blacklist_stop (); | ||
482 | GST_hello_stop (); | ||
483 | |||
484 | if (GST_peerinfo != NULL) | ||
485 | { | ||
486 | GNUNET_PEERINFO_disconnect (GST_peerinfo); | ||
487 | GST_peerinfo = NULL; | ||
488 | } | ||
489 | if (GST_stats != NULL) | ||
490 | { | ||
491 | GNUNET_STATISTICS_destroy (GST_stats, GNUNET_NO); | ||
492 | GST_stats = NULL; | ||
493 | } | ||
494 | if (GST_my_private_key != NULL) | ||
495 | { | ||
496 | GNUNET_CRYPTO_rsa_key_free (GST_my_private_key); | ||
497 | GST_my_private_key = NULL; | ||
498 | } | ||
499 | } | ||
500 | |||
501 | |||
502 | /** | ||
503 | * Initiate transport service. | ||
504 | * | ||
505 | * @param cls closure | ||
506 | * @param server the initialized server | ||
507 | * @param c configuration to use | ||
508 | */ | ||
509 | static void | ||
510 | run (void *cls, struct GNUNET_SERVER_Handle *server, | ||
511 | const struct GNUNET_CONFIGURATION_Handle *c) | ||
512 | { | ||
513 | char *keyfile; | ||
514 | |||
515 | /* setup globals */ | ||
516 | GST_cfg = c; | ||
517 | if (GNUNET_OK != | ||
518 | GNUNET_CONFIGURATION_get_value_filename (c, "GNUNETD", "HOSTKEY", | ||
519 | &keyfile)) | ||
520 | { | ||
521 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | ||
522 | _ | ||
523 | ("Transport service is lacking key configuration settings. Exiting.\n")); | ||
524 | GNUNET_SCHEDULER_shutdown (); | ||
525 | return; | ||
526 | } | ||
527 | GST_my_private_key = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile); | ||
528 | GNUNET_free (keyfile); | ||
529 | if (GST_my_private_key == NULL) | ||
530 | { | ||
531 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | ||
532 | _("Transport service could not access hostkey. Exiting.\n")); | ||
533 | GNUNET_SCHEDULER_shutdown (); | ||
534 | return; | ||
535 | } | ||
536 | GST_stats = GNUNET_STATISTICS_create ("transport", c); | ||
537 | GST_peerinfo = GNUNET_PEERINFO_connect (c); | ||
538 | GNUNET_CRYPTO_rsa_key_get_public (GST_my_private_key, &GST_my_public_key); | ||
539 | GNUNET_CRYPTO_hash (&GST_my_public_key, sizeof (GST_my_public_key), | ||
540 | &GST_my_identity.hashPubKey); | ||
541 | GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &shutdown_task, | ||
542 | NULL); | ||
543 | if (GST_peerinfo == NULL) | ||
544 | { | ||
545 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | ||
546 | _("Could not access PEERINFO service. Exiting.\n")); | ||
547 | GNUNET_SCHEDULER_shutdown (); | ||
548 | return; | ||
549 | } | ||
550 | |||
551 | /* start subsystems */ | ||
552 | GST_hello_start (&process_hello_update, NULL); | ||
553 | GST_blacklist_start (server); | ||
554 | GST_plugins_load (&plugin_env_receive_callback, | ||
555 | &plugin_env_address_change_notification, | ||
556 | &plugin_env_session_end); | ||
557 | GST_ats = GNUNET_ATS_scheduling_init (GST_cfg, &ats_request_address_change, NULL); | ||
558 | GST_neighbours_start (NULL, &neighbours_connect_notification, | ||
559 | &neighbours_disconnect_notification); | ||
560 | GST_clients_start (server); | ||
561 | GST_validation_start (); | ||
562 | } | ||
563 | |||
564 | |||
565 | /** | ||
566 | * The main function for the transport service. | ||
567 | * | ||
568 | * @param argc number of arguments from the command line | ||
569 | * @param argv command line arguments | ||
570 | * @return 0 ok, 1 on error | ||
571 | */ | ||
572 | int | ||
573 | main (int argc, char *const *argv) | ||
574 | { | ||
575 | return (GNUNET_OK == | ||
576 | GNUNET_SERVICE_run (argc, argv, "transport", | ||
577 | GNUNET_SERVICE_OPTION_NONE, &run, NULL)) ? 0 : 1; | ||
578 | } | ||
579 | |||
580 | /* end of file gnunet-service-transport-new.c */ | ||
diff --git a/src/transport/gnunet-service-transport_neighbours_fsm.c b/src/transport/gnunet-service-transport_neighbours_3way.c index fd3ad37f9..fd3ad37f9 100644 --- a/src/transport/gnunet-service-transport_neighbours_fsm.c +++ b/src/transport/gnunet-service-transport_neighbours_3way.c | |||
diff --git a/src/transport/gnunet-service-transport_neighbours_3way.h b/src/transport/gnunet-service-transport_neighbours_3way.h new file mode 100644 index 000000000..88790449e --- /dev/null +++ b/src/transport/gnunet-service-transport_neighbours_3way.h | |||
@@ -0,0 +1,272 @@ | |||
1 | /* | ||
2 | This file is part of GNUnet. | ||
3 | (C) 2010,2011 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 3, 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/gnunet-service-transport_neighbours.h | ||
23 | * @brief neighbour management API | ||
24 | * @author Christian Grothoff | ||
25 | */ | ||
26 | #ifndef GNUNET_SERVICE_TRANSPORT_NEIGHBOURS_H | ||
27 | #define GNUNET_SERVICE_TRANSPORT_NEIGHBOURS_H | ||
28 | |||
29 | #include "gnunet_statistics_service.h" | ||
30 | #include "gnunet_transport_service.h" | ||
31 | #include "gnunet_transport_plugin.h" | ||
32 | #include "gnunet_util_lib.h" | ||
33 | |||
34 | // TODO: | ||
35 | // - ATS and similar info is a bit lacking in the API right now... | ||
36 | |||
37 | |||
38 | |||
39 | /** | ||
40 | * Initialize the neighbours subsystem. | ||
41 | * | ||
42 | * @param cls closure for callbacks | ||
43 | * @param connect_cb function to call if we connect to a peer | ||
44 | * @param disconnect_cb function to call if we disconnect from a peer | ||
45 | */ | ||
46 | void | ||
47 | GST_neighbours_start (void *cls, GNUNET_TRANSPORT_NotifyConnect connect_cb, | ||
48 | GNUNET_TRANSPORT_NotifyDisconnect disconnect_cb); | ||
49 | |||
50 | |||
51 | /** | ||
52 | * Cleanup the neighbours subsystem. | ||
53 | */ | ||
54 | void | ||
55 | GST_neighbours_stop (void); | ||
56 | |||
57 | |||
58 | /** | ||
59 | * Try to create a connection to the given target (eventually). | ||
60 | * | ||
61 | * @param target peer to try to connect to | ||
62 | */ | ||
63 | void | ||
64 | GST_neighbours_try_connect (const struct GNUNET_PeerIdentity *target); | ||
65 | |||
66 | |||
67 | /** | ||
68 | * Test if we're connected to the given peer. | ||
69 | * | ||
70 | * @param target peer to test | ||
71 | * @return GNUNET_YES if we are connected, GNUNET_NO if not | ||
72 | */ | ||
73 | int | ||
74 | GST_neighbours_test_connected (const struct GNUNET_PeerIdentity *target); | ||
75 | |||
76 | |||
77 | /** | ||
78 | * Function called after the transmission is done. | ||
79 | * | ||
80 | * @param cls closure | ||
81 | * @param success GNUNET_OK on success, GNUNET_NO on failure, GNUNET_SYSERR if we're not connected | ||
82 | */ | ||
83 | typedef void (*GST_NeighbourSendContinuation) (void *cls, int success); | ||
84 | |||
85 | |||
86 | /** | ||
87 | * Transmit a message to the given target using the active connection. | ||
88 | * | ||
89 | * @param target destination | ||
90 | * @param msg message to send | ||
91 | * @param msg_size number of bytes in msg | ||
92 | * @param timeout when to fail with timeout | ||
93 | * @param cont function to call when done | ||
94 | * @param cont_cls closure for 'cont' | ||
95 | */ | ||
96 | void | ||
97 | GST_neighbours_send (const struct GNUNET_PeerIdentity *target, const void *msg, | ||
98 | size_t msg_size, struct GNUNET_TIME_Relative timeout, | ||
99 | GST_NeighbourSendContinuation cont, void *cont_cls); | ||
100 | |||
101 | |||
102 | /** | ||
103 | * We have received a message from the given sender. | ||
104 | * How long should we delay before receiving more? | ||
105 | * (Also used to keep the peer marked as live). | ||
106 | * | ||
107 | * @param sender sender of the message | ||
108 | * @param size size of the message | ||
109 | * @param do_forward set to GNUNET_YES if the message should be forwarded to clients | ||
110 | * GNUNET_NO if the neighbour is not connected or violates the quota | ||
111 | * @return how long to wait before reading more from this sender | ||
112 | */ | ||
113 | struct GNUNET_TIME_Relative | ||
114 | GST_neighbours_calculate_receive_delay (const struct GNUNET_PeerIdentity | ||
115 | *sender, ssize_t size, int *do_forward); | ||
116 | |||
117 | |||
118 | /** | ||
119 | * Keep the connection to the given neighbour alive longer, | ||
120 | * we received a KEEPALIVE (or equivalent). | ||
121 | * | ||
122 | * @param neighbour neighbour to keep alive | ||
123 | */ | ||
124 | void | ||
125 | GST_neighbours_keepalive (const struct GNUNET_PeerIdentity *neighbour); | ||
126 | |||
127 | |||
128 | /** | ||
129 | * Change the incoming quota for the given peer. | ||
130 | * | ||
131 | * @param neighbour identity of peer to change qutoa for | ||
132 | * @param quota new quota | ||
133 | */ | ||
134 | void | ||
135 | GST_neighbours_set_incoming_quota (const struct GNUNET_PeerIdentity *neighbour, | ||
136 | struct GNUNET_BANDWIDTH_Value32NBO quota); | ||
137 | |||
138 | |||
139 | /** | ||
140 | * If we have an active connection to the given target, it must be shutdown. | ||
141 | * | ||
142 | * @param target peer to disconnect from | ||
143 | */ | ||
144 | void | ||
145 | GST_neighbours_force_disconnect (const struct GNUNET_PeerIdentity *target); | ||
146 | |||
147 | |||
148 | /** | ||
149 | * Function called for each connected neighbour. | ||
150 | * | ||
151 | * @param cls closure | ||
152 | * @param neighbour identity of the neighbour | ||
153 | * @param ats performance data | ||
154 | * @param ats_count number of entries in ats (including 0-termination) | ||
155 | * @param transport plugin | ||
156 | * @param addr address | ||
157 | * @param addrlen address length | ||
158 | */ | ||
159 | typedef void (*GST_NeighbourIterator) (void *cls, | ||
160 | const struct GNUNET_PeerIdentity * | ||
161 | neighbour, | ||
162 | const struct | ||
163 | GNUNET_ATS_Information * ats, | ||
164 | uint32_t ats_count, | ||
165 | const char * transport, | ||
166 | const void * addr, | ||
167 | size_t addrlen); | ||
168 | |||
169 | |||
170 | /** | ||
171 | * Iterate over all connected neighbours. | ||
172 | * | ||
173 | * @param cb function to call | ||
174 | * @param cb_cls closure for cb | ||
175 | */ | ||
176 | void | ||
177 | GST_neighbours_iterate (GST_NeighbourIterator cb, void *cb_cls); | ||
178 | |||
179 | |||
180 | /** | ||
181 | * A session was terminated. Take note. | ||
182 | * | ||
183 | * @param peer identity of the peer where the session died | ||
184 | * @param session session that is gone | ||
185 | */ | ||
186 | void | ||
187 | GST_neighbours_session_terminated (const struct GNUNET_PeerIdentity *peer, | ||
188 | struct Session *session); | ||
189 | |||
190 | |||
191 | /** | ||
192 | * For an existing neighbour record, set the active connection to | ||
193 | * use the given address. | ||
194 | * | ||
195 | * @param peer identity of the peer to switch the address for | ||
196 | * @param plugin_name name of transport that delivered the PONG | ||
197 | * @param address address of the other peer, NULL if other peer | ||
198 | * connected to us | ||
199 | * @param address_len number of bytes in address | ||
200 | * @param session session to use (or NULL) | ||
201 | * @param ats performance data | ||
202 | * @param ats_count number of entries in ats | ||
203 | * @param bandwidth_in inbound quota to be used when connection is up | ||
204 | * @param bandwidth_out outbound quota to be used when connection is up | ||
205 | * @return GNUNET_YES if we are currently connected, GNUNET_NO if the | ||
206 | * connection is not up (yet) | ||
207 | */ | ||
208 | int | ||
209 | GST_neighbours_switch_to_address (const struct GNUNET_PeerIdentity *peer, | ||
210 | const char *plugin_name, const void *address, | ||
211 | size_t address_len, struct Session *session, | ||
212 | const struct GNUNET_ATS_Information | ||
213 | *ats, uint32_t ats_count, | ||
214 | struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in, | ||
215 | struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out); | ||
216 | |||
217 | |||
218 | /** | ||
219 | * We received a 'SESSION_CONNECT' message from the other peer. | ||
220 | * Consider switching to it. | ||
221 | * | ||
222 | * @param message possibly a 'struct SessionConnectMessage' (check format) | ||
223 | * @param peer identity of the peer to switch the address for | ||
224 | * @param plugin_name name of transport that delivered the PONG | ||
225 | * @param address address of the other peer, NULL if other peer | ||
226 | * connected to us | ||
227 | * @param address_len number of bytes in address | ||
228 | * @param session session to use (or NULL) | ||
229 | * @param ats performance data | ||
230 | * @param ats_count number of entries in ats (excluding 0-termination) | ||
231 | */ | ||
232 | void | ||
233 | GST_neighbours_handle_connect (const struct GNUNET_MessageHeader *message, | ||
234 | const struct GNUNET_PeerIdentity *peer, | ||
235 | const char *plugin_name, | ||
236 | const char *sender_address, uint16_t sender_address_len, | ||
237 | struct Session *session, | ||
238 | const struct GNUNET_ATS_Information *ats, | ||
239 | uint32_t ats_count); | ||
240 | |||
241 | void | ||
242 | GST_neighbours_handle_connect_ack (const struct GNUNET_MessageHeader *message, | ||
243 | const struct GNUNET_PeerIdentity *peer, | ||
244 | const char *plugin_name, | ||
245 | const char *sender_address, uint16_t sender_address_len, | ||
246 | struct Session *session, | ||
247 | const struct GNUNET_ATS_Information *ats, | ||
248 | uint32_t ats_count); | ||
249 | |||
250 | void | ||
251 | GST_neighbours_handle_ack (const struct GNUNET_MessageHeader *message, | ||
252 | const struct GNUNET_PeerIdentity *peer, | ||
253 | const char *plugin_name, | ||
254 | const char *sender_address, uint16_t sender_address_len, | ||
255 | struct Session *session, | ||
256 | const struct GNUNET_ATS_Information *ats, | ||
257 | uint32_t ats_count); | ||
258 | |||
259 | /** | ||
260 | * We received a disconnect message from the given peer, | ||
261 | * validate and process. | ||
262 | * | ||
263 | * @param peer sender of the message | ||
264 | * @param msg the disconnect message | ||
265 | */ | ||
266 | void | ||
267 | GST_neighbours_handle_disconnect_message (const struct GNUNET_PeerIdentity *peer, | ||
268 | const struct GNUNET_MessageHeader *msg); | ||
269 | |||
270 | |||
271 | #endif | ||
272 | /* end of file gnunet-service-transport_neighbours.h */ | ||