AuroraMiddleware/glibc
1
0
Fork 0
mirror of https://sourceware.org/git/glibc.git synced 2024-12-22 19:00:07 +00:00
Code Issues Packages Projects Releases Wiki Activity

resolv: Reformat resolv/res_mkquery.c to GNU style

Browse Source
This commit is contained in:
Florian Weimer 2017-06-30 11:31:12 +02:00
parent 7ab27b76d2
commit 74084febc4
2 changed files with 145 additions and 144 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
ChangeLog
View File

@ -1,3 +1,8 @@
2017-06-30 Florian Weimer <fweimer@redhat.com>
* resolv/res_mkquery.c: Reformat to GNU style.
(T_OPT): Remove definition. It is present in the header file.
2017-06-30 Florian Weimer <fweimer@redhat.com> 2017-06-30 Florian Weimer <fweimer@redhat.com>
* resolv/res_mkquery.c (DEBUG): Remove macro and preprocessor * resolv/res_mkquery.c (DEBUG): Remove macro and preprocessor

284
resolv/res_mkquery.c
View File

@ -97,172 +97,168 @@
# define RANDOM_BITS(Var) { uint64_t v64; HP_TIMING_NOW (v64); Var = v64; } # define RANDOM_BITS(Var) { uint64_t v64; HP_TIMING_NOW (v64); Var = v64; }
#endif #endif
/* /* Form all types of queries. Returns the size of the result or -1 on
* Form all types of queries. error.
* Returns the size of the result or -1.
*/ STATP points to an initialized resolver state. OP is the opcode of
the query. DNAME is the domain. CLASS and TYPE are the DNS query
class and type. DATA can be NULL; otherwise, it is a pointer to a
domain name which is included in the generated packet (if op ==
NS_NOTIFY_OP). BUF must point to the out buffer of BUFLEN bytes.
DATALEN and NEWRR_IN are currently ignored. */
int int
res_nmkquery(res_state statp, res_nmkquery (res_state statp, int op, const char *dname,
int op, /* opcode of query */ int class, int type,
const char *dname, /* domain name */ const unsigned char *data, int datalen,
int class, int type, /* class and type of query */ const unsigned char *newrr_in,
const u_char *data, /* resource record data */ unsigned char *buf, int buflen)
int datalen, /* length of data */
const u_char *newrr_in, /* new rr for modify or append */
u_char *buf, /* buffer to put query */
int buflen) /* size of buffer */
{ {
HEADER *hp; HEADER *hp;
u_char *cp; unsigned char *cp;
int n; int n;
u_char *dnptrs[20], **dpp, **lastdnptr; unsigned char *dnptrs[20], **dpp, **lastdnptr;
if (class < 0 || class > 65535 if (class < 0 || class > 65535 || type < 0 || type > 65535)
|| type < 0 || type > 65535) return -1;
return -1;
/* /* Initialize header fields. */
* Initialize header fields. if ((buf == NULL) || (buflen < HFIXEDSZ))
*/ return -1;
if ((buf == NULL) || (buflen < HFIXEDSZ)) memset (buf, 0, HFIXEDSZ);
return (-1); hp = (HEADER *) buf;
memset(buf, 0, HFIXEDSZ); /* We randomize the IDs every time. The old code just incremented
hp = (HEADER *) buf; by one after the initial randomization which still predictable if
/* We randomize the IDs every time. The old code just the application does multiple requests. */
incremented by one after the initial randomization which int randombits;
still predictable if the application does multiple do
requests. */ {
int randombits;
do
{
#ifdef RANDOM_BITS #ifdef RANDOM_BITS
RANDOM_BITS (randombits); RANDOM_BITS (randombits);
#else #else
struct timeval tv; struct timeval tv;
__gettimeofday (&tv, NULL); __gettimeofday (&tv, NULL);
randombits = (tv.tv_sec << 8) ^ tv.tv_usec; randombits = (tv.tv_sec << 8) ^ tv.tv_usec;
#endif #endif
} }
while ((randombits & 0xffff) == 0); while ((randombits & 0xffff) == 0);
statp->id = (statp->id + randombits) & 0xffff;
hp->id = statp->id;
hp->opcode = op;
hp->rd = (statp->options & RES_RECURSE) != 0;
hp->rcode = NOERROR;
cp = buf + HFIXEDSZ;
buflen -= HFIXEDSZ;
dpp = dnptrs;
*dpp++ = buf;
*dpp++ = NULL;
lastdnptr = dnptrs + sizeof dnptrs / sizeof dnptrs[0];
/*
* perform opcode specific processing
*/
switch (op) {
case NS_NOTIFY_OP:
if ((buflen -= QFIXEDSZ + (data == NULL ? 0 : RRFIXEDSZ)) < 0)
return (-1);
goto compose;
case QUERY: statp->id = (statp->id + randombits) & 0xffff;
if ((buflen -= QFIXEDSZ) < 0) hp->id = statp->id;
return (-1); hp->opcode = op;
compose: hp->rd = (statp->options & RES_RECURSE) != 0;
n = ns_name_compress(dname, cp, buflen, hp->rcode = NOERROR;
(const u_char **) dnptrs, cp = buf + HFIXEDSZ;
(const u_char **) lastdnptr); buflen -= HFIXEDSZ;
if (n < 0) dpp = dnptrs;
return (-1); *dpp++ = buf;
cp += n; *dpp++ = NULL;
buflen -= n; lastdnptr = dnptrs + sizeof dnptrs / sizeof dnptrs[0];
NS_PUT16 (type, cp);
NS_PUT16 (class, cp);
hp->qdcount = htons(1);
if (op == QUERY || data == NULL)
break;
/*
* Make an additional record for completion domain.
*/
n = ns_name_compress((char *)data, cp, buflen,
(const u_char **) dnptrs,
(const u_char **) lastdnptr);
if (__glibc_unlikely (n < 0))
return (-1);
cp += n;
buflen -= n;
NS_PUT16 (T_NULL, cp);
NS_PUT16 (class, cp);
NS_PUT32 (0, cp);
NS_PUT16 (0, cp);
hp->arcount = htons(1);
break;
default: /* Perform opcode specific processing. */
return (-1); switch (op)
} {
return (cp - buf); case NS_NOTIFY_OP:
if ((buflen -= QFIXEDSZ + (data == NULL ? 0 : RRFIXEDSZ)) < 0)
return -1;
goto compose;
case QUERY:
if ((buflen -= QFIXEDSZ) < 0)
return -1;
compose:
n = ns_name_compress (dname, cp, buflen,
(const unsigned char **) dnptrs,
(const unsigned char **) lastdnptr);
if (n < 0)
return -1;
cp += n;
buflen -= n;
NS_PUT16 (type, cp);
NS_PUT16 (class, cp);
hp->qdcount = htons (1);
if (op == QUERY || data == NULL)
break;
/* Make an additional record for completion domain. */
n = ns_name_compress ((char *)data, cp, buflen,
(const unsigned char **) dnptrs,
(const unsigned char **) lastdnptr);
if (__glibc_unlikely (n < 0))
return -1;
cp += n;
buflen -= n;
NS_PUT16 (T_NULL, cp);
NS_PUT16 (class, cp);
NS_PUT32 (0, cp);
NS_PUT16 (0, cp);
hp->arcount = htons (1);
break;
default:
return -1;
}
return cp - buf;
} }
libresolv_hidden_def (res_nmkquery) libresolv_hidden_def (res_nmkquery)
/* Create an OPT resource record. Return the length of the final
packet, or -1 on error.
/* attach OPT pseudo-RR, as documented in RFC2671 (EDNS0). */ STATP must be an initialized resolver state. N0 is the current
#ifndef T_OPT number of bytes of the packet (already written to BUF by the
#define T_OPT 41 aller). BUF is the packet being constructed. The array it
#endif pointers to must be BUFLEN bytes long. ANSLEN is the advertised
EDNS buffer size (to be included in the OPT resource record). */
int int
__res_nopt(res_state statp, __res_nopt (res_state statp, int n0, unsigned char *buf, int buflen,
int n0, /* current offset in buffer */ int anslen)
u_char *buf, /* buffer to put query */
int buflen, /* size of buffer */
int anslen) /* UDP answer buffer size */
{ {
u_int16_t flags = 0; uint16_t flags = 0;
HEADER *hp = (HEADER *) buf;
unsigned char *cp = buf + n0;
unsigned char *ep = buf + buflen;
HEADER *hp = (HEADER *) buf; if ((ep - cp) < 1 + RRFIXEDSZ)
u_char *cp = buf + n0; return -1;
u_char *ep = buf + buflen;
if ((ep - cp) < 1 + RRFIXEDSZ) /* Add the root label. */
return -1; *cp++ = 0;
*cp++ = 0; /* "." */ NS_PUT16 (T_OPT, cp); /* Record type. */
NS_PUT16(T_OPT, cp); /* TYPE */ /* Lowering the advertised buffer size based on the actual
answer buffer size is desirable because the server will
minimize the reply to fit into the UDP packet (and A
non-minimal response might not fit the buffer).
/* Lowering the advertised buffer size based on the actual The RESOLV_EDNS_BUFFER_SIZE limit could still result in TCP
answer buffer size is desirable because the server will fallback and a non-minimal response which has to be
minimize the reply to fit into the UDP packet (and A hard-truncated in the stub resolver, but this is price to
non-minimal response might not fit the buffer). pay for avoiding fragmentation. (This issue does not
affect the nss_dns functions because they use the stub
resolver in such a way that it allocates a properly sized
response buffer.) */
{
uint16_t buffer_size;
if (anslen < 512)
buffer_size = 512;
else if (anslen > RESOLV_EDNS_BUFFER_SIZE)
buffer_size = RESOLV_EDNS_BUFFER_SIZE;
else
buffer_size = anslen;
NS_PUT16 (buffer_size, cp);
}
The RESOLV_EDNS_BUFFER_SIZE limit could still result in TCP *cp++ = NOERROR; /* Extended RCODE. */
fallback and a non-minimal response which has to be *cp++ = 0; /* EDNS version. */
hard-truncated in the stub resolver, but this is price to
pay for avoiding fragmentation. (This issue does not
affect the nss_dns functions because they use the stub
resolver in such a way that it allocates a properly sized
response buffer.) */
{
uint16_t buffer_size;
if (anslen < 512)
buffer_size = 512;
else if (anslen > RESOLV_EDNS_BUFFER_SIZE)
buffer_size = RESOLV_EDNS_BUFFER_SIZE;
else
buffer_size = anslen;
NS_PUT16 (buffer_size, cp);
}
*cp++ = NOERROR; /* extended RCODE */ if (statp->options & RES_USE_DNSSEC)
*cp++ = 0; /* EDNS version */ flags |= NS_OPT_DNSSEC_OK;
if (statp->options & RES_USE_DNSSEC) { NS_PUT16 (flags, cp);
flags |= NS_OPT_DNSSEC_OK; NS_PUT16 (0, cp); /* RDATA length (no options are preent). */
} hp->arcount = htons (ntohs (hp->arcount) + 1);
NS_PUT16(flags, cp); return cp - buf;
NS_PUT16(0, cp); /* RDLEN */
hp->arcount = htons(ntohs(hp->arcount) + 1);
return cp - buf;
} }