external/bsd/bind/dist/lib/dns/rdata/in_1/dhcid_49.c

   1 /*      $NetBSD$        */
   2
   3 /*
   4  * Copyright (C) 2006, 2007, 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: dhcid_49.c,v 1.7 2009/12/04 22:06:37 tbox Exp */
  20
  21 /* RFC 4701 */
  22
  23 #ifndef RDATA_IN_1_DHCID_49_C
  24 #define RDATA_IN_1_DHCID_49_C 1
  25
  26 #define RRTYPE_DHCID_ATTRIBUTES 0
  27
  28 static inline isc_result_t
  29 fromtext_in_dhcid(ARGS_FROMTEXT) {
  30
  31         REQUIRE(type == 49);
  32         REQUIRE(rdclass == 1);
  33
  34         UNUSED(type);
  35         UNUSED(rdclass);
  36         UNUSED(origin);
  37         UNUSED(options);
  38         UNUSED(callbacks);
  39
  40         return (isc_base64_tobuffer(lexer, target, -1));
  41 }
  42
  43 static inline isc_result_t
  44 totext_in_dhcid(ARGS_TOTEXT) {
  45         isc_region_t sr;
  46         char buf[sizeof(" ; 64000 255 64000")];
  47         size_t n;
  48
  49         REQUIRE(rdata->type == 49);
  50         REQUIRE(rdata->rdclass == 1);
  51         REQUIRE(rdata->length != 0);
  52
  53         dns_rdata_toregion(rdata, &sr);
  54
  55         if ((tctx->flags & DNS_STYLEFLAG_MULTILINE) != 0)
  56                 RETERR(str_totext("( " /*)*/, target));
  57         RETERR(isc_base64_totext(&sr, tctx->width - 2, tctx->linebreak,
  58                                  target));
  59         if ((tctx->flags & DNS_STYLEFLAG_MULTILINE) != 0) {
  60                 RETERR(str_totext(/* ( */ " )", target));
  61                 if (rdata->length > 2) {
  62                         n = snprintf(buf, sizeof(buf), " ; %u %u %u",
  63                                      sr.base[0] * 256 + sr.base[1],
  64                                      sr.base[2], rdata->length - 3);
  65                         INSIST(n < sizeof(buf));
  66                         RETERR(str_totext(buf, target));
  67                 }
  68         }
  69         return (ISC_R_SUCCESS);
  70 }
  71
  72 static inline isc_result_t
  73 fromwire_in_dhcid(ARGS_FROMWIRE) {
  74         isc_region_t sr;
  75
  76         REQUIRE(type == 49);
  77         REQUIRE(rdclass == 1);
  78
  79         UNUSED(type);
  80         UNUSED(rdclass);
  81         UNUSED(dctx);
  82         UNUSED(options);
  83
  84         isc_buffer_activeregion(source, &sr);
  85         if (sr.length == 0)
  86                 return (ISC_R_UNEXPECTEDEND);
  87
  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_in_dhcid(ARGS_TOWIRE) {
  94         isc_region_t sr;
  95
  96         REQUIRE(rdata->type == 49);
  97         REQUIRE(rdata->rdclass == 1);
  98         REQUIRE(rdata->length != 0);
  99
 100         UNUSED(cctx);
 101
 102         dns_rdata_toregion(rdata, &sr);
 103         return (mem_tobuffer(target, sr.base, sr.length));
 104 }
 105
 106 static inline int
 107 compare_in_dhcid(ARGS_COMPARE) {
 108         isc_region_t r1;
 109         isc_region_t r2;
 110
 111         REQUIRE(rdata1->type == rdata2->type);
 112         REQUIRE(rdata1->rdclass == rdata2->rdclass);
 113         REQUIRE(rdata1->type == 49);
 114         REQUIRE(rdata1->rdclass == 1);
 115         REQUIRE(rdata1->length != 0);
 116         REQUIRE(rdata2->length != 0);
 117
 118         dns_rdata_toregion(rdata1, &r1);
 119         dns_rdata_toregion(rdata2, &r2);
 120         return (isc_region_compare(&r1, &r2));
 121 }
 122
 123 static inline isc_result_t
 124 fromstruct_in_dhcid(ARGS_FROMSTRUCT) {
 125         dns_rdata_in_dhcid_t *dhcid = source;
 126
 127         REQUIRE(type == 49);
 128         REQUIRE(rdclass == 1);
 129         REQUIRE(source != NULL);
 130         REQUIRE(dhcid->common.rdtype == type);
 131         REQUIRE(dhcid->common.rdclass == rdclass);
 132         REQUIRE(dhcid->length != 0);
 133
 134         UNUSED(type);
 135         UNUSED(rdclass);
 136
 137         return (mem_tobuffer(target, dhcid->dhcid, dhcid->length));
 138 }
 139
 140 static inline isc_result_t
 141 tostruct_in_dhcid(ARGS_TOSTRUCT) {
 142         dns_rdata_in_dhcid_t *dhcid = target;
 143         isc_region_t region;
 144
 145         REQUIRE(rdata->type == 49);
 146         REQUIRE(rdata->rdclass == 1);
 147         REQUIRE(target != NULL);
 148         REQUIRE(rdata->length != 0);
 149
 150         dhcid->common.rdclass = rdata->rdclass;
 151         dhcid->common.rdtype = rdata->type;
 152         ISC_LINK_INIT(&dhcid->common, link);
 153
 154         dns_rdata_toregion(rdata, &region);
 155
 156         dhcid->dhcid = mem_maybedup(mctx, region.base, region.length);
 157         if (dhcid->dhcid == NULL)
 158                 return (ISC_R_NOMEMORY);
 159
 160         dhcid->mctx = mctx;
 161         return (ISC_R_SUCCESS);
 162 }
 163
 164 static inline void
 165 freestruct_in_dhcid(ARGS_FREESTRUCT) {
 166         dns_rdata_in_dhcid_t *dhcid = source;
 167
 168         REQUIRE(dhcid != NULL);
 169         REQUIRE(dhcid->common.rdtype == 49);
 170         REQUIRE(dhcid->common.rdclass == 1);
 171
 172         if (dhcid->mctx == NULL)
 173                 return;
 174
 175         if (dhcid->dhcid != NULL)
 176                 isc_mem_free(dhcid->mctx, dhcid->dhcid);
 177         dhcid->mctx = NULL;
 178 }
 179
 180 static inline isc_result_t
 181 additionaldata_in_dhcid(ARGS_ADDLDATA) {
 182         REQUIRE(rdata->type == 49);
 183         REQUIRE(rdata->rdclass == 1);
 184
 185         UNUSED(rdata);
 186         UNUSED(add);
 187         UNUSED(arg);
 188
 189         return (ISC_R_SUCCESS);
 190 }
 191
 192 static inline isc_result_t
 193 digest_in_dhcid(ARGS_DIGEST) {
 194         isc_region_t r;
 195
 196         REQUIRE(rdata->type == 49);
 197         REQUIRE(rdata->rdclass == 1);
 198
 199         dns_rdata_toregion(rdata, &r);
 200
 201         return ((digest)(arg, &r));
 202 }
 203
 204 static inline isc_boolean_t
 205 checkowner_in_dhcid(ARGS_CHECKOWNER) {
 206
 207         REQUIRE(type == 49);
 208         REQUIRE(rdclass == 1);
 209
 210         UNUSED(name);
 211         UNUSED(type);
 212         UNUSED(rdclass);
 213         UNUSED(wildcard);
 214
 215         return (ISC_TRUE);
 216 }
 217
 218 static inline isc_boolean_t
 219 checknames_in_dhcid(ARGS_CHECKNAMES) {
 220
 221         REQUIRE(rdata->type == 49);
 222         REQUIRE(rdata->rdclass == 1);
 223
 224         UNUSED(rdata);
 225         UNUSED(owner);
 226         UNUSED(bad);
 227
 228         return (ISC_TRUE);
 229 }
 230
 231 static inline int
 232 casecompare_in_dhcid(ARGS_COMPARE) {
 233         return (compare_in_dhcid(rdata1, rdata2));
 234 }
 235
 236 #endif  /* RDATA_IN_1_DHCID_49_C */