diff options
Diffstat (limited to 'src/namecache/test_namecache_api_cache_block.c')
-rw-r--r-- | src/namecache/test_namecache_api_cache_block.c | 241 |
1 files changed, 122 insertions, 119 deletions
diff --git a/src/namecache/test_namecache_api_cache_block.c b/src/namecache/test_namecache_api_cache_block.c index def6cedb3..2b25a26f9 100644 --- a/src/namecache/test_namecache_api_cache_block.c +++ b/src/namecache/test_namecache_api_cache_block.c | |||
@@ -32,12 +32,12 @@ | |||
32 | 32 | ||
33 | #define TEST_RECORD_DATA 'a' | 33 | #define TEST_RECORD_DATA 'a' |
34 | 34 | ||
35 | #define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 100) | 35 | #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 100) |
36 | 36 | ||
37 | 37 | ||
38 | static struct GNUNET_NAMECACHE_Handle *nsh; | 38 | static struct GNUNET_NAMECACHE_Handle *nsh; |
39 | 39 | ||
40 | static struct GNUNET_SCHEDULER_Task * endbadly_task; | 40 | static struct GNUNET_SCHEDULER_Task *endbadly_task; |
41 | 41 | ||
42 | static struct GNUNET_CRYPTO_EcdsaPrivateKey *privkey; | 42 | static struct GNUNET_CRYPTO_EcdsaPrivateKey *privkey; |
43 | 43 | ||
@@ -49,19 +49,19 @@ static struct GNUNET_NAMECACHE_QueueEntry *nsqe; | |||
49 | 49 | ||
50 | 50 | ||
51 | static void | 51 | static void |
52 | cleanup() | 52 | cleanup () |
53 | { | 53 | { |
54 | if (NULL != nsh) | 54 | if (NULL != nsh) |
55 | { | 55 | { |
56 | GNUNET_NAMECACHE_disconnect(nsh); | 56 | GNUNET_NAMECACHE_disconnect (nsh); |
57 | nsh = NULL; | 57 | nsh = NULL; |
58 | } | 58 | } |
59 | if (NULL != privkey) | 59 | if (NULL != privkey) |
60 | { | 60 | { |
61 | GNUNET_free(privkey); | 61 | GNUNET_free (privkey); |
62 | privkey = NULL; | 62 | privkey = NULL; |
63 | } | 63 | } |
64 | GNUNET_SCHEDULER_shutdown(); | 64 | GNUNET_SCHEDULER_shutdown (); |
65 | } | 65 | } |
66 | 66 | ||
67 | 67 | ||
@@ -71,178 +71,181 @@ cleanup() | |||
71 | * @param cls handle to use to re-connect. | 71 | * @param cls handle to use to re-connect. |
72 | */ | 72 | */ |
73 | static void | 73 | static void |
74 | endbadly(void *cls) | 74 | endbadly (void *cls) |
75 | { | 75 | { |
76 | if (NULL != nsqe) | 76 | if (NULL != nsqe) |
77 | { | 77 | { |
78 | GNUNET_NAMECACHE_cancel(nsqe); | 78 | GNUNET_NAMECACHE_cancel (nsqe); |
79 | nsqe = NULL; | 79 | nsqe = NULL; |
80 | } | 80 | } |
81 | cleanup(); | 81 | cleanup (); |
82 | res = 1; | 82 | res = 1; |
83 | } | 83 | } |
84 | 84 | ||
85 | 85 | ||
86 | static void | 86 | static void |
87 | end(void *cls) | 87 | end (void *cls) |
88 | { | 88 | { |
89 | cleanup(); | 89 | cleanup (); |
90 | res = 0; | 90 | res = 0; |
91 | } | 91 | } |
92 | 92 | ||
93 | 93 | ||
94 | static void | 94 | static void |
95 | rd_decrypt_cb(void *cls, | 95 | rd_decrypt_cb (void *cls, |
96 | unsigned int rd_count, | 96 | unsigned int rd_count, |
97 | const struct GNUNET_GNSRECORD_Data *rd) | 97 | const struct GNUNET_GNSRECORD_Data *rd) |
98 | { | 98 | { |
99 | char rd_cmp_data[TEST_RECORD_DATALEN]; | 99 | char rd_cmp_data[TEST_RECORD_DATALEN]; |
100 | 100 | ||
101 | GNUNET_assert(1 == rd_count); | 101 | GNUNET_assert (1 == rd_count); |
102 | GNUNET_assert(NULL != rd); | 102 | GNUNET_assert (NULL != rd); |
103 | 103 | ||
104 | memset(rd_cmp_data, 'a', TEST_RECORD_DATALEN); | 104 | memset (rd_cmp_data, 'a', TEST_RECORD_DATALEN); |
105 | 105 | ||
106 | GNUNET_assert(TEST_RECORD_TYPE == rd[0].record_type); | 106 | GNUNET_assert (TEST_RECORD_TYPE == rd[0].record_type); |
107 | GNUNET_assert(TEST_RECORD_DATALEN == rd[0].data_size); | 107 | GNUNET_assert (TEST_RECORD_DATALEN == rd[0].data_size); |
108 | GNUNET_assert(0 == memcmp(&rd_cmp_data, rd[0].data, TEST_RECORD_DATALEN)); | 108 | GNUNET_assert (0 == memcmp (&rd_cmp_data, rd[0].data, TEST_RECORD_DATALEN)); |
109 | 109 | ||
110 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 110 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
111 | "Block was decrypted successfully \n"); | 111 | "Block was decrypted successfully \n"); |
112 | 112 | ||
113 | GNUNET_SCHEDULER_add_now(&end, NULL); | 113 | GNUNET_SCHEDULER_add_now (&end, NULL); |
114 | } | 114 | } |
115 | 115 | ||
116 | 116 | ||
117 | static void | 117 | static void |
118 | name_lookup_proc(void *cls, | 118 | name_lookup_proc (void *cls, |
119 | const struct GNUNET_GNSRECORD_Block *block) | 119 | const struct GNUNET_GNSRECORD_Block *block) |
120 | { | 120 | { |
121 | const char *name = cls; | 121 | const char *name = cls; |
122 | 122 | ||
123 | nsqe = NULL; | 123 | nsqe = NULL; |
124 | 124 | ||
125 | GNUNET_assert(NULL != cls); | 125 | GNUNET_assert (NULL != cls); |
126 | 126 | ||
127 | if (endbadly_task != NULL) | 127 | if (endbadly_task != NULL) |
128 | { | 128 | { |
129 | GNUNET_SCHEDULER_cancel(endbadly_task); | 129 | GNUNET_SCHEDULER_cancel (endbadly_task); |
130 | endbadly_task = NULL; | 130 | endbadly_task = NULL; |
131 | } | 131 | } |
132 | 132 | ||
133 | if (NULL == block) | 133 | if (NULL == block) |
134 | { | 134 | { |
135 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | 135 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
136 | _("Namecache returned no block\n")); | 136 | _ ("Namecache returned no block\n")); |
137 | if (NULL != endbadly_task) | 137 | if (NULL != endbadly_task) |
138 | GNUNET_SCHEDULER_cancel(endbadly_task); | 138 | GNUNET_SCHEDULER_cancel (endbadly_task); |
139 | endbadly_task = GNUNET_SCHEDULER_add_now(&endbadly, NULL); | 139 | endbadly_task = GNUNET_SCHEDULER_add_now (&endbadly, NULL); |
140 | return; | 140 | return; |
141 | } | 141 | } |
142 | 142 | ||
143 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 143 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
144 | "Namecache returned block, decrypting \n"); | 144 | "Namecache returned block, decrypting \n"); |
145 | GNUNET_assert(GNUNET_OK == GNUNET_GNSRECORD_block_decrypt(block, | 145 | GNUNET_assert (GNUNET_OK == GNUNET_GNSRECORD_block_decrypt (block, |
146 | &pubkey, name, &rd_decrypt_cb, (void *)name)); | 146 | &pubkey, name, |
147 | &rd_decrypt_cb, | ||
148 | (void *) name)); | ||
147 | } | 149 | } |
148 | 150 | ||
149 | static void | 151 | static void |
150 | cache_cont(void *cls, int32_t success, const char *emsg) | 152 | cache_cont (void *cls, int32_t success, const char *emsg) |
151 | { | 153 | { |
152 | const char *name = cls; | 154 | const char *name = cls; |
153 | struct GNUNET_HashCode derived_hash; | 155 | struct GNUNET_HashCode derived_hash; |
154 | 156 | ||
155 | GNUNET_assert(NULL != cls); | 157 | GNUNET_assert (NULL != cls); |
156 | 158 | ||
157 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 159 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
158 | "Name store cached record for `%s': %s\n", | 160 | "Name store cached record for `%s': %s\n", |
159 | name, | 161 | name, |
160 | (success == GNUNET_OK) ? "SUCCESS" : "FAIL"); | 162 | (success == GNUNET_OK) ? "SUCCESS" : "FAIL"); |
161 | 163 | ||
162 | /* Create derived hash */ | 164 | /* Create derived hash */ |
163 | GNUNET_GNSRECORD_query_from_public_key(&pubkey, name, &derived_hash); | 165 | GNUNET_GNSRECORD_query_from_public_key (&pubkey, name, &derived_hash); |
164 | 166 | ||
165 | nsqe = GNUNET_NAMECACHE_lookup_block(nsh, &derived_hash, | 167 | nsqe = GNUNET_NAMECACHE_lookup_block (nsh, &derived_hash, |
166 | &name_lookup_proc, (void *)name); | 168 | &name_lookup_proc, (void *) name); |
167 | } | 169 | } |
168 | 170 | ||
169 | 171 | ||
170 | static void | 172 | static void |
171 | run(void *cls, | 173 | run (void *cls, |
172 | const struct GNUNET_CONFIGURATION_Handle *cfg, | 174 | const struct GNUNET_CONFIGURATION_Handle *cfg, |
173 | struct GNUNET_TESTING_Peer *peer) | 175 | struct GNUNET_TESTING_Peer *peer) |
174 | { | 176 | { |
175 | struct GNUNET_GNSRECORD_Data rd; | 177 | struct GNUNET_GNSRECORD_Data rd; |
176 | struct GNUNET_GNSRECORD_Block *block; | 178 | struct GNUNET_GNSRECORD_Block *block; |
177 | char *hostkey_file; | 179 | char *hostkey_file; |
178 | const char * name = "dummy.dummy.gnunet"; | 180 | const char *name = "dummy.dummy.gnunet"; |
179 | 181 | ||
180 | endbadly_task = GNUNET_SCHEDULER_add_delayed(TIMEOUT, | 182 | endbadly_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, |
181 | &endbadly, NULL); | 183 | &endbadly, NULL); |
182 | GNUNET_asprintf(&hostkey_file, | 184 | GNUNET_asprintf (&hostkey_file, |
183 | "zonefiles%s%s", | 185 | "zonefiles%s%s", |
184 | DIR_SEPARATOR_STR, | 186 | DIR_SEPARATOR_STR, |
185 | "N0UJMP015AFUNR2BTNM3FKPBLG38913BL8IDMCO2H0A1LIB81960.zkey"); | 187 | "N0UJMP015AFUNR2BTNM3FKPBLG38913BL8IDMCO2H0A1LIB81960.zkey"); |
186 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Using zonekey file `%s' \n", hostkey_file); | 188 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Using zonekey file `%s' \n", |
187 | privkey = GNUNET_CRYPTO_ecdsa_key_create_from_file(hostkey_file); | 189 | hostkey_file); |
188 | GNUNET_free(hostkey_file); | 190 | privkey = GNUNET_CRYPTO_ecdsa_key_create_from_file (hostkey_file); |
189 | GNUNET_assert(privkey != NULL); | 191 | GNUNET_free (hostkey_file); |
190 | GNUNET_CRYPTO_ecdsa_key_get_public(privkey, &pubkey); | 192 | GNUNET_assert (privkey != NULL); |
191 | 193 | GNUNET_CRYPTO_ecdsa_key_get_public (privkey, &pubkey); | |
192 | 194 | ||
193 | rd.expiration_time = GNUNET_TIME_absolute_get().abs_value_us + 10000000000; | 195 | |
196 | rd.expiration_time = GNUNET_TIME_absolute_get ().abs_value_us + 10000000000; | ||
194 | rd.record_type = TEST_RECORD_TYPE; | 197 | rd.record_type = TEST_RECORD_TYPE; |
195 | rd.data_size = TEST_RECORD_DATALEN; | 198 | rd.data_size = TEST_RECORD_DATALEN; |
196 | rd.data = GNUNET_malloc(TEST_RECORD_DATALEN); | 199 | rd.data = GNUNET_malloc (TEST_RECORD_DATALEN); |
197 | rd.flags = 0; | 200 | rd.flags = 0; |
198 | memset((char *)rd.data, 'a', TEST_RECORD_DATALEN); | 201 | memset ((char *) rd.data, 'a', TEST_RECORD_DATALEN); |
199 | block = GNUNET_GNSRECORD_block_create(privkey, | 202 | block = GNUNET_GNSRECORD_block_create (privkey, |
200 | GNUNET_TIME_UNIT_FOREVER_ABS, | 203 | GNUNET_TIME_UNIT_FOREVER_ABS, |
201 | name, &rd, 1); | 204 | name, &rd, 1); |
202 | if (NULL == block) | 205 | if (NULL == block) |
203 | { | 206 | { |
204 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | 207 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
205 | "Namecache cannot cache no block!\n"); | 208 | "Namecache cannot cache no block!\n"); |
206 | GNUNET_SCHEDULER_shutdown(); | 209 | GNUNET_SCHEDULER_shutdown (); |
207 | GNUNET_free(block); | 210 | GNUNET_free (block); |
208 | return; | 211 | return; |
209 | } | 212 | } |
210 | 213 | ||
211 | nsh = GNUNET_NAMECACHE_connect(cfg); | 214 | nsh = GNUNET_NAMECACHE_connect (cfg); |
212 | if (NULL == nsh) | 215 | if (NULL == nsh) |
213 | { | 216 | { |
214 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | 217 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
215 | _("Namecache cannot connect to namecache\n")); | 218 | _ ("Namecache cannot connect to namecache\n")); |
216 | GNUNET_SCHEDULER_shutdown(); | 219 | GNUNET_SCHEDULER_shutdown (); |
217 | GNUNET_free(block); | 220 | GNUNET_free (block); |
218 | return; | 221 | return; |
219 | } | 222 | } |
220 | GNUNET_break(NULL != nsh); | 223 | GNUNET_break (NULL != nsh); |
221 | 224 | ||
222 | nsqe = GNUNET_NAMECACHE_block_cache(nsh, | 225 | nsqe = GNUNET_NAMECACHE_block_cache (nsh, |
223 | block, | 226 | block, |
224 | &cache_cont, (void *)name); | 227 | &cache_cont, (void *) name); |
225 | if (NULL == nsqe) | 228 | if (NULL == nsqe) |
226 | { | 229 | { |
227 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | 230 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
228 | _("Namecache cannot cache no block\n")); | 231 | _ ("Namecache cannot cache no block\n")); |
229 | } | 232 | } |
230 | GNUNET_free(block); | 233 | GNUNET_free (block); |
231 | GNUNET_free((void *)rd.data); | 234 | GNUNET_free ((void *) rd.data); |
232 | } | 235 | } |
233 | 236 | ||
234 | 237 | ||
235 | int | 238 | int |
236 | main(int argc, char *argv[]) | 239 | main (int argc, char *argv[]) |
237 | { | 240 | { |
238 | GNUNET_DISK_directory_remove("/tmp/test-gnunet-namecache/"); | 241 | GNUNET_DISK_directory_remove ("/tmp/test-gnunet-namecache/"); |
239 | res = 1; | 242 | res = 1; |
240 | if (0 != | 243 | if (0 != |
241 | GNUNET_TESTING_service_run("test-namecache-api", | 244 | GNUNET_TESTING_service_run ("test-namecache-api", |
242 | "namecache", | 245 | "namecache", |
243 | "test_namecache_api.conf", | 246 | "test_namecache_api.conf", |
244 | &run, | 247 | &run, |
245 | NULL)) | 248 | NULL)) |
246 | return 1; | 249 | return 1; |
247 | return res; | 250 | return res; |
248 | } | 251 | } |