diff options
author | Christian Grothoff <christian@grothoff.org> | 2019-10-05 15:09:28 +0200 |
---|---|---|
committer | Christian Grothoff <christian@grothoff.org> | 2019-10-05 15:09:28 +0200 |
commit | c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207 (patch) | |
tree | cac3ce030d77b4cbe7c7dc62ed58cfe6d24f73e1 /src/namestore/test_namestore_api_lookup_public.c | |
parent | fbb71d527c7d6babf269a8fefce1db291b9f7068 (diff) | |
download | gnunet-c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207.tar.gz gnunet-c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207.zip |
global reindent, now with uncrustify hook enabled
Diffstat (limited to 'src/namestore/test_namestore_api_lookup_public.c')
-rw-r--r-- | src/namestore/test_namestore_api_lookup_public.c | 218 |
1 files changed, 110 insertions, 108 deletions
diff --git a/src/namestore/test_namestore_api_lookup_public.c b/src/namestore/test_namestore_api_lookup_public.c index 01f07eb39..6640f47ed 100644 --- a/src/namestore/test_namestore_api_lookup_public.c +++ b/src/namestore/test_namestore_api_lookup_public.c | |||
@@ -33,14 +33,14 @@ | |||
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 | ||
39 | static struct GNUNET_NAMESTORE_Handle *nsh; | 39 | static struct GNUNET_NAMESTORE_Handle *nsh; |
40 | 40 | ||
41 | static struct GNUNET_NAMECACHE_Handle *nch; | 41 | static struct GNUNET_NAMECACHE_Handle *nch; |
42 | 42 | ||
43 | static struct GNUNET_SCHEDULER_Task * endbadly_task; | 43 | static struct GNUNET_SCHEDULER_Task *endbadly_task; |
44 | 44 | ||
45 | static struct GNUNET_CRYPTO_EcdsaPrivateKey *privkey; | 45 | static struct GNUNET_CRYPTO_EcdsaPrivateKey *privkey; |
46 | 46 | ||
@@ -54,24 +54,24 @@ static struct GNUNET_NAMECACHE_QueueEntry *ncqe; | |||
54 | 54 | ||
55 | 55 | ||
56 | static void | 56 | static void |
57 | cleanup() | 57 | cleanup () |
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,147 @@ cleanup() | |||
81 | * @param cls handle to use to re-connect. | 81 | * @param cls handle to use to re-connect. |
82 | */ | 82 | */ |
83 | static void | 83 | static void |
84 | endbadly(void *cls) | 84 | endbadly (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 | ||
101 | static void | 101 | static void |
102 | end(void *cls) | 102 | end (void *cls) |
103 | { | 103 | { |
104 | cleanup(); | 104 | cleanup (); |
105 | res = 0; | 105 | res = 0; |
106 | } | 106 | } |
107 | 107 | ||
108 | 108 | ||
109 | static void | 109 | static void |
110 | rd_decrypt_cb(void *cls, | 110 | rd_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 | ||
132 | static void | 132 | static void |
133 | name_lookup_proc(void *cls, | 133 | name_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, |
161 | &rd_decrypt_cb, | ||
162 | (void *) name)); | ||
161 | } | 163 | } |
162 | 164 | ||
163 | 165 | ||
164 | static void | 166 | static void |
165 | put_cont(void *cls, int32_t success, const char *emsg) | 167 | put_cont (void *cls, int32_t success, const char *emsg) |
166 | { | 168 | { |
167 | const char *name = cls; | 169 | const char *name = cls; |
168 | struct GNUNET_HashCode derived_hash; | 170 | struct GNUNET_HashCode derived_hash; |
169 | struct GNUNET_CRYPTO_EcdsaPublicKey pubkey; | 171 | struct GNUNET_CRYPTO_EcdsaPublicKey pubkey; |
170 | 172 | ||
171 | nsqe = NULL; | 173 | nsqe = NULL; |
172 | GNUNET_assert(NULL != cls); | 174 | GNUNET_assert (NULL != cls); |
173 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 175 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
174 | "Name store added record for `%s': %s\n", | 176 | "Name store added record for `%s': %s\n", |
175 | name, | 177 | name, |
176 | (success == GNUNET_OK) ? "SUCCESS" : "FAIL"); | 178 | (success == GNUNET_OK) ? "SUCCESS" : "FAIL"); |
177 | 179 | ||
178 | /* Create derived hash */ | 180 | /* Create derived hash */ |
179 | GNUNET_CRYPTO_ecdsa_key_get_public(privkey, &pubkey); | 181 | GNUNET_CRYPTO_ecdsa_key_get_public (privkey, &pubkey); |
180 | GNUNET_GNSRECORD_query_from_public_key(&pubkey, name, &derived_hash); | 182 | GNUNET_GNSRECORD_query_from_public_key (&pubkey, name, &derived_hash); |
181 | 183 | ||
182 | ncqe = GNUNET_NAMECACHE_lookup_block(nch, &derived_hash, | 184 | ncqe = GNUNET_NAMECACHE_lookup_block (nch, &derived_hash, |
183 | &name_lookup_proc, (void *)name); | 185 | &name_lookup_proc, (void *) name); |
184 | } | 186 | } |
185 | 187 | ||
186 | 188 | ||
187 | static void | 189 | static void |
188 | run(void *cls, | 190 | run (void *cls, |
189 | const struct GNUNET_CONFIGURATION_Handle *cfg, | 191 | const struct GNUNET_CONFIGURATION_Handle *cfg, |
190 | struct GNUNET_TESTING_Peer *peer) | 192 | struct GNUNET_TESTING_Peer *peer) |
191 | { | 193 | { |
192 | struct GNUNET_GNSRECORD_Data rd; | 194 | struct GNUNET_GNSRECORD_Data rd; |
193 | const char * name = "dummy.dummy.gnunet"; | 195 | const char *name = "dummy.dummy.gnunet"; |
194 | 196 | ||
195 | endbadly_task = GNUNET_SCHEDULER_add_delayed(TIMEOUT, | 197 | endbadly_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, |
196 | &endbadly, | 198 | &endbadly, |
197 | NULL); | 199 | NULL); |
198 | privkey = GNUNET_CRYPTO_ecdsa_key_create(); | 200 | privkey = GNUNET_CRYPTO_ecdsa_key_create (); |
199 | GNUNET_assert(privkey != NULL); | 201 | GNUNET_assert (privkey != NULL); |
200 | GNUNET_CRYPTO_ecdsa_key_get_public(privkey, | 202 | GNUNET_CRYPTO_ecdsa_key_get_public (privkey, |
201 | &pubkey); | 203 | &pubkey); |
202 | 204 | ||
203 | rd.expiration_time = GNUNET_TIME_absolute_get().abs_value_us + 1000000000; | 205 | rd.expiration_time = GNUNET_TIME_absolute_get ().abs_value_us + 1000000000; |
204 | rd.record_type = TEST_RECORD_TYPE; | 206 | rd.record_type = TEST_RECORD_TYPE; |
205 | rd.data_size = TEST_RECORD_DATALEN; | 207 | rd.data_size = TEST_RECORD_DATALEN; |
206 | rd.data = GNUNET_malloc(TEST_RECORD_DATALEN); | 208 | rd.data = GNUNET_malloc (TEST_RECORD_DATALEN); |
207 | rd.flags = 0; | 209 | rd.flags = 0; |
208 | memset((char *)rd.data, 'a', TEST_RECORD_DATALEN); | 210 | memset ((char *) rd.data, 'a', TEST_RECORD_DATALEN); |
209 | 211 | ||
210 | nsh = GNUNET_NAMESTORE_connect(cfg); | 212 | nsh = GNUNET_NAMESTORE_connect (cfg); |
211 | nch = GNUNET_NAMECACHE_connect(cfg); | 213 | nch = GNUNET_NAMECACHE_connect (cfg); |
212 | GNUNET_break(NULL != nsh); | 214 | GNUNET_break (NULL != nsh); |
213 | GNUNET_break(NULL != nch); | 215 | GNUNET_break (NULL != nch); |
214 | nsqe = GNUNET_NAMESTORE_records_store(nsh, privkey, name, | 216 | nsqe = GNUNET_NAMESTORE_records_store (nsh, privkey, name, |
215 | 1, &rd, &put_cont, (void *)name); | 217 | 1, &rd, &put_cont, (void *) name); |
216 | if (NULL == nsqe) | 218 | if (NULL == nsqe) |
217 | { | 219 | { |
218 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | 220 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
219 | _("Namestore cannot store no block\n")); | 221 | _ ("Namestore cannot store no block\n")); |
220 | } | 222 | } |
221 | 223 | ||
222 | GNUNET_free((void *)rd.data); | 224 | GNUNET_free ((void *) rd.data); |
223 | } | 225 | } |
224 | 226 | ||
225 | 227 | ||
@@ -227,24 +229,24 @@ run(void *cls, | |||
227 | 229 | ||
228 | 230 | ||
229 | int | 231 | int |
230 | main(int argc, char *argv[]) | 232 | main (int argc, char *argv[]) |
231 | { | 233 | { |
232 | const char *plugin_name; | 234 | const char *plugin_name; |
233 | char *cfg_name; | 235 | char *cfg_name; |
234 | 236 | ||
235 | SETUP_CFG(plugin_name, cfg_name); | 237 | SETUP_CFG (plugin_name, cfg_name); |
236 | res = 1; | 238 | res = 1; |
237 | if (0 != | 239 | if (0 != |
238 | GNUNET_TESTING_peer_run("test-namestore-api", | 240 | GNUNET_TESTING_peer_run ("test-namestore-api", |
239 | cfg_name, | 241 | cfg_name, |
240 | &run, | 242 | &run, |
241 | NULL)) | 243 | NULL)) |
242 | { | 244 | { |
243 | res = 1; | 245 | res = 1; |
244 | } | 246 | } |
245 | GNUNET_DISK_purge_cfg_dir(cfg_name, | 247 | GNUNET_DISK_purge_cfg_dir (cfg_name, |
246 | "GNUNET_TEST_HOME"); | 248 | "GNUNET_TEST_HOME"); |
247 | GNUNET_free(cfg_name); | 249 | GNUNET_free (cfg_name); |
248 | return res; | 250 | return res; |
249 | } | 251 | } |
250 | 252 | ||