contrib/bind9/lib/dns/rdata/generic/keydata_65533.c

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