contrib/bind-9.5.2/lib/dns/rdata/generic/loc_29.c

   1 /*
   2  * Copyright (C) 2004, 2005, 2007, 2009  Internet Systems Consortium, Inc. ("ISC")
   3  * Copyright (C) 1999-2003  Internet Software Consortium.
   4  *
   5  * Permission to use, copy, modify, and/or 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.45.128.4 2009/02/17 05:54:41 marka Exp $ */
  19
  20 /* Reviewed: Wed Mar 15 18:13:09 PST 2000 by explorer */
  21
  22 /* RFC1876 */
  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(options);
  59
  60         /*
  61          * Defaults.
  62          */
  63         m1 = s1 = 0;
  64         m2 = s2 = 0;
  65         size = 0x12;    /* 1.00m */
  66         hp = 0x16;      /* 10000.00 m */
  67         vp = 0x13;      /* 10.00 m */
  68         version = 0;
  69
  70         /*
  71          * Degrees.
  72          */
  73         RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_number,
  74                                       ISC_FALSE));
  75         if (token.value.as_ulong > 90U)
  76                 RETTOK(ISC_R_RANGE);
  77         d1 = (int)token.value.as_ulong;
  78         /*
  79          * Minutes.
  80          */
  81         RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
  82                                       ISC_FALSE));
  83         if (strcasecmp(DNS_AS_STR(token), "N") == 0)
  84                 north = ISC_TRUE;
  85         if (north || strcasecmp(DNS_AS_STR(token), "S") == 0)
  86                 goto getlong;
  87         m1 = strtol(DNS_AS_STR(token), &e, 10);
  88         if (*e != 0)
  89                 RETTOK(DNS_R_SYNTAX);
  90         if (m1 < 0 || m1 > 59)
  91                 RETTOK(ISC_R_RANGE);
  92         if (d1 == 90 && m1 != 0)
  93                 RETTOK(ISC_R_RANGE);
  94
  95         /*
  96          * Seconds.
  97          */
  98         RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
  99                                       ISC_FALSE));
 100         if (strcasecmp(DNS_AS_STR(token), "N") == 0)
 101                 north = ISC_TRUE;
 102         if (north || strcasecmp(DNS_AS_STR(token), "S") == 0)
 103                 goto getlong;
 104         s1 = strtol(DNS_AS_STR(token), &e, 10);
 105         if (*e != 0 && *e != '.')
 106                 RETTOK(DNS_R_SYNTAX);
 107         if (s1 < 0 || s1 > 59)
 108                 RETTOK(ISC_R_RANGE);
 109         if (*e == '.') {
 110                 const char *l;
 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                 l = e;
 123                 while (*e != 0) {
 124                         if (decvalue(*e++) < 0)
 125                                 RETTOK(DNS_R_SYNTAX);
 126                 }
 127                 if (*l != '\0' && callbacks != NULL) {
 128                         const char *file = isc_lex_getsourcename(lexer);
 129                         unsigned long line = isc_lex_getsourceline(lexer);
 130
 131                         if (file == NULL)
 132                                 file = "UNKNOWN";
 133                         (*callbacks->warn)(callbacks, "%s: %s:%u: '%s' extra "
 134                                            "precision digits ignored",
 135                                            "dns_rdata_fromtext", file, line,
 136                                            DNS_AS_STR(token));
 137                 }
 138         } else
 139                 s1 *= 1000;
 140         if (d1 == 90 && s1 != 0)
 141                 RETTOK(ISC_R_RANGE);
 142
 143         /*
 144          * Direction.
 145          */
 146         RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
 147                                       ISC_FALSE));
 148         if (strcasecmp(DNS_AS_STR(token), "N") == 0)
 149                 north = ISC_TRUE;
 150         if (!north && strcasecmp(DNS_AS_STR(token), "S") != 0)
 151                 RETTOK(DNS_R_SYNTAX);
 152
 153  getlong:
 154         /*
 155          * Degrees.
 156          */
 157         RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_number,
 158                                       ISC_FALSE));
 159         if (token.value.as_ulong > 180U)
 160                 RETTOK(ISC_R_RANGE);
 161         d2 = (int)token.value.as_ulong;
 162
 163         /*
 164          * Minutes.
 165          */
 166         RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
 167                                       ISC_FALSE));
 168         if (strcasecmp(DNS_AS_STR(token), "E") == 0)
 169                 east = ISC_TRUE;
 170         if (east || strcasecmp(DNS_AS_STR(token), "W") == 0)
 171                 goto getalt;
 172         m2 = strtol(DNS_AS_STR(token), &e, 10);
 173         if (*e != 0)
 174                 RETTOK(DNS_R_SYNTAX);
 175         if (m2 < 0 || m2 > 59)
 176                 RETTOK(ISC_R_RANGE);
 177         if (d2 == 180 && m2 != 0)
 178                 RETTOK(ISC_R_RANGE);
 179
 180         /*
 181          * Seconds.
 182          */
 183         RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
 184                                       ISC_FALSE));
 185         if (strcasecmp(DNS_AS_STR(token), "E") == 0)
 186                 east = ISC_TRUE;
 187         if (east || strcasecmp(DNS_AS_STR(token), "W") == 0)
 188                 goto getalt;
 189         s2 = strtol(DNS_AS_STR(token), &e, 10);
 190         if (*e != 0 && *e != '.')
 191                 RETTOK(DNS_R_SYNTAX);
 192         if (s2 < 0 || s2 > 59)
 193                 RETTOK(ISC_R_RANGE);
 194         if (*e == '.') {
 195                 const char *l;
 196                 e++;
 197                 for (i = 0; i < 3; i++) {
 198                         if (*e == 0)
 199                                 break;
 200                         if ((tmp = decvalue(*e++)) < 0)
 201                                 RETTOK(DNS_R_SYNTAX);
 202                         s2 *= 10;
 203                         s2 += tmp;
 204                 }
 205                 for (; i < 3; i++)
 206                         s2 *= 10;
 207                 l = e;
 208                 while (*e != 0) {
 209                         if (decvalue(*e++) < 0)
 210                                 RETTOK(DNS_R_SYNTAX);
 211                 }
 212                 if (*l != '\0' && callbacks != NULL) {
 213                         const char *file = isc_lex_getsourcename(lexer);
 214                         unsigned long line = isc_lex_getsourceline(lexer);
 215
 216                         if (file == NULL)
 217                                 file = "UNKNOWN";
 218                         (*callbacks->warn)(callbacks, "%s: %s:%u: '%s' extra "
 219                                            "precision digits ignored",
 220                                            "dns_rdata_fromtext",
 221                                            file, line, DNS_AS_STR(token));
 222                 }
 223         } else
 224                 s2 *= 1000;
 225         if (d2 == 180 && s2 != 0)
 226                 RETTOK(ISC_R_RANGE);
 227
 228         /*
 229          * Direction.
 230          */
 231         RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
 232                                       ISC_FALSE));
 233         if (strcasecmp(DNS_AS_STR(token), "E") == 0)
 234                 east = ISC_TRUE;
 235         if (!east && strcasecmp(DNS_AS_STR(token), "W") != 0)
 236                 RETTOK(DNS_R_SYNTAX);
 237
 238  getalt:
 239         /*
 240          * Altitude.
 241          */
 242         RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
 243                                       ISC_FALSE));
 244         m = strtol(DNS_AS_STR(token), &e, 10);
 245         if (*e != 0 && *e != '.' && *e != 'm')
 246                 RETTOK(DNS_R_SYNTAX);
 247         if (m < -100000 || m > 42849672)
 248                 RETTOK(ISC_R_RANGE);
 249         cm = 0;
 250         if (*e == '.') {
 251                 e++;
 252                 for (i = 0; i < 2; i++) {
 253                         if (*e == 0 || *e == 'm')
 254                                 break;
 255                         if ((tmp = decvalue(*e++)) < 0)
 256                                 return (DNS_R_SYNTAX);
 257                         cm *= 10;
 258                         if (m < 0)
 259                                 cm -= tmp;
 260                         else
 261                                 cm += tmp;
 262                 }
 263                 for (; i < 2; i++)
 264                         cm *= 10;
 265         }
 266         if (*e == 'm')
 267                 e++;
 268         if (*e != 0)
 269                 RETTOK(DNS_R_SYNTAX);
 270         if (m == -100000 && cm != 0)
 271                 RETTOK(ISC_R_RANGE);
 272         if (m == 42849672 && cm > 95)
 273                 RETTOK(ISC_R_RANGE);
 274         /*
 275          * Adjust base.
 276          */
 277         altitude = m + 100000;
 278         altitude *= 100;
 279         altitude += cm;
 280
 281         /*
 282          * Size: optional.
 283          */
 284         RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
 285                                       ISC_TRUE));
 286         if (token.type == isc_tokentype_eol ||
 287             token.type == isc_tokentype_eof) {
 288                 isc_lex_ungettoken(lexer, &token);
 289                 goto encode;
 290         }
 291         m = strtol(DNS_AS_STR(token), &e, 10);
 292         if (*e != 0 && *e != '.' && *e != 'm')
 293                 RETTOK(DNS_R_SYNTAX);
 294         if (m < 0 || m > 90000000)
 295                 RETTOK(ISC_R_RANGE);
 296         cm = 0;
 297         if (*e == '.') {
 298                 e++;
 299                 for (i = 0; i < 2; i++) {
 300                         if (*e == 0 || *e == 'm')
 301                                 break;
 302                         if ((tmp = decvalue(*e++)) < 0)
 303                                 RETTOK(DNS_R_SYNTAX);
 304                         cm *= 10;
 305                         cm += tmp;
 306                 }
 307                 for (; i < 2; i++)
 308                         cm *= 10;
 309         }
 310         if (*e == 'm')
 311                 e++;
 312         if (*e != 0)
 313                 RETTOK(DNS_R_SYNTAX);
 314         /*
 315          * We don't just multiply out as we will overflow.
 316          */
 317         if (m > 0) {
 318                 for (exp = 0; exp < 7; exp++)
 319                         if (m < poweroften[exp+1])
 320                                 break;
 321                 man = m / poweroften[exp];
 322                 exp += 2;
 323         } else {
 324                 if (cm >= 10) {
 325                         man = cm / 10;
 326                         exp = 1;
 327                 } else {
 328                         man = cm;
 329                         exp = 0;
 330                 }
 331         }
 332         size = (man << 4) + exp;
 333
 334         /*
 335          * Horizontal precision: optional.
 336          */
 337         RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
 338                                       ISC_TRUE));
 339         if (token.type == isc_tokentype_eol ||
 340             token.type == isc_tokentype_eof) {
 341                 isc_lex_ungettoken(lexer, &token);
 342                 goto encode;
 343         }
 344         m = strtol(DNS_AS_STR(token), &e, 10);
 345         if (*e != 0 && *e != '.' && *e != 'm')
 346                 RETTOK(DNS_R_SYNTAX);
 347         if (m < 0 || m > 90000000)
 348                 RETTOK(ISC_R_RANGE);
 349         cm = 0;
 350         if (*e == '.') {
 351                 e++;
 352                 for (i = 0; i < 2; i++) {
 353                         if (*e == 0 || *e == 'm')
 354                                 break;
 355                         if ((tmp = decvalue(*e++)) < 0)
 356                                 RETTOK(DNS_R_SYNTAX);
 357                         cm *= 10;
 358                         cm += tmp;
 359                 }
 360                 for (; i < 2; i++)
 361                         cm *= 10;
 362         }
 363         if (*e == 'm')
 364                 e++;
 365         if (*e != 0)
 366                 RETTOK(DNS_R_SYNTAX);
 367         /*
 368          * We don't just multiply out as we will overflow.
 369          */
 370         if (m > 0) {
 371                 for (exp = 0; exp < 7; exp++)
 372                         if (m < poweroften[exp+1])
 373                                 break;
 374                 man = m / poweroften[exp];
 375                 exp += 2;
 376         } else if (cm >= 10) {
 377                 man = cm / 10;
 378                 exp = 1;
 379         } else  {
 380                 man = cm;
 381                 exp = 0;
 382         }
 383         hp = (man << 4) + exp;
 384
 385         /*
 386          * Vertical precision: optional.
 387          */
 388         RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
 389                                       ISC_TRUE));
 390         if (token.type == isc_tokentype_eol ||
 391             token.type == isc_tokentype_eof) {
 392                 isc_lex_ungettoken(lexer, &token);
 393                 goto encode;
 394         }
 395         m = strtol(DNS_AS_STR(token), &e, 10);
 396         if (*e != 0 && *e != '.' && *e != 'm')
 397                 RETTOK(DNS_R_SYNTAX);
 398         if (m < 0 || m > 90000000)
 399                 RETTOK(ISC_R_RANGE);
 400         cm = 0;
 401         if (*e == '.') {
 402                 e++;
 403                 for (i = 0; i < 2; i++) {
 404                         if (*e == 0 || *e == 'm')
 405                                 break;
 406                         if ((tmp = decvalue(*e++)) < 0)
 407                                 RETTOK(DNS_R_SYNTAX);
 408                         cm *= 10;
 409                         cm += tmp;
 410                 }
 411                 for (; i < 2; i++)
 412                         cm *= 10;
 413         }
 414         if (*e == 'm')
 415                 e++;
 416         if (*e != 0)
 417                 RETTOK(DNS_R_SYNTAX);
 418         /*
 419          * We don't just multiply out as we will overflow.
 420          */
 421         if (m > 0) {
 422                 for (exp = 0; exp < 7; exp++)
 423                         if (m < poweroften[exp+1])
 424                                 break;
 425                 man = m / poweroften[exp];
 426                 exp += 2;
 427         } else if (cm >= 10) {
 428                 man = cm / 10;
 429                 exp = 1;
 430         } else {
 431                 man = cm;
 432                 exp = 0;
 433         }
 434         vp = (man << 4) + exp;
 435
 436  encode:
 437         RETERR(mem_tobuffer(target, &version, 1));
 438         RETERR(mem_tobuffer(target, &size, 1));
 439         RETERR(mem_tobuffer(target, &hp, 1));
 440         RETERR(mem_tobuffer(target, &vp, 1));
 441         if (north)
 442                 latitude = 0x80000000 + ( d1 * 3600 + m1 * 60 ) * 1000 + s1;
 443         else
 444                 latitude = 0x80000000 - ( d1 * 3600 + m1 * 60 ) * 1000 - s1;
 445         RETERR(uint32_tobuffer(latitude, target));
 446
 447         if (east)
 448                 longitude = 0x80000000 + ( d2 * 3600 + m2 * 60 ) * 1000 + s2;
 449         else
 450                 longitude = 0x80000000 - ( d2 * 3600 + m2 * 60 ) * 1000 - s2;
 451         RETERR(uint32_tobuffer(longitude, target));
 452
 453         return (uint32_tobuffer(altitude, target));
 454 }
 455
 456 static inline isc_result_t
 457 totext_loc(ARGS_TOTEXT) {
 458         int d1, m1, s1, fs1;
 459         int d2, m2, s2, fs2;
 460         unsigned long latitude;
 461         unsigned long longitude;
 462         unsigned long altitude;
 463         isc_boolean_t north;
 464         isc_boolean_t east;
 465         isc_boolean_t below;
 466         isc_region_t sr;
 467         char buf[sizeof("89 59 59.999 N 179 59 59.999 E "
 468                         "42849672.95m 90000000m 90000000m 90000000m")];
 469         char sbuf[sizeof("90000000m")];
 470         char hbuf[sizeof("90000000m")];
 471         char vbuf[sizeof("90000000m")];
 472         unsigned char size, hp, vp;
 473         unsigned long poweroften[8] = { 1, 10, 100, 1000,
 474                                         10000, 100000, 1000000, 10000000 };
 475
 476         UNUSED(tctx);
 477
 478         REQUIRE(rdata->type == 29);
 479         REQUIRE(rdata->length != 0);
 480
 481         dns_rdata_toregion(rdata, &sr);
 482
 483         /* version = sr.base[0]; */
 484         size = sr.base[1];
 485         INSIST((size&0x0f) < 10 && (size>>4) < 10);
 486         if ((size&0x0f)> 1)
 487                 sprintf(sbuf, "%lum", (size>>4) * poweroften[(size&0x0f)-2]);
 488         else
 489                 sprintf(sbuf, "0.%02lum", (size>>4) * poweroften[(size&0x0f)]);
 490         hp = sr.base[2];
 491         INSIST((hp&0x0f) < 10 && (hp>>4) < 10);
 492         if ((hp&0x0f)> 1)
 493                 sprintf(hbuf, "%lum", (hp>>4) * poweroften[(hp&0x0f)-2]);
 494         else
 495                 sprintf(hbuf, "0.%02lum", (hp>>4) * poweroften[(hp&0x0f)]);
 496         vp = sr.base[3];
 497         INSIST((vp&0x0f) < 10 && (vp>>4) < 10);
 498         if ((vp&0x0f)> 1)
 499                 sprintf(vbuf, "%lum", (vp>>4) * poweroften[(vp&0x0f)-2]);
 500         else
 501                 sprintf(vbuf, "0.%02lum", (vp>>4) * poweroften[(vp&0x0f)]);
 502         isc_region_consume(&sr, 4);
 503
 504         latitude = uint32_fromregion(&sr);
 505         isc_region_consume(&sr, 4);
 506         if (latitude >= 0x80000000) {
 507                 north = ISC_TRUE;
 508                 latitude -= 0x80000000;
 509         } else {
 510                 north = ISC_FALSE;
 511                 latitude = 0x80000000 - latitude;
 512         }
 513         fs1 = (int)(latitude % 1000);
 514         latitude /= 1000;
 515         s1 = (int)(latitude % 60);
 516         latitude /= 60;
 517         m1 = (int)(latitude % 60);
 518         latitude /= 60;
 519         d1 = (int)latitude;
 520         INSIST(latitude <= 90U);
 521
 522         longitude = uint32_fromregion(&sr);
 523         isc_region_consume(&sr, 4);
 524         if (longitude >= 0x80000000) {
 525                 east = ISC_TRUE;
 526                 longitude -= 0x80000000;
 527         } else {
 528                 east = ISC_FALSE;
 529                 longitude = 0x80000000 - longitude;
 530         }
 531         fs2 = (int)(longitude % 1000);
 532         longitude /= 1000;
 533         s2 = (int)(longitude % 60);
 534         longitude /= 60;
 535         m2 = (int)(longitude % 60);
 536         longitude /= 60;
 537         d2 = (int)longitude;
 538         INSIST(longitude <= 180U);
 539
 540         altitude = uint32_fromregion(&sr);
 541         isc_region_consume(&sr, 4);
 542         if (altitude < 10000000U) {
 543                 below = ISC_TRUE;
 544                 altitude = 10000000 - altitude;
 545         } else {
 546                 below =ISC_FALSE;
 547                 altitude -= 10000000;
 548         }
 549
 550         sprintf(buf, "%d %d %d.%03d %s %d %d %d.%03d %s %s%ld.%02ldm %s %s %s",
 551                 d1, m1, s1, fs1, north ? "N" : "S",
 552                 d2, m2, s2, fs2, east ? "E" : "W",
 553                 below ? "-" : "", altitude/100, altitude % 100,
 554                 sbuf, hbuf, vbuf);
 555
 556         return (str_totext(buf, target));
 557 }
 558
 559 static inline isc_result_t
 560 fromwire_loc(ARGS_FROMWIRE) {
 561         isc_region_t sr;
 562         unsigned char c;
 563         unsigned long latitude;
 564         unsigned long longitude;
 565
 566         REQUIRE(type == 29);
 567
 568         UNUSED(type);
 569         UNUSED(rdclass);
 570         UNUSED(dctx);
 571         UNUSED(options);
 572
 573         isc_buffer_activeregion(source, &sr);
 574         if (sr.length < 1)
 575                 return (ISC_R_UNEXPECTEDEND);
 576         if (sr.base[0] != 0)
 577                 return (ISC_R_NOTIMPLEMENTED);
 578         if (sr.length < 16)
 579                 return (ISC_R_UNEXPECTEDEND);
 580
 581         /*
 582          * Size.
 583          */
 584         c = sr.base[1];
 585         if (c != 0)
 586                 if ((c&0xf) > 9 || ((c>>4)&0xf) > 9 || ((c>>4)&0xf) == 0)
 587                         return (ISC_R_RANGE);
 588
 589         /*
 590          * Horizontal precision.
 591          */
 592         c = sr.base[2];
 593         if (c != 0)
 594                 if ((c&0xf) > 9 || ((c>>4)&0xf) > 9 || ((c>>4)&0xf) == 0)
 595                         return (ISC_R_RANGE);
 596
 597         /*
 598          * Vertical precision.
 599          */
 600         c = sr.base[3];
 601         if (c != 0)
 602                 if ((c&0xf) > 9 || ((c>>4)&0xf) > 9 || ((c>>4)&0xf) == 0)
 603                         return (ISC_R_RANGE);
 604         isc_region_consume(&sr, 4);
 605
 606         /*
 607          * Latitude.
 608          */
 609         latitude = uint32_fromregion(&sr);
 610         if (latitude < (0x80000000UL - 90 * 3600000) ||
 611             latitude > (0x80000000UL + 90 * 3600000))
 612                 return (ISC_R_RANGE);
 613         isc_region_consume(&sr, 4);
 614
 615         /*
 616          * Longitude.
 617          */
 618         longitude = uint32_fromregion(&sr);
 619         if (longitude < (0x80000000UL - 180 * 3600000) ||
 620             longitude > (0x80000000UL + 180 * 3600000))
 621                 return (ISC_R_RANGE);
 622
 623         /*
 624          * Altitude.
 625          * All values possible.
 626          */
 627
 628         isc_buffer_activeregion(source, &sr);
 629         isc_buffer_forward(source, 16);
 630         return (mem_tobuffer(target, sr.base, 16));
 631 }
 632
 633 static inline isc_result_t
 634 towire_loc(ARGS_TOWIRE) {
 635         UNUSED(cctx);
 636
 637         REQUIRE(rdata->type == 29);
 638         REQUIRE(rdata->length != 0);
 639
 640         return (mem_tobuffer(target, rdata->data, rdata->length));
 641 }
 642
 643 static inline int
 644 compare_loc(ARGS_COMPARE) {
 645         isc_region_t r1;
 646         isc_region_t r2;
 647
 648         REQUIRE(rdata1->type == rdata2->type);
 649         REQUIRE(rdata1->rdclass == rdata2->rdclass);
 650         REQUIRE(rdata1->type == 29);
 651         REQUIRE(rdata1->length != 0);
 652         REQUIRE(rdata2->length != 0);
 653
 654         dns_rdata_toregion(rdata1, &r1);
 655         dns_rdata_toregion(rdata2, &r2);
 656         return (isc_region_compare(&r1, &r2));
 657 }
 658
 659 static inline isc_result_t
 660 fromstruct_loc(ARGS_FROMSTRUCT) {
 661         dns_rdata_loc_t *loc = source;
 662         isc_uint8_t c;
 663
 664         REQUIRE(type == 29);
 665         REQUIRE(source != NULL);
 666         REQUIRE(loc->common.rdtype == type);
 667         REQUIRE(loc->common.rdclass == rdclass);
 668
 669         UNUSED(type);
 670         UNUSED(rdclass);
 671
 672         if (loc->v.v0.version != 0)
 673                 return (ISC_R_NOTIMPLEMENTED);
 674         RETERR(uint8_tobuffer(loc->v.v0.version, target));
 675
 676         c = loc->v.v0.size;
 677         if ((c&0xf) > 9 || ((c>>4)&0xf) > 9 || ((c>>4)&0xf) == 0)
 678                 return (ISC_R_RANGE);
 679         RETERR(uint8_tobuffer(loc->v.v0.size, target));
 680
 681         c = loc->v.v0.horizontal;
 682         if ((c&0xf) > 9 || ((c>>4)&0xf) > 9 || ((c>>4)&0xf) == 0)
 683                 return (ISC_R_RANGE);
 684         RETERR(uint8_tobuffer(loc->v.v0.horizontal, target));
 685
 686         c = loc->v.v0.vertical;
 687         if ((c&0xf) > 9 || ((c>>4)&0xf) > 9 || ((c>>4)&0xf) == 0)
 688                 return (ISC_R_RANGE);
 689         RETERR(uint8_tobuffer(loc->v.v0.vertical, target));
 690
 691         if (loc->v.v0.latitude < (0x80000000UL - 90 * 3600000) ||
 692             loc->v.v0.latitude > (0x80000000UL + 90 * 3600000))
 693                 return (ISC_R_RANGE);
 694         RETERR(uint32_tobuffer(loc->v.v0.latitude, target));
 695
 696         if (loc->v.v0.longitude < (0x80000000UL - 180 * 3600000) ||
 697             loc->v.v0.longitude > (0x80000000UL + 180 * 3600000))
 698                 return (ISC_R_RANGE);
 699         RETERR(uint32_tobuffer(loc->v.v0.longitude, target));
 700         return (uint32_tobuffer(loc->v.v0.altitude, target));
 701 }
 702
 703 static inline isc_result_t
 704 tostruct_loc(ARGS_TOSTRUCT) {
 705         dns_rdata_loc_t *loc = target;
 706         isc_region_t r;
 707         isc_uint8_t version;
 708
 709         REQUIRE(rdata->type == 29);
 710         REQUIRE(target != NULL);
 711         REQUIRE(rdata->length != 0);
 712
 713         UNUSED(mctx);
 714
 715         dns_rdata_toregion(rdata, &r);
 716         version = uint8_fromregion(&r);
 717         if (version != 0)
 718                 return (ISC_R_NOTIMPLEMENTED);
 719
 720         loc->common.rdclass = rdata->rdclass;
 721         loc->common.rdtype = rdata->type;
 722         ISC_LINK_INIT(&loc->common, link);
 723
 724         loc->v.v0.version = version;
 725         isc_region_consume(&r, 1);
 726         loc->v.v0.size = uint8_fromregion(&r);
 727         isc_region_consume(&r, 1);
 728         loc->v.v0.horizontal = uint8_fromregion(&r);
 729         isc_region_consume(&r, 1);
 730         loc->v.v0.vertical = uint8_fromregion(&r);
 731         isc_region_consume(&r, 1);
 732         loc->v.v0.latitude = uint32_fromregion(&r);
 733         isc_region_consume(&r, 4);
 734         loc->v.v0.longitude = uint32_fromregion(&r);
 735         isc_region_consume(&r, 4);
 736         loc->v.v0.altitude = uint32_fromregion(&r);
 737         isc_region_consume(&r, 4);
 738         return (ISC_R_SUCCESS);
 739 }
 740
 741 static inline void
 742 freestruct_loc(ARGS_FREESTRUCT) {
 743         dns_rdata_loc_t *loc = source;
 744
 745         REQUIRE(source != NULL);
 746         REQUIRE(loc->common.rdtype == 29);
 747
 748         UNUSED(source);
 749         UNUSED(loc);
 750 }
 751
 752 static inline isc_result_t
 753 additionaldata_loc(ARGS_ADDLDATA) {
 754         REQUIRE(rdata->type == 29);
 755
 756         UNUSED(rdata);
 757         UNUSED(add);
 758         UNUSED(arg);
 759
 760         return (ISC_R_SUCCESS);
 761 }
 762
 763 static inline isc_result_t
 764 digest_loc(ARGS_DIGEST) {
 765         isc_region_t r;
 766
 767         REQUIRE(rdata->type == 29);
 768
 769         dns_rdata_toregion(rdata, &r);
 770
 771         return ((digest)(arg, &r));
 772 }
 773
 774 static inline isc_boolean_t
 775 checkowner_loc(ARGS_CHECKOWNER) {
 776
 777         REQUIRE(type == 29);
 778
 779         UNUSED(name);
 780         UNUSED(type);
 781         UNUSED(rdclass);
 782         UNUSED(wildcard);
 783
 784         return (ISC_TRUE);
 785 }
 786
 787 static inline isc_boolean_t
 788 checknames_loc(ARGS_CHECKNAMES) {
 789
 790         REQUIRE(rdata->type == 29);
 791
 792         UNUSED(rdata);
 793         UNUSED(owner);
 794         UNUSED(bad);
 795
 796         return (ISC_TRUE);
 797 }
 798
 799 #endif  /* RDATA_GENERIC_LOC_29_C */