aboutsummaryrefslogtreecommitdiff
path: root/src/mesh
diff options
context:
space:
mode:
authorBart Polot <bart@net.in.tum.de>2011-10-05 13:10:00 +0000
committerBart Polot <bart@net.in.tum.de>2011-10-05 13:10:00 +0000
commite1bb88e67a0a55e5f90e4bc51d5517e4bce63f76 (patch)
tree2d0f85edc49e1765efd8c4fe3d0b7514ff75df5e /src/mesh
parent41785d3e08ea6e38c99289c10303f1471a68a9c2 (diff)
downloadgnunet-e1bb88e67a0a55e5f90e4bc51d5517e4bce63f76.tar.gz
gnunet-e1bb88e67a0a55e5f90e4bc51d5517e4bce63f76.zip
Removed DHT_get restarting, set DEMULTIPLEX_EVERYWHERE on all DHT operations
Diffstat (limited to 'src/mesh')
-rw-r--r--src/mesh/gnunet-service-mesh.c216
1 files changed, 68 insertions, 148 deletions
diff --git a/src/mesh/gnunet-service-mesh.c b/src/mesh/gnunet-service-mesh.c
index 323be7dd3..625a9a383 100644
--- a/src/mesh/gnunet-service-mesh.c
+++ b/src/mesh/gnunet-service-mesh.c
@@ -142,11 +142,6 @@ struct MeshPeerInfo
142 struct GNUNET_DHT_GetHandle *dhtget; 142 struct GNUNET_DHT_GetHandle *dhtget;
143 143
144 /** 144 /**
145 * Task to reissue the DHT get request a path for this peer
146 */
147 GNUNET_SCHEDULER_TaskIdentifier dhtget_task;
148
149 /**
150 * Handles to stop queued transmissions for this peer 145 * Handles to stop queued transmissions for this peer
151 */ 146 */
152 struct GNUNET_CORE_TransmitHandle *core_transmit[CORE_QUEUE_SIZE]; 147 struct GNUNET_CORE_TransmitHandle *core_transmit[CORE_QUEUE_SIZE];
@@ -299,11 +294,6 @@ struct MeshTunnel
299 */ 294 */
300 struct GNUNET_DHT_GetHandle *dht_get_type; 295 struct GNUNET_DHT_GetHandle *dht_get_type;
301 296
302 /**
303 * Task to reissue the DHT get request for a type
304 */
305 GNUNET_SCHEDULER_TaskIdentifier dht_get_type_task;
306
307 /** 297 /**
308 * Task to keep the used paths alive 298 * Task to keep the used paths alive
309 */ 299 */
@@ -518,9 +508,13 @@ static int
518announce_application (void *cls, const GNUNET_HashCode * key, void *value) 508announce_application (void *cls, const GNUNET_HashCode * key, void *value)
519{ 509{
520 /* FIXME are hashes in multihash map equal on all aquitectures? */ 510 /* FIXME are hashes in multihash map equal on all aquitectures? */
521 511 GNUNET_DHT_put (dht_handle,
522 GNUNET_DHT_put (dht_handle, key, 10U, GNUNET_DHT_RO_RECORD_ROUTE, 512 key,
523 GNUNET_BLOCK_TYPE_TEST, sizeof (struct GNUNET_PeerIdentity), 513 10U,
514 GNUNET_DHT_RO_RECORD_ROUTE |
515 GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE,
516 GNUNET_BLOCK_TYPE_TEST,
517 sizeof (struct GNUNET_PeerIdentity),
524 (const char *) &my_full_id, 518 (const char *) &my_full_id,
525#if MESH_DEBUG 519#if MESH_DEBUG
526 GNUNET_TIME_UNIT_FOREVER_ABS, GNUNET_TIME_UNIT_FOREVER_REL, 520 GNUNET_TIME_UNIT_FOREVER_ABS, GNUNET_TIME_UNIT_FOREVER_REL,
@@ -582,7 +576,8 @@ announce_id (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
582 GNUNET_DHT_put (dht_handle, /* DHT handle */ 576 GNUNET_DHT_put (dht_handle, /* DHT handle */
583 &my_full_id.hashPubKey, /* Key to use */ 577 &my_full_id.hashPubKey, /* Key to use */
584 10U, /* Replication level */ 578 10U, /* Replication level */
585 GNUNET_DHT_RO_RECORD_ROUTE, /* DHT options */ 579 GNUNET_DHT_RO_RECORD_ROUTE |
580 GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE, /* DHT options */
586 GNUNET_BLOCK_TYPE_TEST, /* Block type */ 581 GNUNET_BLOCK_TYPE_TEST, /* Block type */
587 sizeof(my_full_id), /* Size of the data */ 582 sizeof(my_full_id), /* Size of the data */
588 (char *)&my_full_id, /* Data itself */ 583 (char *)&my_full_id, /* Data itself */
@@ -620,16 +615,6 @@ dht_get_id_handler (void *cls, struct GNUNET_TIME_Absolute exp,
620 unsigned int put_path_length, 615 unsigned int put_path_length,
621 enum GNUNET_BLOCK_Type type, size_t size, const void *data); 616 enum GNUNET_BLOCK_Type type, size_t size, const void *data);
622 617
623/**
624 * Task to restart the DHT get search for a peer.
625 *
626 * @param cls unused
627 * @param tc unused
628 */
629static void
630dht_get_restart (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
631
632
633 618
634/******************************************************************************/ 619/******************************************************************************/
635/****************** GENERAL HELPER FUNCTIONS ************************/ 620/****************** GENERAL HELPER FUNCTIONS ************************/
@@ -791,19 +776,18 @@ path_remove_from_peer (struct MeshPeerInfo *peer,
791 path_info->path = p; 776 path_info->path = p;
792 path_info->peer = peer_d; 777 path_info->peer = peer_d;
793 path_info->t = peer->tunnels[i]; 778 path_info->t = peer->tunnels[i];
794 peer_d->dhtget = GNUNET_DHT_get_start(dht_handle, /* handle */ 779 peer_d->dhtget =
795 GNUNET_TIME_UNIT_SECONDS, /* timeout */ 780 GNUNET_DHT_get_start(dht_handle, /* handle */
796 GNUNET_BLOCK_TYPE_TEST, /* type */ 781 GNUNET_TIME_UNIT_FOREVER_REL, /* timeout */
797 &id.hashPubKey, /*key to search */ 782 GNUNET_BLOCK_TYPE_TEST, /* type */
798 4, /* replication level */ 783 &id.hashPubKey, /*key to search */
799 GNUNET_DHT_RO_RECORD_ROUTE, 784 4, /* replication level */
800 NULL, /* xquery */ 785 GNUNET_DHT_RO_RECORD_ROUTE |
801 0, /* xquery bits */ 786 GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE,
802 &dht_get_id_handler, 787 NULL, /* xquery */
803 (void *) path_info); 788 0, /* xquery bits */
804 peer_d->dhtget_task = GNUNET_SCHEDULER_add_delayed(GET_RESTART_TIME, 789 &dht_get_id_handler,
805 &dht_get_restart, 790 (void *) path_info);
806 path_info);
807 } 791 }
808 } 792 }
809} 793}
@@ -1226,7 +1210,6 @@ tunnel_destroy_iterator (void *cls, const GNUNET_HashCode * key, void *value)
1226 1210
1227 if (NULL != t->dht_get_type) 1211 if (NULL != t->dht_get_type)
1228 { 1212 {
1229 GNUNET_SCHEDULER_cancel (t->dht_get_type_task);
1230 GNUNET_DHT_get_stop (t->dht_get_type); 1213 GNUNET_DHT_get_stop (t->dht_get_type);
1231 } 1214 }
1232 r = tunnel_destroy (t); 1215 r = tunnel_destroy (t);
@@ -2193,7 +2176,6 @@ dht_get_id_handler (void *cls, struct GNUNET_TIME_Absolute exp,
2193 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, 2176 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
2194 "MESH: Got results from DHT for %s\n", 2177 "MESH: Got results from DHT for %s\n",
2195 GNUNET_h2s_full(&pi.hashPubKey)); 2178 GNUNET_h2s_full(&pi.hashPubKey));
2196 GNUNET_SCHEDULER_cancel(path_info->peer->dhtget_task);
2197 GNUNET_DHT_get_stop(path_info->peer->dhtget); 2179 GNUNET_DHT_get_stop(path_info->peer->dhtget);
2198 path_info->peer->dhtget = NULL; 2180 path_info->peer->dhtget = NULL;
2199 if (NULL == get_path || NULL == put_path) 2181 if (NULL == get_path || NULL == put_path)
@@ -2201,8 +2183,19 @@ dht_get_id_handler (void *cls, struct GNUNET_TIME_Absolute exp,
2201 if (NULL == path_info->peer->path_head) 2183 if (NULL == path_info->peer->path_head)
2202 { 2184 {
2203 // Find ourselves some alternate initial path to the destination: retry 2185 // Find ourselves some alternate initial path to the destination: retry
2204 path_info->peer->dhtget_task = GNUNET_SCHEDULER_add_now (&dht_get_restart, 2186 GNUNET_PEER_resolve(path_info->peer->id, &pi);
2205 path_info); 2187 path_info->peer->dhtget =
2188 GNUNET_DHT_get_start(dht_handle, /* handle */
2189 GNUNET_TIME_UNIT_FOREVER_REL, /* timeout */
2190 GNUNET_BLOCK_TYPE_TEST, /* type */
2191 &pi.hashPubKey, /*key to search */
2192 4, /* replication level */
2193 GNUNET_DHT_RO_RECORD_ROUTE |
2194 GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE,
2195 NULL, /* xquery */
2196 0, /* xquery bits */
2197 &dht_get_id_handler,
2198 (void *) path_info);
2206 return; 2199 return;
2207 } 2200 }
2208 } 2201 }
@@ -2250,44 +2243,6 @@ dht_get_id_handler (void *cls, struct GNUNET_TIME_Absolute exp,
2250 2243
2251 2244
2252/** 2245/**
2253 * Task to restart the DHT get search for a peer.
2254 *
2255 * @param cls unused
2256 * @param tc unused
2257 */
2258static void
2259dht_get_restart (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
2260{
2261 struct MeshPathInfo *path = cls;
2262 struct MeshPeerInfo *peer = path->peer;
2263 struct GNUNET_PeerIdentity id;
2264
2265 if (GNUNET_SCHEDULER_REASON_SHUTDOWN == tc->reason)
2266 return;
2267 GNUNET_PEER_resolve(peer->id, &id);
2268 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2269 "MESH: restarting DHT get for id %s [%u]\n",
2270 GNUNET_i2s (&id),
2271 peer->id);
2272 if (NULL != peer->dhtget)
2273 GNUNET_DHT_get_stop(peer->dhtget);
2274 peer->dhtget = GNUNET_DHT_get_start (dht_handle,
2275 GNUNET_TIME_UNIT_FOREVER_REL,
2276 GNUNET_BLOCK_TYPE_TEST,
2277 &id.hashPubKey,
2278 10U,
2279 GNUNET_DHT_RO_RECORD_ROUTE,
2280 NULL,
2281 0,
2282 &dht_get_id_handler,
2283 path);
2284 peer->dhtget_task = GNUNET_SCHEDULER_add_delayed (GET_RESTART_TIME,
2285 &dht_get_restart,
2286 path);
2287}
2288
2289
2290/**
2291 * Function to process paths received for a new peer addition. The recorded 2246 * Function to process paths received for a new peer addition. The recorded
2292 * paths form the initial tunnel, which can be optimized later. 2247 * paths form the initial tunnel, which can be optimized later.
2293 * Called on each result obtained for the DHT search. 2248 * Called on each result obtained for the DHT search.
@@ -2336,26 +2291,19 @@ dht_get_type_handler (void *cls, struct GNUNET_TIME_Absolute exp,
2336 path_info->peer = peer_info; 2291 path_info->peer = peer_info;
2337 path_info->t = t; 2292 path_info->t = t;
2338 /* we don't have a route to the peer, let's try a direct lookup */ 2293 /* we don't have a route to the peer, let's try a direct lookup */
2339 peer_info->dhtget = GNUNET_DHT_get_start (dht_handle, 2294 peer_info->dhtget =
2340 /* handle */ 2295 GNUNET_DHT_get_start (dht_handle, /* handle */
2341 GNUNET_TIME_UNIT_SECONDS, 2296 GNUNET_TIME_UNIT_FOREVER_REL, /* timeout */
2342 /* timeout */ 2297 GNUNET_BLOCK_TYPE_TEST, /* block type */
2343 GNUNET_BLOCK_TYPE_TEST, 2298 &pi->hashPubKey, /* key to look up */
2344 /* block type */ 2299 10U, /* replication level */
2345 &pi->hashPubKey, 2300 GNUNET_DHT_RO_RECORD_ROUTE |
2346 /* key to look up */ 2301 GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE,
2347 10U, 2302 /* option to dht: record route */
2348 /* replication level */ 2303 NULL, /* xquery */
2349 GNUNET_DHT_RO_RECORD_ROUTE, 2304 0, /* xquery bits */
2350 /* option to dht: record route */ 2305 dht_get_id_handler, /* callback */
2351 NULL, /* xquery */ 2306 path_info); /* closure */
2352 0, /* xquery bits */
2353 dht_get_id_handler,
2354 /* callback */
2355 path_info); /* closure */
2356 peer_info->dhtget_task = GNUNET_SCHEDULER_add_delayed (GET_RESTART_TIME,
2357 &dht_get_restart,
2358 path_info);
2359 return; 2307 return;
2360 } 2308 }
2361 2309
@@ -2407,34 +2355,6 @@ dht_get_type_handler (void *cls, struct GNUNET_TIME_Absolute exp,
2407} 2355}
2408 2356
2409 2357
2410/**
2411 * Task to restart the DHT get search for a peer offering a type.
2412 *
2413 * @param cls unused
2414 * @param tc unused
2415 */
2416static void
2417dht_get_type_restart (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
2418{
2419 struct MeshTunnel *t = cls;
2420 GNUNET_HashCode hash;
2421
2422 if (GNUNET_SCHEDULER_REASON_SHUTDOWN == tc->reason)
2423 return;
2424 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2425 "MESH: restarting DHT get for type %u\n",
2426 t->type);
2427 GNUNET_DHT_get_stop(t->dht_get_type);
2428 GNUNET_CRYPTO_hash (&t->type, sizeof (GNUNET_MESH_ApplicationType), &hash);
2429 t->dht_get_type = GNUNET_DHT_get_start (dht_handle, GNUNET_TIME_UNIT_FOREVER_REL,
2430 GNUNET_BLOCK_TYPE_TEST, &hash, 10U,
2431 GNUNET_DHT_RO_RECORD_ROUTE, NULL, 0,
2432 &dht_get_type_handler, t);
2433 t->dht_get_type_task = GNUNET_SCHEDULER_add_delayed(GET_RESTART_TIME,
2434 &dht_get_type_restart,
2435 t);
2436}
2437
2438/******************************************************************************/ 2358/******************************************************************************/
2439/********************* MESH LOCAL HANDLES **************************/ 2359/********************* MESH LOCAL HANDLES **************************/
2440/******************************************************************************/ 2360/******************************************************************************/
@@ -2809,19 +2729,18 @@ handle_local_connect_add (void *cls, struct GNUNET_SERVER_Client *client,
2809 path_info = GNUNET_malloc(sizeof(struct MeshPathInfo)); 2729 path_info = GNUNET_malloc(sizeof(struct MeshPathInfo));
2810 path_info->peer = peer_info; 2730 path_info->peer = peer_info;
2811 path_info->t = t; 2731 path_info->t = t;
2812 peer_info->dhtget = GNUNET_DHT_get_start(dht_handle, /* handle */ 2732 peer_info->dhtget =
2813 GNUNET_TIME_UNIT_SECONDS, /* timeout */ 2733 GNUNET_DHT_get_start(dht_handle, /* handle */
2814 GNUNET_BLOCK_TYPE_TEST, /* type */ 2734 GNUNET_TIME_UNIT_FOREVER_REL, /* timeout */
2815 &peer_msg->peer.hashPubKey, /*key to search */ 2735 GNUNET_BLOCK_TYPE_TEST, /* type */
2816 4, /* replication level */ 2736 &peer_msg->peer.hashPubKey, /*key to search */
2817 GNUNET_DHT_RO_RECORD_ROUTE, 2737 4, /* replication level */
2818 NULL, /* xquery */ 2738 GNUNET_DHT_RO_RECORD_ROUTE |
2819 0, /* xquery bits */ 2739 GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE,
2820 &dht_get_id_handler, 2740 NULL, /* xquery */
2821 (void *) path_info); 2741 0, /* xquery bits */
2822 peer_info->dhtget_task = GNUNET_SCHEDULER_add_delayed (GET_RESTART_TIME, 2742 &dht_get_id_handler,
2823 &dht_get_restart, 2743 (void *) path_info);
2824 path_info);
2825 } 2744 }
2826 else if (NULL != peer_info->path_head) 2745 else if (NULL != peer_info->path_head)
2827 { 2746 {
@@ -2998,21 +2917,22 @@ handle_local_connect_by_type (void *cls, struct GNUNET_SERVER_Client *client,
2998 return; 2917 return;
2999 } 2918 }
3000 /* Ok, lets find a peer offering the service */ 2919 /* Ok, lets find a peer offering the service */
3001 if (t->dht_get_type) 2920 if (NULL != t->dht_get_type)
3002 { 2921 {
3003 GNUNET_SCHEDULER_cancel (t->dht_get_type_task);
3004 GNUNET_DHT_get_stop (t->dht_get_type); 2922 GNUNET_DHT_get_stop (t->dht_get_type);
3005 } 2923 }
3006 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: looking in DHT for %s\n", 2924 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: looking in DHT for %s\n",
3007 GNUNET_h2s_full (&hash)); 2925 GNUNET_h2s_full (&hash));
3008 t->dht_get_type = 2926 t->dht_get_type =
3009 GNUNET_DHT_get_start (dht_handle, GNUNET_TIME_UNIT_FOREVER_REL, 2927 GNUNET_DHT_get_start (dht_handle,
3010 GNUNET_BLOCK_TYPE_TEST, &hash, 10U, 2928 GNUNET_TIME_UNIT_FOREVER_REL,
3011 GNUNET_DHT_RO_RECORD_ROUTE, NULL, 0, 2929 GNUNET_BLOCK_TYPE_TEST,
2930 &hash,
2931 10U,
2932 GNUNET_DHT_RO_RECORD_ROUTE |
2933 GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE,
2934 NULL, 0,
3012 &dht_get_type_handler, t); 2935 &dht_get_type_handler, t);
3013 t->dht_get_type_task = GNUNET_SCHEDULER_add_delayed(GET_RESTART_TIME,
3014 &dht_get_type_restart,
3015 t);
3016 2936
3017 GNUNET_SERVER_receive_done (client, GNUNET_OK); 2937 GNUNET_SERVER_receive_done (client, GNUNET_OK);
3018 return; 2938 return;
generated by cgit v1.2.3 (git 2.39.1) at 2024-04-19 00:38:12 +0000