# Current and Age. Set Revision to 0, since this is the first
# implementation of the new API.
#
-# Otherwise, we're changing the binary API and breaking bakward
+# Otherwise, we're changing the binary API and breaking backward
# compatibility with old binaries. Increment Current. Set Age to 0,
# since we're backward compatible with no previous APIs. Set Revision
# to 0 too.
+/* ASN: End of added code */
+
/*
- * Return priming query results to interestes super querystates.
+ * Return priming query results to interested super querystates.
*
@@ -2941,6 +3050,9 @@
else if(super->qinfo.qtype == LDNS_RR_TYPE_DS && ((struct iter_qstate*)
+ /**
* Each time a delegation point changes for a given query or a
* query times out and/or wakes up, this state is (re)visited.
- * This state is reponsible for iterating through a list of
+ * This state is responsible for iterating through a list of
@@ -346,6 +357,13 @@
*/
int refetch_glue;
$allstats{$inthread}->{outstandingexc} = $4;
}
elsif ( $line =~ m/info: average recursion processing time ([0-9\.]+) sec/ ) {
- $allstats{$inthread}->{recursionavg} = int($1 * 1000); # change sec to milisec.
+ $allstats{$inthread}->{recursionavg} = int($1 * 1000); # change sec to millisec.
}
elsif ( $line =~ m/info: histogram of recursion processing times/ ) {
next;
}
elsif ( $line =~ m/info: lower\(secs\) upper\(secs\) recursions/ ) {
# since after this line we're unsure if we get these numbers
- # at all, we sould consider this marker as the end of the
+ # at all, we should consider this marker as the end of the
# block. Chances that we're parsing a file halfway written
# at this stage are small. Bold statement.
$donestats{$inthread} = 1;
struct ub_packed_rrset_key* k = (struct ub_packed_rrset_key*)e->key;
struct packed_rrset_data* d = (struct packed_rrset_data*)e->data;
/* delete the parentside negative cache rrsets,
- * these are namerserver rrsets that failed lookup, rdata empty */
+ * these are nameserver rrsets that failed lookup, rdata empty */
if((k->rk.flags & PACKED_RRSET_PARENT_SIDE) && d->count == 1 &&
d->rrsig_count == 0 && d->rr_len[0] == 0) {
d->ttl = inf->expired;
#endif /* HAVE_DAEMON */
}
-/** daemonize, drop user priviliges and chroot if needed */
+/** daemonize, drop user privileges and chroot if needed */
static void
perform_setup(struct daemon* daemon, struct config_file* cfg, int debug_mode,
const char** cfgfile, int need_pidfile)
* In order to be able to serve certs over TXT, we can reuse the local-zone and
* local-data config option. The zone and qname are infered from the
* provider_name and the content of the TXT record from the certificate content.
- * returns the number of certtificate TXT record that were loaded.
+ * returns the number of certificate TXT record that were loaded.
* < 0 in case of error.
*/
static int
15 September 2017: Wouter
- Fix unbound-host to report error for DNSSEC state of failed lookups.
+ - Spelling fixes, from Phil Porada.
13 September 2017: Wouter
- tag 1.6.6rc2
# that set CD but cannot validate themselves.
# ignore-cd-flag: no
- # Serve expired reponses from cache, with TTL 0 in the response,
+ # Serve expired responses from cache, with TTL 0 in the response,
# and then attempt to fetch the data afresh.
# serve-expired: no
5. Choices
----------
-o rfc2181 decourages duplicates RRs in RRsets. unbound does not create
+o rfc2181 discourages duplicates RRs in RRsets. unbound does not create
duplicates, but when presented with duplicates on the wire from the
authoritative servers, does not perform duplicate removal.
It does do some rrsig duplicate removal, in the msgparser, for dnssec qtype
stored in the regular cache.
.LP
Additionally, when a client includes the option in its queries, Unbound will
-forward the option to the authority if prensent in the whitelist, or
+forward the option to the authority if present in the whitelist, or
\fBclient\-subnet\-always\-forward\fR is set to yes. In this case the lookup in
the regular cache is skipped.
.LP
struct addredge {
/** address of connected node */
addrkey_t *str;
- /** lenght in bits of str */
+ /** length in bits of str */
addrlen_t len;
/** child node this edge is connected to */
struct addrnode *node;
ecs->subnet_addr_fam = sldns_read_uint16(ecs_option->opt_data);
ecs->subnet_source_mask = ecs_option->opt_data[2];
ecs->subnet_scope_mask = ecs_option->opt_data[3];
- /* remaing bytes indicate address */
+ /* remaining bytes indicate address */
/* validate input*/
/* option length matches calculated length? */
if(sq->subnet_sent &&
FLAGS_GET_RCODE(response->rep->flags) == LDNS_RCODE_REFUSED) {
- /* REFUSED reponse to ECS query, remove ECS option. */
+ /* REFUSED response to ECS query, remove ECS option. */
edns_opt_list_remove(&qstate->edns_opts_back_out,
qstate->env->cfg->client_subnet_opcode);
sq->subnet_sent = 0;
sq->ecs_server_in.subnet_validdata)
/* Only skip global cache store if we sent an ECS option
* and received one back. Answers from non-whitelisted
- * servers will end up in global cache. Ansers for
+ * servers will end up in global cache. Answers for
* queries with 0 source will not (unless nameserver
* does not support ECS). */
qstate->no_cache_store = 1;
socklen_t addrlen, uint8_t* zone, size_t zonelen,
struct regional* region, int id, void* cbargs);
-/** Check whether reponse from server contains ECS record, if so, skip cache
+/** Check whether response from server contains ECS record, if so, skip cache
* store. Called just after parsing EDNS data from server. */
int ecs_edns_back_parsed(struct module_qstate* qstate, int id, void* cbargs);
int caps_failed_rcode(struct reply_info* rep);
/**
- * Store parent-side rrset in seperate rrset cache entries for later
+ * Store parent-side rrset in separate rrset cache entries for later
* last-resort * lookups in case the child-side versions of this information
* fails.
* @param env: environment with cache, time, ...
/**
* \file
*
- * This file contains a module that performs recusive iterative DNS query
+ * This file contains a module that performs recursive iterative DNS query
* processing.
*/
/**
* Generate A and AAAA checks for glue that is in-zone for the referral
- * we just got to obtain authoritative information on the adresses.
+ * we just got to obtain authoritative information on the addresses.
*
* @param qstate: the qtstate that triggered the need to prime.
* @param iq: iterator query state.
* the same init processing as ones that do not. Request events that reach
* this state must have a valid currentDelegationPoint set.
*
- * This part is primarly handling stub zone priming. Events that reach this
+ * This part is primarily handling stub zone priming. Events that reach this
* state must have a current delegation point.
*
* @param qstate: query state.
if(FLAGS_GET_RCODE(iq->response->rep->flags) ==
LDNS_RCODE_NXDOMAIN) {
/* Stop resolving when NXDOMAIN is DNSSEC
- * signed. Based on assumption that namservers
+ * signed. Based on assumption that nameservers
* serving signed zones do not return NXDOMAIN
* for empty-non-terminals. */
if(iq->dnssec_expected)
/**
* Do final processing on responses to target queries. Events reach this
* state after the iterative resolution algorithm terminates. This state is
- * responsible for reactiving the original event, and housekeeping related
+ * responsible for reactivating the original event, and housekeeping related
* to received target responses (caching, updating the current delegation
* point, etc).
* Callback from walk_supers for every super state that is interested in
}
/*
- * Return priming query results to interestes super querystates.
+ * Return priming query results to interested super querystates.
*
* Sets the delegation point and delegation message (not nonRD queries).
* This is a callback from walk_supers.
/**
* \file
*
- * This file contains a module that performs recusive iterative DNS query
+ * This file contains a module that performs recursive iterative DNS query
* processing.
*/
/** max number of queries-sent-out. Make sure large NS set does not loop */
#define MAX_SENT_COUNT 32
/** max number of queries for which to perform dnsseclameness detection,
- * (rrsigs misssing detection) after that, just pick up that response */
+ * (rrsigs missing detection) after that, just pick up that response */
#define DNSSEC_LAME_DETECT_COUNT 4
/**
* max number of QNAME minimisation iterations. Limits number of queries for
enum minimisation_state {
/**
* (Re)start minimisation. Outgoing QNAME should be set to dp->name.
- * State entered on new query or after following refferal or CNAME.
+ * State entered on new query or after following referral or CNAME.
*/
INIT_MINIMISE_STATE = 0,
/**
- * QNAME minimisataion ongoing. Increase QNAME on every iteration.
+ * QNAME minimisation ongoing. Increase QNAME on every iteration.
*/
MINIMISE_STATE,
/**
/**
* Each time a delegation point changes for a given query or a
* query times out and/or wakes up, this state is (re)visited.
- * This state is reponsible for iterating through a list of
+ * This state is responsible for iterating through a list of
* nameserver targets.
*/
QUERYTARGETS_STATE,
struct query_info qinfo_out;
/**
- * Count number of QNAME minisation iterations. Used to limit number of
+ * Count number of QNAME minimisation iterations. Used to limit number of
* outgoing queries when QNAME minimisation is enabled.
*/
int minimise_count;
struct outbound_entry* outbound);
/**
- * Return priming query results to interestes super querystates.
+ * Return priming query results to interested super querystates.
*
* Sets the delegation point and delegation message (not nonRD queries).
* This is a callback from walk_supers.
int dothread;
/** next thread number for new threads */
int thr_next_num;
- /** if logfile is overriden */
+ /** if logfile is overridden */
int logfile_override;
/** what logfile to use instead */
FILE* log_out;
* \file
*
* This file contains functions to resolve DNS queries and
- * validate the answers. Synchonously and asynchronously.
+ * validate the answers. Synchronously and asynchronously.
*
*/
The :class:`unbound.ub_data` class contains attributes suffix which converts
the dname to UTF string. These attributes have the ``_idn`` suffix.
-Apart from this aproach, two conversion functions exist
+Apart from this approach, two conversion functions exist
(:func:`unbound.idn2dname` and :func:`unbound.dname2idn`).
Source code
* \file
*
* This file contains functions to resolve DNS queries and
- * validate the answers. Synchonously and asynchronously.
+ * validate the answers. Synchronously and asynchronously.
*
* Several ways to use this interface from an application wishing
* to perform (validated) DNS lookups.
* False, if validation failed or domain queried has no security info.
*
* It is possible to get a result with no data (havedata is false),
- * and secure is true. This means that the non-existance of the data
+ * and secure is true. This means that the non-existence of the data
* was cryptographically proven (with signatures).
*/
int secure;
/**
* Statistics to send over the control pipe when asked
- * This struct is made to be memcpied, sent in binary.
+ * This struct is made to be memcopied, sent in binary.
* shm mapped with (number+1) at num_threads+1, with first as total
*/
struct ub_stats_info {
;; MSG SIZE rcvd: 54
As we handle (override) in the python module only queries ending with
-``localdomain.``, unboud can still resolve host names.
+``localdomain.``, unbound can still resolve host names.
3. rewrite the data in cache
4. return modified packet
-Note that the steps 1 and 3 are neccessary only in case, the python module is the first module in the processing chain.
+Note that the steps 1 and 3 are necessary only in case, the python module is the first module in the processing chain.
In other cases, the validator module guarantees updating data which are produced by iterator module.
Complete source code
This example shows how to interact with EDNS options.
-When quering unbound with the EDNS option ``65001`` and data ``0xc001`` we
+When querying unbound with the EDNS option ``65001`` and data ``0xc001`` we
expect an answer with the same EDNS option code and data ``0xdeadbeef``.
python-script: "./examples/edns.py"
-Quering with EDNS option ``65001:0xc001``:
+Querying with EDNS option ``65001:0xc001``:
::
:param rep: reply_info struct;
:param rcode: return code for the query;
:param edns: edns_data sent from the client side. The list with the EDNS
- options is accesible through edns.opt_list. It SHOULD NOT be
+ options is accessible through edns.opt_list. It SHOULD NOT be
altered;
:param opt_list_out: the list with the EDNS options that will be sent as a
reply. It can be populated with EDNS options;
:param rep: reply_info struct;
:param rcode: return code for the query;
:param edns: edns_data sent from the client side. The list with the
- EDNS options is accesible through edns.opt_list. It
+ EDNS options is accessible through edns.opt_list. It
SHOULD NOT be altered;
:param opt_list_out: the list with the EDNS options that will be sent as a
reply. It can be populated with EDNS options;
:param qstate: :class:`module_qstate`
:param qinfo: :class:`query_info`
:param msgrep: :class:`reply_info`
- :param is_referal: integer
+ :param is_referral: integer
:rtype: boolean
.. function:: invalidateQueryInCache(qstate, qinfo)
.. attribute:: qname_len
- Lenght of question name (number of bytes).
+ Length of question name (number of bytes).
.. attribute:: qname_list[]
Dynamic translation service
---------------------------
-DNS request can be translated to virtualy any answer, that's easy to implement in client side
+DNS request can be translated to virtually any answer, that's easy to implement in client side
because of many DNS libraries available.
Examples :
The function's signature is the same as the C counterpart and allows for
extra functionality during init.
..note:: This function is preferred by unbound over the old init function.
- ..note:: The previously accesible configuration options can now be found in
+ ..note:: The previously accessible configuration options can now be found in
env.cgf.
"""
log_info("python: inited script {}".format(env.cfg.python_script))
"""Previous version init function.
..note:: This function is still supported for backwards compatibility when
the init_standard function is missing. When init_standard is
- present this function SHOULD be ommited to avoid confusion to the
+ present this function SHOULD be omitted to avoid confusion to the
reader.
"""
return True
:param rep: reply_info struct;
:param rcode: return code for the query;
:param edns: edns_data sent from the client side. The list with the EDNS
- options is accesible through edns.opt_list. It SHOULD NOT be
+ options is accessible through edns.opt_list. It SHOULD NOT be
altered;
:param opt_list_out: the list with the EDNS options that will be sent as a
reply. It can be populated with EDNS options;
want to append a new option to opt_list_out.
:return: True on success, False on failure.
- For demostration purposes we want to see if EDNS option 65002 is present
+ For demonstration purposes we want to see if EDNS option 65002 is present
and reply with a new value.
"""
log_info("python: called back while answering from cache.")
:param rep: reply_info struct;
:param rcode: return code for the query;
:param edns: edns_data sent from the client side. The list with the
- EDNS options is accesible through edns.opt_list. It
+ EDNS options is accessible through edns.opt_list. It
SHOULD NOT be altered;
:param opt_list_out: the list with the EDNS options that will be sent as a
reply. It can be populated with EDNS options;
want to append a new option to opt_list_out.
:return: True on success, False on failure.
- For demostration purposes we want to reply with an empty EDNS code '65003'.
+ For demonstration purposes we want to reply with an empty EDNS code '65003'.
"""
log_info("python: called back while servfail.")
b = bytearray.fromhex("")
The function's signature is the same as the C counterpart and allows for
extra functionality during init.
..note:: This function is preferred by unbound over the old init function.
- ..note:: The previously accesible configuration options can now be found in
+ ..note:: The previously accessible configuration options can now be found in
env.cgf.
"""
log_info("python: inited script {}".format(env.cfg.python_script))
"""Previous version init function.
..note:: This function is still supported for backwards compatibility when
the init_standard function is missing. When init_standard is
- present this function SHOULD be ommited to avoid confusion to the
+ present this function SHOULD be omitted to avoid confusion to the
reader.
"""
return True
Functions
* ************************************************************************************ */
/******************************
- * Various debuging functions *
+ * Various debugging functions *
******************************/
void verbose(enum verbosity_value level, const char* format, ...);
void log_info(const char* format, ...);
/**
* Continue processing the mesh state at another module.
- * Handles module to modules tranfer of control.
+ * Handles module to modules transfer of control.
* Handles module finished.
* @param mesh: the mesh area.
* @param mstate: currently active mesh state.
}
}
-/** decomission a tcp buffer, closes commpoint and frees waiting_tcp entry */
+/** decommission a tcp buffer, closes commpoint and frees waiting_tcp entry */
static void
-decomission_pending_tcp(struct outside_network* outnet,
+decommission_pending_tcp(struct outside_network* outnet,
struct pending_tcp* pend)
{
if(pend->c->ssl) {
}
fptr_ok(fptr_whitelist_pending_tcp(pend->query->cb));
(void)(*pend->query->cb)(c, pend->query->cb_arg, error, reply_info);
- decomission_pending_tcp(outnet, pend);
+ decommission_pending_tcp(outnet, pend);
return 0;
}
struct waiting_tcp* p = (struct waiting_tcp*)
sq->pending;
if(p->pkt == NULL) {
- decomission_pending_tcp(sq->outnet,
+ decommission_pending_tcp(sq->outnet,
(struct pending_tcp*)p->next_waiting);
} else {
waiting_list_remove(sq->outnet, p);
/** rbtree node, key is name */
rbnode_type node;
/** view name.
- * Has to be right after rbnode_t due to pointer arithmatic in
+ * Has to be right after rbnode_t due to pointer arithmetic in
* view_create's lock protect */
char* name;
/** view specific local authority zones */
sldns_fget_token_l(FILE *f, char *token, const char *delim, size_t limit, int *line_nr)
{
int c, prev_c;
- int p; /* 0 -> no parenthese seen, >0 nr of ( seen */
+ int p; /* 0 -> no parentheses seen, >0 nr of ( seen */
int com, quoted;
char *t;
size_t i;
const char *d;
const char *del;
- /* standard delimeters */
+ /* standard delimiters */
if (!delim) {
/* from isspace(3) */
del = LDNS_PARSE_NORMAL;
size_t limit, int* par, const char* skipw)
{
int c, lc;
- int p; /* 0 -> no parenthese seen, >0 nr of ( seen */
+ int p; /* 0 -> no parentheses seen, >0 nr of ( seen */
int com, quoted;
char *t;
size_t i;
* after the keyword + k_del until we hit d_del
* \param[in] f file pointer to read from
* \param[in] keyword keyword to look for
- * \param[in] k_del keyword delimeter
+ * \param[in] k_del keyword delimiter
* \param[out] data the data found
- * \param[in] d_del the data delimeter
+ * \param[in] d_del the data delimiter
* \param[in] data_limit maximum size the the data buffer
* \return the number of character read
*/
* after the keyword + k_del until we hit d_del
* \param[in] f file pointer to read from
* \param[in] keyword keyword to look for
- * \param[in] k_del keyword delimeter
+ * \param[in] k_del keyword delimiter
* \param[out] data the data found
- * \param[in] d_del the data delimeter
+ * \param[in] d_del the data delimiter
* \param[in] data_limit maximum size the the data buffer
* \param[in] line_nr pointer to an integer containing the current line number (for
debugging purposes)
* after the keyword + k_del until we hit d_del
* \param[in] b buffer pointer to read from
* \param[in] keyword keyword to look for
- * \param[in] k_del keyword delimeter
+ * \param[in] k_del keyword delimiter
* \param[out] data the data found
- * \param[in] d_del the data delimeter
+ * \param[in] d_del the data delimiter
* \param[in] data_limit maximum size the the data buffer
* \return the number of character read
*/
#endif /* SIZEOF_TIME_T <= 4 */
static int64_t
-sldns_serial_arithmitics_time(int32_t time, time_t now)
+sldns_serial_arithmetics_time(int32_t time, time_t now)
{
int32_t offset = time - (int32_t) now;
return (int64_t) now + offset;
}
struct tm *
-sldns_serial_arithmitics_gmtime_r(int32_t time, time_t now, struct tm *result)
+sldns_serial_arithmetics_gmtime_r(int32_t time, time_t now, struct tm *result)
{
#if SIZEOF_TIME_T <= 4
- int64_t secs_since_epoch = sldns_serial_arithmitics_time(time, now);
+ int64_t secs_since_epoch = sldns_serial_arithmetics_time(time, now);
return sldns_gmtime64_r(secs_since_epoch, result);
#else
- time_t secs_since_epoch = sldns_serial_arithmitics_time(time, now);
+ time_t secs_since_epoch = sldns_serial_arithmetics_time(time, now);
return gmtime_r(&secs_since_epoch, result);
#endif
}
* fields of RRSIG records.
*
* \param[in] time number of seconds since epoch (midnight, January 1st, 1970)
- * to be intepreted as a serial arithmetics number relative to now.
+ * to be interpreted as a serial arithmetics number relative to now.
* \param[in] now number of seconds since epoch (midnight, January 1st, 1970)
* to which the time value is compared to determine the final value.
* \param[out] result the struct with the broken-out time information
* \return result on success or NULL on error
*/
-struct tm * sldns_serial_arithmitics_gmtime_r(int32_t time, time_t now, struct tm *result);
+struct tm * sldns_serial_arithmetics_gmtime_r(int32_t time, time_t now, struct tm *result);
/**
* converts a ttl value (like 5d2h) to a long.
LDNS_RDF_TYPE_NSEC3_NEXT_OWNER,
/** 4 shorts represented as 4 * 16 bit hex numbers
- * seperated by colons. For NID and L64.
+ * separated by colons. For NID and L64.
*/
LDNS_RDF_TYPE_ILNP64,
- /** 6 * 8 bit hex numbers seperated by dashes. For EUI48. */
+ /** 6 * 8 bit hex numbers separated by dashes. For EUI48. */
LDNS_RDF_TYPE_EUI48,
- /** 8 * 8 bit hex numbers seperated by dashes. For EUI64. */
+ /** 8 * 8 bit hex numbers separated by dashes. For EUI64. */
LDNS_RDF_TYPE_EUI64,
/** A non-zero sequence of US-ASCII letters and numbers in lower case.
* writes count bytes of data to the current position of the buffer
* \param[in] buffer the buffer
* \param[in] data the data to write
- * \param[in] count the lenght of the data to write
+ * \param[in] count the length of the data to write
*/
INLINE void
sldns_buffer_write(sldns_buffer *buffer, const void *data, size_t count)
s = strtod(my_str, &my_str);
}
- /* skip blanks before norterness */
+ /* skip blanks before northerness */
while (isblank((unsigned char) *my_str)) {
my_str++;
}
if(*dl < 4) return -1;
t = sldns_read_uint32(*d);
date_buf[15]=0;
- if(sldns_serial_arithmitics_gmtime_r(t, time(NULL), &tm) &&
+ if(sldns_serial_arithmetics_gmtime_r(t, time(NULL), &tm) &&
strftime(date_buf, 15, "%Y%m%d%H%M%S", &tm)) {
(*d) += 4;
(*dl) -= 4;
}
}
-/** cound unused IPs */
+/** count unused IPs */
static int
count_unused(struct ip_list* p)
{
WSADATA wsa_data;
#endif
#ifdef USE_THREAD_DEBUG
- /* stop the file output from unbound-control, overwites the servers */
+ /* stop the file output from unbound-control, overwrites the servers */
extern int check_locking_order;
check_locking_order = 0;
#endif /* USE_THREAD_DEBUG */
* @param area: ptr to mem.
* @param size: length of area.
* You can call it multiple times with the same lock to give several areas.
- * Call it when you are done initialising the area, since it will be copied
+ * Call it when you are done initializing the area, since it will be copied
* at this time and protected right away against unauthorised changes until
* the next lock() call is done.
*/
*/
/* what should we check?
- * X - is it balanced? (a node with 1 child shoudl not have
+ * X - is it balanced? (a node with 1 child should not have
* a node with 1 child MUST have elem
* child must be sub of parent
* edge must be longer than parent edge
#include <pwd.h>
#endif
-/** from cfg username, after daemonise setup performed */
+/** from cfg username, after daemonize setup performed */
uid_t cfg_uid = (uid_t)-1;
-/** from cfg username, after daemonise setup performed */
+/** from cfg username, after daemonize setup performed */
gid_t cfg_gid = (gid_t)-1;
/** for debug allow small timeout values for fast rollovers */
int autr_permit_small_holddown = 0;
#endif
};
-/** from cfg username, after daemonise setup performed */
+/** from cfg username, after daemonize setup performed */
extern uid_t cfg_uid;
-/** from cfg username, after daemonise setup performed */
+/** from cfg username, after daemonize setup performed */
extern gid_t cfg_gid;
/** debug and enable small timeouts */
extern int autr_permit_small_holddown;
{
#ifdef CLIENT_SUBNET
OUTYY(("P(client_subnet_opcode:%s)\n", (yyvsp[0].str)));
- OUTYY(("P(Depricated option, ignoring)\n"));
+ OUTYY(("P(Deprecated option, ignoring)\n"));
#else
OUTYY(("P(Compiled without edns subnet option, ignoring)\n"));
#endif
{
#ifdef CLIENT_SUBNET
OUTYY(("P(client_subnet_opcode:%s)\n", $2));
- OUTYY(("P(Depricated option, ignoring)\n"));
+ OUTYY(("P(Deprecated option, ignoring)\n"));
#else
OUTYY(("P(Compiled without edns subnet option, ignoring)\n"));
#endif
struct module_qstate* qstate);
/**
- * Call the registered functions in the inplace_cb_query_reponse linked list.
+ * Call the registered functions in the inplace_cb_query_response linked list.
* This function is going to get called after receiving a reply from a
* nameserver.
* @param env: module environment.
/**
* Kill newly attached sub. If attach_sub returns newq for
* initialisation, but that fails, then this routine will cleanup and
- * delete the fresly created sub.
+ * delete the freshly created sub.
* @param newq: the new subquery that is no longer needed.
* It is removed.
*/
if (r == -1) {
#if defined(EINPROGRESS) && defined(EWOULDBLOCK)
/* Handshake is underway, maybe because no TFO cookie available.
- Come back to write the messsage*/
+ Come back to write the message*/
if(errno == EINPROGRESS || errno == EWOULDBLOCK)
return 1;
#endif
* But entry->data is set to NULL before deletion, and put into
* the existing entry. The data is then freed.
* @param data: the data.
- * @param cb_override: if not NULL overrides the cb_arg for deletfunc.
+ * @param cb_override: if not NULL overrides the cb_arg for deletefunc.
*/
void slabhash_insert(struct slabhash* table, hashvalue_type hash,
struct lruhash_entry* entry, void* data, void* cb_override);
/** Return the name, system and method for the pluggable event base */
void ub_get_event_sys(struct ub_event_base*, const char** n, const char** s,
const char** m);
-/** Return a default event base. In the deamon thess will be the only event
+/** Return a default event base. In the daemon this will be the only event
* bases used.
*/
struct ub_event_base* ub_default_event_base(int, time_t*, struct timeval*);
verbose(VERB_ALGO, "autotrust: no dnskey rrset");
/* no update of query_failed, because then we would have
* to write to disk. But we cannot because we maybe are
- * still 'initialising' with DS records, that we cannot write
+ * still 'initializing' with DS records, that we cannot write
* in the full format (which only contains KSKs). */
return 1; /* trust point exists */
}
"nsec3 is an insecure delegation");
return sec;
}
- log_nametypeclass(VERB_ALGO, "nsec3 namerror: proven ce=", ce.ce,0,0);
+ log_nametypeclass(VERB_ALGO, "nsec3 nameerror: proven ce=", ce.ce,0,0);
/* At this point, we know that qname does not exist. Now we need
* to prove that the wildcard does not exist. */
setup_ecdsa_sig(unsigned char** sig, unsigned int* len)
{
/* convert from two BIGNUMs in the rdata buffer, to ASN notation.
- * ASN preable: 30440220 <R 32bytefor256> 0220 <S 32bytefor256>
+ * ASN preamble: 30440220 <R 32bytefor256> 0220 <S 32bytefor256>
* the '20' is the length of that field (=bnsize).
i * the '44' is the total remaining length.
* if negative, start with leading zero.
}
/**
- * Inser canonical owner name into buffer.
+ * Insert canonical owner name into buffer.
* @param buf: buffer to insert into at current position.
* @param k: rrset with its owner name.
* @param sig: signature with signer name and label count.
/** A NXDOMAIN response. */
VAL_CLASS_NAMEERROR,
/** A CNAME/DNAME chain, and the offset is at the end of it,
- * but there is no answer here, it can be NAMERROR or NODATA. */
+ * but there is no answer here, it can be NAMEERROR or NODATA. */
VAL_CLASS_CNAMENOANSWER,
/** A referral, from cache with a nonRD query. */
VAL_CLASS_REFERRAL,
uint8_t* ce = NULL; /* for wildcard nodata responses. This is the
proven closest encloser. */
uint8_t* wc = NULL; /* for wildcard nodata responses. wildcard nsec */
- int nxdomain_valid_nsec = 0; /* if true, namerror has been proven */
+ int nxdomain_valid_nsec = 0; /* if true, nameerror has been proven */
int nxdomain_valid_wnsec = 0;
int nsec3s_seen = 0; /* nsec3s seen */
struct ub_packed_rrset_key* s;
projects / thirdparty / unbound.git / commitdiff
