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.c231
1 files changed, 116 insertions, 115 deletions
diff --git a/src/namecache/test_namecache_api_cache_block.c b/src/namecache/test_namecache_api_cache_block.c
index 1d522e7fb..def6cedb3 100644
--- a/src/namecache/test_namecache_api_cache_block.c
+++ b/src/namecache/test_namecache_api_cache_block.c
@@ -11,12 +11,12 @@
11 WITHOUT ANY WARRANTY; without even the implied warranty of 11 WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Affero General Public License for more details. 13 Affero General Public License for more details.
14 14
15 You should have received a copy of the GNU Affero General Public License 15 You should have received a copy of the GNU Affero General Public License
16 along with this program. If not, see <http://www.gnu.org/licenses/>. 16 along with this program. If not, see <http://www.gnu.org/licenses/>.
17 17
18 SPDX-License-Identifier: AGPL3.0-or-later 18 SPDX-License-Identifier: AGPL3.0-or-later
19*/ 19 */
20/** 20/**
21 * @file namecache/test_namecache_api.c 21 * @file namecache/test_namecache_api.c
22 * @brief testcase for namecache_api.c: store a record and perform a lookup 22 * @brief testcase for namecache_api.c: store a record and perform a lookup
@@ -32,7 +32,7 @@
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;
@@ -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,177 +71,178 @@ 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 nsqe = NULL; 123 nsqe = NULL;
123 124
124 GNUNET_assert (NULL != cls); 125 GNUNET_assert(NULL != cls);
125 126
126 if (endbadly_task != NULL) 127 if (endbadly_task != NULL)
127 { 128 {
128 GNUNET_SCHEDULER_cancel (endbadly_task); 129 GNUNET_SCHEDULER_cancel(endbadly_task);
129 endbadly_task = NULL; 130 endbadly_task = NULL;
130 } 131 }
131 132
132 if (NULL == block) 133 if (NULL == block)
133 { 134 {
134 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, 135 GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
135 _("Namecache returned no block\n")); 136 _("Namecache returned no block\n"));
136 if (NULL != endbadly_task) 137 if (NULL != endbadly_task)
137 GNUNET_SCHEDULER_cancel (endbadly_task); 138 GNUNET_SCHEDULER_cancel(endbadly_task);
138 endbadly_task = GNUNET_SCHEDULER_add_now (&endbadly, NULL); 139 endbadly_task = GNUNET_SCHEDULER_add_now(&endbadly, NULL);
139 return; 140 return;
140 } 141 }
141 142
142 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 143 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
143 "Namecache returned block, decrypting \n"); 144 "Namecache returned block, decrypting \n");
144 GNUNET_assert (GNUNET_OK == GNUNET_GNSRECORD_block_decrypt(block, 145 GNUNET_assert(GNUNET_OK == GNUNET_GNSRECORD_block_decrypt(block,
145 &pubkey, name, &rd_decrypt_cb, (void *) name)); 146 &pubkey, name, &rd_decrypt_cb, (void *)name));
146} 147}
147 148
148static void 149static void
149cache_cont (void *cls, int32_t success, const char *emsg) 150cache_cont(void *cls, int32_t success, const char *emsg)
150{ 151{
151 const char *name = cls; 152 const char *name = cls;
152 struct GNUNET_HashCode derived_hash; 153 struct GNUNET_HashCode derived_hash;
153 154
154 GNUNET_assert (NULL != cls); 155 GNUNET_assert(NULL != cls);
155 156
156 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 157 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
157 "Name store cached record for `%s': %s\n", 158 "Name store cached record for `%s': %s\n",
158 name, 159 name,
159 (success == GNUNET_OK) ? "SUCCESS" : "FAIL"); 160 (success == GNUNET_OK) ? "SUCCESS" : "FAIL");
160 161
161 /* Create derived hash */ 162 /* Create derived hash */
162 GNUNET_GNSRECORD_query_from_public_key (&pubkey, name, &derived_hash); 163 GNUNET_GNSRECORD_query_from_public_key(&pubkey, name, &derived_hash);
163 164
164 nsqe = GNUNET_NAMECACHE_lookup_block (nsh, &derived_hash, 165 nsqe = GNUNET_NAMECACHE_lookup_block(nsh, &derived_hash,
165 &name_lookup_proc, (void *) name); 166 &name_lookup_proc, (void *)name);
166} 167}
167 168
168 169
169static void 170static void
170run (void *cls, 171run(void *cls,
171 const struct GNUNET_CONFIGURATION_Handle *cfg, 172 const struct GNUNET_CONFIGURATION_Handle *cfg,
172 struct GNUNET_TESTING_Peer *peer) 173 struct GNUNET_TESTING_Peer *peer)
173{ 174{
174 struct GNUNET_GNSRECORD_Data rd; 175 struct GNUNET_GNSRECORD_Data rd;
175 struct GNUNET_GNSRECORD_Block *block; 176 struct GNUNET_GNSRECORD_Block *block;
176 char *hostkey_file; 177 char *hostkey_file;
177 const char * name = "dummy.dummy.gnunet"; 178 const char * name = "dummy.dummy.gnunet";
178 179
179 endbadly_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, 180 endbadly_task = GNUNET_SCHEDULER_add_delayed(TIMEOUT,
180 &endbadly, NULL); 181 &endbadly, NULL);
181 GNUNET_asprintf (&hostkey_file, 182 GNUNET_asprintf(&hostkey_file,
182 "zonefiles%s%s", 183 "zonefiles%s%s",
183 DIR_SEPARATOR_STR, 184 DIR_SEPARATOR_STR,
184 "N0UJMP015AFUNR2BTNM3FKPBLG38913BL8IDMCO2H0A1LIB81960.zkey"); 185 "N0UJMP015AFUNR2BTNM3FKPBLG38913BL8IDMCO2H0A1LIB81960.zkey");
185 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Using zonekey file `%s' \n", hostkey_file); 186 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Using zonekey file `%s' \n", hostkey_file);
186 privkey = GNUNET_CRYPTO_ecdsa_key_create_from_file (hostkey_file); 187 privkey = GNUNET_CRYPTO_ecdsa_key_create_from_file(hostkey_file);
187 GNUNET_free (hostkey_file); 188 GNUNET_free(hostkey_file);
188 GNUNET_assert (privkey != NULL); 189 GNUNET_assert(privkey != NULL);
189 GNUNET_CRYPTO_ecdsa_key_get_public (privkey, &pubkey); 190 GNUNET_CRYPTO_ecdsa_key_get_public(privkey, &pubkey);
190 191
191 192
192 rd.expiration_time = GNUNET_TIME_absolute_get().abs_value_us + 10000000000; 193 rd.expiration_time = GNUNET_TIME_absolute_get().abs_value_us + 10000000000;
193 rd.record_type = TEST_RECORD_TYPE; 194 rd.record_type = TEST_RECORD_TYPE;
194 rd.data_size = TEST_RECORD_DATALEN; 195 rd.data_size = TEST_RECORD_DATALEN;
195 rd.data = GNUNET_malloc (TEST_RECORD_DATALEN); 196 rd.data = GNUNET_malloc(TEST_RECORD_DATALEN);
196 rd.flags = 0; 197 rd.flags = 0;
197 memset ((char *) rd.data, 'a', TEST_RECORD_DATALEN); 198 memset((char *)rd.data, 'a', TEST_RECORD_DATALEN);
198 block = GNUNET_GNSRECORD_block_create (privkey, 199 block = GNUNET_GNSRECORD_block_create(privkey,
199 GNUNET_TIME_UNIT_FOREVER_ABS, 200 GNUNET_TIME_UNIT_FOREVER_ABS,
200 name, &rd, 1); 201 name, &rd, 1);
201 if (NULL == block) 202 if (NULL == block)
202 { 203 {
203 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, 204 GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
204 "Namecache cannot cache no block!\n"); 205 "Namecache cannot cache no block!\n");
205 GNUNET_SCHEDULER_shutdown (); 206 GNUNET_SCHEDULER_shutdown();
206 GNUNET_free (block); 207 GNUNET_free(block);
207 return; 208 return;
208 } 209 }
209 210
210 nsh = GNUNET_NAMECACHE_connect (cfg); 211 nsh = GNUNET_NAMECACHE_connect(cfg);
211 if (NULL == nsh) 212 if (NULL == nsh)
212 { 213 {
213 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, 214 GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
214 _("Namecache cannot connect to namecache\n")); 215 _("Namecache cannot connect to namecache\n"));
215 GNUNET_SCHEDULER_shutdown (); 216 GNUNET_SCHEDULER_shutdown();
216 GNUNET_free (block); 217 GNUNET_free(block);
217 return; 218 return;
218 } 219 }
219 GNUNET_break (NULL != nsh); 220 GNUNET_break(NULL != nsh);
220 221
221 nsqe = GNUNET_NAMECACHE_block_cache (nsh, 222 nsqe = GNUNET_NAMECACHE_block_cache(nsh,
222 block, 223 block,
223 &cache_cont, (void *) name); 224 &cache_cont, (void *)name);
224 if (NULL == nsqe) 225 if (NULL == nsqe)
225 { 226 {
226 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, 227 GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
227 _("Namecache cannot cache no block\n")); 228 _("Namecache cannot cache no block\n"));
228 } 229 }
229 GNUNET_free (block); 230 GNUNET_free(block);
230 GNUNET_free ((void *)rd.data); 231 GNUNET_free((void *)rd.data);
231} 232}
232 233
233 234
234int 235int
235main (int argc, char *argv[]) 236main(int argc, char *argv[])
236{ 237{
237 GNUNET_DISK_directory_remove ("/tmp/test-gnunet-namecache/"); 238 GNUNET_DISK_directory_remove("/tmp/test-gnunet-namecache/");
238 res = 1; 239 res = 1;
239 if (0 != 240 if (0 !=
240 GNUNET_TESTING_service_run ("test-namecache-api", 241 GNUNET_TESTING_service_run("test-namecache-api",
241 "namecache", 242 "namecache",
242 "test_namecache_api.conf", 243 "test_namecache_api.conf",
243 &run, 244 &run,
244 NULL)) 245 NULL))
245 return 1; 246 return 1;
246 return res; 247 return res;
247} 248}