7 * This file is part of adns, which is
8 * Copyright (C) 1997-2000,2003,2006 Ian Jackson
9 * Copyright (C) 1999-2000,2003,2006 Tony Finch
10 * Copyright (C) 1991 Massachusetts Institute of Technology
11 * (See the file INSTALL for full details.)
13 * This program is free software; you can redistribute it and/or modify
14 * it under the terms of the GNU General Public License as published by
15 * the Free Software Foundation; either version 2, or (at your option)
18 * This program is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU General Public License for more details.
23 * You should have received a copy of the GNU General Public License
24 * along with this program; if not, write to the Free Software Foundation,
25 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
30 #include <sys/types.h>
36 #define MKQUERY_START(vb) (rqp= (vb)->buf+(vb)->used)
37 #define MKQUERY_ADDB(b) *rqp++= (b)
38 #define MKQUERY_ADDW(w) (MKQUERY_ADDB(((w)>>8)&0x0ff), MKQUERY_ADDB((w)&0x0ff))
39 #define MKQUERY_STOP(vb) ((vb)->used= rqp-(vb)->buf)
41 static adns_status
mkquery_header(adns_state ads
, vbuf
*vb
,
42 int *id_r
, int qdlen
) {
46 if (!adns__vbuf_ensure(vb
,DNS_HDRSIZE
+qdlen
+4)) return adns_s_nomemory
;
51 *id_r
= id
= (ads
->nextid
++) & 0x0ffff;
53 MKQUERY_ADDB(0x01); /* QR=Q(0), OPCODE=QUERY(0000), !AA, !TC, RD */
54 MKQUERY_ADDB(0x00); /* !RA, Z=000, RCODE=NOERROR(0000) */
55 MKQUERY_ADDW(1); /* QDCOUNT=1 */
56 MKQUERY_ADDW(0); /* ANCOUNT=0 */
57 MKQUERY_ADDW(0); /* NSCOUNT=0 */
58 MKQUERY_ADDW(0); /* ARCOUNT=0 */
65 static adns_status
mkquery_footer(vbuf
*vb
, adns_rrtype type
) {
69 MKQUERY_ADDW(type
& adns_rrt_typemask
); /* QTYPE */
70 MKQUERY_ADDW(DNS_CLASS_IN
); /* QCLASS=IN */
72 assert(vb
->used
<= vb
->avail
);
77 static adns_status
qdparselabel(adns_state ads
,
78 const char **p_io
, const char *pe
,
79 char label_r
[], int *ll_io
,
80 adns_queryflags flags
) {
87 while (p
!=pe
&& (c
= *p
++)!='.') {
89 if (!(flags
& adns_qf_quoteok_query
)) return adns_s_querydomaininvalid
;
90 if (ctype_digit(p
[0])) {
91 if (p
+1==pe
|| p
+2==pe
) return adns_s_querydomaininvalid
;
92 if (ctype_digit(p
[1]) && ctype_digit(p
[2])) {
96 if (c
>= 256) return adns_s_querydomaininvalid
;
98 return adns_s_querydomaininvalid
;
100 } else if (!(c
= *p
++)) {
101 return adns_s_querydomaininvalid
;
104 if (ll
== *ll_io
) return adns_s_querydomaininvalid
;
113 adns_status
adns__mkquery(adns_state ads
, vbuf
*vb
, int *id_r
,
114 const char *owner
, int ol
,
115 const typeinfo
*typei
, adns_rrtype type
,
116 adns_queryflags flags
) {
123 st
= mkquery_header(ads
,vb
,id_r
,ol
+2); if (st
) return st
;
127 p
= owner
; pe
= owner
+ol
;
131 st
= qdparselabel(ads
, &p
,pe
, label
, &ll
, flags
);
133 if (!ll
) return adns_s_querydomaininvalid
;
134 if (ll
> DNS_MAXLABEL
) return adns_s_querydomaintoolong
;
136 if (nbytes
>= DNS_MAXDOMAIN
) return adns_s_querydomaintoolong
;
138 memcpy(rqp
,label
,ll
); rqp
+= ll
;
144 st
= mkquery_footer(vb
,type
);
149 adns_status
adns__mkquery_frdgram(adns_state ads
, vbuf
*vb
, int *id_r
,
150 const byte
*qd_dgram
, int qd_dglen
,
152 adns_rrtype type
, adns_queryflags flags
) {
155 int lablen
, labstart
;
158 st
= mkquery_header(ads
,vb
,id_r
,qd_dglen
); if (st
) return st
;
162 adns__findlabel_start(&fls
,ads
,-1,0,qd_dgram
,qd_dglen
,qd_dglen
,qd_begin
,0);
164 st
= adns__findlabel_next(&fls
,&lablen
,&labstart
); assert(!st
);
167 MKQUERY_ADDB(lablen
);
168 memcpy(rqp
,qd_dgram
+labstart
,lablen
);
175 st
= mkquery_footer(vb
,type
);
180 void adns__querysend_tcp(adns_query qu
, struct timeval now
) {
186 if (qu
->ads
->tcpstate
!= server_ok
) return;
188 assert(qu
->state
== query_tcpw
);
190 length
[0]= (qu
->query_dglen
&0x0ff00U
) >>8;
191 length
[1]= (qu
->query_dglen
&0x0ff);
194 if (!adns__vbuf_ensure(&ads
->tcpsend
,ads
->tcpsend
.used
+qu
->query_dglen
+2))
199 /* Reset idle timeout. */
200 ads
->tcptimeout
.tv_sec
= ads
->tcptimeout
.tv_usec
= 0;
202 if (ads
->tcpsend
.used
) {
205 iov
[0].iov_base
= length
;
207 iov
[1].iov_base
= qu
->query_dgram
;
208 iov
[1].iov_len
= qu
->query_dglen
;
209 adns__sigpipe_protect(qu
->ads
);
210 wr
= writev(qu
->ads
->tcpsocket
,iov
,2);
211 adns__sigpipe_unprotect(qu
->ads
);
213 if (!(errno
== EAGAIN
|| errno
== EINTR
|| errno
== ENOSPC
||
214 errno
== ENOBUFS
|| errno
== ENOMEM
)) {
215 adns__tcp_broken(ads
,"write",strerror(errno
));
223 r
= adns__vbuf_append(&ads
->tcpsend
,length
,2-wr
); assert(r
);
228 if (wr
<qu
->query_dglen
) {
229 r
= adns__vbuf_append(&ads
->tcpsend
,qu
->query_dgram
+wr
,qu
->query_dglen
-wr
);
234 static void query_usetcp(adns_query qu
, struct timeval now
) {
235 qu
->state
= query_tcpw
;
237 timevaladd(&qu
->timeout
,TCPWAITMS
);
238 LIST_LINK_TAIL(qu
->ads
->tcpw
,qu
);
239 adns__querysend_tcp(qu
,now
);
240 adns__tcp_tryconnect(qu
->ads
,now
);
243 struct udpsocket
*adns__udpsocket_by_af(adns_state ads
, int af
) {
245 for (i
=0; i
<ads
->nudp
; i
++)
246 if (ads
->udpsocket
[i
].af
== af
) return &ads
->udpsocket
[i
];
250 void adns__query_send(adns_query qu
, struct timeval now
) {
253 struct udpsocket
*udp
;
256 assert(qu
->state
== query_tosend
);
257 if ((qu
->flags
& adns_qf_usevc
) || (qu
->query_dglen
> DNS_MAXUDP
)) {
258 query_usetcp(qu
,now
);
262 if (qu
->retries
>= UDPMAXRETRIES
) {
263 adns__query_fail(qu
,adns_s_timeout
);
268 serv
= qu
->udpnextserver
;
269 addr
= &ads
->servers
[serv
];
270 udp
= adns__udpsocket_by_af(ads
, addr
->addr
.sa
.sa_family
);
273 r
= sendto(udp
->fd
,qu
->query_dgram
,qu
->query_dglen
,0,
274 &addr
->addr
.sa
,addr
->len
);
275 if (r
<0 && errno
== EMSGSIZE
) {
277 query_usetcp(qu
,now
);
280 if (r
<0 && errno
!= EAGAIN
)
281 adns__warn(ads
,serv
,0,"sendto failed: %s",strerror(errno
));
284 timevaladd(&qu
->timeout
,UDPRETRYMS
);
285 qu
->udpsent
|= (1<<serv
);
286 qu
->udpnextserver
= (serv
+1)%ads
->nservers
;
288 LIST_LINK_TAIL(ads
->udpw
,qu
);