diff options
Diffstat (limited to 'src/transport/gnunet-service-transport_3way.c')
-rw-r--r-- | src/transport/gnunet-service-transport_3way.c | 580 |
1 files changed, 580 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 */ | ||