summaryrefslogtreecommitdiff
path: root/src/namecache/test_namecache_api_cache_block.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/namecache/test_namecache_api_cache_block.c')
-rw-r--r--src/namecache/test_namecache_api_cache_block.c241
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
38static struct GNUNET_NAMECACHE_Handle *nsh; 38static struct GNUNET_NAMECACHE_Handle *nsh;
39 39
40static struct GNUNET_SCHEDULER_Task * endbadly_task; 40static struct GNUNET_SCHEDULER_Task *endbadly_task;
41 41
42static struct GNUNET_CRYPTO_EcdsaPrivateKey *privkey; 42static struct GNUNET_CRYPTO_EcdsaPrivateKey *privkey;
43 43
@@ -49,19 +49,19 @@ static struct GNUNET_NAMECACHE_QueueEntry *nsqe;
49 49
50 50
51static void 51static void
52cleanup() 52cleanup ()
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 */
73static void 73static void
74endbadly(void *cls) 74endbadly (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
86static void 86static void
87end(void *cls) 87end (void *cls)
88{ 88{
89 cleanup(); 89 cleanup ();
90 res = 0; 90 res = 0;
91} 91}
92 92
93 93
94static void 94static void
95rd_decrypt_cb(void *cls, 95rd_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
117static void 117static void
118name_lookup_proc(void *cls, 118name_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
149static void 151static void
150cache_cont(void *cls, int32_t success, const char *emsg) 152cache_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
170static void 172static void
171run(void *cls, 173run (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
235int 238int
236main(int argc, char *argv[]) 239main (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}