diff options
Diffstat (limited to 'src/gnsrecord/gnunet-gnsrecord-tvg.c')
-rw-r--r-- | src/gnsrecord/gnunet-gnsrecord-tvg.c | 226 |
1 files changed, 121 insertions, 105 deletions
diff --git a/src/gnsrecord/gnunet-gnsrecord-tvg.c b/src/gnsrecord/gnunet-gnsrecord-tvg.c index f9b83e48b..87de32066 100644 --- a/src/gnsrecord/gnunet-gnsrecord-tvg.c +++ b/src/gnsrecord/gnunet-gnsrecord-tvg.c | |||
@@ -33,9 +33,6 @@ | |||
33 | #include <inttypes.h> | 33 | #include <inttypes.h> |
34 | #include "gnsrecord_crypto.h" | 34 | #include "gnsrecord_crypto.h" |
35 | 35 | ||
36 | #define TEST_RECORD_LABEL "test" | ||
37 | #define TEST_RECORD_A "1.2.3.4" | ||
38 | #define TEST_RRCOUNT 2 | ||
39 | 36 | ||
40 | static char *d_pkey = | 37 | static char *d_pkey = |
41 | "50d7b652a4efeadff37396909785e5952171a02178c8e7d450fa907925fafd98"; | 38 | "50d7b652a4efeadff37396909785e5952171a02178c8e7d450fa907925fafd98"; |
@@ -43,7 +40,9 @@ static char *d_pkey = | |||
43 | static char *d_edkey = | 40 | static char *d_edkey = |
44 | "5af7020ee19160328832352bbc6a68a8d71a7cbe1b929969a7c66d415a0d8f65"; | 41 | "5af7020ee19160328832352bbc6a68a8d71a7cbe1b929969a7c66d415a0d8f65"; |
45 | 42 | ||
46 | int parsehex (char *src, char *dst, size_t dstlen, int invert) | 43 | |
44 | static int | ||
45 | parsehex (char *src, char *dst, size_t dstlen, int invert) | ||
47 | { | 46 | { |
48 | char *line = src; | 47 | char *line = src; |
49 | char *data = line; | 48 | char *data = line; |
@@ -83,6 +82,7 @@ print_bytes_ (void *buf, | |||
83 | printf ("\n"); | 82 | printf ("\n"); |
84 | } | 83 | } |
85 | 84 | ||
85 | |||
86 | static void | 86 | static void |
87 | print_bytes (void *buf, | 87 | print_bytes (void *buf, |
88 | size_t buf_len, | 88 | size_t buf_len, |
@@ -95,7 +95,7 @@ print_bytes (void *buf, | |||
95 | static void | 95 | static void |
96 | print_record (const struct GNUNET_GNSRECORD_Data *rd) | 96 | print_record (const struct GNUNET_GNSRECORD_Data *rd) |
97 | { | 97 | { |
98 | 98 | uint16_t flags = htons (rd->flags); | |
99 | fprintf (stdout, | 99 | fprintf (stdout, |
100 | "EXPIRATION: %" PRIu64 "\n", rd->expiration_time); | 100 | "EXPIRATION: %" PRIu64 "\n", rd->expiration_time); |
101 | fprintf (stdout, | 101 | fprintf (stdout, |
@@ -103,7 +103,9 @@ print_record (const struct GNUNET_GNSRECORD_Data *rd) | |||
103 | fprintf (stdout, | 103 | fprintf (stdout, |
104 | "TYPE: %d\n", rd->record_type); | 104 | "TYPE: %d\n", rd->record_type); |
105 | fprintf (stdout, | 105 | fprintf (stdout, |
106 | "FLAGS: %d\n", rd->flags); | 106 | "FLAGS: "); |
107 | print_bytes ((void*) &flags, sizeof (flags), 8); | ||
108 | printf ("\n"); | ||
107 | fprintf (stdout, | 109 | fprintf (stdout, |
108 | "DATA:\n"); | 110 | "DATA:\n"); |
109 | print_bytes ((char*) rd->data, rd->data_size, 8); | 111 | print_bytes ((char*) rd->data, rd->data_size, 8); |
@@ -120,15 +122,9 @@ print_record (const struct GNUNET_GNSRECORD_Data *rd) | |||
120 | * @param cfg configuration | 122 | * @param cfg configuration |
121 | */ | 123 | */ |
122 | static void | 124 | static void |
123 | run_pkey (void) | 125 | run_pkey (struct GNUNET_GNSRECORD_Data *rd, int rd_count, const char *label) |
124 | { | 126 | { |
125 | struct GNUNET_GNSRECORD_Data rd[2]; | ||
126 | struct GNUNET_TIME_Absolute expire; | 127 | struct GNUNET_TIME_Absolute expire; |
127 | struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get (); | ||
128 | struct GNUNET_TIME_Absolute exp1; | ||
129 | struct GNUNET_TIME_Absolute exp2; | ||
130 | struct GNUNET_TIME_Relative delta1; | ||
131 | struct GNUNET_TIME_Relative delta2; | ||
132 | struct GNUNET_GNSRECORD_Block *rrblock; | 128 | struct GNUNET_GNSRECORD_Block *rrblock; |
133 | char *bdata; | 129 | char *bdata; |
134 | struct GNUNET_IDENTITY_PrivateKey id_priv; | 130 | struct GNUNET_IDENTITY_PrivateKey id_priv; |
@@ -136,24 +132,12 @@ run_pkey (void) | |||
136 | struct GNUNET_IDENTITY_PrivateKey pkey_data_p; | 132 | struct GNUNET_IDENTITY_PrivateKey pkey_data_p; |
137 | struct GNUNET_IDENTITY_PublicKey pkey_data; | 133 | struct GNUNET_IDENTITY_PublicKey pkey_data; |
138 | struct GNUNET_HashCode query; | 134 | struct GNUNET_HashCode query; |
139 | void *data; | ||
140 | size_t data_size; | ||
141 | char *rdata; | 135 | char *rdata; |
142 | size_t rdata_size; | 136 | size_t rdata_size; |
143 | uint32_t rd_count_nbo; | ||
144 | char ztld[128]; | 137 | char ztld[128]; |
145 | unsigned char ctr[GNUNET_CRYPTO_AES_KEY_LENGTH / 2]; | 138 | unsigned char ctr[GNUNET_CRYPTO_AES_KEY_LENGTH / 2]; |
146 | unsigned char skey[GNUNET_CRYPTO_AES_KEY_LENGTH]; | 139 | unsigned char skey[GNUNET_CRYPTO_AES_KEY_LENGTH]; |
147 | 140 | ||
148 | /* | ||
149 | * Make two different expiration times | ||
150 | */ | ||
151 | GNUNET_STRINGS_fancy_time_to_absolute ("2048-01-23 10:51:34", | ||
152 | &exp1); | ||
153 | GNUNET_STRINGS_fancy_time_to_absolute ("3540-05-22 07:55:01", | ||
154 | &exp2); | ||
155 | |||
156 | |||
157 | id_priv.type = htonl (GNUNET_GNSRECORD_TYPE_PKEY); | 141 | id_priv.type = htonl (GNUNET_GNSRECORD_TYPE_PKEY); |
158 | GNUNET_CRYPTO_ecdsa_key_create (&id_priv.ecdsa_key); | 142 | GNUNET_CRYPTO_ecdsa_key_create (&id_priv.ecdsa_key); |
159 | parsehex (d_pkey, | 143 | parsehex (d_pkey, |
@@ -168,13 +152,14 @@ run_pkey (void) | |||
168 | sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey), 8, 1); | 152 | sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey), 8, 1); |
169 | fprintf (stdout, "\n"); | 153 | fprintf (stdout, "\n"); |
170 | fprintf (stdout, "Zone identifier (ztype|zkey):\n"); | 154 | fprintf (stdout, "Zone identifier (ztype|zkey):\n"); |
155 | GNUNET_assert (0 < GNUNET_IDENTITY_key_get_length (&id_pub)); | ||
171 | print_bytes (&id_pub, GNUNET_IDENTITY_key_get_length (&id_pub), 8); | 156 | print_bytes (&id_pub, GNUNET_IDENTITY_key_get_length (&id_pub), 8); |
172 | GNUNET_STRINGS_data_to_string (&id_pub, | 157 | GNUNET_STRINGS_data_to_string (&id_pub, |
173 | GNUNET_IDENTITY_key_get_length (&id_pub), | 158 | GNUNET_IDENTITY_key_get_length (&id_pub), |
174 | ztld, | 159 | ztld, |
175 | sizeof (ztld)); | 160 | sizeof (ztld)); |
176 | fprintf (stdout, "\n"); | 161 | fprintf (stdout, "\n"); |
177 | fprintf (stdout, "Encoded zone identifier (zkl = zTLD):\n"); | 162 | fprintf (stdout, "zTLD:\n"); |
178 | fprintf (stdout, "%s\n", ztld); | 163 | fprintf (stdout, "%s\n", ztld); |
179 | fprintf (stdout, "\n"); | 164 | fprintf (stdout, "\n"); |
180 | 165 | ||
@@ -183,39 +168,31 @@ run_pkey (void) | |||
183 | GNUNET_IDENTITY_key_get_public (&pkey_data_p, | 168 | GNUNET_IDENTITY_key_get_public (&pkey_data_p, |
184 | &pkey_data); | 169 | &pkey_data); |
185 | fprintf (stdout, | 170 | fprintf (stdout, |
186 | "Label: %s\nRRCOUNT: %d\n\n", TEST_RECORD_LABEL, TEST_RRCOUNT); | 171 | "Label: %s\nRRCOUNT: %d\n\n", label, rd_count); |
187 | memset (rd, 0, sizeof (struct GNUNET_GNSRECORD_Data) * 2); | ||
188 | GNUNET_assert (GNUNET_OK == GNUNET_GNSRECORD_string_to_value ( | ||
189 | GNUNET_DNSPARSER_TYPE_A, TEST_RECORD_A, &data, &data_size)); | ||
190 | rd[0].data = data; | ||
191 | rd[0].data_size = data_size; | ||
192 | rd[0].expiration_time = exp1.abs_value_us; | ||
193 | rd[0].record_type = GNUNET_DNSPARSER_TYPE_A; | ||
194 | fprintf (stdout, "Record #0\n"); | ||
195 | print_record (&rd[0]); | ||
196 | 172 | ||
197 | rd[1].data = "Some nick"; | 173 | for (int i = 0; i < rd_count; i++) |
198 | rd[1].data_size = sizeof (struct GNUNET_IDENTITY_PublicKey); | 174 | { |
199 | rd[1].expiration_time = exp2.abs_value_us; | 175 | fprintf (stdout, "Record #%d\n", i); |
200 | rd[1].record_type = GNUNET_GNSRECORD_TYPE_NICK; | 176 | print_record (&rd[i]); |
201 | rd[1].flags = GNUNET_GNSRECORD_RF_PRIVATE; | 177 | } |
202 | fprintf (stdout, "Record #1\n"); | ||
203 | print_record (&rd[1]); | ||
204 | 178 | ||
205 | rdata_size = GNUNET_GNSRECORD_records_get_size (TEST_RRCOUNT, | 179 | rdata_size = GNUNET_GNSRECORD_records_get_size (rd_count, |
206 | rd); | 180 | rd); |
207 | rdata = GNUNET_malloc (rdata_size); | 181 | rdata = GNUNET_malloc (rdata_size); |
208 | GNUNET_GNSRECORD_records_serialize (2, | 182 | GNUNET_GNSRECORD_records_serialize (rd_count, |
209 | rd, | 183 | rd, |
210 | rdata_size, | 184 | (size_t) rdata_size, |
211 | rdata); | 185 | rdata); |
212 | fprintf (stdout, "RDATA:\n"); | 186 | fprintf (stdout, "RDATA:\n"); |
213 | print_bytes (rdata, rdata_size, 8); | 187 | print_bytes (rdata, |
188 | (size_t) rdata_size, | ||
189 | 8); | ||
214 | fprintf (stdout, "\n"); | 190 | fprintf (stdout, "\n"); |
215 | expire = GNUNET_GNSRECORD_record_get_expiration_time (TEST_RRCOUNT, rd); | 191 | expire = GNUNET_GNSRECORD_record_get_expiration_time (rd_count, rd, |
192 | GNUNET_TIME_UNIT_ZERO_ABS); | ||
216 | GNR_derive_block_aes_key (ctr, | 193 | GNR_derive_block_aes_key (ctr, |
217 | skey, | 194 | skey, |
218 | TEST_RECORD_LABEL, | 195 | label, |
219 | GNUNET_TIME_absolute_hton ( | 196 | GNUNET_TIME_absolute_hton ( |
220 | expire).abs_value_us__, | 197 | expire).abs_value_us__, |
221 | &id_pub.ecdsa_key); | 198 | &id_pub.ecdsa_key); |
@@ -227,25 +204,26 @@ run_pkey (void) | |||
227 | print_bytes (skey, sizeof (skey), 8); | 204 | print_bytes (skey, sizeof (skey), 8); |
228 | fprintf (stdout, "\n"); | 205 | fprintf (stdout, "\n"); |
229 | GNUNET_GNSRECORD_query_from_public_key (&id_pub, | 206 | GNUNET_GNSRECORD_query_from_public_key (&id_pub, |
230 | TEST_RECORD_LABEL, | 207 | label, |
231 | &query); | 208 | &query); |
232 | fprintf (stdout, "Storage key (q):\n"); | 209 | fprintf (stdout, "Storage key (q):\n"); |
233 | print_bytes (&query, sizeof (query), 8); | 210 | print_bytes (&query, sizeof (query), 8); |
234 | fprintf (stdout, "\n"); | 211 | fprintf (stdout, "\n"); |
235 | GNUNET_assert (GNUNET_OK == GNUNET_GNSRECORD_block_create (&id_priv, | 212 | GNUNET_assert (GNUNET_OK == GNUNET_GNSRECORD_block_create (&id_priv, |
236 | expire, | 213 | expire, |
237 | TEST_RECORD_LABEL, | 214 | label, |
238 | rd, | 215 | rd, |
239 | TEST_RRCOUNT, | 216 | rd_count, |
240 | &rrblock)); | 217 | &rrblock)); |
241 | size_t bdata_size = ntohl(rrblock->size) - sizeof (struct GNUNET_GNSRECORD_Block); | 218 | size_t bdata_size = ntohl (rrblock->size) - sizeof (struct |
219 | GNUNET_GNSRECORD_Block); | ||
242 | 220 | ||
243 | bdata = (char*) &(&rrblock->ecdsa_block)[1]; | 221 | bdata = (char*) &(&rrblock->ecdsa_block)[1]; |
244 | fprintf (stdout, "BDATA:\n"); | 222 | fprintf (stdout, "BDATA:\n"); |
245 | print_bytes (bdata, bdata_size, 8); | 223 | print_bytes (bdata, bdata_size, 8); |
246 | fprintf (stdout, "\n"); | 224 | fprintf (stdout, "\n"); |
247 | fprintf (stdout, "RRBLOCK:\n"); | 225 | fprintf (stdout, "RRBLOCK:\n"); |
248 | print_bytes (rrblock, ntohl(rrblock->size), 8); | 226 | print_bytes (rrblock, ntohl (rrblock->size), 8); |
249 | fprintf (stdout, "\n"); | 227 | fprintf (stdout, "\n"); |
250 | GNUNET_free (rdata); | 228 | GNUNET_free (rdata); |
251 | } | 229 | } |
@@ -260,15 +238,9 @@ run_pkey (void) | |||
260 | * @param cfg configuration | 238 | * @param cfg configuration |
261 | */ | 239 | */ |
262 | static void | 240 | static void |
263 | run_edkey (void) | 241 | run_edkey (struct GNUNET_GNSRECORD_Data *rd, int rd_count, const char*label) |
264 | { | 242 | { |
265 | struct GNUNET_GNSRECORD_Data rd[2]; | ||
266 | struct GNUNET_TIME_Absolute expire; | 243 | struct GNUNET_TIME_Absolute expire; |
267 | struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get (); | ||
268 | struct GNUNET_TIME_Absolute exp1; | ||
269 | struct GNUNET_TIME_Absolute exp2; | ||
270 | struct GNUNET_TIME_Relative delta1; | ||
271 | struct GNUNET_TIME_Relative delta2; | ||
272 | struct GNUNET_GNSRECORD_Block *rrblock; | 244 | struct GNUNET_GNSRECORD_Block *rrblock; |
273 | char *bdata; | 245 | char *bdata; |
274 | struct GNUNET_IDENTITY_PrivateKey id_priv; | 246 | struct GNUNET_IDENTITY_PrivateKey id_priv; |
@@ -276,23 +248,13 @@ run_edkey (void) | |||
276 | struct GNUNET_IDENTITY_PrivateKey pkey_data_p; | 248 | struct GNUNET_IDENTITY_PrivateKey pkey_data_p; |
277 | struct GNUNET_IDENTITY_PublicKey pkey_data; | 249 | struct GNUNET_IDENTITY_PublicKey pkey_data; |
278 | struct GNUNET_HashCode query; | 250 | struct GNUNET_HashCode query; |
279 | void *data; | ||
280 | size_t data_size; | ||
281 | char *rdata; | 251 | char *rdata; |
282 | size_t rdata_size; | 252 | size_t rdata_size; |
283 | uint32_t rd_count_nbo; | 253 | |
284 | char ztld[128]; | 254 | char ztld[128]; |
285 | unsigned char nonce[crypto_secretbox_NONCEBYTES]; | 255 | unsigned char nonce[crypto_secretbox_NONCEBYTES]; |
286 | unsigned char skey[crypto_secretbox_KEYBYTES]; | 256 | unsigned char skey[crypto_secretbox_KEYBYTES]; |
287 | 257 | ||
288 | /* | ||
289 | * Make two different expiration times | ||
290 | */ | ||
291 | GNUNET_STRINGS_fancy_time_to_absolute ("%2048-01-23 10:51:34", | ||
292 | &exp1); | ||
293 | GNUNET_STRINGS_fancy_time_to_absolute ("3540-05-22 07:55:01", | ||
294 | &exp2); | ||
295 | |||
296 | id_priv.type = htonl (GNUNET_GNSRECORD_TYPE_PKEY); | 258 | id_priv.type = htonl (GNUNET_GNSRECORD_TYPE_PKEY); |
297 | GNUNET_CRYPTO_ecdsa_key_create (&id_priv.ecdsa_key); | 259 | GNUNET_CRYPTO_ecdsa_key_create (&id_priv.ecdsa_key); |
298 | GNUNET_IDENTITY_key_get_public (&id_priv, | 260 | GNUNET_IDENTITY_key_get_public (&id_priv, |
@@ -311,13 +273,14 @@ run_edkey (void) | |||
311 | GNUNET_CRYPTO_EddsaPrivateKey), 8); | 273 | GNUNET_CRYPTO_EddsaPrivateKey), 8); |
312 | fprintf (stdout, "\n"); | 274 | fprintf (stdout, "\n"); |
313 | fprintf (stdout, "Zone identifier (ztype|zkey):\n"); | 275 | fprintf (stdout, "Zone identifier (ztype|zkey):\n"); |
276 | GNUNET_assert (0 < GNUNET_IDENTITY_key_get_length (&id_pub)); | ||
314 | print_bytes (&id_pub, GNUNET_IDENTITY_key_get_length (&id_pub), 8); | 277 | print_bytes (&id_pub, GNUNET_IDENTITY_key_get_length (&id_pub), 8); |
315 | GNUNET_STRINGS_data_to_string (&id_pub, | 278 | GNUNET_STRINGS_data_to_string (&id_pub, |
316 | GNUNET_IDENTITY_key_get_length (&id_pub), | 279 | GNUNET_IDENTITY_key_get_length (&id_pub), |
317 | ztld, | 280 | ztld, |
318 | sizeof (ztld)); | 281 | sizeof (ztld)); |
319 | fprintf (stdout, "\n"); | 282 | fprintf (stdout, "\n"); |
320 | fprintf (stdout, "Encoded zone identifier (zkl = zTLD):\n"); | 283 | fprintf (stdout, "zTLD:\n"); |
321 | fprintf (stdout, "%s\n", ztld); | 284 | fprintf (stdout, "%s\n", ztld); |
322 | fprintf (stdout, "\n"); | 285 | fprintf (stdout, "\n"); |
323 | 286 | ||
@@ -326,40 +289,33 @@ run_edkey (void) | |||
326 | GNUNET_IDENTITY_key_get_public (&pkey_data_p, | 289 | GNUNET_IDENTITY_key_get_public (&pkey_data_p, |
327 | &pkey_data); | 290 | &pkey_data); |
328 | fprintf (stdout, | 291 | fprintf (stdout, |
329 | "Label: %s\nRRCOUNT: %d\n\n", TEST_RECORD_LABEL, TEST_RRCOUNT); | 292 | "Label: %s\nRRCOUNT: %d\n\n", label, rd_count); |
330 | memset (rd, 0, sizeof (struct GNUNET_GNSRECORD_Data) * 2); | ||
331 | GNUNET_assert (GNUNET_OK == GNUNET_GNSRECORD_string_to_value ( | ||
332 | GNUNET_DNSPARSER_TYPE_A, TEST_RECORD_A, &data, &data_size)); | ||
333 | rd[0].data = data; | ||
334 | rd[0].data_size = data_size; | ||
335 | rd[0].expiration_time = exp1.abs_value_us; | ||
336 | rd[0].record_type = GNUNET_DNSPARSER_TYPE_A; | ||
337 | fprintf (stdout, "Record #0\n"); | ||
338 | print_record (&rd[0]); | ||
339 | 293 | ||
340 | rd[1].data = "My Nick"; | 294 | for (int i = 0; i < rd_count; i++) |
341 | rd[1].data_size = sizeof (struct GNUNET_IDENTITY_PublicKey); | 295 | { |
342 | rd[1].expiration_time = exp2.abs_value_us; | 296 | fprintf (stdout, "Record #%d\n", i); |
343 | rd[1].record_type = GNUNET_GNSRECORD_TYPE_NICK; | 297 | print_record (&rd[i]); |
344 | rd[1].flags = GNUNET_GNSRECORD_RF_PRIVATE; | 298 | } |
345 | fprintf (stdout, "Record #1\n"); | ||
346 | print_record (&rd[1]); | ||
347 | 299 | ||
348 | rdata_size = GNUNET_GNSRECORD_records_get_size (TEST_RRCOUNT, | 300 | rdata_size = GNUNET_GNSRECORD_records_get_size (rd_count, |
349 | rd); | 301 | rd); |
350 | expire = GNUNET_GNSRECORD_record_get_expiration_time (TEST_RRCOUNT, | 302 | expire = GNUNET_GNSRECORD_record_get_expiration_time (rd_count, |
351 | rd); | 303 | rd, |
352 | rdata = GNUNET_malloc (rdata_size); | 304 | GNUNET_TIME_UNIT_ZERO_ABS); |
353 | GNUNET_GNSRECORD_records_serialize (2, | 305 | GNUNET_assert (0 < rdata_size); |
306 | rdata = GNUNET_malloc ((size_t) rdata_size); | ||
307 | GNUNET_GNSRECORD_records_serialize (rd_count, | ||
354 | rd, | 308 | rd, |
355 | rdata_size, | 309 | (size_t) rdata_size, |
356 | rdata); | 310 | rdata); |
357 | fprintf (stdout, "RDATA:\n"); | 311 | fprintf (stdout, "RDATA:\n"); |
358 | print_bytes (rdata, rdata_size, 8); | 312 | print_bytes (rdata, |
313 | (size_t) rdata_size, | ||
314 | 8); | ||
359 | fprintf (stdout, "\n"); | 315 | fprintf (stdout, "\n"); |
360 | GNR_derive_block_xsalsa_key (nonce, | 316 | GNR_derive_block_xsalsa_key (nonce, |
361 | skey, | 317 | skey, |
362 | TEST_RECORD_LABEL, | 318 | label, |
363 | GNUNET_TIME_absolute_hton ( | 319 | GNUNET_TIME_absolute_hton ( |
364 | expire).abs_value_us__, | 320 | expire).abs_value_us__, |
365 | &id_pub.eddsa_key); | 321 | &id_pub.eddsa_key); |
@@ -370,7 +326,7 @@ run_edkey (void) | |||
370 | print_bytes (skey, sizeof (skey), 8); | 326 | print_bytes (skey, sizeof (skey), 8); |
371 | fprintf (stdout, "\n"); | 327 | fprintf (stdout, "\n"); |
372 | GNUNET_GNSRECORD_query_from_public_key (&id_pub, | 328 | GNUNET_GNSRECORD_query_from_public_key (&id_pub, |
373 | TEST_RECORD_LABEL, | 329 | label, |
374 | &query); | 330 | &query); |
375 | fprintf (stdout, "Storage key (q):\n"); | 331 | fprintf (stdout, "Storage key (q):\n"); |
376 | print_bytes (&query, sizeof (query), 8); | 332 | print_bytes (&query, sizeof (query), 8); |
@@ -378,18 +334,19 @@ run_edkey (void) | |||
378 | 334 | ||
379 | GNUNET_assert (GNUNET_OK == GNUNET_GNSRECORD_block_create (&id_priv, | 335 | GNUNET_assert (GNUNET_OK == GNUNET_GNSRECORD_block_create (&id_priv, |
380 | expire, | 336 | expire, |
381 | TEST_RECORD_LABEL, | 337 | label, |
382 | rd, | 338 | rd, |
383 | TEST_RRCOUNT, | 339 | rd_count, |
384 | &rrblock)); | 340 | &rrblock)); |
385 | size_t bdata_size = ntohl(rrblock->size) - sizeof (struct GNUNET_GNSRECORD_Block); | 341 | size_t bdata_size = ntohl (rrblock->size) - sizeof (struct |
342 | GNUNET_GNSRECORD_Block); | ||
386 | 343 | ||
387 | bdata = (char*) &(&rrblock->eddsa_block)[1]; | 344 | bdata = (char*) &(&rrblock->eddsa_block)[1]; |
388 | fprintf (stdout, "BDATA:\n"); | 345 | fprintf (stdout, "BDATA:\n"); |
389 | print_bytes (bdata, bdata_size, 8); | 346 | print_bytes (bdata, bdata_size, 8); |
390 | fprintf (stdout, "\n"); | 347 | fprintf (stdout, "\n"); |
391 | fprintf (stdout, "RRBLOCK:\n"); | 348 | fprintf (stdout, "RRBLOCK:\n"); |
392 | print_bytes (rrblock, ntohl(rrblock->size), 8); | 349 | print_bytes (rrblock, ntohl (rrblock->size), 8); |
393 | fprintf (stdout, "\n"); | 350 | fprintf (stdout, "\n"); |
394 | GNUNET_free (rdata); | 351 | GNUNET_free (rdata); |
395 | } | 352 | } |
@@ -409,8 +366,67 @@ run (void *cls, | |||
409 | const char *cfgfile, | 366 | const char *cfgfile, |
410 | const struct GNUNET_CONFIGURATION_Handle *cfg) | 367 | const struct GNUNET_CONFIGURATION_Handle *cfg) |
411 | { | 368 | { |
412 | run_pkey (); | 369 | struct GNUNET_GNSRECORD_Data rd_pkey; |
413 | run_edkey (); | 370 | struct GNUNET_GNSRECORD_Data rd[3]; |
371 | struct GNUNET_TIME_Absolute exp1; | ||
372 | struct GNUNET_TIME_Absolute exp2; | ||
373 | struct GNUNET_TIME_Relative exp3; | ||
374 | size_t pkey_data_size; | ||
375 | size_t ip_data_size; | ||
376 | char *pkey_data; | ||
377 | char *ip_data; | ||
378 | |||
379 | /* | ||
380 | * Make different expiration times | ||
381 | */ | ||
382 | GNUNET_STRINGS_fancy_time_to_absolute ("2048-01-23 10:51:34", | ||
383 | &exp1); | ||
384 | GNUNET_STRINGS_fancy_time_to_absolute ("3540-05-22 07:55:01", | ||
385 | &exp2); | ||
386 | GNUNET_STRINGS_fancy_time_to_relative ("100y", | ||
387 | &exp3); | ||
388 | |||
389 | |||
390 | memset (&rd_pkey, 0, sizeof (struct GNUNET_GNSRECORD_Data)); | ||
391 | GNUNET_assert (GNUNET_OK == GNUNET_GNSRECORD_string_to_value ( | ||
392 | GNUNET_GNSRECORD_TYPE_PKEY, | ||
393 | "000G0011WESGZY9VRV9NNJ66W3GKNZFZF56BFD2BQF3MHMJST2G2GKDYGG", | ||
394 | (void**) &pkey_data, | ||
395 | &pkey_data_size)); | ||
396 | rd_pkey.data = pkey_data; | ||
397 | rd_pkey.data_size = pkey_data_size; | ||
398 | rd_pkey.expiration_time = exp1.abs_value_us; | ||
399 | rd_pkey.record_type = GNUNET_GNSRECORD_TYPE_PKEY; | ||
400 | rd_pkey.flags = GNUNET_GNSRECORD_RF_CRITICAL; | ||
401 | GNUNET_assert (GNUNET_OK == GNUNET_GNSRECORD_string_to_value ( | ||
402 | GNUNET_DNSPARSER_TYPE_AAAA, | ||
403 | "::dead:beef", | ||
404 | (void**) &ip_data, | ||
405 | &ip_data_size)); | ||
406 | |||
407 | rd[0].data = ip_data; | ||
408 | rd[0].data_size = ip_data_size; | ||
409 | rd[0].expiration_time = exp1.abs_value_us; | ||
410 | rd[0].record_type = GNUNET_DNSPARSER_TYPE_AAAA; | ||
411 | rd[0].flags = GNUNET_GNSRECORD_RF_NONE; | ||
412 | |||
413 | rd[1].data = "\u611b\u79f0"; | ||
414 | rd[1].data_size = strlen (rd[1].data); | ||
415 | rd[1].expiration_time = exp2.abs_value_us; | ||
416 | rd[1].record_type = GNUNET_GNSRECORD_TYPE_NICK; | ||
417 | rd[1].flags = GNUNET_GNSRECORD_RF_PRIVATE; | ||
418 | |||
419 | rd[2].data = "Hello World"; | ||
420 | rd[2].data_size = strlen (rd[2].data); | ||
421 | rd[2].expiration_time = exp3.rel_value_us; | ||
422 | rd[2].record_type = GNUNET_DNSPARSER_TYPE_TXT; | ||
423 | rd[2].flags = GNUNET_GNSRECORD_RF_SUPPLEMENTAL | ||
424 | | GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION; | ||
425 | |||
426 | run_pkey (&rd_pkey, 1, "testdelegation"); | ||
427 | run_pkey (rd, 3, "namesystem"); | ||
428 | run_edkey (&rd_pkey, 1, "testdelegation"); | ||
429 | run_edkey (rd, 3, "namesystem"); | ||
414 | } | 430 | } |
415 | 431 | ||
416 | 432 | ||