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

   1 /*      $NetBSD: openpgpkey_61.c,v 1.1.1.2 2015/09/03 07:21:39 christos Exp $   */
   2
   3 /*
   4  * Copyright (C) 2014  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 #ifndef RDATA_GENERIC_OPENPGPKEY_61_C
  20 #define RDATA_GENERIC_OPENPGPKEY_61_C
  21
  22 #define RRTYPE_OPENPGPKEY_ATTRIBUTES 0
  23
  24 static inline isc_result_t
  25 fromtext_openpgpkey(ARGS_FROMTEXT) {
  26
  27         REQUIRE(type == 61);
  28
  29         UNUSED(type);
  30         UNUSED(rdclass);
  31         UNUSED(callbacks);
  32         UNUSED(options);
  33         UNUSED(origin);
  34
  35         /*
  36          * Keyring.
  37          */
  38         return (isc_base64_tobuffer(lexer, target, -1));
  39 }
  40
  41 static inline isc_result_t
  42 totext_openpgpkey(ARGS_TOTEXT) {
  43         isc_region_t sr;
  44
  45         REQUIRE(rdata->type == 61);
  46         REQUIRE(rdata->length != 0);
  47
  48         dns_rdata_toregion(rdata, &sr);
  49
  50         /*
  51          * Keyring
  52          */
  53         if ((tctx->flags & DNS_STYLEFLAG_MULTILINE) != 0)
  54                 RETERR(str_totext("( ", target));
  55
  56         if ((tctx->flags & DNS_STYLEFLAG_NOCRYPTO) == 0) {
  57                 if (tctx->width == 0)   /* No splitting */
  58                         RETERR(isc_base64_totext(&sr, 60, "", target));
  59                 else
  60                         RETERR(isc_base64_totext(&sr, tctx->width - 2,
  61                                                  tctx->linebreak, target));
  62         } else
  63                 RETERR(str_totext("[omitted]", target));
  64
  65         if ((tctx->flags & DNS_STYLEFLAG_MULTILINE) != 0)
  66                 RETERR(str_totext(" )", target));
  67
  68         return (ISC_R_SUCCESS);
  69 }
  70
  71 static inline isc_result_t
  72 fromwire_openpgpkey(ARGS_FROMWIRE) {
  73         isc_region_t sr;
  74
  75         REQUIRE(type == 61);
  76
  77         UNUSED(type);
  78         UNUSED(rdclass);
  79         UNUSED(dctx);
  80         UNUSED(options);
  81
  82         /*
  83          * Keyring.
  84          */
  85         isc_buffer_activeregion(source, &sr);
  86         if (sr.length < 1)
  87                 return (ISC_R_UNEXPECTEDEND);
  88         isc_buffer_forward(source, sr.length);
  89         return (mem_tobuffer(target, sr.base, sr.length));
  90 }
  91
  92 static inline isc_result_t
  93 towire_openpgpkey(ARGS_TOWIRE) {
  94         isc_region_t sr;
  95
  96         REQUIRE(rdata->type == 61);
  97         REQUIRE(rdata->length != 0);
  98
  99         UNUSED(cctx);
 100
 101         dns_rdata_toregion(rdata, &sr);
 102         return (mem_tobuffer(target, sr.base, sr.length));
 103 }
 104
 105 static inline int
 106 compare_openpgpkey(ARGS_COMPARE) {
 107         isc_region_t r1;
 108         isc_region_t r2;
 109
 110         REQUIRE(rdata1->type == rdata2->type);
 111         REQUIRE(rdata1->rdclass == rdata2->rdclass);
 112         REQUIRE(rdata1->type == 61);
 113         REQUIRE(rdata1->length != 0);
 114         REQUIRE(rdata2->length != 0);
 115
 116         dns_rdata_toregion(rdata1, &r1);
 117         dns_rdata_toregion(rdata2, &r2);
 118         return (isc_region_compare(&r1, &r2));
 119 }
 120
 121 static inline isc_result_t
 122 fromstruct_openpgpkey(ARGS_FROMSTRUCT) {
 123         dns_rdata_openpgpkey_t *sig = source;
 124
 125         REQUIRE(type == 61);
 126         REQUIRE(source != NULL);
 127         REQUIRE(sig->common.rdtype == type);
 128         REQUIRE(sig->common.rdclass == rdclass);
 129         REQUIRE(sig->keyring != NULL && sig->length != 0);
 130
 131         UNUSED(type);
 132         UNUSED(rdclass);
 133
 134         /*
 135          * Keyring.
 136          */
 137         return (mem_tobuffer(target, sig->keyring, sig->length));
 138 }
 139
 140 static inline isc_result_t
 141 tostruct_openpgpkey(ARGS_TOSTRUCT) {
 142         isc_region_t sr;
 143         dns_rdata_openpgpkey_t *sig = target;
 144
 145         REQUIRE(rdata->type == 61);
 146         REQUIRE(target != NULL);
 147         REQUIRE(rdata->length != 0);
 148
 149         sig->common.rdclass = rdata->rdclass;
 150         sig->common.rdtype = rdata->type;
 151         ISC_LINK_INIT(&sig->common, link);
 152
 153         dns_rdata_toregion(rdata, &sr);
 154
 155         /*
 156          * Keyring.
 157          */
 158         sig->length = sr.length;
 159         sig->keyring = mem_maybedup(mctx, sr.base, sig->length);
 160         if (sig->keyring == NULL)
 161                 goto cleanup;
 162
 163         sig->mctx = mctx;
 164         return (ISC_R_SUCCESS);
 165
 166  cleanup:
 167         return (ISC_R_NOMEMORY);
 168 }
 169
 170 static inline void
 171 freestruct_openpgpkey(ARGS_FREESTRUCT) {
 172         dns_rdata_openpgpkey_t *sig = (dns_rdata_openpgpkey_t *) source;
 173
 174         REQUIRE(source != NULL);
 175         REQUIRE(sig->common.rdtype == 61);
 176
 177         if (sig->mctx == NULL)
 178                 return;
 179
 180         if (sig->keyring != NULL)
 181                 isc_mem_free(sig->mctx, sig->keyring);
 182         sig->mctx = NULL;
 183 }
 184
 185 static inline isc_result_t
 186 additionaldata_openpgpkey(ARGS_ADDLDATA) {
 187         REQUIRE(rdata->type == 61);
 188
 189         UNUSED(rdata);
 190         UNUSED(add);
 191         UNUSED(arg);
 192
 193         return (ISC_R_SUCCESS);
 194 }
 195
 196 static inline isc_result_t
 197 digest_openpgpkey(ARGS_DIGEST) {
 198         isc_region_t r;
 199
 200         REQUIRE(rdata->type == 61);
 201
 202         dns_rdata_toregion(rdata, &r);
 203
 204         return ((digest)(arg, &r));
 205 }
 206
 207 static inline isc_boolean_t
 208 checkowner_openpgpkey(ARGS_CHECKOWNER) {
 209
 210         REQUIRE(type == 61);
 211
 212         UNUSED(name);
 213         UNUSED(type);
 214         UNUSED(rdclass);
 215         UNUSED(wildcard);
 216
 217         return (ISC_TRUE);
 218 }
 219
 220 static inline isc_boolean_t
 221 checknames_openpgpkey(ARGS_CHECKNAMES) {
 222
 223         REQUIRE(rdata->type == 61);
 224
 225         UNUSED(rdata);
 226         UNUSED(owner);
 227         UNUSED(bad);
 228
 229         return (ISC_TRUE);
 230 }
 231
 232 static inline int
 233 casecompare_openpgpkey(ARGS_COMPARE) {
 234         isc_region_t r1;
 235         isc_region_t r2;
 236
 237         REQUIRE(rdata1->type == rdata2->type);
 238         REQUIRE(rdata1->rdclass == rdata2->rdclass);
 239         REQUIRE(rdata1->type == 61);
 240         REQUIRE(rdata1->length != 0);
 241         REQUIRE(rdata2->length != 0);
 242
 243         dns_rdata_toregion(rdata1, &r1);
 244         dns_rdata_toregion(rdata2, &r2);
 245
 246         return (isc_region_compare(&r1, &r2));
 247 }
 248
 249 #endif  /* RDATA_GENERIC_OPENPGPKEY_61_C */