aboutsummaryrefslogtreecommitdiff
path: root/src/namestore/test_namestore_api_lookup_public.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/namestore/test_namestore_api_lookup_public.c')
-rw-r--r--src/namestore/test_namestore_api_lookup_public.c214
1 files changed, 107 insertions, 107 deletions
diff --git a/src/namestore/test_namestore_api_lookup_public.c b/src/namestore/test_namestore_api_lookup_public.c
index 460be0a18..01f07eb39 100644
--- a/src/namestore/test_namestore_api_lookup_public.c
+++ b/src/namestore/test_namestore_api_lookup_public.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 namestore/test_namestore_api.c 21 * @file namestore/test_namestore_api.c
22 * @brief testcase for namestore_api.c: store a record and perform a lookup 22 * @brief testcase for namestore_api.c: store a record and perform a lookup
@@ -33,7 +33,7 @@
33 33
34#define TEST_RECORD_DATA 'a' 34#define TEST_RECORD_DATA 'a'
35 35
36#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 100) 36#define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 100)
37 37
38 38
39static struct GNUNET_NAMESTORE_Handle *nsh; 39static struct GNUNET_NAMESTORE_Handle *nsh;
@@ -54,24 +54,24 @@ static struct GNUNET_NAMECACHE_QueueEntry *ncqe;
54 54
55 55
56static void 56static void
57cleanup () 57cleanup()
58{ 58{
59 if (NULL != nsh) 59 if (NULL != nsh)
60 { 60 {
61 GNUNET_NAMESTORE_disconnect (nsh); 61 GNUNET_NAMESTORE_disconnect(nsh);
62 nsh = NULL; 62 nsh = NULL;
63 } 63 }
64 if (NULL != nch) 64 if (NULL != nch)
65 { 65 {
66 GNUNET_NAMECACHE_disconnect (nch); 66 GNUNET_NAMECACHE_disconnect(nch);
67 nch = NULL; 67 nch = NULL;
68 } 68 }
69 if (NULL != privkey) 69 if (NULL != privkey)
70 { 70 {
71 GNUNET_free (privkey); 71 GNUNET_free(privkey);
72 privkey = NULL; 72 privkey = NULL;
73 } 73 }
74 GNUNET_SCHEDULER_shutdown (); 74 GNUNET_SCHEDULER_shutdown();
75} 75}
76 76
77 77
@@ -81,145 +81,145 @@ cleanup ()
81 * @param cls handle to use to re-connect. 81 * @param cls handle to use to re-connect.
82 */ 82 */
83static void 83static void
84endbadly (void *cls) 84endbadly(void *cls)
85{ 85{
86 if (NULL != nsqe) 86 if (NULL != nsqe)
87 { 87 {
88 GNUNET_NAMESTORE_cancel (nsqe); 88 GNUNET_NAMESTORE_cancel(nsqe);
89 nsqe = NULL; 89 nsqe = NULL;
90 } 90 }
91 if (NULL != ncqe) 91 if (NULL != ncqe)
92 { 92 {
93 GNUNET_NAMECACHE_cancel (ncqe); 93 GNUNET_NAMECACHE_cancel(ncqe);
94 ncqe = NULL; 94 ncqe = NULL;
95 } 95 }
96 cleanup (); 96 cleanup();
97 res = 1; 97 res = 1;
98} 98}
99 99
100 100
101static void 101static void
102end (void *cls) 102end(void *cls)
103{ 103{
104 cleanup (); 104 cleanup();
105 res = 0; 105 res = 0;
106} 106}
107 107
108 108
109static void 109static void
110rd_decrypt_cb (void *cls, 110rd_decrypt_cb(void *cls,
111 unsigned int rd_count, 111 unsigned int rd_count,
112 const struct GNUNET_GNSRECORD_Data *rd) 112 const struct GNUNET_GNSRECORD_Data *rd)
113{ 113{
114 char rd_cmp_data[TEST_RECORD_DATALEN]; 114 char rd_cmp_data[TEST_RECORD_DATALEN];
115 115
116 GNUNET_assert (1 == rd_count); 116 GNUNET_assert(1 == rd_count);
117 GNUNET_assert (NULL != rd); 117 GNUNET_assert(NULL != rd);
118 118
119 memset (rd_cmp_data, 'a', TEST_RECORD_DATALEN); 119 memset(rd_cmp_data, 'a', TEST_RECORD_DATALEN);
120 120
121 GNUNET_assert (TEST_RECORD_TYPE == rd[0].record_type); 121 GNUNET_assert(TEST_RECORD_TYPE == rd[0].record_type);
122 GNUNET_assert (TEST_RECORD_DATALEN == rd[0].data_size); 122 GNUNET_assert(TEST_RECORD_DATALEN == rd[0].data_size);
123 GNUNET_assert (0 == memcmp (&rd_cmp_data, rd[0].data, TEST_RECORD_DATALEN)); 123 GNUNET_assert(0 == memcmp(&rd_cmp_data, rd[0].data, TEST_RECORD_DATALEN));
124 124
125 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 125 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
126 "Block was decrypted successfully \n"); 126 "Block was decrypted successfully \n");
127 127
128 GNUNET_SCHEDULER_add_now (&end, NULL); 128 GNUNET_SCHEDULER_add_now(&end, NULL);
129} 129}
130 130
131 131
132static void 132static void
133name_lookup_proc (void *cls, 133name_lookup_proc(void *cls,
134 const struct GNUNET_GNSRECORD_Block *block) 134 const struct GNUNET_GNSRECORD_Block *block)
135{ 135{
136 const char *name = cls; 136 const char *name = cls;
137 137
138 ncqe = NULL; 138 ncqe = NULL;
139 GNUNET_assert (NULL != cls); 139 GNUNET_assert(NULL != cls);
140 140
141 if (endbadly_task != NULL) 141 if (endbadly_task != NULL)
142 { 142 {
143 GNUNET_SCHEDULER_cancel (endbadly_task); 143 GNUNET_SCHEDULER_cancel(endbadly_task);
144 endbadly_task = NULL; 144 endbadly_task = NULL;
145 } 145 }
146 146
147 if (NULL == block) 147 if (NULL == block)
148 { 148 {
149 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, 149 GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
150 _("Namestore returned no block\n")); 150 _("Namestore returned no block\n"));
151 if (endbadly_task != NULL) 151 if (endbadly_task != NULL)
152 GNUNET_SCHEDULER_cancel (endbadly_task); 152 GNUNET_SCHEDULER_cancel(endbadly_task);
153 endbadly_task = GNUNET_SCHEDULER_add_now (&endbadly, NULL); 153 endbadly_task = GNUNET_SCHEDULER_add_now(&endbadly, NULL);
154 return; 154 return;
155 } 155 }
156 156
157 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 157 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
158 "Namestore returned block, decrypting \n"); 158 "Namestore returned block, decrypting \n");
159 GNUNET_assert (GNUNET_OK == GNUNET_GNSRECORD_block_decrypt(block, 159 GNUNET_assert(GNUNET_OK == GNUNET_GNSRECORD_block_decrypt(block,
160 &pubkey, name, &rd_decrypt_cb, (void *) name)); 160 &pubkey, name, &rd_decrypt_cb, (void *)name));
161} 161}
162 162
163 163
164static void 164static void
165put_cont (void *cls, int32_t success, const char *emsg) 165put_cont(void *cls, int32_t success, const char *emsg)
166{ 166{
167 const char *name = cls; 167 const char *name = cls;
168 struct GNUNET_HashCode derived_hash; 168 struct GNUNET_HashCode derived_hash;
169 struct GNUNET_CRYPTO_EcdsaPublicKey pubkey; 169 struct GNUNET_CRYPTO_EcdsaPublicKey pubkey;
170 170
171 nsqe = NULL; 171 nsqe = NULL;
172 GNUNET_assert (NULL != cls); 172 GNUNET_assert(NULL != cls);
173 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 173 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
174 "Name store added record for `%s': %s\n", 174 "Name store added record for `%s': %s\n",
175 name, 175 name,
176 (success == GNUNET_OK) ? "SUCCESS" : "FAIL"); 176 (success == GNUNET_OK) ? "SUCCESS" : "FAIL");
177 177
178 /* Create derived hash */ 178 /* Create derived hash */
179 GNUNET_CRYPTO_ecdsa_key_get_public (privkey, &pubkey); 179 GNUNET_CRYPTO_ecdsa_key_get_public(privkey, &pubkey);
180 GNUNET_GNSRECORD_query_from_public_key (&pubkey, name, &derived_hash); 180 GNUNET_GNSRECORD_query_from_public_key(&pubkey, name, &derived_hash);
181 181
182 ncqe = GNUNET_NAMECACHE_lookup_block (nch, &derived_hash, 182 ncqe = GNUNET_NAMECACHE_lookup_block(nch, &derived_hash,
183 &name_lookup_proc, (void *) name); 183 &name_lookup_proc, (void *)name);
184} 184}
185 185
186 186
187static void 187static void
188run (void *cls, 188run(void *cls,
189 const struct GNUNET_CONFIGURATION_Handle *cfg, 189 const struct GNUNET_CONFIGURATION_Handle *cfg,
190 struct GNUNET_TESTING_Peer *peer) 190 struct GNUNET_TESTING_Peer *peer)
191{ 191{
192 struct GNUNET_GNSRECORD_Data rd; 192 struct GNUNET_GNSRECORD_Data rd;
193 const char * name = "dummy.dummy.gnunet"; 193 const char * name = "dummy.dummy.gnunet";
194 194
195 endbadly_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, 195 endbadly_task = GNUNET_SCHEDULER_add_delayed(TIMEOUT,
196 &endbadly, 196 &endbadly,
197 NULL); 197 NULL);
198 privkey = GNUNET_CRYPTO_ecdsa_key_create (); 198 privkey = GNUNET_CRYPTO_ecdsa_key_create();
199 GNUNET_assert (privkey != NULL); 199 GNUNET_assert(privkey != NULL);
200 GNUNET_CRYPTO_ecdsa_key_get_public (privkey, 200 GNUNET_CRYPTO_ecdsa_key_get_public(privkey,
201 &pubkey); 201 &pubkey);
202 202
203 rd.expiration_time = GNUNET_TIME_absolute_get().abs_value_us + 1000000000; 203 rd.expiration_time = GNUNET_TIME_absolute_get().abs_value_us + 1000000000;
204 rd.record_type = TEST_RECORD_TYPE; 204 rd.record_type = TEST_RECORD_TYPE;
205 rd.data_size = TEST_RECORD_DATALEN; 205 rd.data_size = TEST_RECORD_DATALEN;
206 rd.data = GNUNET_malloc (TEST_RECORD_DATALEN); 206 rd.data = GNUNET_malloc(TEST_RECORD_DATALEN);
207 rd.flags = 0; 207 rd.flags = 0;
208 memset ((char *) rd.data, 'a', TEST_RECORD_DATALEN); 208 memset((char *)rd.data, 'a', TEST_RECORD_DATALEN);
209 209
210 nsh = GNUNET_NAMESTORE_connect (cfg); 210 nsh = GNUNET_NAMESTORE_connect(cfg);
211 nch = GNUNET_NAMECACHE_connect (cfg); 211 nch = GNUNET_NAMECACHE_connect(cfg);
212 GNUNET_break (NULL != nsh); 212 GNUNET_break(NULL != nsh);
213 GNUNET_break (NULL != nch); 213 GNUNET_break(NULL != nch);
214 nsqe = GNUNET_NAMESTORE_records_store (nsh, privkey, name, 214 nsqe = GNUNET_NAMESTORE_records_store(nsh, privkey, name,
215 1, &rd, &put_cont, (void *) name); 215 1, &rd, &put_cont, (void *)name);
216 if (NULL == nsqe) 216 if (NULL == nsqe)
217 { 217 {
218 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, 218 GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
219 _("Namestore cannot store no block\n")); 219 _("Namestore cannot store no block\n"));
220 } 220 }
221 221
222 GNUNET_free ((void *)rd.data); 222 GNUNET_free((void *)rd.data);
223} 223}
224 224
225 225
@@ -227,24 +227,24 @@ run (void *cls,
227 227
228 228
229int 229int
230main (int argc, char *argv[]) 230main(int argc, char *argv[])
231{ 231{
232 const char *plugin_name; 232 const char *plugin_name;
233 char *cfg_name; 233 char *cfg_name;
234 234
235 SETUP_CFG (plugin_name, cfg_name); 235 SETUP_CFG(plugin_name, cfg_name);
236 res = 1; 236 res = 1;
237 if (0 != 237 if (0 !=
238 GNUNET_TESTING_peer_run ("test-namestore-api", 238 GNUNET_TESTING_peer_run("test-namestore-api",
239 cfg_name, 239 cfg_name,
240 &run, 240 &run,
241 NULL)) 241 NULL))
242 { 242 {
243 res = 1; 243 res = 1;
244 } 244 }
245 GNUNET_DISK_purge_cfg_dir (cfg_name, 245 GNUNET_DISK_purge_cfg_dir(cfg_name,
246 "GNUNET_TEST_HOME"); 246 "GNUNET_TEST_HOME");
247 GNUNET_free (cfg_name); 247 GNUNET_free(cfg_name);
248 return res; 248 return res;
249} 249}
250 250