apl_42.c revision 1.5
1210284Sjmallett/* $NetBSD: apl_42.c,v 1.5 2020/05/24 19:46:25 christos Exp $ */ 2232812Sjmallett 3215990Sjmallett/* 4210284Sjmallett * Copyright (C) Internet Systems Consortium, Inc. ("ISC") 5210284Sjmallett * 6215990Sjmallett * This Source Code Form is subject to the terms of the Mozilla Public 7215990Sjmallett * License, v. 2.0. If a copy of the MPL was not distributed with this 8215990Sjmallett * file, You can obtain one at http://mozilla.org/MPL/2.0/. 9210284Sjmallett * 10215990Sjmallett * See the COPYRIGHT file distributed with this work for additional 11215990Sjmallett * information regarding copyright ownership. 12210284Sjmallett */ 13215990Sjmallett 14215990Sjmallett/* RFC3123 */ 15215990Sjmallett 16215990Sjmallett#ifndef RDATA_IN_1_APL_42_C 17215990Sjmallett#define RDATA_IN_1_APL_42_C 18232812Sjmallett 19215990Sjmallett#define RRTYPE_APL_ATTRIBUTES (0) 20215990Sjmallett 21215990Sjmallettstatic inline isc_result_t 22215990Sjmallettfromtext_in_apl(ARGS_FROMTEXT) { 23215990Sjmallett isc_token_t token; 24215990Sjmallett unsigned char addr[16]; 25215990Sjmallett unsigned long afi; 26215990Sjmallett uint8_t prefix; 27215990Sjmallett uint8_t len; 28215990Sjmallett bool neg; 29232812Sjmallett char *cp, *ap, *slash; 30215990Sjmallett int n; 31215990Sjmallett 32215990Sjmallett REQUIRE(type == dns_rdatatype_apl); 33215990Sjmallett REQUIRE(rdclass == dns_rdataclass_in); 34215990Sjmallett 35215990Sjmallett UNUSED(type); 36215990Sjmallett UNUSED(rdclass); 37215990Sjmallett UNUSED(origin); 38210284Sjmallett UNUSED(options); 39210284Sjmallett UNUSED(callbacks); 40210284Sjmallett 41210284Sjmallett do { 42210284Sjmallett RETERR(isc_lex_getmastertoken(lexer, &token, 43210284Sjmallett isc_tokentype_string, true)); 44210284Sjmallett if (token.type != isc_tokentype_string) { 45215990Sjmallett break; 46210284Sjmallett } 47210284Sjmallett 48210284Sjmallett cp = DNS_AS_STR(token); 49210284Sjmallett neg = (*cp == '!'); 50210284Sjmallett if (neg) { 51232812Sjmallett cp++; 52210284Sjmallett } 53215990Sjmallett afi = strtoul(cp, &ap, 10); 54215990Sjmallett if (*ap++ != ':' || cp == ap) { 55232812Sjmallett RETTOK(DNS_R_SYNTAX); 56215990Sjmallett } 57215990Sjmallett if (afi > 0xffffU) { 58215990Sjmallett RETTOK(ISC_R_RANGE); 59215990Sjmallett } 60215990Sjmallett slash = strchr(ap, '/'); 61215990Sjmallett if (slash == NULL || slash == ap) { 62215990Sjmallett RETTOK(DNS_R_SYNTAX); 63215990Sjmallett } 64232812Sjmallett RETTOK(isc_parse_uint8(&prefix, slash + 1, 10)); 65232812Sjmallett switch (afi) { 66232812Sjmallett case 1: 67232812Sjmallett *slash = '\0'; 68215990Sjmallett n = inet_pton(AF_INET, ap, addr); 69215990Sjmallett *slash = '/'; 70215990Sjmallett if (n != 1) { 71215990Sjmallett RETTOK(DNS_R_BADDOTTEDQUAD); 72215990Sjmallett } 73210284Sjmallett if (prefix > 32) { 74210284Sjmallett RETTOK(ISC_R_RANGE); 75210284Sjmallett } 76210284Sjmallett for (len = 4; len > 0; len--) { 77210284Sjmallett if (addr[len - 1] != 0) { 78232812Sjmallett break; 79210284Sjmallett } 80210284Sjmallett } 81210284Sjmallett break; 82210284Sjmallett 83210284Sjmallett case 2: 84210284Sjmallett *slash = '\0'; 85210284Sjmallett n = inet_pton(AF_INET6, ap, addr); 86232812Sjmallett *slash = '/'; 87232812Sjmallett if (n != 1) { 88215990Sjmallett RETTOK(DNS_R_BADAAAA); 89210284Sjmallett } 90210284Sjmallett if (prefix > 128) { 91210284Sjmallett RETTOK(ISC_R_RANGE); 92232812Sjmallett } 93232812Sjmallett for (len = 16; len > 0; len--) { 94232812Sjmallett if (addr[len - 1] != 0) { 95232812Sjmallett break; 96232812Sjmallett } 97232812Sjmallett } 98232812Sjmallett break; 99232812Sjmallett 100232812Sjmallett default: 101232812Sjmallett RETTOK(ISC_R_NOTIMPLEMENTED); 102232812Sjmallett } 103232812Sjmallett RETERR(uint16_tobuffer(afi, target)); 104232812Sjmallett RETERR(uint8_tobuffer(prefix, target)); 105215990Sjmallett RETERR(uint8_tobuffer(len | ((neg) ? 0x80 : 0), target)); 106210284Sjmallett RETERR(mem_tobuffer(target, addr, len)); 107210284Sjmallett } while (1); 108210284Sjmallett 109210284Sjmallett /* 110210284Sjmallett * Let upper layer handle eol/eof. 111210284Sjmallett */ 112210284Sjmallett isc_lex_ungettoken(lexer, &token); 113210284Sjmallett 114210284Sjmallett return (ISC_R_SUCCESS); 115210284Sjmallett} 116215990Sjmallett 117210284Sjmallettstatic inline isc_result_t 118210284Sjmalletttotext_in_apl(ARGS_TOTEXT) { 119210284Sjmallett isc_region_t sr; 120210284Sjmallett isc_region_t ir; 121210284Sjmallett uint16_t afi; 122210284Sjmallett uint8_t prefix; 123210284Sjmallett uint8_t len; 124210284Sjmallett bool neg; 125210284Sjmallett unsigned char buf[16]; 126210284Sjmallett char txt[sizeof(" !64000:")]; 127210284Sjmallett const char *sep = ""; 128210284Sjmallett int n; 129210284Sjmallett 130210284Sjmallett REQUIRE(rdata->type == dns_rdatatype_apl); 131210284Sjmallett REQUIRE(rdata->rdclass == dns_rdataclass_in); 132210284Sjmallett 133210284Sjmallett UNUSED(tctx); 134210284Sjmallett 135232812Sjmallett dns_rdata_toregion(rdata, &sr); 136210284Sjmallett ir.base = buf; 137210284Sjmallett ir.length = sizeof(buf); 138210284Sjmallett 139210284Sjmallett while (sr.length > 0) { 140215990Sjmallett INSIST(sr.length >= 4); 141232812Sjmallett afi = uint16_fromregion(&sr); 142210284Sjmallett isc_region_consume(&sr, 2); 143210284Sjmallett prefix = *sr.base; 144210284Sjmallett isc_region_consume(&sr, 1); 145210284Sjmallett len = (*sr.base & 0x7f); 146210284Sjmallett neg = (*sr.base & 0x80); 147210284Sjmallett isc_region_consume(&sr, 1); 148210284Sjmallett INSIST(len <= sr.length); 149210284Sjmallett n = snprintf(txt, sizeof(txt), "%s%s%u:", sep, neg ? "!" : "", 150210284Sjmallett afi); 151210284Sjmallett INSIST(n < (int)sizeof(txt)); 152210284Sjmallett RETERR(str_totext(txt, target)); 153210284Sjmallett switch (afi) { 154210284Sjmallett case 1: 155210284Sjmallett INSIST(len <= 4); 156210284Sjmallett INSIST(prefix <= 32); 157210284Sjmallett memset(buf, 0, sizeof(buf)); 158210284Sjmallett memmove(buf, sr.base, len); 159210284Sjmallett RETERR(inet_totext(AF_INET, &ir, target)); 160210284Sjmallett break; 161210284Sjmallett 162232812Sjmallett case 2: 163232812Sjmallett INSIST(len <= 16); 164232812Sjmallett INSIST(prefix <= 128); 165210284Sjmallett memset(buf, 0, sizeof(buf)); 166210284Sjmallett memmove(buf, sr.base, len); 167210284Sjmallett RETERR(inet_totext(AF_INET6, &ir, target)); 168210284Sjmallett break; 169210284Sjmallett 170210284Sjmallett default: 171210284Sjmallett return (ISC_R_NOTIMPLEMENTED); 172210284Sjmallett } 173210284Sjmallett n = snprintf(txt, sizeof(txt), "/%u", prefix); 174210284Sjmallett INSIST(n < (int)sizeof(txt)); 175210284Sjmallett RETERR(str_totext(txt, target)); 176210284Sjmallett isc_region_consume(&sr, len); 177210284Sjmallett sep = " "; 178210284Sjmallett } 179210284Sjmallett return (ISC_R_SUCCESS); 180210284Sjmallett} 181210284Sjmallett 182210284Sjmallettstatic inline isc_result_t 183210284Sjmallettfromwire_in_apl(ARGS_FROMWIRE) { 184210284Sjmallett isc_region_t sr, sr2; 185210284Sjmallett isc_region_t tr; 186210284Sjmallett uint16_t afi; 187210284Sjmallett uint8_t prefix; 188210284Sjmallett uint8_t len; 189210284Sjmallett 190210284Sjmallett REQUIRE(type == dns_rdatatype_apl); 191210284Sjmallett REQUIRE(rdclass == dns_rdataclass_in); 192210284Sjmallett 193210284Sjmallett UNUSED(type); 194232812Sjmallett UNUSED(dctx); 195210284Sjmallett UNUSED(rdclass); 196210284Sjmallett UNUSED(options); 197210284Sjmallett 198210284Sjmallett isc_buffer_activeregion(source, &sr); 199210284Sjmallett isc_buffer_availableregion(target, &tr); 200210284Sjmallett if (sr.length > tr.length) { 201210284Sjmallett return (ISC_R_NOSPACE); 202210284Sjmallett } 203210284Sjmallett sr2 = sr; 204210284Sjmallett 205210284Sjmallett /* Zero or more items */ 206210284Sjmallett while (sr.length > 0) { 207210284Sjmallett if (sr.length < 4) { 208210284Sjmallett return (ISC_R_UNEXPECTEDEND); 209210284Sjmallett } 210210284Sjmallett afi = uint16_fromregion(&sr); 211210284Sjmallett isc_region_consume(&sr, 2); 212210284Sjmallett prefix = *sr.base; 213210284Sjmallett isc_region_consume(&sr, 1); 214210284Sjmallett len = (*sr.base & 0x7f); 215210284Sjmallett isc_region_consume(&sr, 1); 216210284Sjmallett if (len > sr.length) { 217210284Sjmallett return (ISC_R_UNEXPECTEDEND); 218210284Sjmallett } 219210284Sjmallett switch (afi) { 220210284Sjmallett case 1: 221210284Sjmallett if (prefix > 32 || len > 4) { 222210284Sjmallett return (ISC_R_RANGE); 223210284Sjmallett } 224210284Sjmallett break; 225210284Sjmallett case 2: 226210284Sjmallett if (prefix > 128 || len > 16) { 227210284Sjmallett return (ISC_R_RANGE); 228210284Sjmallett } 229210284Sjmallett } 230210284Sjmallett if (len > 0 && sr.base[len - 1] == 0) { 231210284Sjmallett return (DNS_R_FORMERR); 232210284Sjmallett } 233210284Sjmallett isc_region_consume(&sr, len); 234210284Sjmallett } 235210284Sjmallett isc_buffer_forward(source, sr2.length); 236210284Sjmallett return (mem_tobuffer(target, sr2.base, sr2.length)); 237210284Sjmallett} 238210284Sjmallett 239210284Sjmallettstatic inline isc_result_t 240210284Sjmalletttowire_in_apl(ARGS_TOWIRE) { 241210284Sjmallett UNUSED(cctx); 242210284Sjmallett 243210284Sjmallett REQUIRE(rdata->type == dns_rdatatype_apl); 244210284Sjmallett REQUIRE(rdata->rdclass == dns_rdataclass_in); 245210284Sjmallett 246210284Sjmallett return (mem_tobuffer(target, rdata->data, rdata->length)); 247210284Sjmallett} 248210284Sjmallett 249215990Sjmallettstatic inline int 250210284Sjmallettcompare_in_apl(ARGS_COMPARE) { 251210284Sjmallett isc_region_t r1; 252210284Sjmallett isc_region_t r2; 253210284Sjmallett 254210284Sjmallett REQUIRE(rdata1->type == rdata2->type); 255210284Sjmallett REQUIRE(rdata1->rdclass == rdata2->rdclass); 256210284Sjmallett REQUIRE(rdata1->type == dns_rdatatype_apl); 257210284Sjmallett REQUIRE(rdata1->rdclass == dns_rdataclass_in); 258210284Sjmallett 259210284Sjmallett dns_rdata_toregion(rdata1, &r1); 260210284Sjmallett dns_rdata_toregion(rdata2, &r2); 261210284Sjmallett return (isc_region_compare(&r1, &r2)); 262210284Sjmallett} 263210284Sjmallett 264210284Sjmallettstatic inline isc_result_t 265210284Sjmallettfromstruct_in_apl(ARGS_FROMSTRUCT) { 266210284Sjmallett dns_rdata_in_apl_t *apl = source; 267210284Sjmallett isc_buffer_t b; 268210284Sjmallett 269210284Sjmallett REQUIRE(type == dns_rdatatype_apl); 270210284Sjmallett REQUIRE(rdclass == dns_rdataclass_in); 271210284Sjmallett REQUIRE(apl != NULL); 272210284Sjmallett REQUIRE(apl->common.rdtype == type); 273210284Sjmallett REQUIRE(apl->common.rdclass == rdclass); 274210284Sjmallett REQUIRE(apl->apl != NULL || apl->apl_len == 0); 275210284Sjmallett 276210284Sjmallett isc_buffer_init(&b, apl->apl, apl->apl_len); 277210284Sjmallett isc_buffer_add(&b, apl->apl_len); 278210284Sjmallett isc_buffer_setactive(&b, apl->apl_len); 279210284Sjmallett return (fromwire_in_apl(rdclass, type, &b, NULL, false, target)); 280210284Sjmallett} 281210284Sjmallett 282210284Sjmallettstatic inline isc_result_t 283210284Sjmalletttostruct_in_apl(ARGS_TOSTRUCT) { 284210284Sjmallett dns_rdata_in_apl_t *apl = target; 285210284Sjmallett isc_region_t r; 286210284Sjmallett 287210284Sjmallett REQUIRE(apl != NULL); 288232812Sjmallett REQUIRE(rdata->type == dns_rdatatype_apl); 289232812Sjmallett REQUIRE(rdata->rdclass == dns_rdataclass_in); 290232812Sjmallett 291232812Sjmallett apl->common.rdclass = rdata->rdclass; 292210284Sjmallett apl->common.rdtype = rdata->type; 293232812Sjmallett ISC_LINK_INIT(&apl->common, link); 294232812Sjmallett 295232812Sjmallett dns_rdata_toregion(rdata, &r); 296232812Sjmallett apl->apl_len = r.length; 297232812Sjmallett apl->apl = mem_maybedup(mctx, r.base, r.length); 298232812Sjmallett if (apl->apl == NULL) { 299232812Sjmallett return (ISC_R_NOMEMORY); 300232812Sjmallett } 301232812Sjmallett 302232812Sjmallett apl->offset = 0; 303232812Sjmallett apl->mctx = mctx; 304232812Sjmallett return (ISC_R_SUCCESS); 305232812Sjmallett} 306232812Sjmallett 307232812Sjmallettstatic inline void 308232812Sjmallettfreestruct_in_apl(ARGS_FREESTRUCT) { 309210284Sjmallett dns_rdata_in_apl_t *apl = source; 310232812Sjmallett 311232812Sjmallett REQUIRE(apl != NULL); 312232812Sjmallett REQUIRE(apl->common.rdtype == dns_rdatatype_apl); 313210284Sjmallett REQUIRE(apl->common.rdclass == dns_rdataclass_in); 314232812Sjmallett 315232812Sjmallett if (apl->mctx == NULL) { 316232812Sjmallett return; 317232812Sjmallett } 318232812Sjmallett if (apl->apl != NULL) { 319232812Sjmallett isc_mem_free(apl->mctx, apl->apl); 320232812Sjmallett } 321232812Sjmallett apl->mctx = NULL; 322232812Sjmallett} 323232812Sjmallett 324232812Sjmallettisc_result_t 325232812Sjmallettdns_rdata_apl_first(dns_rdata_in_apl_t *apl) { 326210284Sjmallett uint32_t length; 327210284Sjmallett 328232812Sjmallett REQUIRE(apl != NULL); 329232812Sjmallett REQUIRE(apl->common.rdtype == dns_rdatatype_apl); 330232812Sjmallett REQUIRE(apl->common.rdclass == dns_rdataclass_in); 331232812Sjmallett REQUIRE(apl->apl != NULL || apl->apl_len == 0); 332232812Sjmallett 333232812Sjmallett /* 334232812Sjmallett * If no APL return ISC_R_NOMORE. 335232812Sjmallett */ 336210284Sjmallett if (apl->apl == NULL) { 337232812Sjmallett return (ISC_R_NOMORE); 338232812Sjmallett } 339232812Sjmallett 340232812Sjmallett /* 341232812Sjmallett * Sanity check data. 342232812Sjmallett */ 343232812Sjmallett INSIST(apl->apl_len > 3U); 344232812Sjmallett length = apl->apl[apl->offset + 3] & 0x7f; 345232812Sjmallett INSIST(4 + length <= apl->apl_len); 346210284Sjmallett 347232812Sjmallett apl->offset = 0; 348232812Sjmallett return (ISC_R_SUCCESS); 349232812Sjmallett} 350232812Sjmallett 351232812Sjmallettisc_result_t 352232812Sjmallettdns_rdata_apl_next(dns_rdata_in_apl_t *apl) { 353232812Sjmallett uint32_t length; 354232812Sjmallett 355232812Sjmallett REQUIRE(apl != NULL); 356232812Sjmallett REQUIRE(apl->common.rdtype == dns_rdatatype_apl); 357232812Sjmallett REQUIRE(apl->common.rdclass == dns_rdataclass_in); 358232812Sjmallett REQUIRE(apl->apl != NULL || apl->apl_len == 0); 359232812Sjmallett 360232812Sjmallett /* 361232812Sjmallett * No APL or have already reached the end return ISC_R_NOMORE. 362232812Sjmallett */ 363232812Sjmallett if (apl->apl == NULL || apl->offset == apl->apl_len) { 364232812Sjmallett return (ISC_R_NOMORE); 365232812Sjmallett } 366215990Sjmallett 367232812Sjmallett /* 368232812Sjmallett * Sanity check data. 369232812Sjmallett */ 370232812Sjmallett INSIST(apl->offset < apl->apl_len); 371232812Sjmallett INSIST(apl->apl_len > 3U); 372232812Sjmallett INSIST(apl->offset <= apl->apl_len - 4U); 373232812Sjmallett length = apl->apl[apl->offset + 3] & 0x7f; 374232812Sjmallett /* 375232812Sjmallett * 16 to 32 bits promotion as 'length' is 32 bits so there is 376232812Sjmallett * no overflow problems. 377232812Sjmallett */ 378232812Sjmallett INSIST(4 + length + apl->offset <= apl->apl_len); 379232812Sjmallett 380232812Sjmallett apl->offset += 4 + length; 381232812Sjmallett return ((apl->offset < apl->apl_len) ? ISC_R_SUCCESS : ISC_R_NOMORE); 382232812Sjmallett} 383232812Sjmallett 384232812Sjmallettisc_result_t 385215990Sjmallettdns_rdata_apl_current(dns_rdata_in_apl_t *apl, dns_rdata_apl_ent_t *ent) { 386215990Sjmallett uint32_t length; 387210284Sjmallett 388210284Sjmallett REQUIRE(apl != NULL); 389215990Sjmallett REQUIRE(apl->common.rdtype == dns_rdatatype_apl); 390215990Sjmallett REQUIRE(apl->common.rdclass == dns_rdataclass_in); 391215990Sjmallett REQUIRE(ent != NULL); 392210284Sjmallett REQUIRE(apl->apl != NULL || apl->apl_len == 0); 393210284Sjmallett REQUIRE(apl->offset <= apl->apl_len); 394210284Sjmallett 395210284Sjmallett if (apl->offset == apl->apl_len) { 396210284Sjmallett return (ISC_R_NOMORE); 397210284Sjmallett } 398210284Sjmallett 399210284Sjmallett /* 400210284Sjmallett * Sanity check data. 401210284Sjmallett */ 402210284Sjmallett INSIST(apl->apl_len > 3U); 403210284Sjmallett INSIST(apl->offset <= apl->apl_len - 4U); 404210284Sjmallett length = (apl->apl[apl->offset + 3] & 0x7f); 405210284Sjmallett /* 406210284Sjmallett * 16 to 32 bits promotion as 'length' is 32 bits so there is 407210284Sjmallett * no overflow problems. 408210284Sjmallett */ 409210284Sjmallett INSIST(4 + length + apl->offset <= apl->apl_len); 410210284Sjmallett 411210284Sjmallett ent->family = (apl->apl[apl->offset] << 8) + apl->apl[apl->offset + 1]; 412210284Sjmallett ent->prefix = apl->apl[apl->offset + 2]; 413232812Sjmallett ent->length = length; 414232812Sjmallett ent->negative = (apl->apl[apl->offset + 3] & 0x80); 415232812Sjmallett if (ent->length != 0) { 416210284Sjmallett ent->data = &apl->apl[apl->offset + 4]; 417210284Sjmallett } else { 418210284Sjmallett ent->data = NULL; 419210284Sjmallett } 420232812Sjmallett return (ISC_R_SUCCESS); 421232812Sjmallett} 422232812Sjmallett 423232812Sjmallettunsigned int 424210284Sjmallettdns_rdata_apl_count(const dns_rdata_in_apl_t *apl) { 425210284Sjmallett return (apl->apl_len); 426210284Sjmallett} 427210284Sjmallett 428210284Sjmallettstatic inline isc_result_t 429210284Sjmallettadditionaldata_in_apl(ARGS_ADDLDATA) { 430210284Sjmallett REQUIRE(rdata->type == dns_rdatatype_apl); 431210284Sjmallett REQUIRE(rdata->rdclass == dns_rdataclass_in); 432210284Sjmallett 433210284Sjmallett (void)add; 434210284Sjmallett (void)arg; 435210284Sjmallett 436210284Sjmallett return (ISC_R_SUCCESS); 437210284Sjmallett} 438210284Sjmallett 439210284Sjmallettstatic inline isc_result_t 440232812Sjmallettdigest_in_apl(ARGS_DIGEST) { 441232812Sjmallett isc_region_t r; 442232812Sjmallett 443232812Sjmallett REQUIRE(rdata->type == dns_rdatatype_apl); 444232812Sjmallett REQUIRE(rdata->rdclass == dns_rdataclass_in); 445232812Sjmallett 446210284Sjmallett dns_rdata_toregion(rdata, &r); 447210284Sjmallett 448210284Sjmallett return ((digest)(arg, &r)); 449210284Sjmallett} 450210284Sjmallett 451210284Sjmallettstatic inline bool 452210284Sjmallettcheckowner_in_apl(ARGS_CHECKOWNER) { 453210284Sjmallett REQUIRE(type == dns_rdatatype_apl); 454210284Sjmallett REQUIRE(rdclass == dns_rdataclass_in); 455210284Sjmallett 456210284Sjmallett UNUSED(name); 457210284Sjmallett UNUSED(type); 458210284Sjmallett UNUSED(rdclass); 459210284Sjmallett UNUSED(wildcard); 460210284Sjmallett 461210284Sjmallett return (true); 462210284Sjmallett} 463210284Sjmallett 464210284Sjmallettstatic inline bool 465210284Sjmallettchecknames_in_apl(ARGS_CHECKNAMES) { 466210284Sjmallett REQUIRE(rdata->type == dns_rdatatype_apl); 467210284Sjmallett REQUIRE(rdata->rdclass == dns_rdataclass_in); 468210284Sjmallett 469210284Sjmallett UNUSED(rdata); 470210284Sjmallett UNUSED(owner); 471210284Sjmallett UNUSED(bad); 472210284Sjmallett 473210284Sjmallett return (true); 474210284Sjmallett} 475210284Sjmallett 476210284Sjmallettstatic inline int 477210284Sjmallettcasecompare_in_apl(ARGS_COMPARE) { 478232812Sjmallett return (compare_in_apl(rdata1, rdata2)); 479232812Sjmallett} 480232812Sjmallett 481232812Sjmallett#endif /* RDATA_IN_1_APL_42_C */ 482232812Sjmallett