?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add BIND 9.2.4rc7.
[dragonfly.git] / contrib / bind-9.2.4rc7 / lib / dns / rdata / generic / loc_29.c
blobde9aaf2909303f8c7e1f33b4392a065abe449337
1 /*
2 * Copyright (C) 2004 Internet Systems Consortium, Inc. ("ISC")
3 * Copyright (C) 1999-2003 Internet Software Consortium.
4 *
5 * Permission to use, copy, modify, and distribute this software for any
6 * purpose with or without fee is hereby granted, provided that the above
7 * copyright notice and this permission notice appear in all copies.
8 *
9 * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
10 * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
11 * AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
12 * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
13 * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
14 * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
15 * PERFORMANCE OF THIS SOFTWARE.
16 */
17
18 /* $Id: loc_29.c,v 1.30.2.5 2004/03/09 06:11:29 marka Exp $ */
19
20 /* Reviewed: Wed Mar 15 18:13:09 PST 2000 by explorer */
21
22 /* RFC 1876 */
23
24 #ifndef RDATA_GENERIC_LOC_29_C
25 #define RDATA_GENERIC_LOC_29_C
26
27 #define RRTYPE_LOC_ATTRIBUTES (0)
28
29 static inline isc_result_t
30 fromtext_loc(ARGS_FROMTEXT) {
31 isc_token_t token;
32 int d1, m1, s1;
33 int d2, m2, s2;
34 unsigned char size;
35 unsigned char hp;
36 unsigned char vp;
37 unsigned char version;
38 isc_boolean_t east = ISC_FALSE;
39 isc_boolean_t north = ISC_FALSE;
40 long tmp;
41 long m;
42 long cm;
43 long poweroften[8] = { 1, 10, 100, 1000,
44 10000, 100000, 1000000, 10000000 };
45 int man;
46 int exp;
47 char *e;
48 int i;
49 unsigned long latitude;
50 unsigned long longitude;
51 unsigned long altitude;
52
53 REQUIRE(type == 29);
54
55 UNUSED(type);
56 UNUSED(rdclass);
57 UNUSED(origin);
58 UNUSED(downcase);
59 UNUSED(callbacks);
60
61 /*
62 * Defaults.
63 */
64 m1 = s1 = 0;
65 m2 = s2 = 0;
66 size = 0x12; /* 1.00m */
67 hp = 0x16; /* 10000.00 m */
68 vp = 0x13; /* 10.00 m */
69 version = 0;
70
71 /*
72 * Degrees.
73 */
74 RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_number,
75 ISC_FALSE));
76 if (token.value.as_ulong > 90U)
77 RETTOK(ISC_R_RANGE);
78 d1 = (int)token.value.as_ulong;
79 /*
80 * Minutes.
81 */
82 RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
83 ISC_FALSE));
84 if (strcasecmp(token.value.as_pointer, "N") == 0)
85 north = ISC_TRUE;
86 if (north || strcasecmp(token.value.as_pointer, "S") == 0)
87 goto getlong;
88 m1 = strtol(token.value.as_pointer, &e, 10);
89 if (*e != 0)
90 RETTOK(DNS_R_SYNTAX);
91 if (m1 < 0 || m1 > 59)
92 RETTOK(ISC_R_RANGE);
93 if (d1 == 90 && m1 != 0)
94 RETTOK(ISC_R_RANGE);
95
96 /*
97 * Seconds.
98 */
99 RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
100 ISC_FALSE));
101 if (strcasecmp(token.value.as_pointer, "N") == 0)
102 north = ISC_TRUE;
103 if (north || strcasecmp(token.value.as_pointer, "S") == 0)
104 goto getlong;
105 s1 = strtol(token.value.as_pointer, &e, 10);
106 if (*e != 0 && *e != '.')
107 RETTOK(DNS_R_SYNTAX);
108 if (s1 < 0 || s1 > 59)
109 RETTOK(ISC_R_RANGE);
110 if (*e == '.') {
111 e++;
112 for (i = 0; i < 3 ; i++) {
113 if (*e == 0)
114 break;
115 if ((tmp = decvalue(*e++)) < 0)
116 RETTOK(DNS_R_SYNTAX);
117 s1 *= 10;
118 s1 += tmp;
119 }
120 for ( ; i < 3 ; i++)
121 s1 *= 10;
122 if (*e != 0)
123 RETTOK(DNS_R_SYNTAX);
124 } else
125 s1 *= 1000;
126 if (d1 == 90 && s1 != 0)
127 RETTOK(ISC_R_RANGE);
128
129 /*
130 * Direction.
131 */
132 RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
133 ISC_FALSE));
134 if (strcasecmp(token.value.as_pointer, "N") == 0)
135 north = ISC_TRUE;
136 if (!north && strcasecmp(token.value.as_pointer, "S") != 0)
137 RETTOK(DNS_R_SYNTAX);
138
139 getlong:
140 /*
141 * Degrees.
142 */
143 RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_number,
144 ISC_FALSE));
145 if (token.value.as_ulong > 180U)
146 RETTOK(ISC_R_RANGE);
147 d2 = (int)token.value.as_ulong;
148
149 /*
150 * Minutes.
151 */
152 RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
153 ISC_FALSE));
154 if (strcasecmp(token.value.as_pointer, "E") == 0)
155 east = ISC_TRUE;
156 if (east || strcasecmp(token.value.as_pointer, "W") == 0)
157 goto getalt;
158 m2 = strtol(token.value.as_pointer, &e, 10);
159 if (*e != 0)
160 RETTOK(DNS_R_SYNTAX);
161 if (m2 < 0 || m2 > 59)
162 RETTOK(ISC_R_RANGE);
163 if (d2 == 180 && m2 != 0)
164 RETTOK(ISC_R_RANGE);
165
166 /*
167 * Seconds.
168 */
169 RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
170 ISC_FALSE));
171 if (strcasecmp(token.value.as_pointer, "E") == 0)
172 east = ISC_TRUE;
173 if (east || strcasecmp(token.value.as_pointer, "W") == 0)
174 goto getalt;
175 s2 = strtol(token.value.as_pointer, &e, 10);
176 if (*e != 0 && *e != '.')
177 RETTOK(DNS_R_SYNTAX);
178 if (s2 < 0 || s2 > 59)
179 RETTOK(ISC_R_RANGE);
180 if (*e == '.') {
181 e++;
182 for (i = 0; i < 3 ; i++) {
183 if (*e == 0)
184 break;
185 if ((tmp = decvalue(*e++)) < 0)
186 RETTOK(DNS_R_SYNTAX);
187 s2 *= 10;
188 s2 += tmp;
189 }
190 for ( ; i < 3 ; i++)
191 s2 *= 10;
192 if (*e != 0)
193 RETTOK(DNS_R_SYNTAX);
194 } else
195 s2 *= 1000;
196 if (d2 == 180 && s2 != 0)
197 RETTOK(ISC_R_RANGE);
198
199 /*
200 * Direction.
201 */
202 RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
203 ISC_FALSE));
204 if (strcasecmp(token.value.as_pointer, "E") == 0)
205 east = ISC_TRUE;
206 if (!east && strcasecmp(token.value.as_pointer, "W") != 0)
207 RETTOK(DNS_R_SYNTAX);
208
209 getalt:
210 /*
211 * Altitude.
212 */
213 RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
214 ISC_FALSE));
215 m = strtol(token.value.as_pointer, &e, 10);
216 if (*e != 0 && *e != '.' && *e != 'm')
217 RETTOK(DNS_R_SYNTAX);
218 if (m < -100000 || m > 42849672)
219 RETTOK(ISC_R_RANGE);
220 cm = 0;
221 if (*e == '.') {
222 e++;
223 for (i = 0; i < 2 ; i++) {
224 if (*e == 0 || *e == 'm')
225 break;
226 if ((tmp = decvalue(*e++)) < 0)
227 return (DNS_R_SYNTAX);
228 cm *= 10;
229 if (m < 0)
230 cm -= tmp;
231 else
232 cm += tmp;
233 }
234 for ( ; i < 2 ; i++)
235 cm *= 10;
236 }
237 if (*e == 'm')
238 e++;
239 if (*e != 0)
240 RETTOK(DNS_R_SYNTAX);
241 if (m == -100000 && cm != 0)
242 RETTOK(ISC_R_RANGE);
243 if (m == 42849672 && cm > 95)
244 RETTOK(ISC_R_RANGE);
245 /*
246 * Adjust base.
247 */
248 altitude = m + 100000;
249 altitude *= 100;
250 altitude += cm;
251
252 /*
253 * Size: optional.
254 */
255 RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
256 ISC_TRUE));
257 if (token.type == isc_tokentype_eol ||
258 token.type == isc_tokentype_eof) {
259 isc_lex_ungettoken(lexer, &token);
260 goto encode;
261 }
262 m = strtol(token.value.as_pointer, &e, 10);
263 if (*e != 0 && *e != '.' && *e != 'm')
264 RETTOK(DNS_R_SYNTAX);
265 if (m < 0 || m > 90000000)
266 RETTOK(ISC_R_RANGE);
267 cm = 0;
268 if (*e == '.') {
269 e++;
270 for (i = 0; i < 2 ; i++) {
271 if (*e == 0 || *e == 'm')
272 break;
273 if ((tmp = decvalue(*e++)) < 0)
274 RETTOK(DNS_R_SYNTAX);
275 cm *= 10;
276 cm += tmp;
277 }
278 for ( ; i < 2 ; i++)
279 cm *= 10;
280 }
281 if (*e == 'm')
282 e++;
283 if (*e != 0)
284 RETTOK(DNS_R_SYNTAX);
285 /*
286 * We don't just multiply out as we will overflow.
287 */
288 if (m > 0) {
289 for (exp = 0 ; exp < 7 ; exp++)
290 if (m < poweroften[exp+1])
291 break;
292 man = m / poweroften[exp];
293 exp += 2;
294 } else {
295 if (cm >= 10) {
296 man = cm / 10;
297 exp = 1;
298 } else {
299 man = cm;
300 exp = 0;
301 }
302 }
303 size = (man << 4) + exp;
304
305 /*
306 * Horizontal precision: optional.
307 */
308 RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
309 ISC_TRUE));
310 if (token.type == isc_tokentype_eol ||
311 token.type == isc_tokentype_eof) {
312 isc_lex_ungettoken(lexer, &token);
313 goto encode;
314 }
315 m = strtol(token.value.as_pointer, &e, 10);
316 if (*e != 0 && *e != '.' && *e != 'm')
317 RETTOK(DNS_R_SYNTAX);
318 if (m < 0 || m > 90000000)
319 RETTOK(ISC_R_RANGE);
320 cm = 0;
321 if (*e == '.') {
322 e++;
323 for (i = 0; i < 2 ; i++) {
324 if (*e == 0 || *e == 'm')
325 break;
326 if ((tmp = decvalue(*e++)) < 0)
327 RETTOK(DNS_R_SYNTAX);
328 cm *= 10;
329 cm += tmp;
330 }
331 for ( ; i < 2 ; i++)
332 cm *= 10;
333 }
334 if (*e == 'm')
335 e++;
336 if (*e != 0)
337 RETTOK(DNS_R_SYNTAX);
338 /*
339 * We don't just multiply out as we will overflow.
340 */
341 if (m > 0) {
342 for (exp = 0 ; exp < 7 ; exp++)
343 if (m < poweroften[exp+1])
344 break;
345 man = m / poweroften[exp];
346 exp += 2;
347 } else if (cm >= 10) {
348 man = cm / 10;
349 exp = 1;
350 } else {
351 man = cm;
352 exp = 0;
353 }
354 hp = (man << 4) + exp;
355
356 /*
357 * Vertical precision: optional.
358 */
359 RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
360 ISC_TRUE));
361 if (token.type == isc_tokentype_eol ||
362 token.type == isc_tokentype_eof) {
363 isc_lex_ungettoken(lexer, &token);
364 goto encode;
365 }
366 m = strtol(token.value.as_pointer, &e, 10);
367 if (*e != 0 && *e != '.' && *e != 'm')
368 RETTOK(DNS_R_SYNTAX);
369 if (m < 0 || m > 90000000)
370 RETTOK(ISC_R_RANGE);
371 cm = 0;
372 if (*e == '.') {
373 e++;
374 for (i = 0; i < 2 ; i++) {
375 if (*e == 0 || *e == 'm')
376 break;
377 if ((tmp = decvalue(*e++)) < 0)
378 RETTOK(DNS_R_SYNTAX);
379 cm *= 10;
380 cm += tmp;
381 }
382 for ( ; i < 2 ; i++)
383 cm *= 10;
384 }
385 if (*e == 'm')
386 e++;
387 if (*e != 0)
388 RETTOK(DNS_R_SYNTAX);
389 /*
390 * We don't just multiply out as we will overflow.
391 */
392 if (m > 0) {
393 for (exp = 0 ; exp < 7 ; exp++)
394 if (m < poweroften[exp+1])
395 break;
396 man = m / poweroften[exp];
397 exp += 2;
398 } else if (cm >= 10) {
399 man = cm / 10;
400 exp = 1;
401 } else {
402 man = cm;
403 exp = 0;
404 }
405 vp = (man << 4) + exp;
406
407 encode:
408 RETERR(mem_tobuffer(target, &version, 1));
409 RETERR(mem_tobuffer(target, &size, 1));
410 RETERR(mem_tobuffer(target, &hp, 1));
411 RETERR(mem_tobuffer(target, &vp, 1));
412 if (north)
413 latitude = 0x80000000 + ( d1 * 3600 + m1 * 60 ) * 1000 + s1;
414 else
415 latitude = 0x80000000 - ( d1 * 3600 + m1 * 60 ) * 1000 - s1;
416 RETERR(uint32_tobuffer(latitude, target));
417
418 if (east)
419 longitude = 0x80000000 + ( d2 * 3600 + m2 * 60 ) * 1000 + s2;
420 else
421 longitude = 0x80000000 - ( d2 * 3600 + m2 * 60 ) * 1000 - s2;
422 RETERR(uint32_tobuffer(longitude, target));
423
424 return (uint32_tobuffer(altitude, target));
425 }
426
427 static inline isc_result_t
428 totext_loc(ARGS_TOTEXT) {
429 int d1, m1, s1, fs1;
430 int d2, m2, s2, fs2;
431 unsigned long latitude;
432 unsigned long longitude;
433 unsigned long altitude;
434 isc_boolean_t north;
435 isc_boolean_t east;
436 isc_boolean_t below;
437 isc_region_t sr;
438 char buf[sizeof("89 59 59.999 N 179 59 59.999 E "
439 "42849672.95m 90000000m 90000000m 90000000m")];
440 char sbuf[sizeof("90000000m")];
441 char hbuf[sizeof("90000000m")];
442 char vbuf[sizeof("90000000m")];
443 unsigned char size, hp, vp;
444 unsigned long poweroften[8] = { 1, 10, 100, 1000,
445 10000, 100000, 1000000, 10000000 };
446
447 UNUSED(tctx);
448
449 REQUIRE(rdata->type == 29);
450 REQUIRE(rdata->length != 0);
451
452 dns_rdata_toregion(rdata, &sr);
453
454 /* version = sr.base[0]; */
455 size = sr.base[1];
456 if ((size&0x0f)> 1)
457 sprintf(sbuf, "%lum", (size>>4) * poweroften[(size&0x0f)-2]);
458 else
459 sprintf(sbuf, "0.%02lum", (size>>4) * poweroften[(size&0x0f)]);
460 hp = sr.base[2];
461 if ((hp&0x0f)> 1)
462 sprintf(hbuf, "%lum", (hp>>4) * poweroften[(hp&0x0f)-2]);
463 else
464 sprintf(hbuf, "0.%02lum", (hp>>4) * poweroften[(hp&0x0f)]);
465 vp = sr.base[3];
466 if ((vp&0x0f)> 1)
467 sprintf(vbuf, "%lum", (vp>>4) * poweroften[(vp&0x0f)-2]);
468 else
469 sprintf(vbuf, "0.%02lum", (vp>>4) * poweroften[(vp&0x0f)]);
470 isc_region_consume(&sr, 4);
471
472 latitude = uint32_fromregion(&sr);
473 isc_region_consume(&sr, 4);
474 if (latitude >= 0x80000000) {
475 north = ISC_TRUE;
476 latitude -= 0x80000000;
477 } else {
478 north = ISC_FALSE;
479 latitude = 0x80000000 - latitude;
480 }
481 fs1 = (int)(latitude % 1000);
482 latitude /= 1000;
483 s1 = (int)(latitude % 60);
484 latitude /= 60;
485 m1 = (int)(latitude % 60);
486 latitude /= 60;
487 d1 = (int)latitude;
488
489 longitude = uint32_fromregion(&sr);
490 isc_region_consume(&sr, 4);
491 if (longitude >= 0x80000000) {
492 east = ISC_TRUE;
493 longitude -= 0x80000000;
494 } else {
495 east = ISC_FALSE;
496 longitude = 0x80000000 - longitude;
497 }
498 fs2 = (int)(longitude % 1000);
499 longitude /= 1000;
500 s2 = (int)(longitude % 60);
501 longitude /= 60;
502 m2 = (int)(longitude % 60);
503 longitude /= 60;
504 d2 = (int)longitude;
505
506 altitude = uint32_fromregion(&sr);
507 isc_region_consume(&sr, 4);
508 if (altitude < 10000000U) {
509 below = ISC_TRUE;
510 altitude = 10000000 - altitude;
511 } else {
512 below =ISC_FALSE;
513 altitude -= 10000000;
514 }
515
516 sprintf(buf, "%d %d %d.%03d %s %d %d %d.%03d %s %s%ld.%02ldm %s %s %s",
517 d1, m1, s1, fs1, north ? "N" : "S",
518 d2, m2, s2, fs2, east ? "E" : "W",
519 below ? "-" : "", altitude/100, altitude % 100,
520 sbuf, hbuf, vbuf);
521
522 return (str_totext(buf, target));
523 }
524
525 static inline isc_result_t
526 fromwire_loc(ARGS_FROMWIRE) {
527 isc_region_t sr;
528 unsigned char c;
529 unsigned long latitude;
530 unsigned long longitude;
531
532 REQUIRE(type == 29);
533
534 UNUSED(type);
535 UNUSED(rdclass);
536 UNUSED(dctx);
537 UNUSED(downcase);
538
539 isc_buffer_activeregion(source, &sr);
540 if (sr.length < 1)
541 return (ISC_R_UNEXPECTEDEND);
542 if (sr.base[0] != 0)
543 return (ISC_R_NOTIMPLEMENTED);
544 if (sr.length < 16)
545 return (ISC_R_UNEXPECTEDEND);
546
547 /*
548 * Size.
549 */
550 c = sr.base[1];
551 if (c != 0)
552 if ((c&0xf) > 9 || ((c>>4)&0xf) > 9 || ((c>>4)&0xf) == 0)
553 return (ISC_R_RANGE);
554
555 /*
556 * Horizontal precision.
557 */
558 c = sr.base[2];
559 if (c != 0)
560 if ((c&0xf) > 9 || ((c>>4)&0xf) > 9 || ((c>>4)&0xf) == 0)
561 return (ISC_R_RANGE);
562
563 /*
564 * Vertical precision.
565 */
566 c = sr.base[3];
567 if (c != 0)
568 if ((c&0xf) > 9 || ((c>>4)&0xf) > 9 || ((c>>4)&0xf) == 0)
569 return (ISC_R_RANGE);
570 isc_region_consume(&sr, 4);
571
572 /*
573 * Latitude.
574 */
575 latitude = uint32_fromregion(&sr);
576 if (latitude < (0x80000000UL - 90 * 3600000) ||
577 latitude > (0x80000000UL + 90 * 3600000))
578 return (ISC_R_RANGE);
579 isc_region_consume(&sr, 4);
580
581 /*
582 * Longitude.
583 */
584 longitude = uint32_fromregion(&sr);
585 if (longitude < (0x80000000UL - 180 * 3600000) ||
586 longitude > (0x80000000UL + 180 * 3600000))
587 return (ISC_R_RANGE);
588
589 /*
590 * Altitiude.
591 * All values possible.
592 */
593
594 isc_buffer_activeregion(source, &sr);
595 isc_buffer_forward(source, 16);
596 return (mem_tobuffer(target, sr.base, 16));
597 }
598
599 static inline isc_result_t
600 towire_loc(ARGS_TOWIRE) {
601 UNUSED(cctx);
602
603 REQUIRE(rdata->type == 29);
604 REQUIRE(rdata->length != 0);
605
606 return (mem_tobuffer(target, rdata->data, rdata->length));
607 }
608
609 static inline int
610 compare_loc(ARGS_COMPARE) {
611 isc_region_t r1;
612 isc_region_t r2;
613
614 REQUIRE(rdata1->type == rdata2->type);
615 REQUIRE(rdata1->rdclass == rdata2->rdclass);
616 REQUIRE(rdata1->type == 29);
617 REQUIRE(rdata1->length != 0);
618 REQUIRE(rdata2->length != 0);
619
620 dns_rdata_toregion(rdata1, &r1);
621 dns_rdata_toregion(rdata2, &r2);
622 return (compare_region(&r1, &r2));
623 }
624
625 static inline isc_result_t
626 fromstruct_loc(ARGS_FROMSTRUCT) {
627 dns_rdata_loc_t *loc = source;
628 isc_uint8_t c;
629
630 REQUIRE(type == 29);
631 REQUIRE(source != NULL);
632 REQUIRE(loc->common.rdtype == type);
633 REQUIRE(loc->common.rdclass == rdclass);
634
635 UNUSED(type);
636 UNUSED(rdclass);
637
638 if (loc->v.v0.version != 0)
639 return (ISC_R_NOTIMPLEMENTED);
640 RETERR(uint8_tobuffer(loc->v.v0.version, target));
641
642 c = loc->v.v0.size;
643 if ((c&0xf) > 9 || ((c>>4)&0xf) > 9 || ((c>>4)&0xf) == 0)
644 return (ISC_R_RANGE);
645 RETERR(uint8_tobuffer(loc->v.v0.size, target));
646
647 c = loc->v.v0.horizontal;
648 if ((c&0xf) > 9 || ((c>>4)&0xf) > 9 || ((c>>4)&0xf) == 0)
649 return (ISC_R_RANGE);
650 RETERR(uint8_tobuffer(loc->v.v0.horizontal, target));
651
652 c = loc->v.v0.vertical;
653 if ((c&0xf) > 9 || ((c>>4)&0xf) > 9 || ((c>>4)&0xf) == 0)
654 return (ISC_R_RANGE);
655 RETERR(uint8_tobuffer(loc->v.v0.vertical, target));
656
657 if (loc->v.v0.latitude < (0x80000000UL - 90 * 3600000) ||
658 loc->v.v0.latitude > (0x80000000UL + 90 * 3600000))
659 return (ISC_R_RANGE);
660 RETERR(uint32_tobuffer(loc->v.v0.latitude, target));
661
662 if (loc->v.v0.longitude < (0x80000000UL - 180 * 3600000) ||
663 loc->v.v0.longitude > (0x80000000UL + 180 * 3600000))
664 return (ISC_R_RANGE);
665 RETERR(uint32_tobuffer(loc->v.v0.longitude, target));
666 return (uint32_tobuffer(loc->v.v0.altitude, target));
667 }
668
669 static inline isc_result_t
670 tostruct_loc(ARGS_TOSTRUCT) {
671 dns_rdata_loc_t *loc = target;
672 isc_region_t r;
673 isc_uint8_t version;
674
675 REQUIRE(rdata->type == 29);
676 REQUIRE(target != NULL);
677 REQUIRE(rdata->length != 0);
678
679 UNUSED(mctx);
680
681 dns_rdata_toregion(rdata, &r);
682 version = uint8_fromregion(&r);
683 if (version != 0)
684 return (ISC_R_NOTIMPLEMENTED);
685
686 loc->common.rdclass = rdata->rdclass;
687 loc->common.rdtype = rdata->type;
688 ISC_LINK_INIT(&loc->common, link);
689
690 loc->v.v0.version = version;
691 isc_region_consume(&r, 1);
692 loc->v.v0.size = uint8_fromregion(&r);
693 isc_region_consume(&r, 1);
694 loc->v.v0.horizontal = uint8_fromregion(&r);
695 isc_region_consume(&r, 1);
696 loc->v.v0.vertical = uint8_fromregion(&r);
697 isc_region_consume(&r, 1);
698 loc->v.v0.latitude = uint32_fromregion(&r);
699 isc_region_consume(&r, 4);
700 loc->v.v0.longitude = uint32_fromregion(&r);
701 isc_region_consume(&r, 4);
702 loc->v.v0.altitude = uint32_fromregion(&r);
703 isc_region_consume(&r, 4);
704 return (ISC_R_SUCCESS);
705 }
706
707 static inline void
708 freestruct_loc(ARGS_FREESTRUCT) {
709 dns_rdata_loc_t *loc = source;
710
711 REQUIRE(source != NULL);
712 REQUIRE(loc->common.rdtype == 29);
713
714 UNUSED(source);
715 UNUSED(loc);
716 }
717
718 static inline isc_result_t
719 additionaldata_loc(ARGS_ADDLDATA) {
720 REQUIRE(rdata->type == 29);
721
722 UNUSED(rdata);
723 UNUSED(add);
724 UNUSED(arg);
725
726 return (ISC_R_SUCCESS);
727 }
728
729 static inline isc_result_t
730 digest_loc(ARGS_DIGEST) {
731 isc_region_t r;
732
733 REQUIRE(rdata->type == 29);
734
735 dns_rdata_toregion(rdata, &r);
736
737 return ((digest)(arg, &r));
738 }
739
740 #endif /* RDATA_GENERIC_LOC_29_C */
DragonFly BSD