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

   1 /*
   2  * Copyright (C) 2009, 2011-2013  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 (0)
  25
  26 static inline isc_result_t
  27 fromtext_keydata(ARGS_FROMTEXT) {
  28         isc_result_t result;
  29         isc_token_t token;
  30         dns_secalg_t alg;
  31         dns_secproto_t proto;
  32         dns_keyflags_t flags;
  33         isc_uint32_t refresh, addhd, removehd;
  34
  35         REQUIRE(type == 65533);
  36
  37         UNUSED(type);
  38         UNUSED(rdclass);
  39         UNUSED(origin);
  40         UNUSED(options);
  41         UNUSED(callbacks);
  42
  43         /* refresh timer */
  44         RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
  45                                       ISC_FALSE));
  46         RETTOK(dns_time32_fromtext(DNS_AS_STR(token), &refresh));
  47         RETERR(uint32_tobuffer(refresh, target));
  48
  49         /* add hold-down */
  50         RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
  51                                       ISC_FALSE));
  52         RETTOK(dns_time32_fromtext(DNS_AS_STR(token), &addhd));
  53         RETERR(uint32_tobuffer(addhd, target));
  54
  55         /* remove hold-down */
  56         RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
  57                                       ISC_FALSE));
  58         RETTOK(dns_time32_fromtext(DNS_AS_STR(token), &removehd));
  59         RETERR(uint32_tobuffer(removehd, target));
  60
  61         /* flags */
  62         RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
  63                                       ISC_FALSE));
  64         RETTOK(dns_keyflags_fromtext(&flags, &token.value.as_textregion));
  65         RETERR(uint16_tobuffer(flags, target));
  66
  67         /* protocol */
  68         RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
  69                                       ISC_FALSE));
  70         RETTOK(dns_secproto_fromtext(&proto, &token.value.as_textregion));
  71         RETERR(mem_tobuffer(target, &proto, 1));
  72
  73         /* algorithm */
  74         RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
  75                                       ISC_FALSE));
  76         RETTOK(dns_secalg_fromtext(&alg, &token.value.as_textregion));
  77         RETERR(mem_tobuffer(target, &alg, 1));
  78
  79         /* No Key? */
  80         if ((flags & 0xc000) == 0xc000)
  81                 return (ISC_R_SUCCESS);
  82
  83         result = isc_base64_tobuffer(lexer, target, -1);
  84         if (result != ISC_R_SUCCESS)
  85                 return (result);
  86
  87         /* Ensure there's at least enough data to compute a key ID for MD5 */
  88         if (alg == DST_ALG_RSAMD5 && isc_buffer_usedlength(target) < 19)
  89                 return (ISC_R_UNEXPECTEDEND);
  90
  91         return (ISC_R_SUCCESS);
  92 }
  93
  94 static inline isc_result_t
  95 totext_keydata(ARGS_TOTEXT) {
  96         isc_region_t sr;
  97         char buf[sizeof("64000")];
  98         unsigned int flags;
  99         unsigned char algorithm;
 100         unsigned long when;
 101         char algbuf[DNS_NAME_FORMATSIZE];
 102         const char *keyinfo;
 103
 104         REQUIRE(rdata->type == 65533);
 105
 106         if ((tctx->flags & DNS_STYLEFLAG_KEYDATA) == 0 || rdata->length < 16)
 107                 return (unknown_totext(rdata, tctx, target));
 108
 109         dns_rdata_toregion(rdata, &sr);
 110
 111         /* refresh timer */
 112         when = uint32_fromregion(&sr);
 113         isc_region_consume(&sr, 4);
 114         RETERR(dns_time32_totext(when, target));
 115         RETERR(str_totext(" ", target));
 116
 117         /* add hold-down */
 118         when = uint32_fromregion(&sr);
 119         isc_region_consume(&sr, 4);
 120         RETERR(dns_time32_totext(when, target));
 121         RETERR(str_totext(" ", target));
 122
 123         /* remove hold-down */
 124         when = uint32_fromregion(&sr);
 125         isc_region_consume(&sr, 4);
 126         RETERR(dns_time32_totext(when, target));
 127         RETERR(str_totext(" ", target));
 128
 129         /* flags */
 130         flags = uint16_fromregion(&sr);
 131         isc_region_consume(&sr, 2);
 132         sprintf(buf, "%u", flags);
 133         RETERR(str_totext(buf, target));
 134         RETERR(str_totext(" ", target));
 135         if ((flags & DNS_KEYFLAG_KSK) != 0) {
 136                 if (flags & DNS_KEYFLAG_REVOKE)
 137                         keyinfo = "revoked KSK";
 138                 else
 139                         keyinfo = "KSK";
 140         } else
 141                 keyinfo = "ZSK";
 142
 143         /* protocol */
 144         sprintf(buf, "%u", sr.base[0]);
 145         isc_region_consume(&sr, 1);
 146         RETERR(str_totext(buf, target));
 147         RETERR(str_totext(" ", target));
 148
 149         /* algorithm */
 150         algorithm = sr.base[0];
 151         sprintf(buf, "%u", algorithm);
 152         isc_region_consume(&sr, 1);
 153         RETERR(str_totext(buf, target));
 154
 155         /* No Key? */
 156         if ((flags & 0xc000) == 0xc000)
 157                 return (ISC_R_SUCCESS);
 158
 159         /* key */
 160         if ((tctx->flags & DNS_STYLEFLAG_MULTILINE) != 0)
 161                 RETERR(str_totext(" (", target));
 162         RETERR(str_totext(tctx->linebreak, target));
 163         if (tctx->width == 0)   /* No splitting */
 164                 RETERR(isc_base64_totext(&sr, 60, "", target));
 165         else
 166                 RETERR(isc_base64_totext(&sr, tctx->width - 2,
 167                                          tctx->linebreak, target));
 168
 169         if ((tctx->flags & DNS_STYLEFLAG_RRCOMMENT) != 0)
 170                 RETERR(str_totext(tctx->linebreak, target));
 171         else if ((tctx->flags & DNS_STYLEFLAG_MULTILINE) != 0)
 172                 RETERR(str_totext(" ", target));
 173
 174         if ((tctx->flags & DNS_STYLEFLAG_MULTILINE) != 0)
 175                 RETERR(str_totext(")", target));
 176
 177         if ((tctx->flags & DNS_STYLEFLAG_RRCOMMENT) != 0) {
 178                 isc_region_t tmpr;
 179
 180                 RETERR(str_totext(" ; ", target));
 181                 RETERR(str_totext(keyinfo, target));
 182                 dns_secalg_format((dns_secalg_t) algorithm, algbuf,
 183                                   sizeof(algbuf));
 184                 RETERR(str_totext("; alg = ", target));
 185                 RETERR(str_totext(algbuf, target));
 186                 RETERR(str_totext("; key id = ", target));
 187                 dns_rdata_toregion(rdata, &tmpr);
 188                 /* Skip over refresh, addhd, and removehd */
 189                 isc_region_consume(&tmpr, 12);
 190                 sprintf(buf, "%u", dst_region_computeid(&tmpr, algorithm));
 191                 RETERR(str_totext(buf, target));
 192         }
 193         return (ISC_R_SUCCESS);
 194 }
 195
 196 static inline isc_result_t
 197 fromwire_keydata(ARGS_FROMWIRE) {
 198         isc_region_t sr;
 199
 200         REQUIRE(type == 65533);
 201
 202         UNUSED(type);
 203         UNUSED(rdclass);
 204         UNUSED(dctx);
 205         UNUSED(options);
 206
 207         isc_buffer_activeregion(source, &sr);
 208         isc_buffer_forward(source, sr.length);
 209         return (mem_tobuffer(target, sr.base, sr.length));
 210 }
 211
 212 static inline isc_result_t
 213 towire_keydata(ARGS_TOWIRE) {
 214         isc_region_t sr;
 215
 216         REQUIRE(rdata->type == 65533);
 217
 218         UNUSED(cctx);
 219
 220         dns_rdata_toregion(rdata, &sr);
 221         return (mem_tobuffer(target, sr.base, sr.length));
 222 }
 223
 224 static inline int
 225 compare_keydata(ARGS_COMPARE) {
 226         isc_region_t r1;
 227         isc_region_t r2;
 228
 229         REQUIRE(rdata1->type == rdata2->type);
 230         REQUIRE(rdata1->rdclass == rdata2->rdclass);
 231         REQUIRE(rdata1->type == 65533);
 232
 233         dns_rdata_toregion(rdata1, &r1);
 234         dns_rdata_toregion(rdata2, &r2);
 235         return (isc_region_compare(&r1, &r2));
 236 }
 237
 238 static inline isc_result_t
 239 fromstruct_keydata(ARGS_FROMSTRUCT) {
 240         dns_rdata_keydata_t *keydata = source;
 241
 242         REQUIRE(type == 65533);
 243         REQUIRE(source != NULL);
 244         REQUIRE(keydata->common.rdtype == type);
 245         REQUIRE(keydata->common.rdclass == rdclass);
 246
 247         UNUSED(type);
 248         UNUSED(rdclass);
 249
 250         /* Refresh timer */
 251         RETERR(uint32_tobuffer(keydata->refresh, target));
 252
 253         /* Add hold-down */
 254         RETERR(uint32_tobuffer(keydata->addhd, target));
 255
 256         /* Remove hold-down */
 257         RETERR(uint32_tobuffer(keydata->removehd, target));
 258
 259         /* Flags */
 260         RETERR(uint16_tobuffer(keydata->flags, target));
 261
 262         /* Protocol */
 263         RETERR(uint8_tobuffer(keydata->protocol, target));
 264
 265         /* Algorithm */
 266         RETERR(uint8_tobuffer(keydata->algorithm, target));
 267
 268         /* Data */
 269         return (mem_tobuffer(target, keydata->data, keydata->datalen));
 270 }
 271
 272 static inline isc_result_t
 273 tostruct_keydata(ARGS_TOSTRUCT) {
 274         dns_rdata_keydata_t *keydata = target;
 275         isc_region_t sr;
 276
 277         REQUIRE(rdata->type == 65533);
 278         REQUIRE(target != NULL);
 279
 280         keydata->common.rdclass = rdata->rdclass;
 281         keydata->common.rdtype = rdata->type;
 282         ISC_LINK_INIT(&keydata->common, link);
 283
 284         dns_rdata_toregion(rdata, &sr);
 285
 286         /* Refresh timer */
 287         if (sr.length < 4)
 288                 return (ISC_R_UNEXPECTEDEND);
 289         keydata->refresh = uint32_fromregion(&sr);
 290         isc_region_consume(&sr, 4);
 291
 292         /* Add hold-down */
 293         if (sr.length < 4)
 294                 return (ISC_R_UNEXPECTEDEND);
 295         keydata->addhd = uint32_fromregion(&sr);
 296         isc_region_consume(&sr, 4);
 297
 298         /* Remove hold-down */
 299         if (sr.length < 4)
 300                 return (ISC_R_UNEXPECTEDEND);
 301         keydata->removehd = uint32_fromregion(&sr);
 302         isc_region_consume(&sr, 4);
 303
 304         /* Flags */
 305         if (sr.length < 2)
 306                 return (ISC_R_UNEXPECTEDEND);
 307         keydata->flags = uint16_fromregion(&sr);
 308         isc_region_consume(&sr, 2);
 309
 310         /* Protocol */
 311         if (sr.length < 1)
 312                 return (ISC_R_UNEXPECTEDEND);
 313         keydata->protocol = uint8_fromregion(&sr);
 314         isc_region_consume(&sr, 1);
 315
 316         /* Algorithm */
 317         if (sr.length < 1)
 318                 return (ISC_R_UNEXPECTEDEND);
 319         keydata->algorithm = uint8_fromregion(&sr);
 320         isc_region_consume(&sr, 1);
 321
 322         /* Data */
 323         keydata->datalen = sr.length;
 324         keydata->data = mem_maybedup(mctx, sr.base, keydata->datalen);
 325         if (keydata->data == NULL)
 326                 return (ISC_R_NOMEMORY);
 327
 328         keydata->mctx = mctx;
 329         return (ISC_R_SUCCESS);
 330 }
 331
 332 static inline void
 333 freestruct_keydata(ARGS_FREESTRUCT) {
 334         dns_rdata_keydata_t *keydata = (dns_rdata_keydata_t *) source;
 335
 336         REQUIRE(source != NULL);
 337         REQUIRE(keydata->common.rdtype == 65533);
 338
 339         if (keydata->mctx == NULL)
 340                 return;
 341
 342         if (keydata->data != NULL)
 343                 isc_mem_free(keydata->mctx, keydata->data);
 344         keydata->mctx = NULL;
 345 }
 346
 347 static inline isc_result_t
 348 additionaldata_keydata(ARGS_ADDLDATA) {
 349         REQUIRE(rdata->type == 65533);
 350
 351         UNUSED(rdata);
 352         UNUSED(add);
 353         UNUSED(arg);
 354
 355         return (ISC_R_SUCCESS);
 356 }
 357
 358 static inline isc_result_t
 359 digest_keydata(ARGS_DIGEST) {
 360         isc_region_t r;
 361
 362         REQUIRE(rdata->type == 65533);
 363
 364         dns_rdata_toregion(rdata, &r);
 365
 366         return ((digest)(arg, &r));
 367 }
 368
 369 static inline isc_boolean_t
 370 checkowner_keydata(ARGS_CHECKOWNER) {
 371
 372         REQUIRE(type == 65533);
 373
 374         UNUSED(name);
 375         UNUSED(type);
 376         UNUSED(rdclass);
 377         UNUSED(wildcard);
 378
 379         return (ISC_TRUE);
 380 }
 381
 382 static inline isc_boolean_t
 383 checknames_keydata(ARGS_CHECKNAMES) {
 384
 385         REQUIRE(rdata->type == 65533);
 386
 387         UNUSED(rdata);
 388         UNUSED(owner);
 389         UNUSED(bad);
 390
 391         return (ISC_TRUE);
 392 }
 393
 394 static inline int
 395 casecompare_keydata(ARGS_COMPARE) {
 396         return (compare_keydata(rdata1, rdata2));
 397 }
 398
 399 #endif /* GENERIC_KEYDATA_65533_C */