static inline isc_result_t fromwire_dnskey(ARGS_FROMWIRE) { unsigned char algorithm; isc_region_t sr; REQUIRE(type == 48); UNUSED(type); UNUSED(rdclass); UNUSED(dctx); UNUSED(options); isc_buffer_activeregion(source, &sr); if (sr.length < 4) return (ISC_R_UNEXPECTEDEND); algorithm = sr.base[3]; RETERR(mem_tobuffer(target, sr.base, 4)); isc_region_consume(&sr, 4); isc_buffer_forward(source, 4); if (algorithm == DNS_KEYALG_PRIVATEDNS) { dns_name_t name; dns_decompress_setmethods(dctx, DNS_COMPRESS_NONE); dns_name_init(&name, NULL); RETERR(dns_name_fromwire(&name, source, dctx, options, target)); } isc_buffer_activeregion(source, &sr); isc_buffer_forward(source, sr.length); return (mem_tobuffer(target, sr.base, sr.length)); }
static inline isc_result_t fromwire_tkey(ARGS_FROMWIRE) { isc_region_t sr; unsigned long n; dns_name_t name; REQUIRE(type == 249); UNUSED(type); UNUSED(rdclass); dns_decompress_setmethods(dctx, DNS_COMPRESS_NONE); /* * Algorithm. */ dns_name_init(&name, NULL); RETERR(dns_name_fromwire(&name, source, dctx, options, target)); /* * Inception: 4 * Expiration: 4 * Mode: 2 * Error: 2 */ isc_buffer_activeregion(source, &sr); if (sr.length < 12) return (ISC_R_UNEXPECTEDEND); RETERR(mem_tobuffer(target, sr.base, 12)); isc_region_consume(&sr, 12); isc_buffer_forward(source, 12); /* * Key Length + Key Data. */ if (sr.length < 2) return (ISC_R_UNEXPECTEDEND); n = uint16_fromregion(&sr); if (sr.length < n + 2) return (ISC_R_UNEXPECTEDEND); RETERR(mem_tobuffer(target, sr.base, n + 2)); isc_region_consume(&sr, n + 2); isc_buffer_forward(source, n + 2); /* * Other Length + Other Data. */ if (sr.length < 2) return (ISC_R_UNEXPECTEDEND); n = uint16_fromregion(&sr); if (sr.length < n + 2) return (ISC_R_UNEXPECTEDEND); isc_buffer_forward(source, n + 2); return (mem_tobuffer(target, sr.base, n + 2)); }
static isc_result_t read_one_line(perf_datafile_t *dfile, isc_buffer_t *lines) { const char *cur; unsigned int length, curlen, nrem; isc_result_t result; while (ISC_TRUE) { /* Get the current line */ cur = isc_buffer_current(&dfile->data); curlen = strcspn(cur, "\n"); /* * If the current line contains the rest of the buffer, * we need to read more (unless the full file is cached). */ nrem = isc_buffer_remaininglength(&dfile->data); if (curlen == nrem) { if (! dfile->cached) { result = read_more(dfile); if (result != ISC_R_SUCCESS) return (result); } if (isc_buffer_remaininglength(&dfile->data) == 0) { dfile->nruns++; return (ISC_R_EOF); } if (isc_buffer_remaininglength(&dfile->data) > nrem) continue; } /* We now have a line. Advance the buffer past it. */ isc_buffer_forward(&dfile->data, curlen); if (isc_buffer_remaininglength(&dfile->data) > 0) isc_buffer_forward(&dfile->data, 1); /* If the line is empty or a comment, we need to try again. */ if (curlen > 0 && cur[0] != ';') break; } length = isc_buffer_availablelength(lines); if (curlen > length - 1) curlen = length - 1; isc_buffer_putmem(lines, cur, curlen); isc_buffer_putuint8(lines, 0); return (ISC_R_SUCCESS); }
static inline isc_result_t fromwire_rt(ARGS_FROMWIRE) { dns_name_t name; isc_region_t sregion; isc_region_t tregion; REQUIRE(type == 21); UNUSED(type); UNUSED(rdclass); dns_decompress_setmethods(dctx, DNS_COMPRESS_NONE); dns_name_init(&name, NULL); isc_buffer_activeregion(source, &sregion); isc_buffer_availableregion(target, &tregion); if (tregion.length < 2) return (ISC_R_NOSPACE); if (sregion.length < 2) return (ISC_R_UNEXPECTEDEND); memmove(tregion.base, sregion.base, 2); isc_buffer_forward(source, 2); isc_buffer_add(target, 2); return (dns_name_fromwire(&name, source, dctx, options, target)); }
static inline isc_result_t fromwire_hs_a(ARGS_FROMWIRE) { isc_region_t sregion; isc_region_t tregion; REQUIRE(type == 1); REQUIRE(rdclass == 4); UNUSED(type); UNUSED(dctx); UNUSED(options); UNUSED(rdclass); isc_buffer_activeregion(source, &sregion); isc_buffer_availableregion(target, &tregion); if (sregion.length < 4) return (ISC_R_UNEXPECTEDEND); if (tregion.length < 4) return (ISC_R_NOSPACE); memcpy(tregion.base, sregion.base, 4); isc_buffer_forward(source, 4); isc_buffer_add(target, 4); return (ISC_R_SUCCESS); }
static inline isc_result_t fromwire_nsec3param(ARGS_FROMWIRE) { isc_region_t sr, rr; unsigned int saltlen; REQUIRE(type == dns_rdatatype_nsec3param); UNUSED(type); UNUSED(rdclass); UNUSED(options); UNUSED(dctx); isc_buffer_activeregion(source, &sr); rr = sr; /* hash(1), flags(1), iterations(2), saltlen(1) */ if (sr.length < 5U) RETERR(DNS_R_FORMERR); saltlen = sr.base[4]; isc_region_consume(&sr, 5); if (sr.length < saltlen) RETERR(DNS_R_FORMERR); isc_region_consume(&sr, saltlen); RETERR(mem_tobuffer(target, rr.base, rr.length)); isc_buffer_forward(source, rr.length); return (ISC_R_SUCCESS); }
static inline isc_result_t fromwire_in_px(ARGS_FROMWIRE) { dns_name_t name; isc_region_t sregion; REQUIRE(type == dns_rdatatype_px); REQUIRE(rdclass == dns_rdataclass_in); UNUSED(type); UNUSED(rdclass); dns_decompress_setmethods(dctx, DNS_COMPRESS_NONE); dns_name_init(&name, NULL); /* * Preference. */ isc_buffer_activeregion(source, &sregion); if (sregion.length < 2) return (ISC_R_UNEXPECTEDEND); RETERR(mem_tobuffer(target, sregion.base, 2)); isc_buffer_forward(source, 2); /* * MAP822. */ RETERR(dns_name_fromwire(&name, source, dctx, options, target)); /* * MAPX400. */ return (dns_name_fromwire(&name, source, dctx, options, target)); }
static inline isc_result_t fromwire_ch_a(ARGS_FROMWIRE) { isc_region_t sregion; isc_region_t tregion; dns_name_t name; REQUIRE(type == 1); REQUIRE(rdclass == dns_rdataclass_ch); UNUSED(type); UNUSED(rdclass); dns_decompress_setmethods(dctx, DNS_COMPRESS_GLOBAL14); dns_name_init(&name, NULL); RETERR(dns_name_fromwire(&name, source, dctx, options, target)); isc_buffer_activeregion(source, &sregion); isc_buffer_availableregion(target, &tregion); if (sregion.length < 2) return (ISC_R_UNEXPECTEDEND); if (tregion.length < 2) return (ISC_R_NOSPACE); memcpy(tregion.base, sregion.base, 2); isc_buffer_forward(source, 2); isc_buffer_add(target, 2); return (ISC_R_SUCCESS); }
static inline isc_result_t fromwire_in_srv(ARGS_FROMWIRE) { dns_name_t name; isc_region_t sr; REQUIRE(type == 33); REQUIRE(rdclass == 1); UNUSED(type); UNUSED(rdclass); dns_decompress_setmethods(dctx, DNS_COMPRESS_NONE); dns_name_init(&name, NULL); /* * Priority, weight, port. */ isc_buffer_activeregion(source, &sr); if (sr.length < 6) return (ISC_R_UNEXPECTEDEND); RETERR(mem_tobuffer(target, sr.base, 6)); isc_buffer_forward(source, 6); /* * Target. */ return (dns_name_fromwire(&name, source, dctx, options, target)); }
static inline isc_result_t fromwire_uri(ARGS_FROMWIRE) { isc_region_t region; REQUIRE(type == 256); UNUSED(type); UNUSED(rdclass); UNUSED(dctx); UNUSED(options); /* * Priority, weight */ isc_buffer_activeregion(source, ®ion); if (region.length < 4) return (ISC_R_UNEXPECTEDEND); RETERR(mem_tobuffer(target, region.base, 4)); isc_buffer_forward(source, 4); /* * Target URI */ RETERR(multitxt_fromwire(source, target)); return (ISC_R_SUCCESS); }
static isc_result_t opensslecdsa_fromdns(dst_key_t *key, isc_buffer_t *data) { isc_result_t ret; EVP_PKEY *pkey; EC_KEY *eckey = NULL; isc_region_t r; int group_nid; unsigned int len; const unsigned char *cp; unsigned char buf[DNS_KEY_ECDSA384SIZE + 1]; REQUIRE(key->key_alg == DST_ALG_ECDSA256 || key->key_alg == DST_ALG_ECDSA384); if (key->key_alg == DST_ALG_ECDSA256) { len = DNS_KEY_ECDSA256SIZE; group_nid = NID_X9_62_prime256v1; } else { len = DNS_KEY_ECDSA384SIZE; group_nid = NID_secp384r1; } isc_buffer_remainingregion(data, &r); if (r.length == 0) return (ISC_R_SUCCESS); if (r.length < len) return (DST_R_INVALIDPUBLICKEY); eckey = EC_KEY_new_by_curve_name(group_nid); if (eckey == NULL) return (dst__openssl_toresult(DST_R_OPENSSLFAILURE)); buf[0] = POINT_CONVERSION_UNCOMPRESSED; memmove(buf + 1, r.base, len); cp = buf; if (o2i_ECPublicKey(&eckey, (const unsigned char **) &cp, (long) len + 1) == NULL) DST_RET (dst__openssl_toresult(DST_R_INVALIDPUBLICKEY)); if (EC_KEY_check_key(eckey) != 1) DST_RET (dst__openssl_toresult(DST_R_INVALIDPUBLICKEY)); pkey = EVP_PKEY_new(); if (pkey == NULL) DST_RET (ISC_R_NOMEMORY); if (!EVP_PKEY_set1_EC_KEY(pkey, eckey)) { EVP_PKEY_free(pkey); DST_RET (dst__openssl_toresult(ISC_R_FAILURE)); } isc_buffer_forward(data, len); key->keydata.pkey = pkey; key->key_size = len * 4; ret = ISC_R_SUCCESS; err: if (eckey != NULL) EC_KEY_free(eckey); return (ret); }
static isc_result_t opensslgost_fromdns(dst_key_t *key, isc_buffer_t *data) { isc_region_t r; EVP_PKEY *pkey = NULL; unsigned char der[37 + 64]; const unsigned char *p; isc_buffer_remainingregion(data, &r); if (r.length == 0) return (ISC_R_SUCCESS); if (r.length != 64) return (DST_R_INVALIDPUBLICKEY); memcpy(der, gost_prefix, 37); memcpy(der + 37, r.base, 64); isc_buffer_forward(data, 64); p = der; if (d2i_PUBKEY(&pkey, &p, (long) sizeof(der)) == NULL) return (dst__openssl_toresult2("d2i_PUBKEY", DST_R_OPENSSLFAILURE)); key->keydata.pkey = pkey; return (ISC_R_SUCCESS); }
static inline isc_result_t fromwire_ipseckey(ARGS_FROMWIRE) { dns_name_t name; isc_region_t region; REQUIRE(type == 45); UNUSED(type); UNUSED(rdclass); dns_decompress_setmethods(dctx, DNS_COMPRESS_NONE); dns_name_init(&name, NULL); isc_buffer_activeregion(source, ®ion); if (region.length < 3) return (ISC_R_UNEXPECTEDEND); switch (region.base[1]) { case 0: isc_buffer_forward(source, region.length); return (mem_tobuffer(target, region.base, region.length)); case 1: if (region.length < 7) return (ISC_R_UNEXPECTEDEND); isc_buffer_forward(source, region.length); return (mem_tobuffer(target, region.base, region.length)); case 2: if (region.length < 19) return (ISC_R_UNEXPECTEDEND); isc_buffer_forward(source, region.length); return (mem_tobuffer(target, region.base, region.length)); case 3: RETERR(mem_tobuffer(target, region.base, 3)); isc_buffer_forward(source, 3); RETERR(dns_name_fromwire(&name, source, dctx, options, target)); isc_buffer_activeregion(source, ®ion); isc_buffer_forward(source, region.length); return(mem_tobuffer(target, region.base, region.length)); default: return (ISC_R_NOTIMPLEMENTED); } }
static isc_result_t pkcs11gost_fromdns(dst_key_t *key, isc_buffer_t *data) { pk11_object_t *gost; isc_region_t r; CK_ATTRIBUTE *attr; isc_buffer_remainingregion(data, &r); if (r.length == 0) return (ISC_R_SUCCESS); if (r.length != ISC_GOST_PUBKEYLENGTH) return (DST_R_INVALIDPUBLICKEY); gost = (pk11_object_t *) isc_mem_get(key->mctx, sizeof(*gost)); if (gost == NULL) return (ISC_R_NOMEMORY); memset(gost, 0, sizeof(*gost)); gost->repr = (CK_ATTRIBUTE *) isc_mem_get(key->mctx, sizeof(*attr)); if (gost->repr == NULL) goto nomemory; gost->attrcnt = 1; attr = gost->repr; attr->type = CKA_VALUE; attr->pValue = isc_mem_get(key->mctx, ISC_GOST_PUBKEYLENGTH); if (attr->pValue == NULL) goto nomemory; memmove((CK_BYTE_PTR) attr->pValue, r.base, ISC_GOST_PUBKEYLENGTH); attr->ulValueLen = ISC_GOST_PUBKEYLENGTH; isc_buffer_forward(data, ISC_GOST_PUBKEYLENGTH); key->keydata.pkey = gost; key->key_size = ISC_GOST_KEYSIZE; return (ISC_R_SUCCESS); nomemory: for (attr = pk11_attribute_first(gost); attr != NULL; attr = pk11_attribute_next(gost, attr)) switch (attr->type) { case CKA_VALUE: if (attr->pValue != NULL) { memset(attr->pValue, 0, attr->ulValueLen); isc_mem_put(key->mctx, attr->pValue, attr->ulValueLen); } break; } if (gost->repr != NULL) { memset(gost->repr, 0, gost->attrcnt * sizeof(*attr)); isc_mem_put(key->mctx, gost->repr, gost->attrcnt * sizeof(*attr)); } memset(gost, 0, sizeof(*gost)); isc_mem_put(key->mctx, gost, sizeof(*gost)); return (ISC_R_NOMEMORY); }
static void use(dst_key_t *key, isc_mem_t *mctx) { isc_result_t ret; const char *data = "This is some data"; unsigned char sig[512]; isc_buffer_t databuf, sigbuf; isc_region_t datareg, sigreg; dst_context_t *ctx = NULL; isc_buffer_init(&sigbuf, sig, sizeof(sig)); /* * Advance 1 byte for fun. */ isc_buffer_add(&sigbuf, 1); isc_buffer_init(&databuf, data, strlen(data)); isc_buffer_add(&databuf, strlen(data)); isc_buffer_usedregion(&databuf, &datareg); ret = dst_context_create(key, mctx, &ctx); if (ret != ISC_R_SUCCESS) { printf("contextcreate(%d) returned: %s\n", dst_key_alg(key), isc_result_totext(ret)); return; } ret = dst_context_adddata(ctx, &datareg); if (ret != ISC_R_SUCCESS) { printf("adddata(%d) returned: %s\n", dst_key_alg(key), isc_result_totext(ret)); dst_context_destroy(&ctx); return; } ret = dst_context_sign(ctx, &sigbuf); printf("sign(%d) returned: %s\n", dst_key_alg(key), isc_result_totext(ret)); dst_context_destroy(&ctx); isc_buffer_forward(&sigbuf, 1); isc_buffer_remainingregion(&sigbuf, &sigreg); ret = dst_context_create(key, mctx, &ctx); if (ret != ISC_R_SUCCESS) { printf("contextcreate(%d) returned: %s\n", dst_key_alg(key), isc_result_totext(ret)); return; } ret = dst_context_adddata(ctx, &datareg); if (ret != ISC_R_SUCCESS) { printf("adddata(%d) returned: %s\n", dst_key_alg(key), isc_result_totext(ret)); dst_context_destroy(&ctx); return; } ret = dst_context_verify(ctx, &sigreg); printf("verify(%d) returned: %s\n", dst_key_alg(key), isc_result_totext(ret)); dst_context_destroy(&ctx); }
static inline isc_result_t fromwire_caa(ARGS_FROMWIRE) { isc_region_t sr; unsigned int len, i; REQUIRE(type == 257); UNUSED(type); UNUSED(rdclass); UNUSED(dctx); UNUSED(options); /* * Flags */ isc_buffer_activeregion(source, &sr); if (sr.length < 2) return (ISC_R_UNEXPECTEDEND); /* * Flags, tag length */ RETERR(mem_tobuffer(target, sr.base, 2)); len = sr.base[1]; isc_region_consume(&sr, 2); isc_buffer_forward(source, 2); /* * Zero length tag fields are illegal. */ if (sr.length < len || len == 0) RETERR(DNS_R_FORMERR); /* Check the Tag's value */ for (i = 0; i < len; i++) if (!alphanumeric[sr.base[i]]) RETERR(DNS_R_FORMERR); /* * Tag + Value */ isc_buffer_forward(source, sr.length); return (mem_tobuffer(target, sr.base, sr.length)); }
static inline isc_result_t fromwire_sig(ARGS_FROMWIRE) { isc_region_t sr; dns_name_t name; REQUIRE(type == dns_rdatatype_sig); UNUSED(type); UNUSED(rdclass); dns_decompress_setmethods(dctx, DNS_COMPRESS_NONE); isc_buffer_activeregion(source, &sr); /* * type covered: 2 * algorithm: 1 * labels: 1 * original ttl: 4 * signature expiration: 4 * time signed: 4 * key footprint: 2 */ if (sr.length < 18) return (ISC_R_UNEXPECTEDEND); isc_buffer_forward(source, 18); RETERR(mem_tobuffer(target, sr.base, 18)); /* * Signer. */ dns_name_init(&name, NULL); RETERR(dns_name_fromwire(&name, source, dctx, options, target)); /* * Sig. */ isc_buffer_activeregion(source, &sr); isc_buffer_forward(source, sr.length); return (mem_tobuffer(target, sr.base, sr.length)); }
static inline isc_result_t fromwire_cdnskey(ARGS_FROMWIRE) { unsigned char algorithm; isc_region_t sr; REQUIRE(type == dns_rdatatype_cdnskey); UNUSED(type); UNUSED(rdclass); UNUSED(dctx); UNUSED(options); isc_buffer_activeregion(source, &sr); if (sr.length < 4) return (ISC_R_UNEXPECTEDEND); algorithm = sr.base[3]; RETERR(mem_tobuffer(target, sr.base, 4)); isc_region_consume(&sr, 4); isc_buffer_forward(source, 4); if (algorithm == DNS_KEYALG_PRIVATEDNS) { dns_name_t name; dns_decompress_setmethods(dctx, DNS_COMPRESS_NONE); dns_name_init(&name, NULL); RETERR(dns_name_fromwire(&name, source, dctx, options, target)); } /* * RSAMD5 computes key ID differently from other * algorithms: we need to ensure there's enough data * present for the computation */ if (algorithm == DST_ALG_RSAMD5 && sr.length < 3) return (ISC_R_UNEXPECTEDEND); isc_buffer_activeregion(source, &sr); isc_buffer_forward(source, sr.length); return (mem_tobuffer(target, sr.base, sr.length)); }
static isc_result_t openssldsa_fromdns(dst_key_t *key, isc_buffer_t *data) { DSA *dsa; isc_region_t r; unsigned int t, p_bytes; isc_mem_t *mctx = key->mctx; UNUSED(mctx); isc_buffer_remainingregion(data, &r); if (r.length == 0) return (ISC_R_SUCCESS); dsa = DSA_new(); if (dsa == NULL) return (ISC_R_NOMEMORY); dsa->flags &= ~DSA_FLAG_CACHE_MONT_P; t = (unsigned int) *r.base; isc_region_consume(&r, 1); if (t > 8) { DSA_free(dsa); return (DST_R_INVALIDPUBLICKEY); } p_bytes = 64 + 8 * t; if (r.length < ISC_SHA1_DIGESTLENGTH + 3 * p_bytes) { DSA_free(dsa); return (DST_R_INVALIDPUBLICKEY); } dsa->q = BN_bin2bn(r.base, ISC_SHA1_DIGESTLENGTH, NULL); isc_region_consume(&r, ISC_SHA1_DIGESTLENGTH); dsa->p = BN_bin2bn(r.base, p_bytes, NULL); isc_region_consume(&r, p_bytes); dsa->g = BN_bin2bn(r.base, p_bytes, NULL); isc_region_consume(&r, p_bytes); dsa->pub_key = BN_bin2bn(r.base, p_bytes, NULL); isc_region_consume(&r, p_bytes); key->key_size = p_bytes * 8; isc_buffer_forward(data, 1 + ISC_SHA1_DIGESTLENGTH + 3 * p_bytes); key->keydata.dsa = dsa; return (ISC_R_SUCCESS); }
static isc_result_t opensslrsa_fromdns(dst_key_t *key, isc_buffer_t *data) { RSA *rsa; isc_region_t r; unsigned int e_bytes; isc_buffer_remainingregion(data, &r); if (r.length == 0) return (ISC_R_SUCCESS); rsa = RSA_new(); if (rsa == NULL) return (ISC_R_NOMEMORY); SET_FLAGS(rsa); if (r.length < 1) { RSA_free(rsa); return (DST_R_INVALIDPUBLICKEY); } e_bytes = *r.base++; r.length--; if (e_bytes == 0) { if (r.length < 2) { RSA_free(rsa); return (DST_R_INVALIDPUBLICKEY); } e_bytes = ((*r.base++) << 8); e_bytes += *r.base++; r.length -= 2; } if (r.length < e_bytes) { RSA_free(rsa); return (DST_R_INVALIDPUBLICKEY); } rsa->e = BN_bin2bn(r.base, e_bytes, NULL); r.base += e_bytes; r.length -= e_bytes; rsa->n = BN_bin2bn(r.base, r.length, NULL); key->key_size = BN_num_bits(rsa->n); isc_buffer_forward(data, r.length); key->opaque = (void *) rsa; return (ISC_R_SUCCESS); }
static inline isc_result_t fromwire_in_apl(ARGS_FROMWIRE) { isc_region_t sr, sr2; isc_region_t tr; isc_uint16_t afi; isc_uint8_t prefix; isc_uint8_t len; REQUIRE(type == dns_rdatatype_apl); REQUIRE(rdclass == dns_rdataclass_in); UNUSED(type); UNUSED(dctx); UNUSED(rdclass); UNUSED(options); isc_buffer_activeregion(source, &sr); isc_buffer_availableregion(target, &tr); if (sr.length > tr.length) return (ISC_R_NOSPACE); sr2 = sr; /* Zero or more items */ while (sr.length > 0) { if (sr.length < 4) return (ISC_R_UNEXPECTEDEND); afi = uint16_fromregion(&sr); isc_region_consume(&sr, 2); prefix = *sr.base; isc_region_consume(&sr, 1); len = (*sr.base & 0x7f); isc_region_consume(&sr, 1); if (len > sr.length) return (ISC_R_UNEXPECTEDEND); switch (afi) { case 1: if (prefix > 32 || len > 4) return (ISC_R_RANGE); break; case 2: if (prefix > 128 || len > 16) return (ISC_R_RANGE); } if (len > 0 && sr.base[len - 1] == 0) return (DNS_R_FORMERR); isc_region_consume(&sr, len); } isc_buffer_forward(source, sr2.length); return (mem_tobuffer(target, sr2.base, sr2.length)); }
static inline isc_result_t fromwire_unspec(ARGS_FROMWIRE) { isc_region_t sr; REQUIRE(type == dns_rdatatype_unspec); UNUSED(type); UNUSED(rdclass); UNUSED(dctx); UNUSED(options); isc_buffer_activeregion(source, &sr); isc_buffer_forward(source, sr.length); return (mem_tobuffer(target, sr.base, sr.length)); }
static inline isc_result_t fromwire_ds(ARGS_FROMWIRE) { isc_region_t sr; REQUIRE(type == 43); UNUSED(type); UNUSED(rdclass); UNUSED(dctx); UNUSED(options); isc_buffer_activeregion(source, &sr); /* * Check digest lengths if we know them. */ if (sr.length < 4 || (sr.base[3] == DNS_DSDIGEST_SHA1 && sr.length < 4 + ISC_SHA1_DIGESTLENGTH) || (sr.base[3] == DNS_DSDIGEST_SHA256 && sr.length < 4 + ISC_SHA256_DIGESTLENGTH) || #ifdef ISC_GOST_DIGESTLENGTH (sr.base[3] == DNS_DSDIGEST_GOST && sr.length < 4 + ISC_GOST_DIGESTLENGTH) || #endif (sr.base[3] == DNS_DSDIGEST_SHA384 && sr.length < 4 + ISC_SHA384_DIGESTLENGTH)) return (ISC_R_UNEXPECTEDEND); /* * Only copy digest lengths if we know them. * If there is extra data dns_rdata_fromwire() will * detect that. */ if (sr.base[3] == DNS_DSDIGEST_SHA1) sr.length = 4 + ISC_SHA1_DIGESTLENGTH; else if (sr.base[3] == DNS_DSDIGEST_SHA256) sr.length = 4 + ISC_SHA256_DIGESTLENGTH; #ifdef ISC_GOST_DIGESTLENGTH else if (sr.base[3] == DNS_DSDIGEST_GOST) sr.length = 4 + ISC_GOST_DIGESTLENGTH; #endif else if (sr.base[3] == DNS_DSDIGEST_SHA384) sr.length = 4 + ISC_SHA384_DIGESTLENGTH; isc_buffer_forward(source, sr.length); return (mem_tobuffer(target, sr.base, sr.length)); }
static inline isc_result_t fromwire_naptr(ARGS_FROMWIRE) { dns_name_t name; isc_region_t sr; unsigned char *regex; REQUIRE(type == dns_rdatatype_naptr); UNUSED(type); UNUSED(rdclass); dns_decompress_setmethods(dctx, DNS_COMPRESS_NONE); dns_name_init(&name, NULL); /* * Order, preference. */ isc_buffer_activeregion(source, &sr); if (sr.length < 4) return (ISC_R_UNEXPECTEDEND); RETERR(mem_tobuffer(target, sr.base, 4)); isc_buffer_forward(source, 4); /* * Flags. */ RETERR(txt_fromwire(source, target)); /* * Service. */ RETERR(txt_fromwire(source, target)); /* * Regexp. */ regex = isc_buffer_used(target); RETERR(txt_fromwire(source, target)); RETERR(txt_valid_regex(regex)); /* * Replacement. */ return (dns_name_fromwire(&name, source, dctx, options, target)); }
static inline isc_result_t fromwire_l64(ARGS_FROMWIRE) { isc_region_t sregion; REQUIRE(type == 106); UNUSED(type); UNUSED(options); UNUSED(rdclass); UNUSED(dctx); isc_buffer_activeregion(source, &sregion); if (sregion.length != 10) return (DNS_R_FORMERR); isc_buffer_forward(source, sregion.length); return (mem_tobuffer(target, sregion.base, sregion.length)); }
static inline isc_result_t fromwire_keydata(ARGS_FROMWIRE) { isc_region_t sr; REQUIRE(type == 65533); UNUSED(type); UNUSED(rdclass); UNUSED(dctx); UNUSED(options); isc_buffer_activeregion(source, &sr); if (sr.length < 16) return (ISC_R_UNEXPECTEDEND); isc_buffer_forward(source, sr.length); return (mem_tobuffer(target, sr.base, sr.length)); }
static inline isc_result_t fromwire_opt(ARGS_FROMWIRE) { isc_region_t sregion; isc_region_t tregion; isc_uint16_t length; unsigned int total; REQUIRE(type == 41); UNUSED(type); UNUSED(rdclass); UNUSED(dctx); UNUSED(options); isc_buffer_activeregion(source, &sregion); total = 0; while (sregion.length != 0) { if (sregion.length < 4) return (ISC_R_UNEXPECTEDEND); /* * Eat the 16bit option code. There is nothing to * be done with it currently. */ isc_region_consume(&sregion, 2); length = uint16_fromregion(&sregion); isc_region_consume(&sregion, 2); total += 4; if (sregion.length < length) return (ISC_R_UNEXPECTEDEND); isc_region_consume(&sregion, length); total += length; } isc_buffer_activeregion(source, &sregion); isc_buffer_availableregion(target, &tregion); if (tregion.length < total) return (ISC_R_NOSPACE); memcpy(tregion.base, sregion.base, total); isc_buffer_forward(source, total); isc_buffer_add(target, total); return (ISC_R_SUCCESS); }
isc_result_t dns_db_getsoaserial(dns_db_t *db, dns_dbversion_t *ver, isc_uint32_t *serialp) { isc_result_t result; dns_dbnode_t *node = NULL; dns_rdataset_t rdataset; dns_rdata_t rdata = DNS_RDATA_INIT; isc_buffer_t buffer; REQUIRE(dns_db_iszone(db) || dns_db_isstub(db)); result = dns_db_findnode(db, dns_db_origin(db), ISC_FALSE, &node); if (result != ISC_R_SUCCESS) return (result); dns_rdataset_init(&rdataset); result = dns_db_findrdataset(db, node, ver, dns_rdatatype_soa, 0, (isc_stdtime_t)0, &rdataset, NULL); if (result != ISC_R_SUCCESS) goto freenode; result = dns_rdataset_first(&rdataset); if (result != ISC_R_SUCCESS) goto freerdataset; dns_rdataset_current(&rdataset, &rdata); result = dns_rdataset_next(&rdataset); INSIST(result == ISC_R_NOMORE); INSIST(rdata.length > 20); isc_buffer_init(&buffer, rdata.data, rdata.length); isc_buffer_add(&buffer, rdata.length); isc_buffer_forward(&buffer, rdata.length - 20); *serialp = isc_buffer_getuint32(&buffer); result = ISC_R_SUCCESS; freerdataset: dns_rdataset_disassociate(&rdataset); freenode: dns_db_detachnode(db, &node); return (result); }
static inline isc_result_t fromwire_in_nsap(ARGS_FROMWIRE) { isc_region_t region; REQUIRE(type == 22); REQUIRE(rdclass == 1); UNUSED(type); UNUSED(dctx); UNUSED(options); UNUSED(rdclass); isc_buffer_activeregion(source, ®ion); if (region.length < 1) return (ISC_R_UNEXPECTEDEND); RETERR(mem_tobuffer(target, region.base, region.length)); isc_buffer_forward(source, region.length); return (ISC_R_SUCCESS); }
static inline isc_result_t fromwire_openpgpkey(ARGS_FROMWIRE) { isc_region_t sr; REQUIRE(type == dns_rdatatype_openpgpkey); UNUSED(type); UNUSED(rdclass); UNUSED(dctx); UNUSED(options); /* * Keyring. */ isc_buffer_activeregion(source, &sr); if (sr.length < 1) return (ISC_R_UNEXPECTEDEND); isc_buffer_forward(source, sr.length); return (mem_tobuffer(target, sr.base, sr.length)); }