diff options
Diffstat (limited to 'src/util/dnsparser.c')
-rw-r--r-- | src/util/dnsparser.c | 1292 |
1 files changed, 656 insertions, 636 deletions
diff --git a/src/util/dnsparser.c b/src/util/dnsparser.c index ec10e3ec3..fcec0d4f1 100644 --- a/src/util/dnsparser.c +++ b/src/util/dnsparser.c | |||
@@ -53,22 +53,22 @@ | |||
53 | * #GNUNET_SYSERR if the label is not valid for DNS names | 53 | * #GNUNET_SYSERR if the label is not valid for DNS names |
54 | */ | 54 | */ |
55 | int | 55 | int |
56 | GNUNET_DNSPARSER_check_label (const char *label) | 56 | GNUNET_DNSPARSER_check_label(const char *label) |
57 | { | 57 | { |
58 | char *output; | 58 | char *output; |
59 | size_t slen; | 59 | size_t slen; |
60 | 60 | ||
61 | if (NULL != strchr (label, '.')) | 61 | if (NULL != strchr(label, '.')) |
62 | return GNUNET_SYSERR; /* not a label! Did you mean GNUNET_DNSPARSER_check_name? */ | 62 | return GNUNET_SYSERR; /* not a label! Did you mean GNUNET_DNSPARSER_check_name? */ |
63 | if (0 == strcmp (label, "@")) /* '@' is reserved for the empty label, see #GNUNET_GNS_EMPTY_LABEL_AT */ | 63 | if (0 == strcmp(label, "@")) /* '@' is reserved for the empty label, see #GNUNET_GNS_EMPTY_LABEL_AT */ |
64 | return GNUNET_SYSERR; | 64 | return GNUNET_SYSERR; |
65 | if (IDNA_SUCCESS != idna_to_ascii_8z (label, &output, IDNA_ALLOW_UNASSIGNED)) | 65 | if (IDNA_SUCCESS != idna_to_ascii_8z(label, &output, IDNA_ALLOW_UNASSIGNED)) |
66 | return GNUNET_SYSERR; | 66 | return GNUNET_SYSERR; |
67 | slen = strlen (output); | 67 | slen = strlen(output); |
68 | #if WINDOWS | 68 | #if WINDOWS |
69 | idn_free (output); | 69 | idn_free(output); |
70 | #else | 70 | #else |
71 | free (output); | 71 | free(output); |
72 | #endif | 72 | #endif |
73 | return (slen > 63) ? GNUNET_SYSERR : GNUNET_OK; | 73 | return (slen > 63) ? GNUNET_SYSERR : GNUNET_OK; |
74 | } | 74 | } |
@@ -83,28 +83,28 @@ GNUNET_DNSPARSER_check_label (const char *label) | |||
83 | * #GNUNET_SYSERR if the label is not valid for DNS names | 83 | * #GNUNET_SYSERR if the label is not valid for DNS names |
84 | */ | 84 | */ |
85 | int | 85 | int |
86 | GNUNET_DNSPARSER_check_name (const char *name) | 86 | GNUNET_DNSPARSER_check_name(const char *name) |
87 | { | 87 | { |
88 | char *ldup; | 88 | char *ldup; |
89 | char *output; | 89 | char *output; |
90 | size_t slen; | 90 | size_t slen; |
91 | char *tok; | 91 | char *tok; |
92 | 92 | ||
93 | ldup = GNUNET_strdup (name); | 93 | ldup = GNUNET_strdup(name); |
94 | for (tok = strtok (ldup, "."); NULL != tok; tok = strtok (NULL, ".")) | 94 | for (tok = strtok(ldup, "."); NULL != tok; tok = strtok(NULL, ".")) |
95 | if (GNUNET_OK != GNUNET_DNSPARSER_check_label (tok)) | 95 | if (GNUNET_OK != GNUNET_DNSPARSER_check_label(tok)) |
96 | { | 96 | { |
97 | GNUNET_free (ldup); | 97 | GNUNET_free(ldup); |
98 | return GNUNET_SYSERR; | 98 | return GNUNET_SYSERR; |
99 | } | 99 | } |
100 | GNUNET_free (ldup); | 100 | GNUNET_free(ldup); |
101 | if (IDNA_SUCCESS != idna_to_ascii_8z (name, &output, IDNA_ALLOW_UNASSIGNED)) | 101 | if (IDNA_SUCCESS != idna_to_ascii_8z(name, &output, IDNA_ALLOW_UNASSIGNED)) |
102 | return GNUNET_SYSERR; | 102 | return GNUNET_SYSERR; |
103 | slen = strlen (output); | 103 | slen = strlen(output); |
104 | #if WINDOWS | 104 | #if WINDOWS |
105 | idn_free (output); | 105 | idn_free(output); |
106 | #else | 106 | #else |
107 | free (output); | 107 | free(output); |
108 | #endif | 108 | #endif |
109 | return (slen > 253) ? GNUNET_SYSERR : GNUNET_OK; | 109 | return (slen > 253) ? GNUNET_SYSERR : GNUNET_OK; |
110 | } | 110 | } |
@@ -116,13 +116,13 @@ GNUNET_DNSPARSER_check_name (const char *name) | |||
116 | * @param soa record to free | 116 | * @param soa record to free |
117 | */ | 117 | */ |
118 | void | 118 | void |
119 | GNUNET_DNSPARSER_free_soa (struct GNUNET_DNSPARSER_SoaRecord *soa) | 119 | GNUNET_DNSPARSER_free_soa(struct GNUNET_DNSPARSER_SoaRecord *soa) |
120 | { | 120 | { |
121 | if (NULL == soa) | 121 | if (NULL == soa) |
122 | return; | 122 | return; |
123 | GNUNET_free_non_null (soa->mname); | 123 | GNUNET_free_non_null(soa->mname); |
124 | GNUNET_free_non_null (soa->rname); | 124 | GNUNET_free_non_null(soa->rname); |
125 | GNUNET_free (soa); | 125 | GNUNET_free(soa); |
126 | } | 126 | } |
127 | 127 | ||
128 | 128 | ||
@@ -132,12 +132,12 @@ GNUNET_DNSPARSER_free_soa (struct GNUNET_DNSPARSER_SoaRecord *soa) | |||
132 | * @param cert record to free | 132 | * @param cert record to free |
133 | */ | 133 | */ |
134 | void | 134 | void |
135 | GNUNET_DNSPARSER_free_cert (struct GNUNET_DNSPARSER_CertRecord *cert) | 135 | GNUNET_DNSPARSER_free_cert(struct GNUNET_DNSPARSER_CertRecord *cert) |
136 | { | 136 | { |
137 | if (NULL == cert) | 137 | if (NULL == cert) |
138 | return; | 138 | return; |
139 | GNUNET_free_non_null (cert->certificate_data); | 139 | GNUNET_free_non_null(cert->certificate_data); |
140 | GNUNET_free (cert); | 140 | GNUNET_free(cert); |
141 | } | 141 | } |
142 | 142 | ||
143 | 143 | ||
@@ -147,12 +147,12 @@ GNUNET_DNSPARSER_free_cert (struct GNUNET_DNSPARSER_CertRecord *cert) | |||
147 | * @param srv record to free | 147 | * @param srv record to free |
148 | */ | 148 | */ |
149 | void | 149 | void |
150 | GNUNET_DNSPARSER_free_srv (struct GNUNET_DNSPARSER_SrvRecord *srv) | 150 | GNUNET_DNSPARSER_free_srv(struct GNUNET_DNSPARSER_SrvRecord *srv) |
151 | { | 151 | { |
152 | if (NULL == srv) | 152 | if (NULL == srv) |
153 | return; | 153 | return; |
154 | GNUNET_free_non_null (srv->target); | 154 | GNUNET_free_non_null(srv->target); |
155 | GNUNET_free (srv); | 155 | GNUNET_free(srv); |
156 | } | 156 | } |
157 | 157 | ||
158 | 158 | ||
@@ -162,12 +162,12 @@ GNUNET_DNSPARSER_free_srv (struct GNUNET_DNSPARSER_SrvRecord *srv) | |||
162 | * @param mx record to free | 162 | * @param mx record to free |
163 | */ | 163 | */ |
164 | void | 164 | void |
165 | GNUNET_DNSPARSER_free_mx (struct GNUNET_DNSPARSER_MxRecord *mx) | 165 | GNUNET_DNSPARSER_free_mx(struct GNUNET_DNSPARSER_MxRecord *mx) |
166 | { | 166 | { |
167 | if (NULL == mx) | 167 | if (NULL == mx) |
168 | return; | 168 | return; |
169 | GNUNET_free_non_null (mx->mxhost); | 169 | GNUNET_free_non_null(mx->mxhost); |
170 | GNUNET_free (mx); | 170 | GNUNET_free(mx); |
171 | } | 171 | } |
172 | 172 | ||
173 | 173 | ||
@@ -177,32 +177,37 @@ GNUNET_DNSPARSER_free_mx (struct GNUNET_DNSPARSER_MxRecord *mx) | |||
177 | * @param r record to free | 177 | * @param r record to free |
178 | */ | 178 | */ |
179 | void | 179 | void |
180 | GNUNET_DNSPARSER_free_record (struct GNUNET_DNSPARSER_Record *r) | 180 | GNUNET_DNSPARSER_free_record(struct GNUNET_DNSPARSER_Record *r) |
181 | { | 181 | { |
182 | GNUNET_free_non_null (r->name); | 182 | GNUNET_free_non_null(r->name); |
183 | switch (r->type) | 183 | switch (r->type) |
184 | { | 184 | { |
185 | case GNUNET_DNSPARSER_TYPE_MX: | 185 | case GNUNET_DNSPARSER_TYPE_MX: |
186 | GNUNET_DNSPARSER_free_mx (r->data.mx); | 186 | GNUNET_DNSPARSER_free_mx(r->data.mx); |
187 | break; | 187 | break; |
188 | case GNUNET_DNSPARSER_TYPE_SOA: | 188 | |
189 | GNUNET_DNSPARSER_free_soa (r->data.soa); | 189 | case GNUNET_DNSPARSER_TYPE_SOA: |
190 | break; | 190 | GNUNET_DNSPARSER_free_soa(r->data.soa); |
191 | case GNUNET_DNSPARSER_TYPE_SRV: | 191 | break; |
192 | GNUNET_DNSPARSER_free_srv (r->data.srv); | 192 | |
193 | break; | 193 | case GNUNET_DNSPARSER_TYPE_SRV: |
194 | case GNUNET_DNSPARSER_TYPE_CERT: | 194 | GNUNET_DNSPARSER_free_srv(r->data.srv); |
195 | GNUNET_DNSPARSER_free_cert (r->data.cert); | 195 | break; |
196 | break; | 196 | |
197 | case GNUNET_DNSPARSER_TYPE_NS: | 197 | case GNUNET_DNSPARSER_TYPE_CERT: |
198 | case GNUNET_DNSPARSER_TYPE_CNAME: | 198 | GNUNET_DNSPARSER_free_cert(r->data.cert); |
199 | case GNUNET_DNSPARSER_TYPE_PTR: | 199 | break; |
200 | GNUNET_free_non_null (r->data.hostname); | 200 | |
201 | break; | 201 | case GNUNET_DNSPARSER_TYPE_NS: |
202 | default: | 202 | case GNUNET_DNSPARSER_TYPE_CNAME: |
203 | GNUNET_free_non_null (r->data.raw.data); | 203 | case GNUNET_DNSPARSER_TYPE_PTR: |
204 | break; | 204 | GNUNET_free_non_null(r->data.hostname); |
205 | } | 205 | break; |
206 | |||
207 | default: | ||
208 | GNUNET_free_non_null(r->data.raw.data); | ||
209 | break; | ||
210 | } | ||
206 | } | 211 | } |
207 | 212 | ||
208 | 213 | ||
@@ -217,12 +222,12 @@ GNUNET_DNSPARSER_free_record (struct GNUNET_DNSPARSER_Record *r) | |||
217 | * @return name as 0-terminated C string on success, NULL if the payload is malformed | 222 | * @return name as 0-terminated C string on success, NULL if the payload is malformed |
218 | */ | 223 | */ |
219 | static char * | 224 | static char * |
220 | parse_name (const char *udp_payload, | 225 | parse_name(const char *udp_payload, |
221 | size_t udp_payload_length, | 226 | size_t udp_payload_length, |
222 | size_t *off, | 227 | size_t *off, |
223 | unsigned int depth) | 228 | unsigned int depth) |
224 | { | 229 | { |
225 | const uint8_t *input = (const uint8_t *) udp_payload; | 230 | const uint8_t *input = (const uint8_t *)udp_payload; |
226 | char *ret; | 231 | char *ret; |
227 | char *tmp; | 232 | char *tmp; |
228 | char *xstr; | 233 | char *xstr; |
@@ -231,102 +236,102 @@ parse_name (const char *udp_payload, | |||
231 | char *utf8; | 236 | char *utf8; |
232 | Idna_rc rc; | 237 | Idna_rc rc; |
233 | 238 | ||
234 | ret = GNUNET_strdup (""); | 239 | ret = GNUNET_strdup(""); |
235 | while (1) | 240 | while (1) |
236 | { | ||
237 | if (*off >= udp_payload_length) | ||
238 | { | ||
239 | GNUNET_break_op (0); | ||
240 | goto error; | ||
241 | } | ||
242 | len = input[*off]; | ||
243 | if (0 == len) | ||
244 | { | ||
245 | (*off)++; | ||
246 | break; | ||
247 | } | ||
248 | if (len < 64) | ||
249 | { | 241 | { |
250 | if (*off + 1 + len > udp_payload_length) | 242 | if (*off >= udp_payload_length) |
251 | { | 243 | { |
252 | GNUNET_break_op (0); | 244 | GNUNET_break_op(0); |
253 | goto error; | 245 | goto error; |
254 | } | 246 | } |
255 | GNUNET_asprintf (&tmp, "%.*s", (int) len, &udp_payload[*off + 1]); | 247 | len = input[*off]; |
256 | if (IDNA_SUCCESS != | 248 | if (0 == len) |
257 | (rc = idna_to_unicode_8z8z (tmp, &utf8, IDNA_ALLOW_UNASSIGNED))) | 249 | { |
258 | { | 250 | (*off)++; |
259 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 251 | break; |
260 | _ ("Failed to convert DNS IDNA name `%s' to UTF-8: %s\n"), | 252 | } |
261 | tmp, | 253 | if (len < 64) |
262 | idna_strerror (rc)); | 254 | { |
263 | GNUNET_free (tmp); | 255 | if (*off + 1 + len > udp_payload_length) |
264 | GNUNET_asprintf (&tmp, | 256 | { |
265 | "%s%.*s.", | 257 | GNUNET_break_op(0); |
266 | ret, | 258 | goto error; |
267 | (int) len, | 259 | } |
268 | &udp_payload[*off + 1]); | 260 | GNUNET_asprintf(&tmp, "%.*s", (int)len, &udp_payload[*off + 1]); |
269 | } | 261 | if (IDNA_SUCCESS != |
270 | else | 262 | (rc = idna_to_unicode_8z8z(tmp, &utf8, IDNA_ALLOW_UNASSIGNED))) |
271 | { | 263 | { |
272 | GNUNET_free (tmp); | 264 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, |
273 | GNUNET_asprintf (&tmp, "%s%s.", ret, utf8); | 265 | _("Failed to convert DNS IDNA name `%s' to UTF-8: %s\n"), |
266 | tmp, | ||
267 | idna_strerror(rc)); | ||
268 | GNUNET_free(tmp); | ||
269 | GNUNET_asprintf(&tmp, | ||
270 | "%s%.*s.", | ||
271 | ret, | ||
272 | (int)len, | ||
273 | &udp_payload[*off + 1]); | ||
274 | } | ||
275 | else | ||
276 | { | ||
277 | GNUNET_free(tmp); | ||
278 | GNUNET_asprintf(&tmp, "%s%s.", ret, utf8); | ||
274 | #if WINDOWS | 279 | #if WINDOWS |
275 | idn_free (utf8); | 280 | idn_free(utf8); |
276 | #else | 281 | #else |
277 | free (utf8); | 282 | free(utf8); |
278 | #endif | 283 | #endif |
279 | } | 284 | } |
280 | GNUNET_free (ret); | 285 | GNUNET_free(ret); |
281 | ret = tmp; | 286 | ret = tmp; |
282 | *off += 1 + len; | 287 | *off += 1 + len; |
283 | } | 288 | } |
284 | else if ((64 | 128) == (len & (64 | 128))) | 289 | else if ((64 | 128) == (len & (64 | 128))) |
285 | { | 290 | { |
286 | if (depth > 32) | 291 | if (depth > 32) |
287 | { | 292 | { |
288 | GNUNET_break_op (0); | 293 | GNUNET_break_op(0); |
289 | goto error; /* hard bound on stack to prevent "infinite" recursion, disallow! */ | 294 | goto error; /* hard bound on stack to prevent "infinite" recursion, disallow! */ |
290 | } | 295 | } |
291 | /* pointer to string */ | 296 | /* pointer to string */ |
292 | if (*off + 1 > udp_payload_length) | 297 | if (*off + 1 > udp_payload_length) |
293 | { | 298 | { |
294 | GNUNET_break_op (0); | 299 | GNUNET_break_op(0); |
295 | goto error; | 300 | goto error; |
296 | } | 301 | } |
297 | xoff = ((len - (64 | 128)) << 8) + input[*off + 1]; | 302 | xoff = ((len - (64 | 128)) << 8) + input[*off + 1]; |
298 | xstr = parse_name (udp_payload, udp_payload_length, &xoff, depth + 1); | 303 | xstr = parse_name(udp_payload, udp_payload_length, &xoff, depth + 1); |
299 | if (NULL == xstr) | 304 | if (NULL == xstr) |
300 | { | 305 | { |
301 | GNUNET_break_op (0); | 306 | GNUNET_break_op(0); |
302 | goto error; | 307 | goto error; |
303 | } | 308 | } |
304 | GNUNET_asprintf (&tmp, "%s%s.", ret, xstr); | 309 | GNUNET_asprintf(&tmp, "%s%s.", ret, xstr); |
305 | GNUNET_free (ret); | 310 | GNUNET_free(ret); |
306 | GNUNET_free (xstr); | 311 | GNUNET_free(xstr); |
307 | ret = tmp; | 312 | ret = tmp; |
308 | if (strlen (ret) > udp_payload_length) | 313 | if (strlen(ret) > udp_payload_length) |
309 | { | 314 | { |
310 | GNUNET_break_op (0); | 315 | GNUNET_break_op(0); |
311 | goto error; /* we are looping (building an infinite string) */ | 316 | goto error; /* we are looping (building an infinite string) */ |
312 | } | 317 | } |
313 | *off += 2; | 318 | *off += 2; |
314 | /* pointers always terminate names */ | 319 | /* pointers always terminate names */ |
315 | break; | 320 | break; |
316 | } | 321 | } |
317 | else | 322 | else |
318 | { | 323 | { |
319 | /* neither pointer nor inline string, not supported... */ | 324 | /* neither pointer nor inline string, not supported... */ |
320 | GNUNET_break_op (0); | 325 | GNUNET_break_op(0); |
321 | goto error; | 326 | goto error; |
327 | } | ||
322 | } | 328 | } |
323 | } | 329 | if (0 < strlen(ret)) |
324 | if (0 < strlen (ret)) | 330 | ret[strlen(ret) - 1] = '\0'; /* eat tailing '.' */ |
325 | ret[strlen (ret) - 1] = '\0'; /* eat tailing '.' */ | ||
326 | return ret; | 331 | return ret; |
327 | error: | 332 | error: |
328 | GNUNET_break_op (0); | 333 | GNUNET_break_op(0); |
329 | GNUNET_free (ret); | 334 | GNUNET_free(ret); |
330 | return NULL; | 335 | return NULL; |
331 | } | 336 | } |
332 | 337 | ||
@@ -341,11 +346,11 @@ error: | |||
341 | * @return name as 0-terminated C string on success, NULL if the payload is malformed | 346 | * @return name as 0-terminated C string on success, NULL if the payload is malformed |
342 | */ | 347 | */ |
343 | char * | 348 | char * |
344 | GNUNET_DNSPARSER_parse_name (const char *udp_payload, | 349 | GNUNET_DNSPARSER_parse_name(const char *udp_payload, |
345 | size_t udp_payload_length, | 350 | size_t udp_payload_length, |
346 | size_t *off) | 351 | size_t *off) |
347 | { | 352 | { |
348 | return parse_name (udp_payload, udp_payload_length, off, 0); | 353 | return parse_name(udp_payload, udp_payload_length, off, 0); |
349 | } | 354 | } |
350 | 355 | ||
351 | 356 | ||
@@ -360,30 +365,30 @@ GNUNET_DNSPARSER_parse_name (const char *udp_payload, | |||
360 | * @return #GNUNET_OK on success, #GNUNET_SYSERR if the query is malformed | 365 | * @return #GNUNET_OK on success, #GNUNET_SYSERR if the query is malformed |
361 | */ | 366 | */ |
362 | int | 367 | int |
363 | GNUNET_DNSPARSER_parse_query (const char *udp_payload, | 368 | GNUNET_DNSPARSER_parse_query(const char *udp_payload, |
364 | size_t udp_payload_length, | 369 | size_t udp_payload_length, |
365 | size_t *off, | 370 | size_t *off, |
366 | struct GNUNET_DNSPARSER_Query *q) | 371 | struct GNUNET_DNSPARSER_Query *q) |
367 | { | 372 | { |
368 | char *name; | 373 | char *name; |
369 | struct GNUNET_TUN_DnsQueryLine ql; | 374 | struct GNUNET_TUN_DnsQueryLine ql; |
370 | 375 | ||
371 | name = GNUNET_DNSPARSER_parse_name (udp_payload, udp_payload_length, off); | 376 | name = GNUNET_DNSPARSER_parse_name(udp_payload, udp_payload_length, off); |
372 | if (NULL == name) | 377 | if (NULL == name) |
373 | { | 378 | { |
374 | GNUNET_break_op (0); | 379 | GNUNET_break_op(0); |
375 | return GNUNET_SYSERR; | 380 | return GNUNET_SYSERR; |
376 | } | 381 | } |
377 | q->name = name; | 382 | q->name = name; |
378 | if (*off + sizeof (struct GNUNET_TUN_DnsQueryLine) > udp_payload_length) | 383 | if (*off + sizeof(struct GNUNET_TUN_DnsQueryLine) > udp_payload_length) |
379 | { | 384 | { |
380 | GNUNET_break_op (0); | 385 | GNUNET_break_op(0); |
381 | return GNUNET_SYSERR; | 386 | return GNUNET_SYSERR; |
382 | } | 387 | } |
383 | GNUNET_memcpy (&ql, &udp_payload[*off], sizeof (ql)); | 388 | GNUNET_memcpy(&ql, &udp_payload[*off], sizeof(ql)); |
384 | *off += sizeof (ql); | 389 | *off += sizeof(ql); |
385 | q->type = ntohs (ql.type); | 390 | q->type = ntohs(ql.type); |
386 | q->dns_traffic_class = ntohs (ql.dns_traffic_class); | 391 | q->dns_traffic_class = ntohs(ql.dns_traffic_class); |
387 | return GNUNET_OK; | 392 | return GNUNET_OK; |
388 | } | 393 | } |
389 | 394 | ||
@@ -398,37 +403,37 @@ GNUNET_DNSPARSER_parse_query (const char *udp_payload, | |||
398 | * @return the parsed SOA record, NULL on error | 403 | * @return the parsed SOA record, NULL on error |
399 | */ | 404 | */ |
400 | struct GNUNET_DNSPARSER_SoaRecord * | 405 | struct GNUNET_DNSPARSER_SoaRecord * |
401 | GNUNET_DNSPARSER_parse_soa (const char *udp_payload, | 406 | GNUNET_DNSPARSER_parse_soa(const char *udp_payload, |
402 | size_t udp_payload_length, | 407 | size_t udp_payload_length, |
403 | size_t *off) | 408 | size_t *off) |
404 | { | 409 | { |
405 | struct GNUNET_DNSPARSER_SoaRecord *soa; | 410 | struct GNUNET_DNSPARSER_SoaRecord *soa; |
406 | struct GNUNET_TUN_DnsSoaRecord soa_bin; | 411 | struct GNUNET_TUN_DnsSoaRecord soa_bin; |
407 | size_t old_off; | 412 | size_t old_off; |
408 | 413 | ||
409 | old_off = *off; | 414 | old_off = *off; |
410 | soa = GNUNET_new (struct GNUNET_DNSPARSER_SoaRecord); | 415 | soa = GNUNET_new(struct GNUNET_DNSPARSER_SoaRecord); |
411 | soa->mname = | 416 | soa->mname = |
412 | GNUNET_DNSPARSER_parse_name (udp_payload, udp_payload_length, off); | 417 | GNUNET_DNSPARSER_parse_name(udp_payload, udp_payload_length, off); |
413 | soa->rname = | 418 | soa->rname = |
414 | GNUNET_DNSPARSER_parse_name (udp_payload, udp_payload_length, off); | 419 | GNUNET_DNSPARSER_parse_name(udp_payload, udp_payload_length, off); |
415 | if ((NULL == soa->mname) || (NULL == soa->rname) || | 420 | if ((NULL == soa->mname) || (NULL == soa->rname) || |
416 | (*off + sizeof (struct GNUNET_TUN_DnsSoaRecord) > udp_payload_length)) | 421 | (*off + sizeof(struct GNUNET_TUN_DnsSoaRecord) > udp_payload_length)) |
417 | { | 422 | { |
418 | GNUNET_break_op (0); | 423 | GNUNET_break_op(0); |
419 | GNUNET_DNSPARSER_free_soa (soa); | 424 | GNUNET_DNSPARSER_free_soa(soa); |
420 | *off = old_off; | 425 | *off = old_off; |
421 | return NULL; | 426 | return NULL; |
422 | } | 427 | } |
423 | GNUNET_memcpy (&soa_bin, | 428 | GNUNET_memcpy(&soa_bin, |
424 | &udp_payload[*off], | 429 | &udp_payload[*off], |
425 | sizeof (struct GNUNET_TUN_DnsSoaRecord)); | 430 | sizeof(struct GNUNET_TUN_DnsSoaRecord)); |
426 | soa->serial = ntohl (soa_bin.serial); | 431 | soa->serial = ntohl(soa_bin.serial); |
427 | soa->refresh = ntohl (soa_bin.refresh); | 432 | soa->refresh = ntohl(soa_bin.refresh); |
428 | soa->retry = ntohl (soa_bin.retry); | 433 | soa->retry = ntohl(soa_bin.retry); |
429 | soa->expire = ntohl (soa_bin.expire); | 434 | soa->expire = ntohl(soa_bin.expire); |
430 | soa->minimum_ttl = ntohl (soa_bin.minimum); | 435 | soa->minimum_ttl = ntohl(soa_bin.minimum); |
431 | (*off) += sizeof (struct GNUNET_TUN_DnsSoaRecord); | 436 | (*off) += sizeof(struct GNUNET_TUN_DnsSoaRecord); |
432 | return soa; | 437 | return soa; |
433 | } | 438 | } |
434 | 439 | ||
@@ -443,33 +448,33 @@ GNUNET_DNSPARSER_parse_soa (const char *udp_payload, | |||
443 | * @return the parsed MX record, NULL on error | 448 | * @return the parsed MX record, NULL on error |
444 | */ | 449 | */ |
445 | struct GNUNET_DNSPARSER_MxRecord * | 450 | struct GNUNET_DNSPARSER_MxRecord * |
446 | GNUNET_DNSPARSER_parse_mx (const char *udp_payload, | 451 | GNUNET_DNSPARSER_parse_mx(const char *udp_payload, |
447 | size_t udp_payload_length, | 452 | size_t udp_payload_length, |
448 | size_t *off) | 453 | size_t *off) |
449 | { | 454 | { |
450 | struct GNUNET_DNSPARSER_MxRecord *mx; | 455 | struct GNUNET_DNSPARSER_MxRecord *mx; |
451 | uint16_t mxpref; | 456 | uint16_t mxpref; |
452 | size_t old_off; | 457 | size_t old_off; |
453 | 458 | ||
454 | old_off = *off; | 459 | old_off = *off; |
455 | if (*off + sizeof (uint16_t) > udp_payload_length) | 460 | if (*off + sizeof(uint16_t) > udp_payload_length) |
456 | { | 461 | { |
457 | GNUNET_break_op (0); | 462 | GNUNET_break_op(0); |
458 | return NULL; | 463 | return NULL; |
459 | } | 464 | } |
460 | GNUNET_memcpy (&mxpref, &udp_payload[*off], sizeof (uint16_t)); | 465 | GNUNET_memcpy(&mxpref, &udp_payload[*off], sizeof(uint16_t)); |
461 | (*off) += sizeof (uint16_t); | 466 | (*off) += sizeof(uint16_t); |
462 | mx = GNUNET_new (struct GNUNET_DNSPARSER_MxRecord); | 467 | mx = GNUNET_new(struct GNUNET_DNSPARSER_MxRecord); |
463 | mx->preference = ntohs (mxpref); | 468 | mx->preference = ntohs(mxpref); |
464 | mx->mxhost = | 469 | mx->mxhost = |
465 | GNUNET_DNSPARSER_parse_name (udp_payload, udp_payload_length, off); | 470 | GNUNET_DNSPARSER_parse_name(udp_payload, udp_payload_length, off); |
466 | if (NULL == mx->mxhost) | 471 | if (NULL == mx->mxhost) |
467 | { | 472 | { |
468 | GNUNET_break_op (0); | 473 | GNUNET_break_op(0); |
469 | GNUNET_DNSPARSER_free_mx (mx); | 474 | GNUNET_DNSPARSER_free_mx(mx); |
470 | *off = old_off; | 475 | *off = old_off; |
471 | return NULL; | 476 | return NULL; |
472 | } | 477 | } |
473 | return mx; | 478 | return mx; |
474 | } | 479 | } |
475 | 480 | ||
@@ -484,33 +489,33 @@ GNUNET_DNSPARSER_parse_mx (const char *udp_payload, | |||
484 | * @return the parsed SRV record, NULL on error | 489 | * @return the parsed SRV record, NULL on error |
485 | */ | 490 | */ |
486 | struct GNUNET_DNSPARSER_SrvRecord * | 491 | struct GNUNET_DNSPARSER_SrvRecord * |
487 | GNUNET_DNSPARSER_parse_srv (const char *udp_payload, | 492 | GNUNET_DNSPARSER_parse_srv(const char *udp_payload, |
488 | size_t udp_payload_length, | 493 | size_t udp_payload_length, |
489 | size_t *off) | 494 | size_t *off) |
490 | { | 495 | { |
491 | struct GNUNET_DNSPARSER_SrvRecord *srv; | 496 | struct GNUNET_DNSPARSER_SrvRecord *srv; |
492 | struct GNUNET_TUN_DnsSrvRecord srv_bin; | 497 | struct GNUNET_TUN_DnsSrvRecord srv_bin; |
493 | size_t old_off; | 498 | size_t old_off; |
494 | 499 | ||
495 | old_off = *off; | 500 | old_off = *off; |
496 | if (*off + sizeof (struct GNUNET_TUN_DnsSrvRecord) > udp_payload_length) | 501 | if (*off + sizeof(struct GNUNET_TUN_DnsSrvRecord) > udp_payload_length) |
497 | return NULL; | 502 | return NULL; |
498 | GNUNET_memcpy (&srv_bin, | 503 | GNUNET_memcpy(&srv_bin, |
499 | &udp_payload[*off], | 504 | &udp_payload[*off], |
500 | sizeof (struct GNUNET_TUN_DnsSrvRecord)); | 505 | sizeof(struct GNUNET_TUN_DnsSrvRecord)); |
501 | (*off) += sizeof (struct GNUNET_TUN_DnsSrvRecord); | 506 | (*off) += sizeof(struct GNUNET_TUN_DnsSrvRecord); |
502 | srv = GNUNET_new (struct GNUNET_DNSPARSER_SrvRecord); | 507 | srv = GNUNET_new(struct GNUNET_DNSPARSER_SrvRecord); |
503 | srv->priority = ntohs (srv_bin.prio); | 508 | srv->priority = ntohs(srv_bin.prio); |
504 | srv->weight = ntohs (srv_bin.weight); | 509 | srv->weight = ntohs(srv_bin.weight); |
505 | srv->port = ntohs (srv_bin.port); | 510 | srv->port = ntohs(srv_bin.port); |
506 | srv->target = | 511 | srv->target = |
507 | GNUNET_DNSPARSER_parse_name (udp_payload, udp_payload_length, off); | 512 | GNUNET_DNSPARSER_parse_name(udp_payload, udp_payload_length, off); |
508 | if (NULL == srv->target) | 513 | if (NULL == srv->target) |
509 | { | 514 | { |
510 | GNUNET_DNSPARSER_free_srv (srv); | 515 | GNUNET_DNSPARSER_free_srv(srv); |
511 | *off = old_off; | 516 | *off = old_off; |
512 | return NULL; | 517 | return NULL; |
513 | } | 518 | } |
514 | return srv; | 519 | return srv; |
515 | } | 520 | } |
516 | 521 | ||
@@ -525,31 +530,31 @@ GNUNET_DNSPARSER_parse_srv (const char *udp_payload, | |||
525 | * @return the parsed CERT record, NULL on error | 530 | * @return the parsed CERT record, NULL on error |
526 | */ | 531 | */ |
527 | struct GNUNET_DNSPARSER_CertRecord * | 532 | struct GNUNET_DNSPARSER_CertRecord * |
528 | GNUNET_DNSPARSER_parse_cert (const char *udp_payload, | 533 | GNUNET_DNSPARSER_parse_cert(const char *udp_payload, |
529 | size_t udp_payload_length, | 534 | size_t udp_payload_length, |
530 | size_t *off) | 535 | size_t *off) |
531 | { | 536 | { |
532 | struct GNUNET_DNSPARSER_CertRecord *cert; | 537 | struct GNUNET_DNSPARSER_CertRecord *cert; |
533 | struct GNUNET_TUN_DnsCertRecord dcert; | 538 | struct GNUNET_TUN_DnsCertRecord dcert; |
534 | 539 | ||
535 | if (*off + sizeof (struct GNUNET_TUN_DnsCertRecord) >= udp_payload_length) | 540 | if (*off + sizeof(struct GNUNET_TUN_DnsCertRecord) >= udp_payload_length) |
536 | { | 541 | { |
537 | GNUNET_break_op (0); | 542 | GNUNET_break_op(0); |
538 | return NULL; | 543 | return NULL; |
539 | } | 544 | } |
540 | GNUNET_memcpy (&dcert, | 545 | GNUNET_memcpy(&dcert, |
541 | &udp_payload[*off], | 546 | &udp_payload[*off], |
542 | sizeof (struct GNUNET_TUN_DnsCertRecord)); | 547 | sizeof(struct GNUNET_TUN_DnsCertRecord)); |
543 | (*off) += sizeof (struct GNUNET_TUN_DnsCertRecord); | 548 | (*off) += sizeof(struct GNUNET_TUN_DnsCertRecord); |
544 | cert = GNUNET_new (struct GNUNET_DNSPARSER_CertRecord); | 549 | cert = GNUNET_new(struct GNUNET_DNSPARSER_CertRecord); |
545 | cert->cert_type = ntohs (dcert.cert_type); | 550 | cert->cert_type = ntohs(dcert.cert_type); |
546 | cert->cert_tag = ntohs (dcert.cert_tag); | 551 | cert->cert_tag = ntohs(dcert.cert_tag); |
547 | cert->algorithm = dcert.algorithm; | 552 | cert->algorithm = dcert.algorithm; |
548 | cert->certificate_size = udp_payload_length - (*off); | 553 | cert->certificate_size = udp_payload_length - (*off); |
549 | cert->certificate_data = GNUNET_malloc (cert->certificate_size); | 554 | cert->certificate_data = GNUNET_malloc(cert->certificate_size); |
550 | GNUNET_memcpy (cert->certificate_data, | 555 | GNUNET_memcpy(cert->certificate_data, |
551 | &udp_payload[*off], | 556 | &udp_payload[*off], |
552 | cert->certificate_size); | 557 | cert->certificate_size); |
553 | (*off) += cert->certificate_size; | 558 | (*off) += cert->certificate_size; |
554 | return cert; | 559 | return cert; |
555 | } | 560 | } |
@@ -566,85 +571,89 @@ GNUNET_DNSPARSER_parse_cert (const char *udp_payload, | |||
566 | * @return #GNUNET_OK on success, #GNUNET_SYSERR if the record is malformed | 571 | * @return #GNUNET_OK on success, #GNUNET_SYSERR if the record is malformed |
567 | */ | 572 | */ |
568 | int | 573 | int |
569 | GNUNET_DNSPARSER_parse_record (const char *udp_payload, | 574 | GNUNET_DNSPARSER_parse_record(const char *udp_payload, |
570 | size_t udp_payload_length, | 575 | size_t udp_payload_length, |
571 | size_t *off, | 576 | size_t *off, |
572 | struct GNUNET_DNSPARSER_Record *r) | 577 | struct GNUNET_DNSPARSER_Record *r) |
573 | { | 578 | { |
574 | char *name; | 579 | char *name; |
575 | struct GNUNET_TUN_DnsRecordLine rl; | 580 | struct GNUNET_TUN_DnsRecordLine rl; |
576 | size_t old_off; | 581 | size_t old_off; |
577 | uint16_t data_len; | 582 | uint16_t data_len; |
578 | 583 | ||
579 | name = GNUNET_DNSPARSER_parse_name (udp_payload, udp_payload_length, off); | 584 | name = GNUNET_DNSPARSER_parse_name(udp_payload, udp_payload_length, off); |
580 | if (NULL == name) | 585 | if (NULL == name) |
581 | { | ||
582 | GNUNET_break_op (0); | ||
583 | return GNUNET_SYSERR; | ||
584 | } | ||
585 | r->name = name; | ||
586 | if (*off + sizeof (struct GNUNET_TUN_DnsRecordLine) > udp_payload_length) | ||
587 | { | ||
588 | GNUNET_break_op (0); | ||
589 | return GNUNET_SYSERR; | ||
590 | } | ||
591 | GNUNET_memcpy (&rl, &udp_payload[*off], sizeof (rl)); | ||
592 | (*off) += sizeof (rl); | ||
593 | r->type = ntohs (rl.type); | ||
594 | r->dns_traffic_class = ntohs (rl.dns_traffic_class); | ||
595 | r->expiration_time = GNUNET_TIME_relative_to_absolute ( | ||
596 | GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, ntohl (rl.ttl))); | ||
597 | data_len = ntohs (rl.data_len); | ||
598 | if (*off + data_len > udp_payload_length) | ||
599 | { | ||
600 | GNUNET_break_op (0); | ||
601 | return GNUNET_SYSERR; | ||
602 | } | ||
603 | old_off = *off; | ||
604 | switch (r->type) | ||
605 | { | ||
606 | case GNUNET_DNSPARSER_TYPE_NS: | ||
607 | case GNUNET_DNSPARSER_TYPE_CNAME: | ||
608 | case GNUNET_DNSPARSER_TYPE_DNAME: | ||
609 | case GNUNET_DNSPARSER_TYPE_PTR: | ||
610 | r->data.hostname = | ||
611 | GNUNET_DNSPARSER_parse_name (udp_payload, udp_payload_length, off); | ||
612 | if ((NULL == r->data.hostname) || (old_off + data_len != *off)) | ||
613 | return GNUNET_SYSERR; | ||
614 | return GNUNET_OK; | ||
615 | case GNUNET_DNSPARSER_TYPE_SOA: | ||
616 | r->data.soa = | ||
617 | GNUNET_DNSPARSER_parse_soa (udp_payload, udp_payload_length, off); | ||
618 | if ((NULL == r->data.soa) || (old_off + data_len != *off)) | ||
619 | { | 586 | { |
620 | GNUNET_break_op (0); | 587 | GNUNET_break_op(0); |
621 | return GNUNET_SYSERR; | 588 | return GNUNET_SYSERR; |
622 | } | 589 | } |
623 | return GNUNET_OK; | 590 | r->name = name; |
624 | case GNUNET_DNSPARSER_TYPE_MX: | 591 | if (*off + sizeof(struct GNUNET_TUN_DnsRecordLine) > udp_payload_length) |
625 | r->data.mx = | ||
626 | GNUNET_DNSPARSER_parse_mx (udp_payload, udp_payload_length, off); | ||
627 | if ((NULL == r->data.mx) || (old_off + data_len != *off)) | ||
628 | { | 592 | { |
629 | GNUNET_break_op (0); | 593 | GNUNET_break_op(0); |
630 | return GNUNET_SYSERR; | 594 | return GNUNET_SYSERR; |
631 | } | 595 | } |
632 | return GNUNET_OK; | 596 | GNUNET_memcpy(&rl, &udp_payload[*off], sizeof(rl)); |
633 | case GNUNET_DNSPARSER_TYPE_SRV: | 597 | (*off) += sizeof(rl); |
634 | r->data.srv = | 598 | r->type = ntohs(rl.type); |
635 | GNUNET_DNSPARSER_parse_srv (udp_payload, udp_payload_length, off); | 599 | r->dns_traffic_class = ntohs(rl.dns_traffic_class); |
636 | if ((NULL == r->data.srv) || (old_off + data_len != *off)) | 600 | r->expiration_time = GNUNET_TIME_relative_to_absolute( |
601 | GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, ntohl(rl.ttl))); | ||
602 | data_len = ntohs(rl.data_len); | ||
603 | if (*off + data_len > udp_payload_length) | ||
637 | { | 604 | { |
638 | GNUNET_break_op (0); | 605 | GNUNET_break_op(0); |
639 | return GNUNET_SYSERR; | 606 | return GNUNET_SYSERR; |
640 | } | 607 | } |
641 | return GNUNET_OK; | 608 | old_off = *off; |
642 | default: | 609 | switch (r->type) |
643 | r->data.raw.data = GNUNET_malloc (data_len); | 610 | { |
644 | r->data.raw.data_len = data_len; | 611 | case GNUNET_DNSPARSER_TYPE_NS: |
645 | GNUNET_memcpy (r->data.raw.data, &udp_payload[*off], data_len); | 612 | case GNUNET_DNSPARSER_TYPE_CNAME: |
646 | break; | 613 | case GNUNET_DNSPARSER_TYPE_DNAME: |
647 | } | 614 | case GNUNET_DNSPARSER_TYPE_PTR: |
615 | r->data.hostname = | ||
616 | GNUNET_DNSPARSER_parse_name(udp_payload, udp_payload_length, off); | ||
617 | if ((NULL == r->data.hostname) || (old_off + data_len != *off)) | ||
618 | return GNUNET_SYSERR; | ||
619 | return GNUNET_OK; | ||
620 | |||
621 | case GNUNET_DNSPARSER_TYPE_SOA: | ||
622 | r->data.soa = | ||
623 | GNUNET_DNSPARSER_parse_soa(udp_payload, udp_payload_length, off); | ||
624 | if ((NULL == r->data.soa) || (old_off + data_len != *off)) | ||
625 | { | ||
626 | GNUNET_break_op(0); | ||
627 | return GNUNET_SYSERR; | ||
628 | } | ||
629 | return GNUNET_OK; | ||
630 | |||
631 | case GNUNET_DNSPARSER_TYPE_MX: | ||
632 | r->data.mx = | ||
633 | GNUNET_DNSPARSER_parse_mx(udp_payload, udp_payload_length, off); | ||
634 | if ((NULL == r->data.mx) || (old_off + data_len != *off)) | ||
635 | { | ||
636 | GNUNET_break_op(0); | ||
637 | return GNUNET_SYSERR; | ||
638 | } | ||
639 | return GNUNET_OK; | ||
640 | |||
641 | case GNUNET_DNSPARSER_TYPE_SRV: | ||
642 | r->data.srv = | ||
643 | GNUNET_DNSPARSER_parse_srv(udp_payload, udp_payload_length, off); | ||
644 | if ((NULL == r->data.srv) || (old_off + data_len != *off)) | ||
645 | { | ||
646 | GNUNET_break_op(0); | ||
647 | return GNUNET_SYSERR; | ||
648 | } | ||
649 | return GNUNET_OK; | ||
650 | |||
651 | default: | ||
652 | r->data.raw.data = GNUNET_malloc(data_len); | ||
653 | r->data.raw.data_len = data_len; | ||
654 | GNUNET_memcpy(r->data.raw.data, &udp_payload[*off], data_len); | ||
655 | break; | ||
656 | } | ||
648 | (*off) += data_len; | 657 | (*off) += data_len; |
649 | return GNUNET_OK; | 658 | return GNUNET_OK; |
650 | } | 659 | } |
@@ -659,76 +668,76 @@ GNUNET_DNSPARSER_parse_record (const char *udp_payload, | |||
659 | * @return NULL on error, otherwise the parsed packet | 668 | * @return NULL on error, otherwise the parsed packet |
660 | */ | 669 | */ |
661 | struct GNUNET_DNSPARSER_Packet * | 670 | struct GNUNET_DNSPARSER_Packet * |
662 | GNUNET_DNSPARSER_parse (const char *udp_payload, size_t udp_payload_length) | 671 | GNUNET_DNSPARSER_parse(const char *udp_payload, size_t udp_payload_length) |
663 | { | 672 | { |
664 | struct GNUNET_DNSPARSER_Packet *p; | 673 | struct GNUNET_DNSPARSER_Packet *p; |
665 | const struct GNUNET_TUN_DnsHeader *dns; | 674 | const struct GNUNET_TUN_DnsHeader *dns; |
666 | size_t off; | 675 | size_t off; |
667 | unsigned int n; | 676 | unsigned int n; |
668 | 677 | ||
669 | if (udp_payload_length < sizeof (struct GNUNET_TUN_DnsHeader)) | 678 | if (udp_payload_length < sizeof(struct GNUNET_TUN_DnsHeader)) |
670 | return NULL; | 679 | return NULL; |
671 | dns = (const struct GNUNET_TUN_DnsHeader *) udp_payload; | 680 | dns = (const struct GNUNET_TUN_DnsHeader *)udp_payload; |
672 | off = sizeof (struct GNUNET_TUN_DnsHeader); | 681 | off = sizeof(struct GNUNET_TUN_DnsHeader); |
673 | p = GNUNET_new (struct GNUNET_DNSPARSER_Packet); | 682 | p = GNUNET_new(struct GNUNET_DNSPARSER_Packet); |
674 | p->flags = dns->flags; | 683 | p->flags = dns->flags; |
675 | p->id = dns->id; | 684 | p->id = dns->id; |
676 | n = ntohs (dns->query_count); | 685 | n = ntohs(dns->query_count); |
677 | if (n > 0) | 686 | if (n > 0) |
678 | { | 687 | { |
679 | p->queries = GNUNET_new_array (n, struct GNUNET_DNSPARSER_Query); | 688 | p->queries = GNUNET_new_array(n, struct GNUNET_DNSPARSER_Query); |
680 | p->num_queries = n; | 689 | p->num_queries = n; |
681 | for (unsigned int i = 0; i < n; i++) | 690 | for (unsigned int i = 0; i < n; i++) |
682 | if (GNUNET_OK != GNUNET_DNSPARSER_parse_query (udp_payload, | 691 | if (GNUNET_OK != GNUNET_DNSPARSER_parse_query(udp_payload, |
683 | udp_payload_length, | ||
684 | &off, | ||
685 | &p->queries[i])) | ||
686 | goto error; | ||
687 | } | ||
688 | n = ntohs (dns->answer_rcount); | ||
689 | if (n > 0) | ||
690 | { | ||
691 | p->answers = GNUNET_new_array (n, struct GNUNET_DNSPARSER_Record); | ||
692 | p->num_answers = n; | ||
693 | for (unsigned int i = 0; i < n; i++) | ||
694 | if (GNUNET_OK != GNUNET_DNSPARSER_parse_record (udp_payload, | ||
695 | udp_payload_length, | 692 | udp_payload_length, |
696 | &off, | 693 | &off, |
697 | &p->answers[i])) | 694 | &p->queries[i])) |
698 | goto error; | 695 | goto error; |
699 | } | 696 | } |
700 | n = ntohs (dns->authority_rcount); | 697 | n = ntohs(dns->answer_rcount); |
701 | if (n > 0) | 698 | if (n > 0) |
702 | { | 699 | { |
703 | p->authority_records = GNUNET_new_array (n, struct GNUNET_DNSPARSER_Record); | 700 | p->answers = GNUNET_new_array(n, struct GNUNET_DNSPARSER_Record); |
704 | p->num_authority_records = n; | 701 | p->num_answers = n; |
705 | for (unsigned int i = 0; i < n; i++) | 702 | for (unsigned int i = 0; i < n; i++) |
706 | if (GNUNET_OK != GNUNET_DNSPARSER_parse_record (udp_payload, | 703 | if (GNUNET_OK != GNUNET_DNSPARSER_parse_record(udp_payload, |
707 | udp_payload_length, | 704 | udp_payload_length, |
708 | &off, | 705 | &off, |
709 | &p->authority_records[i])) | 706 | &p->answers[i])) |
710 | goto error; | 707 | goto error; |
711 | } | 708 | } |
712 | n = ntohs (dns->additional_rcount); | 709 | n = ntohs(dns->authority_rcount); |
713 | if (n > 0) | 710 | if (n > 0) |
714 | { | ||
715 | p->additional_records = | ||
716 | GNUNET_new_array (n, struct GNUNET_DNSPARSER_Record); | ||
717 | p->num_additional_records = n; | ||
718 | for (unsigned int i = 0; i < n; i++) | ||
719 | { | 711 | { |
720 | if (GNUNET_OK != | 712 | p->authority_records = GNUNET_new_array(n, struct GNUNET_DNSPARSER_Record); |
721 | GNUNET_DNSPARSER_parse_record (udp_payload, | 713 | p->num_authority_records = n; |
722 | udp_payload_length, | 714 | for (unsigned int i = 0; i < n; i++) |
723 | &off, | 715 | if (GNUNET_OK != GNUNET_DNSPARSER_parse_record(udp_payload, |
724 | &p->additional_records[i])) | 716 | udp_payload_length, |
725 | goto error; | 717 | &off, |
718 | &p->authority_records[i])) | ||
719 | goto error; | ||
720 | } | ||
721 | n = ntohs(dns->additional_rcount); | ||
722 | if (n > 0) | ||
723 | { | ||
724 | p->additional_records = | ||
725 | GNUNET_new_array(n, struct GNUNET_DNSPARSER_Record); | ||
726 | p->num_additional_records = n; | ||
727 | for (unsigned int i = 0; i < n; i++) | ||
728 | { | ||
729 | if (GNUNET_OK != | ||
730 | GNUNET_DNSPARSER_parse_record(udp_payload, | ||
731 | udp_payload_length, | ||
732 | &off, | ||
733 | &p->additional_records[i])) | ||
734 | goto error; | ||
735 | } | ||
726 | } | 736 | } |
727 | } | ||
728 | return p; | 737 | return p; |
729 | error: | 738 | error: |
730 | GNUNET_break_op (0); | 739 | GNUNET_break_op(0); |
731 | GNUNET_DNSPARSER_free_packet (p); | 740 | GNUNET_DNSPARSER_free_packet(p); |
732 | return NULL; | 741 | return NULL; |
733 | } | 742 | } |
734 | 743 | ||
@@ -740,39 +749,44 @@ error: | |||
740 | * @return the newly allocated record | 749 | * @return the newly allocated record |
741 | */ | 750 | */ |
742 | struct GNUNET_DNSPARSER_Record * | 751 | struct GNUNET_DNSPARSER_Record * |
743 | GNUNET_DNSPARSER_duplicate_record (const struct GNUNET_DNSPARSER_Record *r) | 752 | GNUNET_DNSPARSER_duplicate_record(const struct GNUNET_DNSPARSER_Record *r) |
744 | { | 753 | { |
745 | struct GNUNET_DNSPARSER_Record *dup = GNUNET_memdup (r, sizeof (*r)); | 754 | struct GNUNET_DNSPARSER_Record *dup = GNUNET_memdup(r, sizeof(*r)); |
746 | 755 | ||
747 | dup->name = GNUNET_strdup (r->name); | 756 | dup->name = GNUNET_strdup(r->name); |
748 | switch (r->type) | 757 | switch (r->type) |
749 | { | 758 | { |
750 | case GNUNET_DNSPARSER_TYPE_NS: | 759 | case GNUNET_DNSPARSER_TYPE_NS: |
751 | case GNUNET_DNSPARSER_TYPE_CNAME: | 760 | case GNUNET_DNSPARSER_TYPE_CNAME: |
752 | case GNUNET_DNSPARSER_TYPE_PTR: { | 761 | case GNUNET_DNSPARSER_TYPE_PTR: { |
753 | dup->data.hostname = GNUNET_strdup (r->data.hostname); | 762 | dup->data.hostname = GNUNET_strdup(r->data.hostname); |
754 | break; | 763 | break; |
755 | } | 764 | } |
756 | case GNUNET_DNSPARSER_TYPE_SOA: { | 765 | |
757 | dup->data.soa = GNUNET_DNSPARSER_duplicate_soa_record (r->data.soa); | 766 | case GNUNET_DNSPARSER_TYPE_SOA: { |
758 | break; | 767 | dup->data.soa = GNUNET_DNSPARSER_duplicate_soa_record(r->data.soa); |
759 | } | 768 | break; |
760 | case GNUNET_DNSPARSER_TYPE_CERT: { | 769 | } |
761 | dup->data.cert = GNUNET_DNSPARSER_duplicate_cert_record (r->data.cert); | 770 | |
762 | break; | 771 | case GNUNET_DNSPARSER_TYPE_CERT: { |
763 | } | 772 | dup->data.cert = GNUNET_DNSPARSER_duplicate_cert_record(r->data.cert); |
764 | case GNUNET_DNSPARSER_TYPE_MX: { | 773 | break; |
765 | dup->data.mx = GNUNET_DNSPARSER_duplicate_mx_record (r->data.mx); | 774 | } |
766 | break; | 775 | |
767 | } | 776 | case GNUNET_DNSPARSER_TYPE_MX: { |
768 | case GNUNET_DNSPARSER_TYPE_SRV: { | 777 | dup->data.mx = GNUNET_DNSPARSER_duplicate_mx_record(r->data.mx); |
769 | dup->data.srv = GNUNET_DNSPARSER_duplicate_srv_record (r->data.srv); | 778 | break; |
770 | break; | 779 | } |
771 | } | 780 | |
772 | default: { | 781 | case GNUNET_DNSPARSER_TYPE_SRV: { |
773 | dup->data.raw.data = GNUNET_memdup (r->data.raw.data, r->data.raw.data_len); | 782 | dup->data.srv = GNUNET_DNSPARSER_duplicate_srv_record(r->data.srv); |
774 | } | 783 | break; |
775 | } | 784 | } |
785 | |||
786 | default: { | ||
787 | dup->data.raw.data = GNUNET_memdup(r->data.raw.data, r->data.raw.data_len); | ||
788 | } | ||
789 | } | ||
776 | return dup; | 790 | return dup; |
777 | } | 791 | } |
778 | 792 | ||
@@ -784,13 +798,13 @@ GNUNET_DNSPARSER_duplicate_record (const struct GNUNET_DNSPARSER_Record *r) | |||
784 | * @return the newly allocated record | 798 | * @return the newly allocated record |
785 | */ | 799 | */ |
786 | struct GNUNET_DNSPARSER_SoaRecord * | 800 | struct GNUNET_DNSPARSER_SoaRecord * |
787 | GNUNET_DNSPARSER_duplicate_soa_record ( | 801 | GNUNET_DNSPARSER_duplicate_soa_record( |
788 | const struct GNUNET_DNSPARSER_SoaRecord *r) | 802 | const struct GNUNET_DNSPARSER_SoaRecord *r) |
789 | { | 803 | { |
790 | struct GNUNET_DNSPARSER_SoaRecord *dup = GNUNET_memdup (r, sizeof (*r)); | 804 | struct GNUNET_DNSPARSER_SoaRecord *dup = GNUNET_memdup(r, sizeof(*r)); |
791 | 805 | ||
792 | dup->mname = GNUNET_strdup (r->mname); | 806 | dup->mname = GNUNET_strdup(r->mname); |
793 | dup->rname = GNUNET_strdup (r->rname); | 807 | dup->rname = GNUNET_strdup(r->rname); |
794 | return dup; | 808 | return dup; |
795 | } | 809 | } |
796 | 810 | ||
@@ -802,12 +816,12 @@ GNUNET_DNSPARSER_duplicate_soa_record ( | |||
802 | * @return the newly allocated record | 816 | * @return the newly allocated record |
803 | */ | 817 | */ |
804 | struct GNUNET_DNSPARSER_CertRecord * | 818 | struct GNUNET_DNSPARSER_CertRecord * |
805 | GNUNET_DNSPARSER_duplicate_cert_record ( | 819 | GNUNET_DNSPARSER_duplicate_cert_record( |
806 | const struct GNUNET_DNSPARSER_CertRecord *r) | 820 | const struct GNUNET_DNSPARSER_CertRecord *r) |
807 | { | 821 | { |
808 | struct GNUNET_DNSPARSER_CertRecord *dup = GNUNET_memdup (r, sizeof (*r)); | 822 | struct GNUNET_DNSPARSER_CertRecord *dup = GNUNET_memdup(r, sizeof(*r)); |
809 | 823 | ||
810 | dup->certificate_data = GNUNET_strdup (r->certificate_data); | 824 | dup->certificate_data = GNUNET_strdup(r->certificate_data); |
811 | return dup; | 825 | return dup; |
812 | } | 826 | } |
813 | 827 | ||
@@ -819,11 +833,11 @@ GNUNET_DNSPARSER_duplicate_cert_record ( | |||
819 | * @return the newly allocated record | 833 | * @return the newly allocated record |
820 | */ | 834 | */ |
821 | struct GNUNET_DNSPARSER_MxRecord * | 835 | struct GNUNET_DNSPARSER_MxRecord * |
822 | GNUNET_DNSPARSER_duplicate_mx_record (const struct GNUNET_DNSPARSER_MxRecord *r) | 836 | GNUNET_DNSPARSER_duplicate_mx_record(const struct GNUNET_DNSPARSER_MxRecord *r) |
823 | { | 837 | { |
824 | struct GNUNET_DNSPARSER_MxRecord *dup = GNUNET_memdup (r, sizeof (*r)); | 838 | struct GNUNET_DNSPARSER_MxRecord *dup = GNUNET_memdup(r, sizeof(*r)); |
825 | 839 | ||
826 | dup->mxhost = GNUNET_strdup (r->mxhost); | 840 | dup->mxhost = GNUNET_strdup(r->mxhost); |
827 | return dup; | 841 | return dup; |
828 | } | 842 | } |
829 | 843 | ||
@@ -835,12 +849,12 @@ GNUNET_DNSPARSER_duplicate_mx_record (const struct GNUNET_DNSPARSER_MxRecord *r) | |||
835 | * @return the newly allocated record | 849 | * @return the newly allocated record |
836 | */ | 850 | */ |
837 | struct GNUNET_DNSPARSER_SrvRecord * | 851 | struct GNUNET_DNSPARSER_SrvRecord * |
838 | GNUNET_DNSPARSER_duplicate_srv_record ( | 852 | GNUNET_DNSPARSER_duplicate_srv_record( |
839 | const struct GNUNET_DNSPARSER_SrvRecord *r) | 853 | const struct GNUNET_DNSPARSER_SrvRecord *r) |
840 | { | 854 | { |
841 | struct GNUNET_DNSPARSER_SrvRecord *dup = GNUNET_memdup (r, sizeof (*r)); | 855 | struct GNUNET_DNSPARSER_SrvRecord *dup = GNUNET_memdup(r, sizeof(*r)); |
842 | 856 | ||
843 | dup->target = GNUNET_strdup (r->target); | 857 | dup->target = GNUNET_strdup(r->target); |
844 | return dup; | 858 | return dup; |
845 | } | 859 | } |
846 | 860 | ||
@@ -851,21 +865,21 @@ GNUNET_DNSPARSER_duplicate_srv_record ( | |||
851 | * @param p packet to free | 865 | * @param p packet to free |
852 | */ | 866 | */ |
853 | void | 867 | void |
854 | GNUNET_DNSPARSER_free_packet (struct GNUNET_DNSPARSER_Packet *p) | 868 | GNUNET_DNSPARSER_free_packet(struct GNUNET_DNSPARSER_Packet *p) |
855 | { | 869 | { |
856 | for (unsigned int i = 0; i < p->num_queries; i++) | 870 | for (unsigned int i = 0; i < p->num_queries; i++) |
857 | GNUNET_free_non_null (p->queries[i].name); | 871 | GNUNET_free_non_null(p->queries[i].name); |
858 | GNUNET_free_non_null (p->queries); | 872 | GNUNET_free_non_null(p->queries); |
859 | for (unsigned int i = 0; i < p->num_answers; i++) | 873 | for (unsigned int i = 0; i < p->num_answers; i++) |
860 | GNUNET_DNSPARSER_free_record (&p->answers[i]); | 874 | GNUNET_DNSPARSER_free_record(&p->answers[i]); |
861 | GNUNET_free_non_null (p->answers); | 875 | GNUNET_free_non_null(p->answers); |
862 | for (unsigned int i = 0; i < p->num_authority_records; i++) | 876 | for (unsigned int i = 0; i < p->num_authority_records; i++) |
863 | GNUNET_DNSPARSER_free_record (&p->authority_records[i]); | 877 | GNUNET_DNSPARSER_free_record(&p->authority_records[i]); |
864 | GNUNET_free_non_null (p->authority_records); | 878 | GNUNET_free_non_null(p->authority_records); |
865 | for (unsigned int i = 0; i < p->num_additional_records; i++) | 879 | for (unsigned int i = 0; i < p->num_additional_records; i++) |
866 | GNUNET_DNSPARSER_free_record (&p->additional_records[i]); | 880 | GNUNET_DNSPARSER_free_record(&p->additional_records[i]); |
867 | GNUNET_free_non_null (p->additional_records); | 881 | GNUNET_free_non_null(p->additional_records); |
868 | GNUNET_free (p); | 882 | GNUNET_free(p); |
869 | } | 883 | } |
870 | 884 | ||
871 | 885 | ||
@@ -886,10 +900,10 @@ GNUNET_DNSPARSER_free_packet (struct GNUNET_DNSPARSER_Packet *p) | |||
886 | * #GNUNET_OK if @a name was added to @a dst | 900 | * #GNUNET_OK if @a name was added to @a dst |
887 | */ | 901 | */ |
888 | int | 902 | int |
889 | GNUNET_DNSPARSER_builder_add_name (char *dst, | 903 | GNUNET_DNSPARSER_builder_add_name(char *dst, |
890 | size_t dst_len, | 904 | size_t dst_len, |
891 | size_t *off, | 905 | size_t *off, |
892 | const char *name) | 906 | const char *name) |
893 | { | 907 | { |
894 | const char *dot; | 908 | const char *dot; |
895 | const char *idna_name; | 909 | const char *idna_name; |
@@ -903,53 +917,54 @@ GNUNET_DNSPARSER_builder_add_name (char *dst, | |||
903 | return GNUNET_SYSERR; | 917 | return GNUNET_SYSERR; |
904 | 918 | ||
905 | if (IDNA_SUCCESS != | 919 | if (IDNA_SUCCESS != |
906 | (rc = idna_to_ascii_8z (name, &idna_start, IDNA_ALLOW_UNASSIGNED))) | 920 | (rc = idna_to_ascii_8z(name, &idna_start, IDNA_ALLOW_UNASSIGNED))) |
907 | { | 921 | { |
908 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | 922 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, |
909 | _ ( | 923 | _( |
910 | "Failed to convert UTF-8 name `%s' to DNS IDNA format: %s\n"), | 924 | "Failed to convert UTF-8 name `%s' to DNS IDNA format: %s\n"), |
911 | name, | 925 | name, |
912 | idna_strerror (rc)); | 926 | idna_strerror(rc)); |
913 | return GNUNET_NO; | 927 | return GNUNET_NO; |
914 | } | 928 | } |
915 | idna_name = idna_start; | 929 | idna_name = idna_start; |
916 | start = *off; | 930 | start = *off; |
917 | if (start + strlen (idna_name) + 2 > dst_len) | 931 | if (start + strlen(idna_name) + 2 > dst_len) |
918 | goto fail; | 932 | goto fail; |
919 | pos = start; | 933 | pos = start; |
920 | do | 934 | do |
921 | { | ||
922 | dot = strchr (idna_name, '.'); | ||
923 | if (NULL == dot) | ||
924 | len = strlen (idna_name); | ||
925 | else | ||
926 | len = dot - idna_name; | ||
927 | if ((len >= 64) || (0 == len)) | ||
928 | { | 935 | { |
929 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 936 | dot = strchr(idna_name, '.'); |
930 | "Invalid DNS name `%s': label with %u characters encountered\n", | 937 | if (NULL == dot) |
931 | name, | 938 | len = strlen(idna_name); |
932 | (unsigned int) len); | 939 | else |
933 | goto fail; /* label too long or empty */ | 940 | len = dot - idna_name; |
941 | if ((len >= 64) || (0 == len)) | ||
942 | { | ||
943 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | ||
944 | "Invalid DNS name `%s': label with %u characters encountered\n", | ||
945 | name, | ||
946 | (unsigned int)len); | ||
947 | goto fail; /* label too long or empty */ | ||
948 | } | ||
949 | dst[pos++] = (char)(uint8_t)len; | ||
950 | GNUNET_memcpy(&dst[pos], idna_name, len); | ||
951 | pos += len; | ||
952 | idna_name += len + 1; /* also skip dot */ | ||
934 | } | 953 | } |
935 | dst[pos++] = (char) (uint8_t) len; | 954 | while (NULL != dot); |
936 | GNUNET_memcpy (&dst[pos], idna_name, len); | ||
937 | pos += len; | ||
938 | idna_name += len + 1; /* also skip dot */ | ||
939 | } while (NULL != dot); | ||
940 | dst[pos++] = '\0'; /* terminator */ | 955 | dst[pos++] = '\0'; /* terminator */ |
941 | *off = pos; | 956 | *off = pos; |
942 | #if WINDOWS | 957 | #if WINDOWS |
943 | idn_free (idna_start); | 958 | idn_free(idna_start); |
944 | #else | 959 | #else |
945 | free (idna_start); | 960 | free(idna_start); |
946 | #endif | 961 | #endif |
947 | return GNUNET_OK; | 962 | return GNUNET_OK; |
948 | fail: | 963 | fail: |
949 | #if WINDOWS | 964 | #if WINDOWS |
950 | idn_free (idna_start); | 965 | idn_free(idna_start); |
951 | #else | 966 | #else |
952 | free (idna_start); | 967 | free(idna_start); |
953 | #endif | 968 | #endif |
954 | return GNUNET_NO; | 969 | return GNUNET_NO; |
955 | } | 970 | } |
@@ -968,26 +983,26 @@ fail: | |||
968 | * #GNUNET_OK if @a query was added to @a dst | 983 | * #GNUNET_OK if @a query was added to @a dst |
969 | */ | 984 | */ |
970 | int | 985 | int |
971 | GNUNET_DNSPARSER_builder_add_query (char *dst, | 986 | GNUNET_DNSPARSER_builder_add_query(char *dst, |
972 | size_t dst_len, | 987 | size_t dst_len, |
973 | size_t *off, | 988 | size_t *off, |
974 | const struct GNUNET_DNSPARSER_Query *query) | 989 | const struct GNUNET_DNSPARSER_Query *query) |
975 | { | 990 | { |
976 | int ret; | 991 | int ret; |
977 | struct GNUNET_TUN_DnsQueryLine ql; | 992 | struct GNUNET_TUN_DnsQueryLine ql; |
978 | 993 | ||
979 | ret = GNUNET_DNSPARSER_builder_add_name (dst, | 994 | ret = GNUNET_DNSPARSER_builder_add_name(dst, |
980 | dst_len - | 995 | dst_len - |
981 | sizeof ( | 996 | sizeof( |
982 | struct GNUNET_TUN_DnsQueryLine), | 997 | struct GNUNET_TUN_DnsQueryLine), |
983 | off, | 998 | off, |
984 | query->name); | 999 | query->name); |
985 | if (ret != GNUNET_OK) | 1000 | if (ret != GNUNET_OK) |
986 | return ret; | 1001 | return ret; |
987 | ql.type = htons (query->type); | 1002 | ql.type = htons(query->type); |
988 | ql.dns_traffic_class = htons (query->dns_traffic_class); | 1003 | ql.dns_traffic_class = htons(query->dns_traffic_class); |
989 | GNUNET_memcpy (&dst[*off], &ql, sizeof (ql)); | 1004 | GNUNET_memcpy(&dst[*off], &ql, sizeof(ql)); |
990 | (*off) += sizeof (ql); | 1005 | (*off) += sizeof(ql); |
991 | return GNUNET_OK; | 1006 | return GNUNET_OK; |
992 | } | 1007 | } |
993 | 1008 | ||
@@ -1005,19 +1020,19 @@ GNUNET_DNSPARSER_builder_add_query (char *dst, | |||
1005 | * #GNUNET_OK if @a mx was added to @a dst | 1020 | * #GNUNET_OK if @a mx was added to @a dst |
1006 | */ | 1021 | */ |
1007 | int | 1022 | int |
1008 | GNUNET_DNSPARSER_builder_add_mx (char *dst, | 1023 | GNUNET_DNSPARSER_builder_add_mx(char *dst, |
1009 | size_t dst_len, | 1024 | size_t dst_len, |
1010 | size_t *off, | 1025 | size_t *off, |
1011 | const struct GNUNET_DNSPARSER_MxRecord *mx) | 1026 | const struct GNUNET_DNSPARSER_MxRecord *mx) |
1012 | { | 1027 | { |
1013 | uint16_t mxpref; | 1028 | uint16_t mxpref; |
1014 | 1029 | ||
1015 | if (*off + sizeof (uint16_t) > dst_len) | 1030 | if (*off + sizeof(uint16_t) > dst_len) |
1016 | return GNUNET_NO; | 1031 | return GNUNET_NO; |
1017 | mxpref = htons (mx->preference); | 1032 | mxpref = htons(mx->preference); |
1018 | GNUNET_memcpy (&dst[*off], &mxpref, sizeof (mxpref)); | 1033 | GNUNET_memcpy(&dst[*off], &mxpref, sizeof(mxpref)); |
1019 | (*off) += sizeof (mxpref); | 1034 | (*off) += sizeof(mxpref); |
1020 | return GNUNET_DNSPARSER_builder_add_name (dst, dst_len, off, mx->mxhost); | 1035 | return GNUNET_DNSPARSER_builder_add_name(dst, dst_len, off, mx->mxhost); |
1021 | } | 1036 | } |
1022 | 1037 | ||
1023 | 1038 | ||
@@ -1034,7 +1049,7 @@ GNUNET_DNSPARSER_builder_add_mx (char *dst, | |||
1034 | * #GNUNET_OK if @a cert was added to @a dst | 1049 | * #GNUNET_OK if @a cert was added to @a dst |
1035 | */ | 1050 | */ |
1036 | int | 1051 | int |
1037 | GNUNET_DNSPARSER_builder_add_cert ( | 1052 | GNUNET_DNSPARSER_builder_add_cert( |
1038 | char *dst, | 1053 | char *dst, |
1039 | size_t dst_len, | 1054 | size_t dst_len, |
1040 | size_t *off, | 1055 | size_t *off, |
@@ -1047,22 +1062,22 @@ GNUNET_DNSPARSER_builder_add_cert ( | |||
1047 | #pragma clang diagnostic ignored "-Wtautological-constant-out-of-range-compare" | 1062 | #pragma clang diagnostic ignored "-Wtautological-constant-out-of-range-compare" |
1048 | #endif | 1063 | #endif |
1049 | if ((cert->cert_type > UINT16_MAX) || (cert->algorithm > UINT8_MAX)) | 1064 | if ((cert->cert_type > UINT16_MAX) || (cert->algorithm > UINT8_MAX)) |
1050 | { | 1065 | { |
1051 | GNUNET_break (0); | 1066 | GNUNET_break(0); |
1052 | return GNUNET_SYSERR; | 1067 | return GNUNET_SYSERR; |
1053 | } | 1068 | } |
1054 | #ifdef __clang__ | 1069 | #ifdef __clang__ |
1055 | #pragma clang diagnostic pop | 1070 | #pragma clang diagnostic pop |
1056 | #endif | 1071 | #endif |
1057 | if (*off + sizeof (struct GNUNET_TUN_DnsCertRecord) + cert->certificate_size > | 1072 | if (*off + sizeof(struct GNUNET_TUN_DnsCertRecord) + cert->certificate_size > |
1058 | dst_len) | 1073 | dst_len) |
1059 | return GNUNET_NO; | 1074 | return GNUNET_NO; |
1060 | dcert.cert_type = htons ((uint16_t) cert->cert_type); | 1075 | dcert.cert_type = htons((uint16_t)cert->cert_type); |
1061 | dcert.cert_tag = htons ((uint16_t) cert->cert_tag); | 1076 | dcert.cert_tag = htons((uint16_t)cert->cert_tag); |
1062 | dcert.algorithm = (uint8_t) cert->algorithm; | 1077 | dcert.algorithm = (uint8_t)cert->algorithm; |
1063 | GNUNET_memcpy (&dst[*off], &dcert, sizeof (dcert)); | 1078 | GNUNET_memcpy(&dst[*off], &dcert, sizeof(dcert)); |
1064 | (*off) += sizeof (dcert); | 1079 | (*off) += sizeof(dcert); |
1065 | GNUNET_memcpy (&dst[*off], cert->certificate_data, cert->certificate_size); | 1080 | GNUNET_memcpy(&dst[*off], cert->certificate_data, cert->certificate_size); |
1066 | (*off) += cert->certificate_size; | 1081 | (*off) += cert->certificate_size; |
1067 | return GNUNET_OK; | 1082 | return GNUNET_OK; |
1068 | } | 1083 | } |
@@ -1081,30 +1096,30 @@ GNUNET_DNSPARSER_builder_add_cert ( | |||
1081 | * #GNUNET_OK if @a soa was added to @a dst | 1096 | * #GNUNET_OK if @a soa was added to @a dst |
1082 | */ | 1097 | */ |
1083 | int | 1098 | int |
1084 | GNUNET_DNSPARSER_builder_add_soa (char *dst, | 1099 | GNUNET_DNSPARSER_builder_add_soa(char *dst, |
1085 | size_t dst_len, | 1100 | size_t dst_len, |
1086 | size_t *off, | 1101 | size_t *off, |
1087 | const struct GNUNET_DNSPARSER_SoaRecord *soa) | 1102 | const struct GNUNET_DNSPARSER_SoaRecord *soa) |
1088 | { | 1103 | { |
1089 | struct GNUNET_TUN_DnsSoaRecord sd; | 1104 | struct GNUNET_TUN_DnsSoaRecord sd; |
1090 | int ret; | 1105 | int ret; |
1091 | 1106 | ||
1092 | if ((GNUNET_OK != | 1107 | if ((GNUNET_OK != |
1093 | (ret = | 1108 | (ret = |
1094 | GNUNET_DNSPARSER_builder_add_name (dst, dst_len, off, soa->mname))) || | 1109 | GNUNET_DNSPARSER_builder_add_name(dst, dst_len, off, soa->mname))) || |
1095 | (GNUNET_OK != | 1110 | (GNUNET_OK != |
1096 | (ret = | 1111 | (ret = |
1097 | GNUNET_DNSPARSER_builder_add_name (dst, dst_len, off, soa->rname)))) | 1112 | GNUNET_DNSPARSER_builder_add_name(dst, dst_len, off, soa->rname)))) |
1098 | return ret; | 1113 | return ret; |
1099 | if (*off + sizeof (struct GNUNET_TUN_DnsSoaRecord) > dst_len) | 1114 | if (*off + sizeof(struct GNUNET_TUN_DnsSoaRecord) > dst_len) |
1100 | return GNUNET_NO; | 1115 | return GNUNET_NO; |
1101 | sd.serial = htonl (soa->serial); | 1116 | sd.serial = htonl(soa->serial); |
1102 | sd.refresh = htonl (soa->refresh); | 1117 | sd.refresh = htonl(soa->refresh); |
1103 | sd.retry = htonl (soa->retry); | 1118 | sd.retry = htonl(soa->retry); |
1104 | sd.expire = htonl (soa->expire); | 1119 | sd.expire = htonl(soa->expire); |
1105 | sd.minimum = htonl (soa->minimum_ttl); | 1120 | sd.minimum = htonl(soa->minimum_ttl); |
1106 | GNUNET_memcpy (&dst[*off], &sd, sizeof (sd)); | 1121 | GNUNET_memcpy(&dst[*off], &sd, sizeof(sd)); |
1107 | (*off) += sizeof (sd); | 1122 | (*off) += sizeof(sd); |
1108 | return GNUNET_OK; | 1123 | return GNUNET_OK; |
1109 | } | 1124 | } |
1110 | 1125 | ||
@@ -1122,24 +1137,24 @@ GNUNET_DNSPARSER_builder_add_soa (char *dst, | |||
1122 | * #GNUNET_OK if @a srv was added to @a dst | 1137 | * #GNUNET_OK if @a srv was added to @a dst |
1123 | */ | 1138 | */ |
1124 | int | 1139 | int |
1125 | GNUNET_DNSPARSER_builder_add_srv (char *dst, | 1140 | GNUNET_DNSPARSER_builder_add_srv(char *dst, |
1126 | size_t dst_len, | 1141 | size_t dst_len, |
1127 | size_t *off, | 1142 | size_t *off, |
1128 | const struct GNUNET_DNSPARSER_SrvRecord *srv) | 1143 | const struct GNUNET_DNSPARSER_SrvRecord *srv) |
1129 | { | 1144 | { |
1130 | struct GNUNET_TUN_DnsSrvRecord sd; | 1145 | struct GNUNET_TUN_DnsSrvRecord sd; |
1131 | int ret; | 1146 | int ret; |
1132 | 1147 | ||
1133 | if (*off + sizeof (struct GNUNET_TUN_DnsSrvRecord) > dst_len) | 1148 | if (*off + sizeof(struct GNUNET_TUN_DnsSrvRecord) > dst_len) |
1134 | return GNUNET_NO; | 1149 | return GNUNET_NO; |
1135 | sd.prio = htons (srv->priority); | 1150 | sd.prio = htons(srv->priority); |
1136 | sd.weight = htons (srv->weight); | 1151 | sd.weight = htons(srv->weight); |
1137 | sd.port = htons (srv->port); | 1152 | sd.port = htons(srv->port); |
1138 | GNUNET_memcpy (&dst[*off], &sd, sizeof (sd)); | 1153 | GNUNET_memcpy(&dst[*off], &sd, sizeof(sd)); |
1139 | (*off) += sizeof (sd); | 1154 | (*off) += sizeof(sd); |
1140 | if (GNUNET_OK != | 1155 | if (GNUNET_OK != |
1141 | (ret = | 1156 | (ret = |
1142 | GNUNET_DNSPARSER_builder_add_name (dst, dst_len, off, srv->target))) | 1157 | GNUNET_DNSPARSER_builder_add_name(dst, dst_len, off, srv->target))) |
1143 | return ret; | 1158 | return ret; |
1144 | return GNUNET_OK; | 1159 | return GNUNET_OK; |
1145 | } | 1160 | } |
@@ -1158,10 +1173,10 @@ GNUNET_DNSPARSER_builder_add_srv (char *dst, | |||
1158 | * #GNUNET_OK if @a record was added to @a dst | 1173 | * #GNUNET_OK if @a record was added to @a dst |
1159 | */ | 1174 | */ |
1160 | static int | 1175 | static int |
1161 | add_record (char *dst, | 1176 | add_record(char *dst, |
1162 | size_t dst_len, | 1177 | size_t dst_len, |
1163 | size_t *off, | 1178 | size_t *off, |
1164 | const struct GNUNET_DNSPARSER_Record *record) | 1179 | const struct GNUNET_DNSPARSER_Record *record) |
1165 | { | 1180 | { |
1166 | int ret; | 1181 | int ret; |
1167 | size_t start; | 1182 | size_t start; |
@@ -1169,73 +1184,78 @@ add_record (char *dst, | |||
1169 | struct GNUNET_TUN_DnsRecordLine rl; | 1184 | struct GNUNET_TUN_DnsRecordLine rl; |
1170 | 1185 | ||
1171 | start = *off; | 1186 | start = *off; |
1172 | ret = GNUNET_DNSPARSER_builder_add_name (dst, | 1187 | ret = GNUNET_DNSPARSER_builder_add_name(dst, |
1173 | dst_len - | 1188 | dst_len - |
1174 | sizeof ( | 1189 | sizeof( |
1175 | struct GNUNET_TUN_DnsRecordLine), | 1190 | struct GNUNET_TUN_DnsRecordLine), |
1176 | off, | 1191 | off, |
1177 | record->name); | 1192 | record->name); |
1178 | if (GNUNET_OK != ret) | 1193 | if (GNUNET_OK != ret) |
1179 | return ret; | 1194 | return ret; |
1180 | /* '*off' is now the position where we will need to write the record line */ | 1195 | /* '*off' is now the position where we will need to write the record line */ |
1181 | 1196 | ||
1182 | pos = *off + sizeof (struct GNUNET_TUN_DnsRecordLine); | 1197 | pos = *off + sizeof(struct GNUNET_TUN_DnsRecordLine); |
1183 | switch (record->type) | 1198 | switch (record->type) |
1184 | { | ||
1185 | case GNUNET_DNSPARSER_TYPE_MX: | ||
1186 | ret = GNUNET_DNSPARSER_builder_add_mx (dst, dst_len, &pos, record->data.mx); | ||
1187 | break; | ||
1188 | case GNUNET_DNSPARSER_TYPE_CERT: | ||
1189 | ret = | ||
1190 | GNUNET_DNSPARSER_builder_add_cert (dst, dst_len, &pos, record->data.cert); | ||
1191 | break; | ||
1192 | case GNUNET_DNSPARSER_TYPE_SOA: | ||
1193 | ret = | ||
1194 | GNUNET_DNSPARSER_builder_add_soa (dst, dst_len, &pos, record->data.soa); | ||
1195 | break; | ||
1196 | case GNUNET_DNSPARSER_TYPE_NS: | ||
1197 | case GNUNET_DNSPARSER_TYPE_CNAME: | ||
1198 | case GNUNET_DNSPARSER_TYPE_PTR: | ||
1199 | ret = GNUNET_DNSPARSER_builder_add_name (dst, | ||
1200 | dst_len, | ||
1201 | &pos, | ||
1202 | record->data.hostname); | ||
1203 | break; | ||
1204 | case GNUNET_DNSPARSER_TYPE_SRV: | ||
1205 | ret = | ||
1206 | GNUNET_DNSPARSER_builder_add_srv (dst, dst_len, &pos, record->data.srv); | ||
1207 | break; | ||
1208 | default: | ||
1209 | if (pos + record->data.raw.data_len > dst_len) | ||
1210 | { | 1199 | { |
1211 | ret = GNUNET_NO; | 1200 | case GNUNET_DNSPARSER_TYPE_MX: |
1201 | ret = GNUNET_DNSPARSER_builder_add_mx(dst, dst_len, &pos, record->data.mx); | ||
1202 | break; | ||
1203 | |||
1204 | case GNUNET_DNSPARSER_TYPE_CERT: | ||
1205 | ret = | ||
1206 | GNUNET_DNSPARSER_builder_add_cert(dst, dst_len, &pos, record->data.cert); | ||
1207 | break; | ||
1208 | |||
1209 | case GNUNET_DNSPARSER_TYPE_SOA: | ||
1210 | ret = | ||
1211 | GNUNET_DNSPARSER_builder_add_soa(dst, dst_len, &pos, record->data.soa); | ||
1212 | break; | ||
1213 | |||
1214 | case GNUNET_DNSPARSER_TYPE_NS: | ||
1215 | case GNUNET_DNSPARSER_TYPE_CNAME: | ||
1216 | case GNUNET_DNSPARSER_TYPE_PTR: | ||
1217 | ret = GNUNET_DNSPARSER_builder_add_name(dst, | ||
1218 | dst_len, | ||
1219 | &pos, | ||
1220 | record->data.hostname); | ||
1221 | break; | ||
1222 | |||
1223 | case GNUNET_DNSPARSER_TYPE_SRV: | ||
1224 | ret = | ||
1225 | GNUNET_DNSPARSER_builder_add_srv(dst, dst_len, &pos, record->data.srv); | ||
1226 | break; | ||
1227 | |||
1228 | default: | ||
1229 | if (pos + record->data.raw.data_len > dst_len) | ||
1230 | { | ||
1231 | ret = GNUNET_NO; | ||
1232 | break; | ||
1233 | } | ||
1234 | GNUNET_memcpy(&dst[pos], record->data.raw.data, record->data.raw.data_len); | ||
1235 | pos += record->data.raw.data_len; | ||
1236 | ret = GNUNET_OK; | ||
1212 | break; | 1237 | break; |
1213 | } | 1238 | } |
1214 | GNUNET_memcpy (&dst[pos], record->data.raw.data, record->data.raw.data_len); | ||
1215 | pos += record->data.raw.data_len; | ||
1216 | ret = GNUNET_OK; | ||
1217 | break; | ||
1218 | } | ||
1219 | if (GNUNET_OK != ret) | 1239 | if (GNUNET_OK != ret) |
1220 | { | 1240 | { |
1221 | *off = start; | 1241 | *off = start; |
1222 | return GNUNET_NO; | 1242 | return GNUNET_NO; |
1223 | } | 1243 | } |
1224 | 1244 | ||
1225 | if (pos - (*off + sizeof (struct GNUNET_TUN_DnsRecordLine)) > UINT16_MAX) | 1245 | if (pos - (*off + sizeof(struct GNUNET_TUN_DnsRecordLine)) > UINT16_MAX) |
1226 | { | 1246 | { |
1227 | /* record data too long */ | 1247 | /* record data too long */ |
1228 | *off = start; | 1248 | *off = start; |
1229 | return GNUNET_NO; | 1249 | return GNUNET_NO; |
1230 | } | 1250 | } |
1231 | rl.type = htons (record->type); | 1251 | rl.type = htons(record->type); |
1232 | rl.dns_traffic_class = htons (record->dns_traffic_class); | 1252 | rl.dns_traffic_class = htons(record->dns_traffic_class); |
1233 | rl.ttl = htonl ( | 1253 | rl.ttl = htonl( |
1234 | GNUNET_TIME_absolute_get_remaining (record->expiration_time).rel_value_us / | 1254 | GNUNET_TIME_absolute_get_remaining(record->expiration_time).rel_value_us / |
1235 | 1000LL / 1000LL); /* in seconds */ | 1255 | 1000LL / 1000LL); /* in seconds */ |
1236 | rl.data_len = htons ( | 1256 | rl.data_len = htons( |
1237 | (uint16_t) (pos - (*off + sizeof (struct GNUNET_TUN_DnsRecordLine)))); | 1257 | (uint16_t)(pos - (*off + sizeof(struct GNUNET_TUN_DnsRecordLine)))); |
1238 | GNUNET_memcpy (&dst[*off], &rl, sizeof (struct GNUNET_TUN_DnsRecordLine)); | 1258 | GNUNET_memcpy(&dst[*off], &rl, sizeof(struct GNUNET_TUN_DnsRecordLine)); |
1239 | *off = pos; | 1259 | *off = pos; |
1240 | return GNUNET_OK; | 1260 | return GNUNET_OK; |
1241 | } | 1261 | } |
@@ -1256,10 +1276,10 @@ add_record (char *dst, | |||
1256 | * #GNUNET_OK if @a p was packed completely into @a buf | 1276 | * #GNUNET_OK if @a p was packed completely into @a buf |
1257 | */ | 1277 | */ |
1258 | int | 1278 | int |
1259 | GNUNET_DNSPARSER_pack (const struct GNUNET_DNSPARSER_Packet *p, | 1279 | GNUNET_DNSPARSER_pack(const struct GNUNET_DNSPARSER_Packet *p, |
1260 | uint16_t max, | 1280 | uint16_t max, |
1261 | char **buf, | 1281 | char **buf, |
1262 | size_t *buf_length) | 1282 | size_t *buf_length) |
1263 | { | 1283 | { |
1264 | struct GNUNET_TUN_DnsHeader dns; | 1284 | struct GNUNET_TUN_DnsHeader dns; |
1265 | size_t off; | 1285 | size_t off; |
@@ -1273,72 +1293,72 @@ GNUNET_DNSPARSER_pack (const struct GNUNET_DNSPARSER_Packet *p, | |||
1273 | return GNUNET_SYSERR; | 1293 | return GNUNET_SYSERR; |
1274 | dns.id = p->id; | 1294 | dns.id = p->id; |
1275 | dns.flags = p->flags; | 1295 | dns.flags = p->flags; |
1276 | dns.query_count = htons (p->num_queries); | 1296 | dns.query_count = htons(p->num_queries); |
1277 | dns.answer_rcount = htons (p->num_answers); | 1297 | dns.answer_rcount = htons(p->num_answers); |
1278 | dns.authority_rcount = htons (p->num_authority_records); | 1298 | dns.authority_rcount = htons(p->num_authority_records); |
1279 | dns.additional_rcount = htons (p->num_additional_records); | 1299 | dns.additional_rcount = htons(p->num_additional_records); |
1280 | 1300 | ||
1281 | off = sizeof (struct GNUNET_TUN_DnsHeader); | 1301 | off = sizeof(struct GNUNET_TUN_DnsHeader); |
1282 | trc = GNUNET_NO; | 1302 | trc = GNUNET_NO; |
1283 | for (unsigned int i = 0; i < p->num_queries; i++) | 1303 | for (unsigned int i = 0; i < p->num_queries; i++) |
1284 | { | ||
1285 | ret = GNUNET_DNSPARSER_builder_add_query (tmp, | ||
1286 | sizeof (tmp), | ||
1287 | &off, | ||
1288 | &p->queries[i]); | ||
1289 | if (GNUNET_SYSERR == ret) | ||
1290 | return GNUNET_SYSERR; | ||
1291 | if (GNUNET_NO == ret) | ||
1292 | { | 1304 | { |
1293 | dns.query_count = htons ((uint16_t) (i - 1)); | 1305 | ret = GNUNET_DNSPARSER_builder_add_query(tmp, |
1294 | trc = GNUNET_YES; | 1306 | sizeof(tmp), |
1295 | break; | 1307 | &off, |
1308 | &p->queries[i]); | ||
1309 | if (GNUNET_SYSERR == ret) | ||
1310 | return GNUNET_SYSERR; | ||
1311 | if (GNUNET_NO == ret) | ||
1312 | { | ||
1313 | dns.query_count = htons((uint16_t)(i - 1)); | ||
1314 | trc = GNUNET_YES; | ||
1315 | break; | ||
1316 | } | ||
1296 | } | 1317 | } |
1297 | } | ||
1298 | for (unsigned int i = 0; i < p->num_answers; i++) | 1318 | for (unsigned int i = 0; i < p->num_answers; i++) |
1299 | { | ||
1300 | ret = add_record (tmp, sizeof (tmp), &off, &p->answers[i]); | ||
1301 | if (GNUNET_SYSERR == ret) | ||
1302 | return GNUNET_SYSERR; | ||
1303 | if (GNUNET_NO == ret) | ||
1304 | { | 1319 | { |
1305 | dns.answer_rcount = htons ((uint16_t) (i - 1)); | 1320 | ret = add_record(tmp, sizeof(tmp), &off, &p->answers[i]); |
1306 | trc = GNUNET_YES; | 1321 | if (GNUNET_SYSERR == ret) |
1307 | break; | 1322 | return GNUNET_SYSERR; |
1323 | if (GNUNET_NO == ret) | ||
1324 | { | ||
1325 | dns.answer_rcount = htons((uint16_t)(i - 1)); | ||
1326 | trc = GNUNET_YES; | ||
1327 | break; | ||
1328 | } | ||
1308 | } | 1329 | } |
1309 | } | ||
1310 | for (unsigned int i = 0; i < p->num_authority_records; i++) | 1330 | for (unsigned int i = 0; i < p->num_authority_records; i++) |
1311 | { | ||
1312 | ret = add_record (tmp, sizeof (tmp), &off, &p->authority_records[i]); | ||
1313 | if (GNUNET_SYSERR == ret) | ||
1314 | return GNUNET_SYSERR; | ||
1315 | if (GNUNET_NO == ret) | ||
1316 | { | 1331 | { |
1317 | dns.authority_rcount = htons ((uint16_t) (i - 1)); | 1332 | ret = add_record(tmp, sizeof(tmp), &off, &p->authority_records[i]); |
1318 | trc = GNUNET_YES; | 1333 | if (GNUNET_SYSERR == ret) |
1319 | break; | 1334 | return GNUNET_SYSERR; |
1335 | if (GNUNET_NO == ret) | ||
1336 | { | ||
1337 | dns.authority_rcount = htons((uint16_t)(i - 1)); | ||
1338 | trc = GNUNET_YES; | ||
1339 | break; | ||
1340 | } | ||
1320 | } | 1341 | } |
1321 | } | ||
1322 | for (unsigned int i = 0; i < p->num_additional_records; i++) | 1342 | for (unsigned int i = 0; i < p->num_additional_records; i++) |
1323 | { | ||
1324 | ret = add_record (tmp, sizeof (tmp), &off, &p->additional_records[i]); | ||
1325 | if (GNUNET_SYSERR == ret) | ||
1326 | return GNUNET_SYSERR; | ||
1327 | if (GNUNET_NO == ret) | ||
1328 | { | 1343 | { |
1329 | dns.additional_rcount = htons (i - 1); | 1344 | ret = add_record(tmp, sizeof(tmp), &off, &p->additional_records[i]); |
1330 | trc = GNUNET_YES; | 1345 | if (GNUNET_SYSERR == ret) |
1331 | break; | 1346 | return GNUNET_SYSERR; |
1347 | if (GNUNET_NO == ret) | ||
1348 | { | ||
1349 | dns.additional_rcount = htons(i - 1); | ||
1350 | trc = GNUNET_YES; | ||
1351 | break; | ||
1352 | } | ||
1332 | } | 1353 | } |
1333 | } | ||
1334 | 1354 | ||
1335 | if (GNUNET_YES == trc) | 1355 | if (GNUNET_YES == trc) |
1336 | dns.flags.message_truncated = 1; | 1356 | dns.flags.message_truncated = 1; |
1337 | GNUNET_memcpy (tmp, &dns, sizeof (struct GNUNET_TUN_DnsHeader)); | 1357 | GNUNET_memcpy(tmp, &dns, sizeof(struct GNUNET_TUN_DnsHeader)); |
1338 | 1358 | ||
1339 | *buf = GNUNET_malloc (off); | 1359 | *buf = GNUNET_malloc(off); |
1340 | *buf_length = off; | 1360 | *buf_length = off; |
1341 | GNUNET_memcpy (*buf, tmp, off); | 1361 | GNUNET_memcpy(*buf, tmp, off); |
1342 | if (GNUNET_YES == trc) | 1362 | if (GNUNET_YES == trc) |
1343 | return GNUNET_NO; | 1363 | return GNUNET_NO; |
1344 | return GNUNET_OK; | 1364 | return GNUNET_OK; |
@@ -1353,16 +1373,16 @@ GNUNET_DNSPARSER_pack (const struct GNUNET_DNSPARSER_Packet *p, | |||
1353 | * @return HEX string (lower case) | 1373 | * @return HEX string (lower case) |
1354 | */ | 1374 | */ |
1355 | char * | 1375 | char * |
1356 | GNUNET_DNSPARSER_bin_to_hex (const void *data, size_t data_size) | 1376 | GNUNET_DNSPARSER_bin_to_hex(const void *data, size_t data_size) |
1357 | { | 1377 | { |
1358 | char *ret; | 1378 | char *ret; |
1359 | size_t off; | 1379 | size_t off; |
1360 | const uint8_t *idata; | 1380 | const uint8_t *idata; |
1361 | 1381 | ||
1362 | idata = data; | 1382 | idata = data; |
1363 | ret = GNUNET_malloc (data_size * 2 + 1); | 1383 | ret = GNUNET_malloc(data_size * 2 + 1); |
1364 | for (off = 0; off < data_size; off++) | 1384 | for (off = 0; off < data_size; off++) |
1365 | sprintf (&ret[off * 2], "%02x", idata[off]); | 1385 | sprintf(&ret[off * 2], "%02x", idata[off]); |
1366 | return ret; | 1386 | return ret; |
1367 | } | 1387 | } |
1368 | 1388 | ||
@@ -1376,7 +1396,7 @@ GNUNET_DNSPARSER_bin_to_hex (const void *data, size_t data_size) | |||
1376 | * @return number of bytes written to data | 1396 | * @return number of bytes written to data |
1377 | */ | 1397 | */ |
1378 | size_t | 1398 | size_t |
1379 | GNUNET_DNSPARSER_hex_to_bin (const char *hex, void *data) | 1399 | GNUNET_DNSPARSER_hex_to_bin(const char *hex, void *data) |
1380 | { | 1400 | { |
1381 | size_t data_size; | 1401 | size_t data_size; |
1382 | size_t off; | 1402 | size_t off; |
@@ -1384,17 +1404,17 @@ GNUNET_DNSPARSER_hex_to_bin (const char *hex, void *data) | |||
1384 | unsigned int h; | 1404 | unsigned int h; |
1385 | char in[3]; | 1405 | char in[3]; |
1386 | 1406 | ||
1387 | data_size = strlen (hex) / 2; | 1407 | data_size = strlen(hex) / 2; |
1388 | idata = data; | 1408 | idata = data; |
1389 | in[2] = '\0'; | 1409 | in[2] = '\0'; |
1390 | for (off = 0; off < data_size; off++) | 1410 | for (off = 0; off < data_size; off++) |
1391 | { | 1411 | { |
1392 | in[0] = tolower ((unsigned char) hex[off * 2]); | 1412 | in[0] = tolower((unsigned char)hex[off * 2]); |
1393 | in[1] = tolower ((unsigned char) hex[off * 2 + 1]); | 1413 | in[1] = tolower((unsigned char)hex[off * 2 + 1]); |
1394 | if (1 != sscanf (in, "%x", &h)) | 1414 | if (1 != sscanf(in, "%x", &h)) |
1395 | return off; | 1415 | return off; |
1396 | idata[off] = (uint8_t) h; | 1416 | idata[off] = (uint8_t)h; |
1397 | } | 1417 | } |
1398 | return off; | 1418 | return off; |
1399 | } | 1419 | } |
1400 | 1420 | ||