diff options
author | ng0 <ng0@n0.is> | 2019-09-08 12:33:09 +0000 |
---|---|---|
committer | ng0 <ng0@n0.is> | 2019-09-08 12:33:09 +0000 |
commit | d41ed82a4ea0cc8e1674b6d5d2c49fd6462610bb (patch) | |
tree | 9efd18ea7d425652085ed0bd5e8e45604bc5f6b9 /src/namecache/test_namecache_api_cache_block.c | |
parent | a0fce305c565c0937d917a92712f15e9c5736260 (diff) | |
download | gnunet-d41ed82a4ea0cc8e1674b6d5d2c49fd6462610bb.tar.gz gnunet-d41ed82a4ea0cc8e1674b6d5d2c49fd6462610bb.zip |
uncrustify as demanded.
Diffstat (limited to 'src/namecache/test_namecache_api_cache_block.c')
-rw-r--r-- | src/namecache/test_namecache_api_cache_block.c | 231 |
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 | ||
38 | static struct GNUNET_NAMECACHE_Handle *nsh; | 38 | static struct GNUNET_NAMECACHE_Handle *nsh; |
@@ -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,177 +71,178 @@ 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 | 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 | ||
148 | static void | 149 | static void |
149 | cache_cont (void *cls, int32_t success, const char *emsg) | 150 | cache_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 | ||
169 | static void | 170 | static void |
170 | run (void *cls, | 171 | run(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 | ||
234 | int | 235 | int |
235 | main (int argc, char *argv[]) | 236 | main(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 | } |