external/bsd/bind/dist/lib/dns/rdata/generic/keydata_65533.c

   1 /*      $NetBSD$        */
   2
   3 /*
   4  * Copyright (C) 2009  Internet Systems Consortium, Inc. ("ISC")
   5  *
   6  * Permission to use, copy, modify, and/or distribute this software for any
   7  * purpose with or without fee is hereby granted, provided that the above
   8  * copyright notice and this permission notice appear in all copies.
   9  *
  10  * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
  11  * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  12  * AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
  13  * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
  14  * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
  15  * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  16  * PERFORMANCE OF THIS SOFTWARE.
  17  */
  18
  19 /* Id: keydata_65533.c,v 1.3 2009/12/04 21:09:33 marka Exp */
  20
  21 #ifndef GENERIC_KEYDATA_65533_C
  22 #define GENERIC_KEYDATA_65533_C 1
  23
  24 #include <dst/dst.h>
  25
  26 #define RRTYPE_KEYDATA_ATTRIBUTES (DNS_RDATATYPEATTR_DNSSEC)
  27
  28 static inline isc_result_t
  29 fromtext_keydata(ARGS_FROMTEXT) {
  30         isc_token_t token;
  31         dns_secalg_t alg;
  32         dns_secproto_t proto;
  33         dns_keyflags_t flags;
  34         isc_uint32_t refresh, addhd, removehd;
  35
  36         REQUIRE(type == 65533);
  37
  38         UNUSED(type);
  39         UNUSED(rdclass);
  40         UNUSED(origin);
  41         UNUSED(options);
  42         UNUSED(callbacks);
  43
  44         /* refresh timer */
  45         RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
  46                                       ISC_FALSE));
  47         RETTOK(dns_time32_fromtext(DNS_AS_STR(token), &refresh));
  48         RETERR(uint32_tobuffer(refresh, target));
  49
  50         /* add hold-down */
  51         RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
  52                                       ISC_FALSE));
  53         RETTOK(dns_time32_fromtext(DNS_AS_STR(token), &addhd));
  54         RETERR(uint32_tobuffer(addhd, target));
  55
  56         /* remove hold-down */
  57         RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
  58                                       ISC_FALSE));
  59         RETTOK(dns_time32_fromtext(DNS_AS_STR(token), &removehd));
  60         RETERR(uint32_tobuffer(removehd, target));
  61
  62         /* flags */
  63         RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
  64                                       ISC_FALSE));
  65         RETTOK(dns_keyflags_fromtext(&flags, &token.value.as_textregion));
  66         RETERR(uint16_tobuffer(flags, target));
  67
  68         /* protocol */
  69         RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
  70                                       ISC_FALSE));
  71         RETTOK(dns_secproto_fromtext(&proto, &token.value.as_textregion));
  72         RETERR(mem_tobuffer(target, &proto, 1));
  73
  74         /* algorithm */
  75         RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
  76                                       ISC_FALSE));
  77         RETTOK(dns_secalg_fromtext(&alg, &token.value.as_textregion));
  78         RETERR(mem_tobuffer(target, &alg, 1));
  79
  80         /* No Key? */
  81         if ((flags & 0xc000) == 0xc000)
  82                 return (ISC_R_SUCCESS);
  83
  84         return (isc_base64_tobuffer(lexer, target, -1));
  85 }
  86
  87 static inline isc_result_t
  88 totext_keydata(ARGS_TOTEXT) {
  89         isc_region_t sr;
  90         char buf[sizeof("64000")];
  91         unsigned int flags;
  92         unsigned char algorithm;
  93         unsigned long when;
  94
  95         REQUIRE(rdata->type == 65533);
  96         REQUIRE(rdata->length != 0);
  97
  98         dns_rdata_toregion(rdata, &sr);
  99
 100         /* refresh timer */
 101         when = uint32_fromregion(&sr);
 102         isc_region_consume(&sr, 4);
 103         RETERR(dns_time32_totext(when, target));
 104         RETERR(str_totext(" ", target));
 105
 106         /* add hold-down */
 107         when = uint32_fromregion(&sr);
 108         isc_region_consume(&sr, 4);
 109         RETERR(dns_time32_totext(when, target));
 110         RETERR(str_totext(" ", target));
 111
 112         /* remove hold-down */
 113         when = uint32_fromregion(&sr);
 114         isc_region_consume(&sr, 4);
 115         RETERR(dns_time32_totext(when, target));
 116         RETERR(str_totext(" ", target));
 117
 118         /* flags */
 119         flags = uint16_fromregion(&sr);
 120         isc_region_consume(&sr, 2);
 121         sprintf(buf, "%u", flags);
 122         RETERR(str_totext(buf, target));
 123         RETERR(str_totext(" ", target));
 124
 125         /* protocol */
 126         sprintf(buf, "%u", sr.base[0]);
 127         isc_region_consume(&sr, 1);
 128         RETERR(str_totext(buf, target));
 129         RETERR(str_totext(" ", target));
 130
 131         /* algorithm */
 132         algorithm = sr.base[0];
 133         sprintf(buf, "%u", algorithm);
 134         isc_region_consume(&sr, 1);
 135         RETERR(str_totext(buf, target));
 136
 137         /* No Key? */
 138         if ((flags & 0xc000) == 0xc000)
 139                 return (ISC_R_SUCCESS);
 140
 141         /* key */
 142         if ((tctx->flags & DNS_STYLEFLAG_MULTILINE) != 0)
 143                 RETERR(str_totext(" (", target));
 144         RETERR(str_totext(tctx->linebreak, target));
 145         RETERR(isc_base64_totext(&sr, tctx->width - 2,
 146                                  tctx->linebreak, target));
 147
 148         if ((tctx->flags & DNS_STYLEFLAG_COMMENT) != 0)
 149                 RETERR(str_totext(tctx->linebreak, target));
 150         else if ((tctx->flags & DNS_STYLEFLAG_MULTILINE) != 0)
 151                 RETERR(str_totext(" ", target));
 152
 153         if ((tctx->flags & DNS_STYLEFLAG_MULTILINE) != 0)
 154                 RETERR(str_totext(")", target));
 155
 156         if ((tctx->flags & DNS_STYLEFLAG_COMMENT) != 0) {
 157                 isc_region_t tmpr;
 158
 159                 RETERR(str_totext(" ; key id = ", target));
 160                 dns_rdata_toregion(rdata, &tmpr);
 161                 /* Skip over refresh, addhd, and removehd */
 162                 isc_region_consume(&tmpr, 12);
 163                 sprintf(buf, "%u", dst_region_computeid(&tmpr, algorithm));
 164                 RETERR(str_totext(buf, target));
 165         }
 166         return (ISC_R_SUCCESS);
 167 }
 168
 169 static inline isc_result_t
 170 fromwire_keydata(ARGS_FROMWIRE) {
 171         isc_region_t sr;
 172
 173         REQUIRE(type == 65533);
 174
 175         UNUSED(type);
 176         UNUSED(rdclass);
 177         UNUSED(dctx);
 178         UNUSED(options);
 179
 180         isc_buffer_activeregion(source, &sr);
 181         if (sr.length < 4)
 182                 return (ISC_R_UNEXPECTEDEND);
 183
 184         isc_buffer_forward(source, sr.length);
 185         return (mem_tobuffer(target, sr.base, sr.length));
 186 }
 187
 188 static inline isc_result_t
 189 towire_keydata(ARGS_TOWIRE) {
 190         isc_region_t sr;
 191
 192         REQUIRE(rdata->type == 65533);
 193         REQUIRE(rdata->length != 0);
 194
 195         UNUSED(cctx);
 196
 197         dns_rdata_toregion(rdata, &sr);
 198         return (mem_tobuffer(target, sr.base, sr.length));
 199 }
 200
 201 static inline int
 202 compare_keydata(ARGS_COMPARE) {
 203         isc_region_t r1;
 204         isc_region_t r2;
 205
 206         REQUIRE(rdata1->type == rdata2->type);
 207         REQUIRE(rdata1->rdclass == rdata2->rdclass);
 208         REQUIRE(rdata1->type == 65533);
 209         REQUIRE(rdata1->length != 0);
 210         REQUIRE(rdata2->length != 0);
 211
 212         dns_rdata_toregion(rdata1, &r1);
 213         dns_rdata_toregion(rdata2, &r2);
 214         return (isc_region_compare(&r1, &r2));
 215 }
 216
 217 static inline isc_result_t
 218 fromstruct_keydata(ARGS_FROMSTRUCT) {
 219         dns_rdata_keydata_t *keydata = source;
 220
 221         REQUIRE(type == 65533);
 222         REQUIRE(source != NULL);
 223         REQUIRE(keydata->common.rdtype == type);
 224         REQUIRE(keydata->common.rdclass == rdclass);
 225
 226         UNUSED(type);
 227         UNUSED(rdclass);
 228
 229         /* Refresh timer */
 230         RETERR(uint32_tobuffer(keydata->refresh, target));
 231
 232         /* Add hold-down */
 233         RETERR(uint32_tobuffer(keydata->addhd, target));
 234
 235         /* Remove hold-down */
 236         RETERR(uint32_tobuffer(keydata->removehd, target));
 237
 238         /* Flags */
 239         RETERR(uint16_tobuffer(keydata->flags, target));
 240
 241         /* Protocol */
 242         RETERR(uint8_tobuffer(keydata->protocol, target));
 243
 244         /* Algorithm */
 245         RETERR(uint8_tobuffer(keydata->algorithm, target));
 246
 247         /* Data */
 248         return (mem_tobuffer(target, keydata->data, keydata->datalen));
 249 }
 250
 251 static inline isc_result_t
 252 tostruct_keydata(ARGS_TOSTRUCT) {
 253         dns_rdata_keydata_t *keydata = target;
 254         isc_region_t sr;
 255
 256         REQUIRE(rdata->type == 65533);
 257         REQUIRE(target != NULL);
 258         REQUIRE(rdata->length != 0);
 259
 260         keydata->common.rdclass = rdata->rdclass;
 261         keydata->common.rdtype = rdata->type;
 262         ISC_LINK_INIT(&keydata->common, link);
 263
 264         dns_rdata_toregion(rdata, &sr);
 265
 266         /* Refresh timer */
 267         if (sr.length < 4)
 268                 return (ISC_R_UNEXPECTEDEND);
 269         keydata->refresh = uint32_fromregion(&sr);
 270         isc_region_consume(&sr, 4);
 271
 272         /* Add hold-down */
 273         if (sr.length < 4)
 274                 return (ISC_R_UNEXPECTEDEND);
 275         keydata->addhd = uint32_fromregion(&sr);
 276         isc_region_consume(&sr, 4);
 277
 278         /* Remove hold-down */
 279         if (sr.length < 4)
 280                 return (ISC_R_UNEXPECTEDEND);
 281         keydata->removehd = uint32_fromregion(&sr);
 282         isc_region_consume(&sr, 4);
 283
 284         /* Flags */
 285         if (sr.length < 2)
 286                 return (ISC_R_UNEXPECTEDEND);
 287         keydata->flags = uint16_fromregion(&sr);
 288         isc_region_consume(&sr, 2);
 289
 290         /* Protocol */
 291         if (sr.length < 1)
 292                 return (ISC_R_UNEXPECTEDEND);
 293         keydata->protocol = uint8_fromregion(&sr);
 294         isc_region_consume(&sr, 1);
 295
 296         /* Algorithm */
 297         if (sr.length < 1)
 298                 return (ISC_R_UNEXPECTEDEND);
 299         keydata->algorithm = uint8_fromregion(&sr);
 300         isc_region_consume(&sr, 1);
 301
 302         /* Data */
 303         keydata->datalen = sr.length;
 304         keydata->data = mem_maybedup(mctx, sr.base, keydata->datalen);
 305         if (keydata->data == NULL)
 306                 return (ISC_R_NOMEMORY);
 307
 308         keydata->mctx = mctx;
 309         return (ISC_R_SUCCESS);
 310 }
 311
 312 static inline void
 313 freestruct_keydata(ARGS_FREESTRUCT) {
 314         dns_rdata_keydata_t *keydata = (dns_rdata_keydata_t *) source;
 315
 316         REQUIRE(source != NULL);
 317         REQUIRE(keydata->common.rdtype == 65533);
 318
 319         if (keydata->mctx == NULL)
 320                 return;
 321
 322         if (keydata->data != NULL)
 323                 isc_mem_free(keydata->mctx, keydata->data);
 324         keydata->mctx = NULL;
 325 }
 326
 327 static inline isc_result_t
 328 additionaldata_keydata(ARGS_ADDLDATA) {
 329         REQUIRE(rdata->type == 65533);
 330
 331         UNUSED(rdata);
 332         UNUSED(add);
 333         UNUSED(arg);
 334
 335         return (ISC_R_SUCCESS);
 336 }
 337
 338 static inline isc_result_t
 339 digest_keydata(ARGS_DIGEST) {
 340         isc_region_t r;
 341
 342         REQUIRE(rdata->type == 65533);
 343
 344         dns_rdata_toregion(rdata, &r);
 345
 346         return ((digest)(arg, &r));
 347 }
 348
 349 static inline isc_boolean_t
 350 checkowner_keydata(ARGS_CHECKOWNER) {
 351
 352         REQUIRE(type == 65533);
 353
 354         UNUSED(name);
 355         UNUSED(type);
 356         UNUSED(rdclass);
 357         UNUSED(wildcard);
 358
 359         return (ISC_TRUE);
 360 }
 361
 362 static inline isc_boolean_t
 363 checknames_keydata(ARGS_CHECKNAMES) {
 364
 365         REQUIRE(rdata->type == 65533);
 366
 367         UNUSED(rdata);
 368         UNUSED(owner);
 369         UNUSED(bad);
 370
 371         return (ISC_TRUE);
 372 }
 373
 374 static inline int
 375 casecompare_keydata(ARGS_COMPARE) {
 376         return (compare_keydata(rdata1, rdata2));
 377 }
 378
 379 #endif /* GENERIC_KEYDATA_65533_C */