diff options
-rw-r--r-- | src/mesh/gnunet-service-mesh_new.c | 122 | ||||
-rw-r--r-- | src/mesh/test_mesh_regex.c | 10 |
2 files changed, 100 insertions, 32 deletions
diff --git a/src/mesh/gnunet-service-mesh_new.c b/src/mesh/gnunet-service-mesh_new.c index d5e28d6e4..a0adfd691 100644 --- a/src/mesh/gnunet-service-mesh_new.c +++ b/src/mesh/gnunet-service-mesh_new.c | |||
@@ -804,11 +804,31 @@ dht_get_string_handler (void *cls, struct GNUNET_TIME_Absolute exp, | |||
804 | size_t size, const void *data); | 804 | size_t size, const void *data); |
805 | 805 | ||
806 | 806 | ||
807 | /******************************************************************************/ | 807 | /** |
808 | /************************ ITERATORS ****************************/ | 808 | * Function to process DHT string to regex matching. |
809 | /******************************************************************************/ | 809 | * Called on each result obtained for the DHT search. |
810 | * | ||
811 | * @param cls closure (search context) | ||
812 | * @param exp when will this value expire | ||
813 | * @param key key of the result | ||
814 | * @param get_path path of the get request (not used) | ||
815 | * @param get_path_length lenght of get_path (not used) | ||
816 | * @param put_path path of the put request (not used) | ||
817 | * @param put_path_length length of the put_path (not used) | ||
818 | * @param type type of the result | ||
819 | * @param size number of bytes in data | ||
820 | * @param data pointer to the result data | ||
821 | */ | ||
822 | static void | ||
823 | dht_get_string_accept_handler (void *cls, struct GNUNET_TIME_Absolute exp, | ||
824 | const struct GNUNET_HashCode * key, | ||
825 | const struct GNUNET_PeerIdentity *get_path, | ||
826 | unsigned int get_path_length, | ||
827 | const struct GNUNET_PeerIdentity *put_path, | ||
828 | unsigned int put_path_length, | ||
829 | enum GNUNET_BLOCK_Type type, | ||
830 | size_t size, const void *data); | ||
810 | 831 | ||
811 | /* FIXME move iterators here */ | ||
812 | 832 | ||
813 | /** | 833 | /** |
814 | * Iterator over edges in a regex block retrieved from the DHT. | 834 | * Iterator over edges in a regex block retrieved from the DHT. |
@@ -825,14 +845,32 @@ regex_edge_iterator (void *cls, | |||
825 | const char *token, | 845 | const char *token, |
826 | size_t len, | 846 | size_t len, |
827 | const struct GNUNET_HashCode *key); | 847 | const struct GNUNET_HashCode *key); |
848 | |||
849 | |||
828 | /** | 850 | /** |
829 | * Iterator over hash map entries. | 851 | * Find a path to a peer that offers a regex servcie compatible |
852 | * with a given string. | ||
853 | * | ||
854 | * @param key The key of the accepting state. | ||
855 | * @param ctx Context containing info about the string, tunnel, etc. | ||
856 | */ | ||
857 | static void | ||
858 | regex_find_path (const struct GNUNET_HashCode *key, | ||
859 | struct MeshRegexSearchContext *ctx); | ||
860 | |||
861 | /******************************************************************************/ | ||
862 | /************************ ITERATORS ****************************/ | ||
863 | /******************************************************************************/ | ||
864 | |||
865 | /* FIXME move iterators here */ | ||
866 | |||
867 | /** | ||
868 | * Iterator over found existing mesh regex blocks that match an ongoing search. | ||
830 | * | 869 | * |
831 | * @param cls closure | 870 | * @param cls closure |
832 | * @param key current key code | 871 | * @param key current key code |
833 | * @param value value in the hash map | 872 | * @param value value in the hash map |
834 | * @return GNUNET_YES if we should continue to | 873 | * @return GNUNET_YES if we should continue to iterate, |
835 | * iterate, | ||
836 | * GNUNET_NO if not. | 874 | * GNUNET_NO if not. |
837 | */ | 875 | */ |
838 | static int | 876 | static int |
@@ -843,7 +881,20 @@ regex_result_iterator (void *cls, | |||
843 | struct MeshRegexBlock *block = value; | 881 | struct MeshRegexBlock *block = value; |
844 | struct MeshRegexSearchContext *ctx = cls; | 882 | struct MeshRegexSearchContext *ctx = cls; |
845 | 883 | ||
846 | // block was checked when stored, no need to check again | 884 | if (GNUNET_YES == ntohl(block->accepting) && |
885 | ctx->position == strlen (ctx->info->description)) | ||
886 | { | ||
887 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "* Found accepting known block\n"); | ||
888 | regex_find_path (key, ctx); | ||
889 | return GNUNET_YES; // We found an accept state! | ||
890 | } | ||
891 | else | ||
892 | { | ||
893 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "* %u, %u, [%u]\n", | ||
894 | ctx->position, strlen(ctx->info->description), | ||
895 | ntohl(block->accepting)); | ||
896 | |||
897 | } | ||
847 | (void) GNUNET_MESH_regex_block_iterate (block, SIZE_MAX, | 898 | (void) GNUNET_MESH_regex_block_iterate (block, SIZE_MAX, |
848 | ®ex_edge_iterator, ctx); | 899 | ®ex_edge_iterator, ctx); |
849 | 900 | ||
@@ -882,6 +933,7 @@ regex_edge_iterator (void *cls, | |||
882 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "* ctlen : %u\n", current_len); | 933 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "* ctlen : %u\n", current_len); |
883 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "* tklen : %u\n", len); | 934 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "* tklen : %u\n", len); |
884 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "* tk[0] : %c\n", token[0]); | 935 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "* tk[0] : %c\n", token[0]); |
936 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "* nextk : %s\n", GNUNET_h2s(key)); | ||
885 | if (len > current_len) | 937 | if (len > current_len) |
886 | { | 938 | { |
887 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "* Token too long, END\n"); | 939 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "* Token too long, END\n"); |
@@ -894,7 +946,7 @@ regex_edge_iterator (void *cls, | |||
894 | } | 946 | } |
895 | new_ctx = GNUNET_malloc (sizeof (struct MeshRegexSearchContext)); | 947 | new_ctx = GNUNET_malloc (sizeof (struct MeshRegexSearchContext)); |
896 | new_ctx->info = info; | 948 | new_ctx->info = info; |
897 | new_ctx->position += ctx->position + len; | 949 | new_ctx->position = ctx->position + len; |
898 | GNUNET_array_append (info->contexts, info->n_contexts, new_ctx); | 950 | GNUNET_array_append (info->contexts, info->n_contexts, new_ctx); |
899 | if (GNUNET_YES == | 951 | if (GNUNET_YES == |
900 | GNUNET_CONTAINER_multihashmap_contains(info->dht_get_handles, key)) | 952 | GNUNET_CONTAINER_multihashmap_contains(info->dht_get_handles, key)) |
@@ -1096,6 +1148,36 @@ regex_put (const char *regex) | |||
1096 | 1148 | ||
1097 | } | 1149 | } |
1098 | 1150 | ||
1151 | /** | ||
1152 | * Find a path to a peer that offers a regex servcie compatible | ||
1153 | * with a given string. | ||
1154 | * | ||
1155 | * @param key The key of the accepting state. | ||
1156 | * @param ctx Context containing info about the string, tunnel, etc. | ||
1157 | */ | ||
1158 | static void | ||
1159 | regex_find_path (const struct GNUNET_HashCode *key, | ||
1160 | struct MeshRegexSearchContext *ctx) | ||
1161 | { | ||
1162 | struct GNUNET_DHT_GetHandle *get_h; | ||
1163 | |||
1164 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Found peer by service\n"); | ||
1165 | get_h = GNUNET_DHT_get_start (dht_handle, /* handle */ | ||
1166 | GNUNET_BLOCK_TYPE_MESH_REGEX_ACCEPT, /* type */ | ||
1167 | key, /* key to search */ | ||
1168 | DHT_REPLICATION_LEVEL, /* replication level */ | ||
1169 | GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE | | ||
1170 | GNUNET_DHT_RO_RECORD_ROUTE, | ||
1171 | NULL, /* xquery */ // FIXME BLOOMFILTER | ||
1172 | 0, /* xquery bits */ // FIXME BLOOMFILTER SIZE | ||
1173 | &dht_get_string_accept_handler, ctx); | ||
1174 | GNUNET_break (GNUNET_OK == | ||
1175 | GNUNET_CONTAINER_multihashmap_put(ctx->info->dht_get_handles, | ||
1176 | key, | ||
1177 | get_h, | ||
1178 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE)); | ||
1179 | } | ||
1180 | |||
1099 | 1181 | ||
1100 | /******************************************************************************/ | 1182 | /******************************************************************************/ |
1101 | /************************ PERIODIC FUNCTIONS ****************************/ | 1183 | /************************ PERIODIC FUNCTIONS ****************************/ |
@@ -4025,7 +4107,7 @@ handle_mesh_path_ack (void *cls, const struct GNUNET_PeerIdentity *peer, | |||
4025 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received a path ACK msg [%s]\n", | 4107 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received a path ACK msg [%s]\n", |
4026 | GNUNET_i2s (&my_full_id)); | 4108 | GNUNET_i2s (&my_full_id)); |
4027 | msg = (struct GNUNET_MESH_PathACK *) message; | 4109 | msg = (struct GNUNET_MESH_PathACK *) message; |
4028 | t = tunnel_get (&msg->oid, msg->tid); | 4110 | t = tunnel_get (&msg->oid, ntohl(msg->tid)); |
4029 | if (NULL == t) | 4111 | if (NULL == t) |
4030 | { | 4112 | { |
4031 | /* TODO notify that we don't know the tunnel */ | 4113 | /* TODO notify that we don't know the tunnel */ |
@@ -4396,7 +4478,8 @@ dht_get_string_accept_handler (void *cls, struct GNUNET_TIME_Absolute exp, | |||
4396 | const struct GNUNET_PeerIdentity *get_path, | 4478 | const struct GNUNET_PeerIdentity *get_path, |
4397 | unsigned int get_path_length, | 4479 | unsigned int get_path_length, |
4398 | const struct GNUNET_PeerIdentity *put_path, | 4480 | const struct GNUNET_PeerIdentity *put_path, |
4399 | unsigned int put_path_length, enum GNUNET_BLOCK_Type type, | 4481 | unsigned int put_path_length, |
4482 | enum GNUNET_BLOCK_Type type, | ||
4400 | size_t size, const void *data) | 4483 | size_t size, const void *data) |
4401 | { | 4484 | { |
4402 | const struct MeshRegexAccept *block = data; | 4485 | const struct MeshRegexAccept *block = data; |
@@ -4490,22 +4573,7 @@ dht_get_string_handler (void *cls, struct GNUNET_TIME_Absolute exp, | |||
4490 | { | 4573 | { |
4491 | if (GNUNET_YES == ntohl (block->accepting)) | 4574 | if (GNUNET_YES == ntohl (block->accepting)) |
4492 | { | 4575 | { |
4493 | struct GNUNET_DHT_GetHandle *get_h; | 4576 | regex_find_path(key, ctx); |
4494 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Found peer by service\n"); | ||
4495 | get_h = GNUNET_DHT_get_start (dht_handle, /* handle */ | ||
4496 | GNUNET_BLOCK_TYPE_MESH_REGEX_ACCEPT, /* type */ | ||
4497 | key, /* key to search */ | ||
4498 | DHT_REPLICATION_LEVEL, /* replication level */ | ||
4499 | GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE | | ||
4500 | GNUNET_DHT_RO_RECORD_ROUTE, | ||
4501 | NULL, /* xquery */ // FIXME BLOOMFILTER | ||
4502 | 0, /* xquery bits */ // FIXME BLOOMFILTER SIZE | ||
4503 | &dht_get_string_accept_handler, ctx); | ||
4504 | GNUNET_break (GNUNET_OK == | ||
4505 | GNUNET_CONTAINER_multihashmap_put(info->dht_get_handles, | ||
4506 | key, | ||
4507 | get_h, | ||
4508 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE)); | ||
4509 | } | 4577 | } |
4510 | else | 4578 | else |
4511 | { | 4579 | { |
diff --git a/src/mesh/test_mesh_regex.c b/src/mesh/test_mesh_regex.c index f7c880474..049b03241 100644 --- a/src/mesh/test_mesh_regex.c +++ b/src/mesh/test_mesh_regex.c | |||
@@ -50,7 +50,7 @@ static int ok[MESH_REGEX_PEERS]; | |||
50 | /** | 50 | /** |
51 | * How many connects have happened. | 51 | * How many connects have happened. |
52 | */ | 52 | */ |
53 | static int connected_peers; | 53 | static int regex_peers; |
54 | 54 | ||
55 | /** | 55 | /** |
56 | * Be verbose | 56 | * Be verbose |
@@ -286,7 +286,7 @@ ch (void *cls, const struct GNUNET_PeerIdentity *peer, | |||
286 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 286 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
287 | "Peer connected: %s\n", | 287 | "Peer connected: %s\n", |
288 | GNUNET_i2s (peer)); | 288 | GNUNET_i2s (peer)); |
289 | connected_peers++; | 289 | regex_peers++; |
290 | 290 | ||
291 | GNUNET_MESH_notify_transmit_ready(t[i], 0, 0, | 291 | GNUNET_MESH_notify_transmit_ready(t[i], 0, 0, |
292 | GNUNET_TIME_UNIT_FOREVER_REL, | 292 | GNUNET_TIME_UNIT_FOREVER_REL, |
@@ -432,7 +432,7 @@ peergroup_ready (void *cls, const char *emsg) | |||
432 | NULL, | 432 | NULL, |
433 | handlers, | 433 | handlers, |
434 | &app); | 434 | &app); |
435 | connected_peers = 0; | 435 | regex_peers = 0; |
436 | for (i = 0; i < MESH_REGEX_PEERS; i++) | 436 | for (i = 0; i < MESH_REGEX_PEERS; i++) |
437 | { | 437 | { |
438 | ok[i] = GNUNET_NO; | 438 | ok[i] = GNUNET_NO; |
@@ -601,11 +601,11 @@ main (int argc, char *argv[]) | |||
601 | i, strings[i]); | 601 | i, strings[i]); |
602 | } | 602 | } |
603 | } | 603 | } |
604 | if (GNUNET_OK != result || connected_peers != MESH_REGEX_PEERS) | 604 | if (GNUNET_OK != result || regex_peers != MESH_REGEX_PEERS) |
605 | { | 605 | { |
606 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 606 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
607 | "test: FAILED! %u connected peers\n", | 607 | "test: FAILED! %u connected peers\n", |
608 | connected_peers); | 608 | regex_peers); |
609 | return 1; | 609 | return 1; |
610 | } | 610 | } |
611 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test: success\n"); | 611 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test: success\n"); |