Chiebot-Mirror
/
c-ares
mirror of https://github.com/c-ares/c-ares.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity
A C library for asynchronous DNS requests (grpc依赖)
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
811 Commits
14 Branches
97 Tags
23 MiB
Tag: Branch: Tree: coverity_scan
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'coverity_scan'
${ noResults }
c-ares/test/ares-test-fuzz.c

317 lines
11 KiB
Raw Permalink Normal View History Unescape

test: fix outdated license headers
1 year ago
/* MIT License
provide SPDX identifiers and a REUSE CI job to verify All files have their licence and copyright information clearly identifiable. If not in the file header, they are set separately in .reuse/dep5. All used license texts are provided in LICENSES/
2 years ago
*
test: fix outdated license headers
1 year ago
* Copyright (c) The c-ares project and its contributors
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
provide SPDX identifiers and a REUSE CI job to verify All files have their licence and copyright information clearly identifiable. If not in the file header, they are set separately in .reuse/dep5. All used license texts are provided in LICENSES/
2 years ago
*
* SPDX-License-Identifier: MIT
*/
Avoid buffer overflow in RC4 loop comparison (#336) The rc4 function iterates over a buffer of size buffer_len who's maximum value is INT_MAX with a counter of type short that is not guaranteed to have maximum size INT_MAX. In circumstances where short is narrower than int and where buffer_len is larger than the maximum value of a short, it may be possible to loop infinitely as counter will overflow and never be greater than or equal to buffer_len. The solution is to make the comparison be between types of equal width. This commit defines counter as an int. Fix By: Fionn Fitzmaurice (@fionn)
5 years ago
#include <stddef.h>
build fix
8 months ago
#include <stdio.h>
Avoid buffer overflow in RC4 loop comparison (#336) The rc4 function iterates over a buffer of size buffer_len who's maximum value is INT_MAX with a counter of type short that is not guaranteed to have maximum size INT_MAX. In circumstances where short is narrower than int and where buffer_len is larger than the maximum value of a short, it may be possible to loop infinitely as counter will overflow and never be greater than or equal to buffer_len. The solution is to make the comparison be between types of equal width. This commit defines counter as an int. Fix By: Fionn Fitzmaurice (@fionn)
5 years ago
#include "ares.h"
Remove `ares__` prefix, just use `ares_` (#872) At some point in time, internal non-public functions were prefixed with `ares__` where as functions that may become public were prefixed with just `ares_`. This was never very consistent. Organizing the code better typically provides more benefit in this way, which we've made great progress on. All non-static symbols must contain the `ares_` prefix, and that should be more than sufficient in preventing any sort of issues. Authored-By: Brad House (@bradh352)
6 months ago
#include "include/ares_buf.h"
OSS-Fuzz: can't modify build commands easily, work around on our side We modified the include path with recent changes, that isn't good for OSS-Fuzz. Lets make the path relative for including some semi-public headers to allow OSS-Fuzz to build again. Fix By: Brad House (@bradh352)
6 months ago
#include "include/ares_mem.h"
Avoid buffer overflow in RC4 loop comparison (#336) The rc4 function iterates over a buffer of size buffer_len who's maximum value is INT_MAX with a counter of type short that is not guaranteed to have maximum size INT_MAX. In circumstances where short is narrower than int and where buffer_len is larger than the maximum value of a short, it may be possible to loop infinitely as counter will overflow and never be greater than or equal to buffer_len. The solution is to make the comparison be between types of equal width. This commit defines counter as an int. Fix By: Fionn Fitzmaurice (@fionn)
5 years ago
Fix internal datatype usage and warnings (#573) PR #568 increased the warning levels and c-ares code emitted a bunch of warnings. This PR fixes those warnings and starts transitioning internal data types into more proper forms (e.g. data lengths should be size_t not int). It does, however, have to manually cast back to what the public API needs due to API and ABI compliance (we aren't looking to break integrations, just clean up internals). Fix By: Brad House (@bradh352)
1 year ago
int LLVMFuzzerTestOneInput(const unsigned char *data, unsigned long size);
fuzzer: call parser directly for enhanced iterations per second The legacy c-ares parsers such as ares_parse_txt_reply() and ares_parse_srv_reply() historically all used different logic and parsing. As of c-ares 1.21.0 these are simply wrappers around a single parser, and simply convert the parsed DNS response into the data structures the legacy parsers used which is a small amount of code and not likely going to vary based on the input data. Instead, these days, it makes more sense to test the new parser directly instead of calling it 10 or 11 times with the same input data to speed up the number of iterations per second the fuzzer can perform. We are keeping this legacy fuzzer test for historic reasons or if someone finds them of use hidden behind a define of USE_LEGACY_PARSERS. Authored-By: Brad House (@bradh352)
6 months ago
#ifdef USE_LEGACY_PARSERS
/* This implementation calls the legacy c-ares parsers, which historically
* all used different logic and parsing. As of c-ares 1.21.0 these are
* simply wrappers around a single parser, and simply convert the parsed
* DNS response into the data structures the legacy parsers used which is a
* small amount of code and not likely going to vary based on the input data.
*
* Instead, these days, it makes more sense to test the new parser directly
* instead of calling it 10 or 11 times with the same input data to speed up
* the number of iterations per second the fuzzer can perform.
*
* We are keeping this legacy fuzzer test for historic reasons or if someone
* finds them of use.
*/
Fix internal datatype usage and warnings (#573) PR #568 increased the warning levels and c-ares code emitted a bunch of warnings. This PR fixes those warnings and starts transitioning internal data types into more proper forms (e.g. data lengths should be size_t not int). It does, however, have to manually cast back to what the public API needs due to API and ABI compliance (we aren't looking to break integrations, just clean up internals). Fix By: Brad House (@bradh352)
1 year ago
int LLVMFuzzerTestOneInput(const unsigned char *data, unsigned long size)
{
cleanup more warnings due to new compiler flags
8 months ago
/* Feed the data into each of the ares_parse_*_reply functions. */
Reformat code using clang-format (#579) c-ares uses multiple code styles, standardize on one. Talking with @bagder he feels strongly about maintaining an 80 column limit, but feels less strongly about things I feel strongly about (like alignment). Can re-run the formatter on the codebase via: ``` clang-format -i */*.c */*.h */*/*.c */*/*.h ``` Fix By: Brad House (@bradh352)
1 year ago
struct hostent *host = NULL;
struct ares_addrttl info[5];
struct ares_addr6ttl info6[5];
unsigned char addrv4[4] = { 0x10, 0x20, 0x30, 0x40 };
struct ares_srv_reply *srv = NULL;
struct ares_mx_reply *mx = NULL;
struct ares_txt_reply *txt = NULL;
struct ares_soa_reply *soa = NULL;
struct ares_naptr_reply *naptr = NULL;
struct ares_caa_reply *caa = NULL;
struct ares_uri_reply *uri = NULL;
int count = 5;
Fix internal datatype usage and warnings (#573) PR #568 increased the warning levels and c-ares code emitted a bunch of warnings. This PR fixes those warnings and starts transitioning internal data types into more proper forms (e.g. data lengths should be size_t not int). It does, however, have to manually cast back to what the public API needs due to API and ABI compliance (we aren't looking to break integrations, just clean up internals). Fix By: Brad House (@bradh352)
1 year ago
ares_parse_a_reply(data, (int)size, &host, info, &count);
Reformat code using clang-format (#579) c-ares uses multiple code styles, standardize on one. Talking with @bagder he feels strongly about maintaining an 80 column limit, but feels less strongly about things I feel strongly about (like alignment). Can re-run the formatter on the codebase via: ``` clang-format -i */*.c */*.h */*/*.c */*/*.h ``` Fix By: Brad House (@bradh352)
1 year ago
if (host) {
ares_free_hostent(host);
}
Avoid buffer overflow in RC4 loop comparison (#336) The rc4 function iterates over a buffer of size buffer_len who's maximum value is INT_MAX with a counter of type short that is not guaranteed to have maximum size INT_MAX. In circumstances where short is narrower than int and where buffer_len is larger than the maximum value of a short, it may be possible to loop infinitely as counter will overflow and never be greater than or equal to buffer_len. The solution is to make the comparison be between types of equal width. This commit defines counter as an int. Fix By: Fionn Fitzmaurice (@fionn)
5 years ago
Reformat code using clang-format (#579) c-ares uses multiple code styles, standardize on one. Talking with @bagder he feels strongly about maintaining an 80 column limit, but feels less strongly about things I feel strongly about (like alignment). Can re-run the formatter on the codebase via: ``` clang-format -i */*.c */*.h */*/*.c */*/*.h ``` Fix By: Brad House (@bradh352)
1 year ago
host = NULL;
Avoid buffer overflow in RC4 loop comparison (#336) The rc4 function iterates over a buffer of size buffer_len who's maximum value is INT_MAX with a counter of type short that is not guaranteed to have maximum size INT_MAX. In circumstances where short is narrower than int and where buffer_len is larger than the maximum value of a short, it may be possible to loop infinitely as counter will overflow and never be greater than or equal to buffer_len. The solution is to make the comparison be between types of equal width. This commit defines counter as an int. Fix By: Fionn Fitzmaurice (@fionn)
5 years ago
count = 5;
Fix internal datatype usage and warnings (#573) PR #568 increased the warning levels and c-ares code emitted a bunch of warnings. This PR fixes those warnings and starts transitioning internal data types into more proper forms (e.g. data lengths should be size_t not int). It does, however, have to manually cast back to what the public API needs due to API and ABI compliance (we aren't looking to break integrations, just clean up internals). Fix By: Brad House (@bradh352)
1 year ago
ares_parse_aaaa_reply(data, (int)size, &host, info6, &count);
Reformat code using clang-format (#579) c-ares uses multiple code styles, standardize on one. Talking with @bagder he feels strongly about maintaining an 80 column limit, but feels less strongly about things I feel strongly about (like alignment). Can re-run the formatter on the codebase via: ``` clang-format -i */*.c */*.h */*/*.c */*/*.h ``` Fix By: Brad House (@bradh352)
1 year ago
if (host) {
ares_free_hostent(host);
}
Avoid buffer overflow in RC4 loop comparison (#336) The rc4 function iterates over a buffer of size buffer_len who's maximum value is INT_MAX with a counter of type short that is not guaranteed to have maximum size INT_MAX. In circumstances where short is narrower than int and where buffer_len is larger than the maximum value of a short, it may be possible to loop infinitely as counter will overflow and never be greater than or equal to buffer_len. The solution is to make the comparison be between types of equal width. This commit defines counter as an int. Fix By: Fionn Fitzmaurice (@fionn)
5 years ago
host = NULL;
Fix internal datatype usage and warnings (#573) PR #568 increased the warning levels and c-ares code emitted a bunch of warnings. This PR fixes those warnings and starts transitioning internal data types into more proper forms (e.g. data lengths should be size_t not int). It does, however, have to manually cast back to what the public API needs due to API and ABI compliance (we aren't looking to break integrations, just clean up internals). Fix By: Brad House (@bradh352)
1 year ago
ares_parse_ptr_reply(data, (int)size, addrv4, sizeof(addrv4), AF_INET, &host);
Reformat code using clang-format (#579) c-ares uses multiple code styles, standardize on one. Talking with @bagder he feels strongly about maintaining an 80 column limit, but feels less strongly about things I feel strongly about (like alignment). Can re-run the formatter on the codebase via: ``` clang-format -i */*.c */*.h */*/*.c */*/*.h ``` Fix By: Brad House (@bradh352)
1 year ago
if (host) {
ares_free_hostent(host);
}
Avoid buffer overflow in RC4 loop comparison (#336) The rc4 function iterates over a buffer of size buffer_len who's maximum value is INT_MAX with a counter of type short that is not guaranteed to have maximum size INT_MAX. In circumstances where short is narrower than int and where buffer_len is larger than the maximum value of a short, it may be possible to loop infinitely as counter will overflow and never be greater than or equal to buffer_len. The solution is to make the comparison be between types of equal width. This commit defines counter as an int. Fix By: Fionn Fitzmaurice (@fionn)
5 years ago
host = NULL;
Fix internal datatype usage and warnings (#573) PR #568 increased the warning levels and c-ares code emitted a bunch of warnings. This PR fixes those warnings and starts transitioning internal data types into more proper forms (e.g. data lengths should be size_t not int). It does, however, have to manually cast back to what the public API needs due to API and ABI compliance (we aren't looking to break integrations, just clean up internals). Fix By: Brad House (@bradh352)
1 year ago
ares_parse_ns_reply(data, (int)size, &host);
Reformat code using clang-format (#579) c-ares uses multiple code styles, standardize on one. Talking with @bagder he feels strongly about maintaining an 80 column limit, but feels less strongly about things I feel strongly about (like alignment). Can re-run the formatter on the codebase via: ``` clang-format -i */*.c */*.h */*/*.c */*/*.h ``` Fix By: Brad House (@bradh352)
1 year ago
if (host) {
ares_free_hostent(host);
}
Avoid buffer overflow in RC4 loop comparison (#336) The rc4 function iterates over a buffer of size buffer_len who's maximum value is INT_MAX with a counter of type short that is not guaranteed to have maximum size INT_MAX. In circumstances where short is narrower than int and where buffer_len is larger than the maximum value of a short, it may be possible to loop infinitely as counter will overflow and never be greater than or equal to buffer_len. The solution is to make the comparison be between types of equal width. This commit defines counter as an int. Fix By: Fionn Fitzmaurice (@fionn)
5 years ago
Fix internal datatype usage and warnings (#573) PR #568 increased the warning levels and c-ares code emitted a bunch of warnings. This PR fixes those warnings and starts transitioning internal data types into more proper forms (e.g. data lengths should be size_t not int). It does, however, have to manually cast back to what the public API needs due to API and ABI compliance (we aren't looking to break integrations, just clean up internals). Fix By: Brad House (@bradh352)
1 year ago
ares_parse_srv_reply(data, (int)size, &srv);
Reformat code using clang-format (#579) c-ares uses multiple code styles, standardize on one. Talking with @bagder he feels strongly about maintaining an 80 column limit, but feels less strongly about things I feel strongly about (like alignment). Can re-run the formatter on the codebase via: ``` clang-format -i */*.c */*.h */*/*.c */*/*.h ``` Fix By: Brad House (@bradh352)
1 year ago
if (srv) {
ares_free_data(srv);
}
Avoid buffer overflow in RC4 loop comparison (#336) The rc4 function iterates over a buffer of size buffer_len who's maximum value is INT_MAX with a counter of type short that is not guaranteed to have maximum size INT_MAX. In circumstances where short is narrower than int and where buffer_len is larger than the maximum value of a short, it may be possible to loop infinitely as counter will overflow and never be greater than or equal to buffer_len. The solution is to make the comparison be between types of equal width. This commit defines counter as an int. Fix By: Fionn Fitzmaurice (@fionn)
5 years ago
Fix internal datatype usage and warnings (#573) PR #568 increased the warning levels and c-ares code emitted a bunch of warnings. This PR fixes those warnings and starts transitioning internal data types into more proper forms (e.g. data lengths should be size_t not int). It does, however, have to manually cast back to what the public API needs due to API and ABI compliance (we aren't looking to break integrations, just clean up internals). Fix By: Brad House (@bradh352)
1 year ago
ares_parse_mx_reply(data, (int)size, &mx);
Reformat code using clang-format (#579) c-ares uses multiple code styles, standardize on one. Talking with @bagder he feels strongly about maintaining an 80 column limit, but feels less strongly about things I feel strongly about (like alignment). Can re-run the formatter on the codebase via: ``` clang-format -i */*.c */*.h */*/*.c */*/*.h ``` Fix By: Brad House (@bradh352)
1 year ago
if (mx) {
ares_free_data(mx);
}
Avoid buffer overflow in RC4 loop comparison (#336) The rc4 function iterates over a buffer of size buffer_len who's maximum value is INT_MAX with a counter of type short that is not guaranteed to have maximum size INT_MAX. In circumstances where short is narrower than int and where buffer_len is larger than the maximum value of a short, it may be possible to loop infinitely as counter will overflow and never be greater than or equal to buffer_len. The solution is to make the comparison be between types of equal width. This commit defines counter as an int. Fix By: Fionn Fitzmaurice (@fionn)
5 years ago
Fix internal datatype usage and warnings (#573) PR #568 increased the warning levels and c-ares code emitted a bunch of warnings. This PR fixes those warnings and starts transitioning internal data types into more proper forms (e.g. data lengths should be size_t not int). It does, however, have to manually cast back to what the public API needs due to API and ABI compliance (we aren't looking to break integrations, just clean up internals). Fix By: Brad House (@bradh352)
1 year ago
ares_parse_txt_reply(data, (int)size, &txt);
Reformat code using clang-format (#579) c-ares uses multiple code styles, standardize on one. Talking with @bagder he feels strongly about maintaining an 80 column limit, but feels less strongly about things I feel strongly about (like alignment). Can re-run the formatter on the codebase via: ``` clang-format -i */*.c */*.h */*/*.c */*/*.h ``` Fix By: Brad House (@bradh352)
1 year ago
if (txt) {
ares_free_data(txt);
}
Avoid buffer overflow in RC4 loop comparison (#336) The rc4 function iterates over a buffer of size buffer_len who's maximum value is INT_MAX with a counter of type short that is not guaranteed to have maximum size INT_MAX. In circumstances where short is narrower than int and where buffer_len is larger than the maximum value of a short, it may be possible to loop infinitely as counter will overflow and never be greater than or equal to buffer_len. The solution is to make the comparison be between types of equal width. This commit defines counter as an int. Fix By: Fionn Fitzmaurice (@fionn)
5 years ago
Fix internal datatype usage and warnings (#573) PR #568 increased the warning levels and c-ares code emitted a bunch of warnings. This PR fixes those warnings and starts transitioning internal data types into more proper forms (e.g. data lengths should be size_t not int). It does, however, have to manually cast back to what the public API needs due to API and ABI compliance (we aren't looking to break integrations, just clean up internals). Fix By: Brad House (@bradh352)
1 year ago
ares_parse_soa_reply(data, (int)size, &soa);
Reformat code using clang-format (#579) c-ares uses multiple code styles, standardize on one. Talking with @bagder he feels strongly about maintaining an 80 column limit, but feels less strongly about things I feel strongly about (like alignment). Can re-run the formatter on the codebase via: ``` clang-format -i */*.c */*.h */*/*.c */*/*.h ``` Fix By: Brad House (@bradh352)
1 year ago
if (soa) {
ares_free_data(soa);
}
Avoid buffer overflow in RC4 loop comparison (#336) The rc4 function iterates over a buffer of size buffer_len who's maximum value is INT_MAX with a counter of type short that is not guaranteed to have maximum size INT_MAX. In circumstances where short is narrower than int and where buffer_len is larger than the maximum value of a short, it may be possible to loop infinitely as counter will overflow and never be greater than or equal to buffer_len. The solution is to make the comparison be between types of equal width. This commit defines counter as an int. Fix By: Fionn Fitzmaurice (@fionn)
5 years ago
Fix internal datatype usage and warnings (#573) PR #568 increased the warning levels and c-ares code emitted a bunch of warnings. This PR fixes those warnings and starts transitioning internal data types into more proper forms (e.g. data lengths should be size_t not int). It does, however, have to manually cast back to what the public API needs due to API and ABI compliance (we aren't looking to break integrations, just clean up internals). Fix By: Brad House (@bradh352)
1 year ago
ares_parse_naptr_reply(data, (int)size, &naptr);
Reformat code using clang-format (#579) c-ares uses multiple code styles, standardize on one. Talking with @bagder he feels strongly about maintaining an 80 column limit, but feels less strongly about things I feel strongly about (like alignment). Can re-run the formatter on the codebase via: ``` clang-format -i */*.c */*.h */*/*.c */*/*.h ``` Fix By: Brad House (@bradh352)
1 year ago
if (naptr) {
ares_free_data(naptr);
}
Avoid buffer overflow in RC4 loop comparison (#336) The rc4 function iterates over a buffer of size buffer_len who's maximum value is INT_MAX with a counter of type short that is not guaranteed to have maximum size INT_MAX. In circumstances where short is narrower than int and where buffer_len is larger than the maximum value of a short, it may be possible to loop infinitely as counter will overflow and never be greater than or equal to buffer_len. The solution is to make the comparison be between types of equal width. This commit defines counter as an int. Fix By: Fionn Fitzmaurice (@fionn)
5 years ago
Fix internal datatype usage and warnings (#573) PR #568 increased the warning levels and c-ares code emitted a bunch of warnings. This PR fixes those warnings and starts transitioning internal data types into more proper forms (e.g. data lengths should be size_t not int). It does, however, have to manually cast back to what the public API needs due to API and ABI compliance (we aren't looking to break integrations, just clean up internals). Fix By: Brad House (@bradh352)
1 year ago
ares_parse_caa_reply(data, (int)size, &caa);
Reformat code using clang-format (#579) c-ares uses multiple code styles, standardize on one. Talking with @bagder he feels strongly about maintaining an 80 column limit, but feels less strongly about things I feel strongly about (like alignment). Can re-run the formatter on the codebase via: ``` clang-format -i */*.c */*.h */*/*.c */*/*.h ``` Fix By: Brad House (@bradh352)
1 year ago
if (caa) {
ares_free_data(caa);
}
fuzz CAA parsing (#363) Add fuzz support for CAA parsing Fix By: David Hotham (@dimbleby)
4 years ago
Fix internal datatype usage and warnings (#573) PR #568 increased the warning levels and c-ares code emitted a bunch of warnings. This PR fixes those warnings and starts transitioning internal data types into more proper forms (e.g. data lengths should be size_t not int). It does, however, have to manually cast back to what the public API needs due to API and ABI compliance (we aren't looking to break integrations, just clean up internals). Fix By: Brad House (@bradh352)
1 year ago
ares_parse_uri_reply(data, (int)size, &uri);
Reformat code using clang-format (#579) c-ares uses multiple code styles, standardize on one. Talking with @bagder he feels strongly about maintaining an 80 column limit, but feels less strongly about things I feel strongly about (like alignment). Can re-run the formatter on the codebase via: ``` clang-format -i */*.c */*.h */*/*.c */*/*.h ``` Fix By: Brad House (@bradh352)
1 year ago
if (uri) {
ares_free_data(uri);
}
Add support for URI(Uniform Resource Identifier) records. (#411) Add ares_parse_uri_reply() for parsing URI DNS replies. Fix By: Martin Holeš (@martin-256)
4 years ago
Avoid buffer overflow in RC4 loop comparison (#336) The rc4 function iterates over a buffer of size buffer_len who's maximum value is INT_MAX with a counter of type short that is not guaranteed to have maximum size INT_MAX. In circumstances where short is narrower than int and where buffer_len is larger than the maximum value of a short, it may be possible to loop infinitely as counter will overflow and never be greater than or equal to buffer_len. The solution is to make the comparison be between types of equal width. This commit defines counter as an int. Fix By: Fionn Fitzmaurice (@fionn)
5 years ago
return 0;
}
fuzzer: call parser directly for enhanced iterations per second The legacy c-ares parsers such as ares_parse_txt_reply() and ares_parse_srv_reply() historically all used different logic and parsing. As of c-ares 1.21.0 these are simply wrappers around a single parser, and simply convert the parsed DNS response into the data structures the legacy parsers used which is a small amount of code and not likely going to vary based on the input data. Instead, these days, it makes more sense to test the new parser directly instead of calling it 10 or 11 times with the same input data to speed up the number of iterations per second the fuzzer can perform. We are keeping this legacy fuzzer test for historic reasons or if someone finds them of use hidden behind a define of USE_LEGACY_PARSERS. Authored-By: Brad House (@bradh352)
6 months ago
#else
int LLVMFuzzerTestOneInput(const unsigned char *data, unsigned long size)
{
Remove `ares__` prefix, just use `ares_` (#872) At some point in time, internal non-public functions were prefixed with `ares__` where as functions that may become public were prefixed with just `ares_`. This was never very consistent. Organizing the code better typically provides more benefit in this way, which we've made great progress on. All non-static symbols must contain the `ares_` prefix, and that should be more than sufficient in preventing any sort of issues. Authored-By: Brad House (@bradh352)
6 months ago
ares_dns_record_t *dnsrec = NULL;
char *printdata = NULL;
ares_buf_t *printmsg = NULL;
Fuzzing: add fetcher/writers to fuzzing suite The coverage of the fuzzer is fairly low as it was only testing the parsing, not trying to read the data from the datastructure or writing it back out as a DNS message. Lets extend, and also provide a FUZZING.md to help people new to fuzzing get up and running. Authored-By: Brad House (@bradh352)
6 months ago
size_t i;
unsigned char *datadup = NULL;
size_t datadup_len = 0;
fuzzer: call parser directly for enhanced iterations per second The legacy c-ares parsers such as ares_parse_txt_reply() and ares_parse_srv_reply() historically all used different logic and parsing. As of c-ares 1.21.0 these are simply wrappers around a single parser, and simply convert the parsed DNS response into the data structures the legacy parsers used which is a small amount of code and not likely going to vary based on the input data. Instead, these days, it makes more sense to test the new parser directly instead of calling it 10 or 11 times with the same input data to speed up the number of iterations per second the fuzzer can perform. We are keeping this legacy fuzzer test for historic reasons or if someone finds them of use hidden behind a define of USE_LEGACY_PARSERS. Authored-By: Brad House (@bradh352)
6 months ago
/* There is never a reason to have a size > 65535, it is immediately
* rejected by the parser */
if (size > 65535) {
return -1;
}
Fuzzing: add fetcher/writers to fuzzing suite The coverage of the fuzzer is fairly low as it was only testing the parsing, not trying to read the data from the datastructure or writing it back out as a DNS message. Lets extend, and also provide a FUZZING.md to help people new to fuzzing get up and running. Authored-By: Brad House (@bradh352)
6 months ago
if (ares_dns_parse(data, size, 0, &dnsrec) != ARES_SUCCESS) {
goto done;
fuzzer: call parser directly for enhanced iterations per second The legacy c-ares parsers such as ares_parse_txt_reply() and ares_parse_srv_reply() historically all used different logic and parsing. As of c-ares 1.21.0 these are simply wrappers around a single parser, and simply convert the parsed DNS response into the data structures the legacy parsers used which is a small amount of code and not likely going to vary based on the input data. Instead, these days, it makes more sense to test the new parser directly instead of calling it 10 or 11 times with the same input data to speed up the number of iterations per second the fuzzer can perform. We are keeping this legacy fuzzer test for historic reasons or if someone finds them of use hidden behind a define of USE_LEGACY_PARSERS. Authored-By: Brad House (@bradh352)
6 months ago
}
Fuzzing: add fetcher/writers to fuzzing suite The coverage of the fuzzer is fairly low as it was only testing the parsing, not trying to read the data from the datastructure or writing it back out as a DNS message. Lets extend, and also provide a FUZZING.md to help people new to fuzzing get up and running. Authored-By: Brad House (@bradh352)
6 months ago
/* Lets test the message fetchers */
Remove `ares__` prefix, just use `ares_` (#872) At some point in time, internal non-public functions were prefixed with `ares__` where as functions that may become public were prefixed with just `ares_`. This was never very consistent. Organizing the code better typically provides more benefit in this way, which we've made great progress on. All non-static symbols must contain the `ares_` prefix, and that should be more than sufficient in preventing any sort of issues. Authored-By: Brad House (@bradh352)
6 months ago
printmsg = ares_buf_create();
Fuzzing: add fetcher/writers to fuzzing suite The coverage of the fuzzer is fairly low as it was only testing the parsing, not trying to read the data from the datastructure or writing it back out as a DNS message. Lets extend, and also provide a FUZZING.md to help people new to fuzzing get up and running. Authored-By: Brad House (@bradh352)
6 months ago
if (printmsg == NULL) {
goto done;
}
Remove `ares__` prefix, just use `ares_` (#872) At some point in time, internal non-public functions were prefixed with `ares__` where as functions that may become public were prefixed with just `ares_`. This was never very consistent. Organizing the code better typically provides more benefit in this way, which we've made great progress on. All non-static symbols must contain the `ares_` prefix, and that should be more than sufficient in preventing any sort of issues. Authored-By: Brad House (@bradh352)
6 months ago
ares_buf_append_str(printmsg, ";; ->>HEADER<<- opcode: ");
ares_buf_append_str(
printmsg, ares_dns_opcode_tostr(ares_dns_record_get_opcode(dnsrec)));
ares_buf_append_str(printmsg, ", status: ");
ares_buf_append_str(printmsg,
ares_dns_rcode_tostr(ares_dns_record_get_rcode(dnsrec)));
ares_buf_append_str(printmsg, ", id: ");
ares_buf_append_num_dec(printmsg, (size_t)ares_dns_record_get_id(dnsrec), 0);
ares_buf_append_str(printmsg, "\n;; flags: ");
ares_buf_append_num_hex(printmsg, (size_t)ares_dns_record_get_flags(dnsrec),
0);
ares_buf_append_str(printmsg, "; QUERY: ");
ares_buf_append_num_dec(printmsg, ares_dns_record_query_cnt(dnsrec), 0);
ares_buf_append_str(printmsg, ", ANSWER: ");
ares_buf_append_num_dec(
printmsg, ares_dns_record_rr_cnt(dnsrec, ARES_SECTION_ANSWER), 0);
ares_buf_append_str(printmsg, ", AUTHORITY: ");
ares_buf_append_num_dec(
printmsg, ares_dns_record_rr_cnt(dnsrec, ARES_SECTION_AUTHORITY), 0);
ares_buf_append_str(printmsg, ", ADDITIONAL: ");
ares_buf_append_num_dec(
printmsg, ares_dns_record_rr_cnt(dnsrec, ARES_SECTION_ADDITIONAL), 0);
ares_buf_append_str(printmsg, "\n\n");
ares_buf_append_str(printmsg, ";; QUESTION SECTION:\n");
Fuzzing: add fetcher/writers to fuzzing suite The coverage of the fuzzer is fairly low as it was only testing the parsing, not trying to read the data from the datastructure or writing it back out as a DNS message. Lets extend, and also provide a FUZZING.md to help people new to fuzzing get up and running. Authored-By: Brad House (@bradh352)
6 months ago
for (i = 0; i < ares_dns_record_query_cnt(dnsrec); i++) {
const char *name;
ares_dns_rec_type_t qtype;
ares_dns_class_t qclass;
Remove `ares__` prefix, just use `ares_` (#872) At some point in time, internal non-public functions were prefixed with `ares__` where as functions that may become public were prefixed with just `ares_`. This was never very consistent. Organizing the code better typically provides more benefit in this way, which we've made great progress on. All non-static symbols must contain the `ares_` prefix, and that should be more than sufficient in preventing any sort of issues. Authored-By: Brad House (@bradh352)
6 months ago
if (ares_dns_record_query_get(dnsrec, i, &name, &qtype, &qclass) !=
ARES_SUCCESS) {
Fuzzing: add fetcher/writers to fuzzing suite The coverage of the fuzzer is fairly low as it was only testing the parsing, not trying to read the data from the datastructure or writing it back out as a DNS message. Lets extend, and also provide a FUZZING.md to help people new to fuzzing get up and running. Authored-By: Brad House (@bradh352)
6 months ago
goto done;
}
Remove `ares__` prefix, just use `ares_` (#872) At some point in time, internal non-public functions were prefixed with `ares__` where as functions that may become public were prefixed with just `ares_`. This was never very consistent. Organizing the code better typically provides more benefit in this way, which we've made great progress on. All non-static symbols must contain the `ares_` prefix, and that should be more than sufficient in preventing any sort of issues. Authored-By: Brad House (@bradh352)
6 months ago
ares_buf_append_str(printmsg, ";");
ares_buf_append_str(printmsg, name);
ares_buf_append_str(printmsg, ".\t\t\t");
ares_buf_append_str(printmsg, ares_dns_class_tostr(qclass));
ares_buf_append_str(printmsg, "\t");
ares_buf_append_str(printmsg, ares_dns_rec_type_tostr(qtype));
ares_buf_append_str(printmsg, "\n");
Fuzzing: add fetcher/writers to fuzzing suite The coverage of the fuzzer is fairly low as it was only testing the parsing, not trying to read the data from the datastructure or writing it back out as a DNS message. Lets extend, and also provide a FUZZING.md to help people new to fuzzing get up and running. Authored-By: Brad House (@bradh352)
6 months ago
}
Remove `ares__` prefix, just use `ares_` (#872) At some point in time, internal non-public functions were prefixed with `ares__` where as functions that may become public were prefixed with just `ares_`. This was never very consistent. Organizing the code better typically provides more benefit in this way, which we've made great progress on. All non-static symbols must contain the `ares_` prefix, and that should be more than sufficient in preventing any sort of issues. Authored-By: Brad House (@bradh352)
6 months ago
ares_buf_append_str(printmsg, "\n");
Fuzzing: add fetcher/writers to fuzzing suite The coverage of the fuzzer is fairly low as it was only testing the parsing, not trying to read the data from the datastructure or writing it back out as a DNS message. Lets extend, and also provide a FUZZING.md to help people new to fuzzing get up and running. Authored-By: Brad House (@bradh352)
6 months ago
for (i = ARES_SECTION_ANSWER; i < ARES_SECTION_ADDITIONAL + 1; i++) {
size_t j;
Remove `ares__` prefix, just use `ares_` (#872) At some point in time, internal non-public functions were prefixed with `ares__` where as functions that may become public were prefixed with just `ares_`. This was never very consistent. Organizing the code better typically provides more benefit in this way, which we've made great progress on. All non-static symbols must contain the `ares_` prefix, and that should be more than sufficient in preventing any sort of issues. Authored-By: Brad House (@bradh352)
6 months ago
ares_buf_append_str(printmsg, ";; ");
ares_buf_append_str(printmsg,
ares_dns_section_tostr((ares_dns_section_t)i));
ares_buf_append_str(printmsg, " SECTION:\n");
for (j = 0; j < ares_dns_record_rr_cnt(dnsrec, (ares_dns_section_t)i);
j++) {
Fuzzing: add fetcher/writers to fuzzing suite The coverage of the fuzzer is fairly low as it was only testing the parsing, not trying to read the data from the datastructure or writing it back out as a DNS message. Lets extend, and also provide a FUZZING.md to help people new to fuzzing get up and running. Authored-By: Brad House (@bradh352)
6 months ago
size_t keys_cnt = 0;
const ares_dns_rr_key_t *keys = NULL;
ares_dns_rr_t *rr = NULL;
size_t k;
rr = ares_dns_record_rr_get(dnsrec, (ares_dns_section_t)i, j);
Remove `ares__` prefix, just use `ares_` (#872) At some point in time, internal non-public functions were prefixed with `ares__` where as functions that may become public were prefixed with just `ares_`. This was never very consistent. Organizing the code better typically provides more benefit in this way, which we've made great progress on. All non-static symbols must contain the `ares_` prefix, and that should be more than sufficient in preventing any sort of issues. Authored-By: Brad House (@bradh352)
6 months ago
ares_buf_append_str(printmsg, ares_dns_rr_get_name(rr));
ares_buf_append_str(printmsg, ".\t\t\t");
ares_buf_append_str(printmsg,
ares_dns_class_tostr(ares_dns_rr_get_class(rr)));
ares_buf_append_str(printmsg, "\t");
ares_buf_append_str(printmsg,
ares_dns_rec_type_tostr(ares_dns_rr_get_type(rr)));
ares_buf_append_str(printmsg, "\t");
ares_buf_append_num_dec(printmsg, ares_dns_rr_get_ttl(rr), 0);
ares_buf_append_str(printmsg, "\t");
Fuzzing: add fetcher/writers to fuzzing suite The coverage of the fuzzer is fairly low as it was only testing the parsing, not trying to read the data from the datastructure or writing it back out as a DNS message. Lets extend, and also provide a FUZZING.md to help people new to fuzzing get up and running. Authored-By: Brad House (@bradh352)
6 months ago
keys = ares_dns_rr_get_keys(ares_dns_rr_get_type(rr), &keys_cnt);
Remove `ares__` prefix, just use `ares_` (#872) At some point in time, internal non-public functions were prefixed with `ares__` where as functions that may become public were prefixed with just `ares_`. This was never very consistent. Organizing the code better typically provides more benefit in this way, which we've made great progress on. All non-static symbols must contain the `ares_` prefix, and that should be more than sufficient in preventing any sort of issues. Authored-By: Brad House (@bradh352)
6 months ago
for (k = 0; k < keys_cnt; k++) {
Fuzzing: add fetcher/writers to fuzzing suite The coverage of the fuzzer is fairly low as it was only testing the parsing, not trying to read the data from the datastructure or writing it back out as a DNS message. Lets extend, and also provide a FUZZING.md to help people new to fuzzing get up and running. Authored-By: Brad House (@bradh352)
6 months ago
char buf[256] = "";
Remove `ares__` prefix, just use `ares_` (#872) At some point in time, internal non-public functions were prefixed with `ares__` where as functions that may become public were prefixed with just `ares_`. This was never very consistent. Organizing the code better typically provides more benefit in this way, which we've made great progress on. All non-static symbols must contain the `ares_` prefix, and that should be more than sufficient in preventing any sort of issues. Authored-By: Brad House (@bradh352)
6 months ago
ares_buf_append_str(printmsg, ares_dns_rr_key_tostr(keys[k]));
ares_buf_append_str(printmsg, "=");
Fuzzing: add fetcher/writers to fuzzing suite The coverage of the fuzzer is fairly low as it was only testing the parsing, not trying to read the data from the datastructure or writing it back out as a DNS message. Lets extend, and also provide a FUZZING.md to help people new to fuzzing get up and running. Authored-By: Brad House (@bradh352)
6 months ago
switch (ares_dns_rr_key_datatype(keys[k])) {
case ARES_DATATYPE_INADDR:
Remove `ares__` prefix, just use `ares_` (#872) At some point in time, internal non-public functions were prefixed with `ares__` where as functions that may become public were prefixed with just `ares_`. This was never very consistent. Organizing the code better typically provides more benefit in this way, which we've made great progress on. All non-static symbols must contain the `ares_` prefix, and that should be more than sufficient in preventing any sort of issues. Authored-By: Brad House (@bradh352)
6 months ago
ares_inet_ntop(AF_INET, ares_dns_rr_get_addr(rr, keys[k]), buf,
sizeof(buf));
ares_buf_append_str(printmsg, buf);
Fuzzing: add fetcher/writers to fuzzing suite The coverage of the fuzzer is fairly low as it was only testing the parsing, not trying to read the data from the datastructure or writing it back out as a DNS message. Lets extend, and also provide a FUZZING.md to help people new to fuzzing get up and running. Authored-By: Brad House (@bradh352)
6 months ago
break;
case ARES_DATATYPE_INADDR6:
Remove `ares__` prefix, just use `ares_` (#872) At some point in time, internal non-public functions were prefixed with `ares__` where as functions that may become public were prefixed with just `ares_`. This was never very consistent. Organizing the code better typically provides more benefit in this way, which we've made great progress on. All non-static symbols must contain the `ares_` prefix, and that should be more than sufficient in preventing any sort of issues. Authored-By: Brad House (@bradh352)
6 months ago
ares_inet_ntop(AF_INET6, ares_dns_rr_get_addr6(rr, keys[k]), buf,
sizeof(buf));
ares_buf_append_str(printmsg, buf);
Fuzzing: add fetcher/writers to fuzzing suite The coverage of the fuzzer is fairly low as it was only testing the parsing, not trying to read the data from the datastructure or writing it back out as a DNS message. Lets extend, and also provide a FUZZING.md to help people new to fuzzing get up and running. Authored-By: Brad House (@bradh352)
6 months ago
break;
case ARES_DATATYPE_U8:
Remove `ares__` prefix, just use `ares_` (#872) At some point in time, internal non-public functions were prefixed with `ares__` where as functions that may become public were prefixed with just `ares_`. This was never very consistent. Organizing the code better typically provides more benefit in this way, which we've made great progress on. All non-static symbols must contain the `ares_` prefix, and that should be more than sufficient in preventing any sort of issues. Authored-By: Brad House (@bradh352)
6 months ago
ares_buf_append_num_dec(printmsg, ares_dns_rr_get_u8(rr, keys[k]),
0);
Fuzzing: add fetcher/writers to fuzzing suite The coverage of the fuzzer is fairly low as it was only testing the parsing, not trying to read the data from the datastructure or writing it back out as a DNS message. Lets extend, and also provide a FUZZING.md to help people new to fuzzing get up and running. Authored-By: Brad House (@bradh352)
6 months ago
break;
case ARES_DATATYPE_U16:
Remove `ares__` prefix, just use `ares_` (#872) At some point in time, internal non-public functions were prefixed with `ares__` where as functions that may become public were prefixed with just `ares_`. This was never very consistent. Organizing the code better typically provides more benefit in this way, which we've made great progress on. All non-static symbols must contain the `ares_` prefix, and that should be more than sufficient in preventing any sort of issues. Authored-By: Brad House (@bradh352)
6 months ago
ares_buf_append_num_dec(printmsg, ares_dns_rr_get_u16(rr, keys[k]),
0);
Fuzzing: add fetcher/writers to fuzzing suite The coverage of the fuzzer is fairly low as it was only testing the parsing, not trying to read the data from the datastructure or writing it back out as a DNS message. Lets extend, and also provide a FUZZING.md to help people new to fuzzing get up and running. Authored-By: Brad House (@bradh352)
6 months ago
break;
case ARES_DATATYPE_U32:
Remove `ares__` prefix, just use `ares_` (#872) At some point in time, internal non-public functions were prefixed with `ares__` where as functions that may become public were prefixed with just `ares_`. This was never very consistent. Organizing the code better typically provides more benefit in this way, which we've made great progress on. All non-static symbols must contain the `ares_` prefix, and that should be more than sufficient in preventing any sort of issues. Authored-By: Brad House (@bradh352)
6 months ago
ares_buf_append_num_dec(printmsg, ares_dns_rr_get_u32(rr, keys[k]),
0);
Fuzzing: add fetcher/writers to fuzzing suite The coverage of the fuzzer is fairly low as it was only testing the parsing, not trying to read the data from the datastructure or writing it back out as a DNS message. Lets extend, and also provide a FUZZING.md to help people new to fuzzing get up and running. Authored-By: Brad House (@bradh352)
6 months ago
break;
case ARES_DATATYPE_NAME:
case ARES_DATATYPE_STR:
Remove `ares__` prefix, just use `ares_` (#872) At some point in time, internal non-public functions were prefixed with `ares__` where as functions that may become public were prefixed with just `ares_`. This was never very consistent. Organizing the code better typically provides more benefit in this way, which we've made great progress on. All non-static symbols must contain the `ares_` prefix, and that should be more than sufficient in preventing any sort of issues. Authored-By: Brad House (@bradh352)
6 months ago
ares_buf_append_byte(printmsg, '"');
ares_buf_append_str(printmsg, ares_dns_rr_get_str(rr, keys[k]));
ares_buf_append_byte(printmsg, '"');
Fuzzing: add fetcher/writers to fuzzing suite The coverage of the fuzzer is fairly low as it was only testing the parsing, not trying to read the data from the datastructure or writing it back out as a DNS message. Lets extend, and also provide a FUZZING.md to help people new to fuzzing get up and running. Authored-By: Brad House (@bradh352)
6 months ago
break;
case ARES_DATATYPE_BIN:
/* TODO */
break;
case ARES_DATATYPE_BINP:
{
size_t templen;
Remove `ares__` prefix, just use `ares_` (#872) At some point in time, internal non-public functions were prefixed with `ares__` where as functions that may become public were prefixed with just `ares_`. This was never very consistent. Organizing the code better typically provides more benefit in this way, which we've made great progress on. All non-static symbols must contain the `ares_` prefix, and that should be more than sufficient in preventing any sort of issues. Authored-By: Brad House (@bradh352)
6 months ago
ares_buf_append_byte(printmsg, '"');
ares_buf_append_str(printmsg, (const char *)ares_dns_rr_get_bin(
rr, keys[k], &templen));
ares_buf_append_byte(printmsg, '"');
Fuzzing: add fetcher/writers to fuzzing suite The coverage of the fuzzer is fairly low as it was only testing the parsing, not trying to read the data from the datastructure or writing it back out as a DNS message. Lets extend, and also provide a FUZZING.md to help people new to fuzzing get up and running. Authored-By: Brad House (@bradh352)
6 months ago
}
break;
case ARES_DATATYPE_ABINP:
{
size_t a;
Remove `ares__` prefix, just use `ares_` (#872) At some point in time, internal non-public functions were prefixed with `ares__` where as functions that may become public were prefixed with just `ares_`. This was never very consistent. Organizing the code better typically provides more benefit in this way, which we've made great progress on. All non-static symbols must contain the `ares_` prefix, and that should be more than sufficient in preventing any sort of issues. Authored-By: Brad House (@bradh352)
6 months ago
for (a = 0; a < ares_dns_rr_get_abin_cnt(rr, keys[k]); a++) {
Fuzzing: add fetcher/writers to fuzzing suite The coverage of the fuzzer is fairly low as it was only testing the parsing, not trying to read the data from the datastructure or writing it back out as a DNS message. Lets extend, and also provide a FUZZING.md to help people new to fuzzing get up and running. Authored-By: Brad House (@bradh352)
6 months ago
size_t templen;
if (a != 0) {
Remove `ares__` prefix, just use `ares_` (#872) At some point in time, internal non-public functions were prefixed with `ares__` where as functions that may become public were prefixed with just `ares_`. This was never very consistent. Organizing the code better typically provides more benefit in this way, which we've made great progress on. All non-static symbols must contain the `ares_` prefix, and that should be more than sufficient in preventing any sort of issues. Authored-By: Brad House (@bradh352)
6 months ago
ares_buf_append_byte(printmsg, ' ');
Fuzzing: add fetcher/writers to fuzzing suite The coverage of the fuzzer is fairly low as it was only testing the parsing, not trying to read the data from the datastructure or writing it back out as a DNS message. Lets extend, and also provide a FUZZING.md to help people new to fuzzing get up and running. Authored-By: Brad House (@bradh352)
6 months ago
}
Remove `ares__` prefix, just use `ares_` (#872) At some point in time, internal non-public functions were prefixed with `ares__` where as functions that may become public were prefixed with just `ares_`. This was never very consistent. Organizing the code better typically provides more benefit in this way, which we've made great progress on. All non-static symbols must contain the `ares_` prefix, and that should be more than sufficient in preventing any sort of issues. Authored-By: Brad House (@bradh352)
6 months ago
ares_buf_append_byte(printmsg, '"');
ares_buf_append_str(
printmsg,
(const char *)ares_dns_rr_get_abin(rr, keys[k], a, &templen));
ares_buf_append_byte(printmsg, '"');
Fuzzing: add fetcher/writers to fuzzing suite The coverage of the fuzzer is fairly low as it was only testing the parsing, not trying to read the data from the datastructure or writing it back out as a DNS message. Lets extend, and also provide a FUZZING.md to help people new to fuzzing get up and running. Authored-By: Brad House (@bradh352)
6 months ago
}
}
break;
case ARES_DATATYPE_OPT:
/* TODO */
break;
}
Remove `ares__` prefix, just use `ares_` (#872) At some point in time, internal non-public functions were prefixed with `ares__` where as functions that may become public were prefixed with just `ares_`. This was never very consistent. Organizing the code better typically provides more benefit in this way, which we've made great progress on. All non-static symbols must contain the `ares_` prefix, and that should be more than sufficient in preventing any sort of issues. Authored-By: Brad House (@bradh352)
6 months ago
ares_buf_append_str(printmsg, " ");
Fuzzing: add fetcher/writers to fuzzing suite The coverage of the fuzzer is fairly low as it was only testing the parsing, not trying to read the data from the datastructure or writing it back out as a DNS message. Lets extend, and also provide a FUZZING.md to help people new to fuzzing get up and running. Authored-By: Brad House (@bradh352)
6 months ago
}
Remove `ares__` prefix, just use `ares_` (#872) At some point in time, internal non-public functions were prefixed with `ares__` where as functions that may become public were prefixed with just `ares_`. This was never very consistent. Organizing the code better typically provides more benefit in this way, which we've made great progress on. All non-static symbols must contain the `ares_` prefix, and that should be more than sufficient in preventing any sort of issues. Authored-By: Brad House (@bradh352)
6 months ago
ares_buf_append_str(printmsg, "\n");
Fuzzing: add fetcher/writers to fuzzing suite The coverage of the fuzzer is fairly low as it was only testing the parsing, not trying to read the data from the datastructure or writing it back out as a DNS message. Lets extend, and also provide a FUZZING.md to help people new to fuzzing get up and running. Authored-By: Brad House (@bradh352)
6 months ago
}
}
Remove `ares__` prefix, just use `ares_` (#872) At some point in time, internal non-public functions were prefixed with `ares__` where as functions that may become public were prefixed with just `ares_`. This was never very consistent. Organizing the code better typically provides more benefit in this way, which we've made great progress on. All non-static symbols must contain the `ares_` prefix, and that should be more than sufficient in preventing any sort of issues. Authored-By: Brad House (@bradh352)
6 months ago
ares_buf_append_str(printmsg, ";; SIZE: ");
ares_buf_append_num_dec(printmsg, size, 0);
ares_buf_append_str(printmsg, "\n\n");
Fuzzing: add fetcher/writers to fuzzing suite The coverage of the fuzzer is fairly low as it was only testing the parsing, not trying to read the data from the datastructure or writing it back out as a DNS message. Lets extend, and also provide a FUZZING.md to help people new to fuzzing get up and running. Authored-By: Brad House (@bradh352)
6 months ago
Remove `ares__` prefix, just use `ares_` (#872) At some point in time, internal non-public functions were prefixed with `ares__` where as functions that may become public were prefixed with just `ares_`. This was never very consistent. Organizing the code better typically provides more benefit in this way, which we've made great progress on. All non-static symbols must contain the `ares_` prefix, and that should be more than sufficient in preventing any sort of issues. Authored-By: Brad House (@bradh352)
6 months ago
printdata = ares_buf_finish_str(printmsg, NULL);
Fuzzing: add fetcher/writers to fuzzing suite The coverage of the fuzzer is fairly low as it was only testing the parsing, not trying to read the data from the datastructure or writing it back out as a DNS message. Lets extend, and also provide a FUZZING.md to help people new to fuzzing get up and running. Authored-By: Brad House (@bradh352)
6 months ago
printmsg = NULL;
/* Write it back out as a dns message to test writer */
if (ares_dns_write(dnsrec, &datadup, &datadup_len) != ARES_SUCCESS) {
goto done;
}
done:
ares_dns_record_destroy(dnsrec);
Remove `ares__` prefix, just use `ares_` (#872) At some point in time, internal non-public functions were prefixed with `ares__` where as functions that may become public were prefixed with just `ares_`. This was never very consistent. Organizing the code better typically provides more benefit in this way, which we've made great progress on. All non-static symbols must contain the `ares_` prefix, and that should be more than sufficient in preventing any sort of issues. Authored-By: Brad House (@bradh352)
6 months ago
ares_buf_destroy(printmsg);
Fuzzing: add fetcher/writers to fuzzing suite The coverage of the fuzzer is fairly low as it was only testing the parsing, not trying to read the data from the datastructure or writing it back out as a DNS message. Lets extend, and also provide a FUZZING.md to help people new to fuzzing get up and running. Authored-By: Brad House (@bradh352)
6 months ago
ares_free(printdata);
Fuzzing: Fix memory leak in test case The test case changes introduced a memory leak in the test itself (not in c-ares). Fix this memory leak. Also move prior fuzzing information into the new fuzzing document. Fix By: Brad House (@bradh352)
6 months ago
ares_free(datadup);
fuzzer: call parser directly for enhanced iterations per second The legacy c-ares parsers such as ares_parse_txt_reply() and ares_parse_srv_reply() historically all used different logic and parsing. As of c-ares 1.21.0 these are simply wrappers around a single parser, and simply convert the parsed DNS response into the data structures the legacy parsers used which is a small amount of code and not likely going to vary based on the input data. Instead, these days, it makes more sense to test the new parser directly instead of calling it 10 or 11 times with the same input data to speed up the number of iterations per second the fuzzer can perform. We are keeping this legacy fuzzer test for historic reasons or if someone finds them of use hidden behind a define of USE_LEGACY_PARSERS. Authored-By: Brad House (@bradh352)
6 months ago
return 0;
}
#endif