cc9fd0070dc0ae8e0445b42dd420e1dac034f402
[kopensolaris-gnu/glibc.git] / resolv / res_send.c
1 /*
2  * Copyright (c) 1985, 1989, 1993
3  *    The Regents of the University of California.  All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  * 4. Neither the name of the University nor the names of its contributors
14  *    may be used to endorse or promote products derived from this software
15  *    without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27  * SUCH DAMAGE.
28  */
29
30 /*
31  * Portions Copyright (c) 1993 by Digital Equipment Corporation.
32  *
33  * Permission to use, copy, modify, and distribute this software for any
34  * purpose with or without fee is hereby granted, provided that the above
35  * copyright notice and this permission notice appear in all copies, and that
36  * the name of Digital Equipment Corporation not be used in advertising or
37  * publicity pertaining to distribution of the document or software without
38  * specific, written prior permission.
39  *
40  * THE SOFTWARE IS PROVIDED "AS IS" AND DIGITAL EQUIPMENT CORP. DISCLAIMS ALL
41  * WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES
42  * OF MERCHANTABILITY AND FITNESS.   IN NO EVENT SHALL DIGITAL EQUIPMENT
43  * CORPORATION BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
44  * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
45  * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
46  * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
47  * SOFTWARE.
48  */
49
50 /*
51  * Portions Copyright (c) 1996-1999 by Internet Software Consortium.
52  *
53  * Permission to use, copy, modify, and distribute this software for any
54  * purpose with or without fee is hereby granted, provided that the above
55  * copyright notice and this permission notice appear in all copies.
56  *
57  * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM DISCLAIMS
58  * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
59  * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE
60  * CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
61  * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
62  * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
63  * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
64  * SOFTWARE.
65  */
66
67 #if defined(LIBC_SCCS) && !defined(lint)
68 static const char sccsid[] = "@(#)res_send.c    8.1 (Berkeley) 6/4/93";
69 static const char rcsid[] = "$BINDId: res_send.c,v 8.38 2000/03/30 20:16:51 vixie Exp $";
70 #endif /* LIBC_SCCS and not lint */
71
72 /*
73  * Send query to name server and wait for reply.
74  */
75
76 #include <sys/types.h>
77 #include <sys/param.h>
78 #include <sys/time.h>
79 #include <sys/socket.h>
80 #include <sys/uio.h>
81 #ifdef _LIBC
82 #include <sys/poll.h>
83 #endif
84
85 #include <netinet/in.h>
86 #include <arpa/nameser.h>
87 #include <arpa/inet.h>
88
89 #include <errno.h>
90 #include <netdb.h>
91 #include <resolv.h>
92 #include <signal.h>
93 #include <stdio.h>
94 #include <stdlib.h>
95 #include <string.h>
96 #include <unistd.h>
97
98 #ifndef _LIBC
99 #include <isc/eventlib.h>
100 #else
101
102 /* From ev_streams.c.  */
103
104 static inline struct iovec
105 evConsIovec(void *buf, size_t cnt) {
106         struct iovec ret;
107
108         memset(&ret, 0xf5, sizeof ret);
109         ret.iov_base = buf;
110         ret.iov_len = cnt;
111         return (ret);
112 }
113
114 /* From ev_timers.c.  */
115
116 #define BILLION 1000000000
117
118 static inline struct timespec
119 evTimeSpec(struct timeval tv) {
120         struct timespec ts;
121
122         ts.tv_sec = tv.tv_sec;
123         ts.tv_nsec = tv.tv_usec * 1000;
124         return (ts);
125 }
126
127 static inline struct timespec
128 evConsTime(time_t sec, long nsec) {
129         struct timespec x;
130
131         x.tv_sec = sec;
132         x.tv_nsec = nsec;
133         return (x);
134 }
135
136 static inline struct timespec
137 evAddTime(struct timespec addend1, struct timespec addend2) {
138         struct timespec x;
139
140         x.tv_sec = addend1.tv_sec + addend2.tv_sec;
141         x.tv_nsec = addend1.tv_nsec + addend2.tv_nsec;
142         if (x.tv_nsec >= BILLION) {
143                 x.tv_sec++;
144                 x.tv_nsec -= BILLION;
145         }
146         return (x);
147 }
148
149 static inline struct timespec
150 evSubTime(struct timespec minuend, struct timespec subtrahend) {
151         struct timespec x;
152
153         x.tv_sec = minuend.tv_sec - subtrahend.tv_sec;
154         if (minuend.tv_nsec >= subtrahend.tv_nsec)
155                 x.tv_nsec = minuend.tv_nsec - subtrahend.tv_nsec;
156         else {
157                 x.tv_nsec = BILLION - subtrahend.tv_nsec + minuend.tv_nsec;
158                 x.tv_sec--;
159         }
160         return (x);
161 }
162
163 static inline int
164 evCmpTime(struct timespec a, struct timespec b) {
165         long x = a.tv_sec - b.tv_sec;
166
167         if (x == 0L)
168                 x = a.tv_nsec - b.tv_nsec;
169         return (x < 0L ? (-1) : x > 0L ? (1) : (0));
170 }
171
172 static inline struct timespec
173 evNowTime() {
174         struct timeval now;
175
176         if (gettimeofday(&now, NULL) < 0)
177                 return (evConsTime(0, 0));
178         return (evTimeSpec(now));
179 }
180
181 #endif
182
183 /* Options.  Leave them on. */
184 /* #undef DEBUG */
185 #include "res_debug.h"
186
187 #define EXT(res) ((res)->_u._ext)
188
189 #ifndef _LIBC
190 static const int highestFD = FD_SETSIZE - 1;
191 #endif
192
193 /* Forward. */
194
195 static int              send_vc(res_state, const u_char *, int,
196                                 u_char *, int, int *, int);
197 static int              send_dg(res_state, const u_char *, int,
198                                 u_char *, int, int *, int,
199                                 int *, int *);
200 #ifdef DEBUG
201 static void             Aerror(const res_state, FILE *, const char *, int,
202                                struct sockaddr_in);
203 static void             Perror(const res_state, FILE *, const char *, int);
204 #endif
205 #ifdef _LIBC
206 static int              sock_eq(struct sockaddr_in6 *, struct sockaddr_in6 *);
207 #else
208 static int              sock_eq(struct sockaddr_in *, struct sockaddr_in *);
209 #endif
210 #ifdef NEED_PSELECT
211 static int              pselect(int, void *, void *, void *,
212                                 struct timespec *,
213                                 const sigset_t *);
214 #endif
215
216 /* Reachover. */
217
218 #ifdef _LIBC
219 static void convaddr4to6(struct sockaddr_in6 *sa);
220 #endif
221 void res_pquery(const res_state, const u_char *, int, FILE *);
222
223 /* Public. */
224
225 /* int
226  * res_isourserver(ina)
227  *      looks up "ina" in _res.ns_addr_list[]
228  * returns:
229  *      0  : not found
230  *      >0 : found
231  * author:
232  *      paul vixie, 29may94
233  */
234 int
235 #ifdef _LIBC
236 res_ourserver_p(const res_state statp, const struct sockaddr_in6 *inp)
237 #else
238 res_ourserver_p(const res_state statp, const struct sockaddr_in *inp)
239 #endif
240 {
241         int ns;
242
243 #ifdef _LIBC
244         if (inp->sin6_family == AF_INET) {
245             struct sockaddr_in *in4p = (struct sockaddr_in *) inp;
246             in_port_t port = in4p->sin_port;
247             in_addr_t addr = in4p->sin_addr.s_addr;
248
249             for (ns = 0;  ns < MAXNS;  ns++) {
250                 const struct sockaddr_in *srv =
251                     (struct sockaddr_in *)EXT(statp).nsaddrs[ns];
252
253                 if ((srv != NULL) && (srv->sin_family == AF_INET) &&
254                     (srv->sin_port == port) &&
255                     (srv->sin_addr.s_addr == INADDR_ANY ||
256                      srv->sin_addr.s_addr == addr))
257                     return (1);
258             }
259         } else if (inp->sin6_family == AF_INET6) {
260             for (ns = 0;  ns < MAXNS;  ns++) {
261                 const struct sockaddr_in6 *srv = EXT(statp).nsaddrs[ns];
262                 if ((srv != NULL) && (srv->sin6_family == AF_INET6) &&
263                     (srv->sin6_port == inp->sin6_port) &&
264                     !(memcmp(&srv->sin6_addr, &in6addr_any,
265                              sizeof (struct in6_addr)) &&
266                       memcmp(&srv->sin6_addr, &inp->sin6_addr,
267                              sizeof (struct in6_addr))))
268                     return (1);
269             }
270         }
271 #else
272         struct sockaddr_in ina = *inp;
273         for (ns = 0; ns < statp->nscount; ns++) {
274                 const struct sockaddr_in *srv = &statp->nsaddr_list[ns];
275
276                 if (srv->sin_family == ina.sin_family &&
277                     srv->sin_port == ina.sin_port &&
278                     (srv->sin_addr.s_addr == INADDR_ANY ||
279                      srv->sin_addr.s_addr == ina.sin_addr.s_addr))
280                         return (1);
281         }
282 #endif
283         return (0);
284 }
285
286 /* int
287  * res_nameinquery(name, type, class, buf, eom)
288  *      look for (name,type,class) in the query section of packet (buf,eom)
289  * requires:
290  *      buf + HFIXEDSZ <= eom
291  * returns:
292  *      -1 : format error
293  *      0  : not found
294  *      >0 : found
295  * author:
296  *      paul vixie, 29may94
297  */
298 int
299 res_nameinquery(const char *name, int type, int class,
300                 const u_char *buf, const u_char *eom)
301 {
302         const u_char *cp = buf + HFIXEDSZ;
303         int qdcount = ntohs(((HEADER*)buf)->qdcount);
304
305         while (qdcount-- > 0) {
306                 char tname[MAXDNAME+1];
307                 int n, ttype, tclass;
308
309                 n = dn_expand(buf, eom, cp, tname, sizeof tname);
310                 if (n < 0)
311                         return (-1);
312                 cp += n;
313                 if (cp + 2 * INT16SZ > eom)
314                         return (-1);
315                 ttype = ns_get16(cp); cp += INT16SZ;
316                 tclass = ns_get16(cp); cp += INT16SZ;
317                 if (ttype == type && tclass == class &&
318                     ns_samename(tname, name) == 1)
319                         return (1);
320         }
321         return (0);
322 }
323
324 /* int
325  * res_queriesmatch(buf1, eom1, buf2, eom2)
326  *      is there a 1:1 mapping of (name,type,class)
327  *      in (buf1,eom1) and (buf2,eom2)?
328  * returns:
329  *      -1 : format error
330  *      0  : not a 1:1 mapping
331  *      >0 : is a 1:1 mapping
332  * author:
333  *      paul vixie, 29may94
334  */
335 int
336 res_queriesmatch(const u_char *buf1, const u_char *eom1,
337                  const u_char *buf2, const u_char *eom2)
338 {
339         const u_char *cp = buf1 + HFIXEDSZ;
340         int qdcount = ntohs(((HEADER*)buf1)->qdcount);
341
342         if (buf1 + HFIXEDSZ > eom1 || buf2 + HFIXEDSZ > eom2)
343                 return (-1);
344
345         /*
346          * Only header section present in replies to
347          * dynamic update packets.
348          */
349         if ((((HEADER *)buf1)->opcode == ns_o_update) &&
350             (((HEADER *)buf2)->opcode == ns_o_update))
351                 return (1);
352
353         if (qdcount != ntohs(((HEADER*)buf2)->qdcount))
354                 return (0);
355         while (qdcount-- > 0) {
356                 char tname[MAXDNAME+1];
357                 int n, ttype, tclass;
358
359                 n = dn_expand(buf1, eom1, cp, tname, sizeof tname);
360                 if (n < 0)
361                         return (-1);
362                 cp += n;
363                 if (cp + 2 * INT16SZ > eom1)
364                         return (-1);
365                 ttype = ns_get16(cp);   cp += INT16SZ;
366                 tclass = ns_get16(cp); cp += INT16SZ;
367                 if (!res_nameinquery(tname, ttype, tclass, buf2, eom2))
368                         return (0);
369         }
370         return (1);
371 }
372
373 int
374 res_nsend(res_state statp,
375           const u_char *buf, int buflen, u_char *ans, int anssiz)
376 {
377         int gotsomewhere, terrno, try, v_circuit, resplen, ns, n;
378
379         if (statp->nscount == 0) {
380                 __set_errno (ESRCH);
381                 return (-1);
382         }
383         if (anssiz < HFIXEDSZ) {
384                 __set_errno (EINVAL);
385                 return (-1);
386         }
387         DprintQ((statp->options & RES_DEBUG) || (statp->pfcode & RES_PRF_QUERY),
388                 (stdout, ";; res_send()\n"), buf, buflen);
389         v_circuit = (statp->options & RES_USEVC) || buflen > PACKETSZ;
390         gotsomewhere = 0;
391         terrno = ETIMEDOUT;
392
393         /*
394          * If the ns_addr_list in the resolver context has changed, then
395          * invalidate our cached copy and the associated timing data.
396          */
397         if (EXT(statp).nscount != 0) {
398                 int needclose = 0;
399
400                 if (EXT(statp).nscount != statp->nscount)
401                         needclose++;
402                 else
403                         for (ns = 0; ns < statp->nscount; ns++)
404 #ifdef _LIBC
405                                 if (!sock_eq((struct sockaddr_in6 *)
406                                              &statp->nsaddr_list[ns],
407                                              EXT(statp).nsaddrs[ns]))
408 #else
409                                 if (!sock_eq(&statp->nsaddr_list[ns],
410                                              &EXT(statp).nsaddrs[ns]))
411 #endif
412                                 {
413                                         needclose++;
414                                         break;
415                                 }
416                 if (needclose)
417                         res_nclose(statp);
418         }
419
420         /*
421          * Maybe initialize our private copy of the ns_addr_list.
422          */
423         if (EXT(statp).nscount == 0) {
424 #ifdef _LIBC
425                 n = 0;
426 #endif
427                 for (ns = 0; ns < statp->nscount; ns++) {
428 #ifdef _LIBC
429                         /* find a hole */
430                         while ((n < MAXNS) &&
431                             (EXT(statp).nsaddrs[n] != NULL) &&
432                             (EXT(statp).nsaddrs[n]->sin6_family == AF_INET6) &&
433                             !IN6_IS_ADDR_V4MAPPED(
434                                 &EXT(statp).nsaddrs[n]->sin6_addr))
435                                 n++;
436                         if (n == MAXNS)
437                                 break;
438
439                         if (EXT(statp).nsaddrs[n] == NULL)
440                                 EXT(statp).nsaddrs[n] =
441                                     malloc(sizeof (struct sockaddr_in6));
442                         if (EXT(statp).nsaddrs[n] != NULL) {
443                                 memcpy(EXT(statp).nsaddrs[n],
444                                        &statp->nsaddr_list[ns],
445                                        sizeof (struct sockaddr_in));
446                                 EXT(statp).nstimes[n] = RES_MAXTIME;
447                                 EXT(statp).nssocks[n] = -1;
448                                 n++;
449                         }
450 #else
451                         EXT(statp).nsaddrs[ns] = statp->nsaddr_list[ns];
452                         EXT(statp).nstimes[ns] = RES_MAXTIME;
453                         EXT(statp).nssocks[ns] = -1;
454 #endif
455                 }
456                 EXT(statp).nscount = statp->nscount;
457 #ifdef _LIBC
458                 /* If holes left, free memory and set to NULL */
459                 while (n < MAXNS) {
460                         if ((EXT(statp).nsaddrs[n] != NULL) &&
461                             ((EXT(statp).nsaddrs[n]->sin6_family != AF_INET6)
462                             || IN6_IS_ADDR_V4MAPPED(
463                                    &EXT(statp).nsaddrs[n]->sin6_addr))) {
464                                 free(EXT(statp).nsaddrs[n]);
465                                 EXT(statp).nsaddrs[n] = NULL;
466                         }
467                         n++;
468                 }
469 #endif
470         }
471
472         /*
473          * Some resolvers want to even out the load on their nameservers.
474          * Note that RES_BLAST overrides RES_ROTATE.
475          */
476         if ((statp->options & RES_ROTATE) != 0 &&
477             (statp->options & RES_BLAST) == 0) {
478 #ifdef _LIBC
479                 struct sockaddr_in6 *ina;
480                 int lastns = statp->nscount + EXT(statp).nscount6 - 1;
481
482                 ina = EXT(statp).nsaddrs[0];
483                 for (ns = 0; ns < lastns; ns++)
484                         EXT(statp).nsaddrs[ns] = EXT(statp).nsaddrs[ns + 1];
485                 EXT(statp).nsaddrs[lastns] = ina;
486 #else
487                 struct sockaddr_in ina;
488                 int lastns = statp->nscount - 1;
489
490                 ina = statp->nsaddr_list[0];
491                 for (ns = 0; ns < lastns; ns++)
492                         statp->nsaddr_list[ns] = statp->nsaddr_list[ns + 1];
493                 statp->nsaddr_list[lastns] = ina;
494 #endif
495         }
496
497         /*
498          * Send request, RETRY times, or until successful.
499          */
500         for (try = 0; try < statp->retry; try++) {
501 #ifdef _LIBC
502             for (ns = 0; ns < MAXNS; ns++)
503 #else
504             for (ns = 0; ns < statp->nscount; ns++)
505 #endif
506             {
507 #ifdef _LIBC
508                 struct sockaddr_in6 *nsap = EXT(statp).nsaddrs[ns];
509
510                 if (nsap == NULL)
511                         goto next_ns;
512 #else
513                 struct sockaddr_in *nsap = &statp->nsaddr_list[ns];
514 #endif
515  same_ns:
516                 if (statp->qhook) {
517                         int done = 0, loops = 0;
518
519                         do {
520                                 res_sendhookact act;
521
522 #ifdef _LIBC
523                                 act = (*statp->qhook)((struct sockaddr_in **)
524                                                       &nsap, &buf, &buflen,
525                                                       ans, anssiz, &resplen);
526 #else
527                                 act = (*statp->qhook)(&nsap, &buf, &buflen,
528                                                       ans, anssiz, &resplen);
529 #endif
530                                 switch (act) {
531                                 case res_goahead:
532                                         done = 1;
533                                         break;
534                                 case res_nextns:
535                                         res_nclose(statp);
536                                         goto next_ns;
537                                 case res_done:
538                                         return (resplen);
539                                 case res_modified:
540                                         /* give the hook another try */
541                                         if (++loops < 42) /*doug adams*/
542                                                 break;
543                                         /*FALLTHROUGH*/
544                                 case res_error:
545                                         /*FALLTHROUGH*/
546                                 default:
547                                         return (-1);
548                                 }
549                         } while (!done);
550                 }
551
552                 Dprint(statp->options & RES_DEBUG,
553                        (stdout, ";; Querying server (# %d) address = %s\n",
554                         ns + 1, inet_ntoa(nsap->sin_addr)));
555
556                 if (v_circuit) {
557                         /* Use VC; at most one attempt per server. */
558                         try = statp->retry;
559                         n = send_vc(statp, buf, buflen, ans, anssiz, &terrno,
560                                     ns);
561                         if (n < 0)
562                                 return (-1);
563                         if (n == 0)
564                                 goto next_ns;
565                         resplen = n;
566                 } else {
567                         /* Use datagrams. */
568                         n = send_dg(statp, buf, buflen, ans, anssiz, &terrno,
569                                     ns, &v_circuit, &gotsomewhere);
570                         if (n < 0)
571                                 return (-1);
572                         if (n == 0)
573                                 goto next_ns;
574                         if (v_circuit)
575                                 goto same_ns;
576                         resplen = n;
577                 }
578
579                 Dprint((statp->options & RES_DEBUG) ||
580                        ((statp->pfcode & RES_PRF_REPLY) &&
581                         (statp->pfcode & RES_PRF_HEAD1)),
582                        (stdout, ";; got answer:\n"));
583
584                 DprintQ((statp->options & RES_DEBUG) ||
585                         (statp->pfcode & RES_PRF_REPLY),
586                         (stdout, ""),
587                         ans, (resplen > anssiz) ? anssiz : resplen);
588
589                 /*
590                  * If we have temporarily opened a virtual circuit,
591                  * or if we haven't been asked to keep a socket open,
592                  * close the socket.
593                  */
594                 if ((v_circuit && (statp->options & RES_USEVC) == 0) ||
595                     (statp->options & RES_STAYOPEN) == 0) {
596                         res_nclose(statp);
597                 }
598                 if (statp->rhook) {
599                         int done = 0, loops = 0;
600
601                         do {
602                                 res_sendhookact act;
603
604 #ifdef _LIBC
605                                 act = (*statp->rhook)((struct sockaddr_in *)
606                                                       nsap, buf, buflen,
607                                                       ans, anssiz, &resplen);
608 #else
609                                 act = (*statp->rhook)(nsap, buf, buflen,
610                                                       ans, anssiz, &resplen);
611 #endif
612                                 switch (act) {
613                                 case res_goahead:
614                                 case res_done:
615                                         done = 1;
616                                         break;
617                                 case res_nextns:
618                                         res_nclose(statp);
619                                         goto next_ns;
620                                 case res_modified:
621                                         /* give the hook another try */
622                                         if (++loops < 42) /*doug adams*/
623                                                 break;
624                                         /*FALLTHROUGH*/
625                                 case res_error:
626                                         /*FALLTHROUGH*/
627                                 default:
628                                         return (-1);
629                                 }
630                         } while (!done);
631
632                 }
633                 return (resplen);
634  next_ns: ;
635            } /*foreach ns*/
636         } /*foreach retry*/
637         res_nclose(statp);
638         if (!v_circuit) {
639                 if (!gotsomewhere)
640                         __set_errno (ECONNREFUSED);     /* no nameservers found */
641                 else
642                         __set_errno (ETIMEDOUT);        /* no answer obtained */
643         } else
644                 __set_errno (terrno);
645         return (-1);
646 }
647
648 /* Private */
649
650 static int
651 send_vc(res_state statp,
652         const u_char *buf, int buflen, u_char *ans, int anssiz,
653         int *terrno, int ns)
654 {
655         const HEADER *hp = (HEADER *) buf;
656         HEADER *anhp = (HEADER *) ans;
657 #ifdef _LIBC
658         struct sockaddr_in6 *nsap = EXT(statp).nsaddrs[ns];
659 #else
660         struct sockaddr_in *nsap = &statp->nsaddr_list[ns];
661 #endif
662         int truncating, connreset, resplen, n;
663         struct iovec iov[2];
664         u_short len;
665         u_char *cp;
666
667         connreset = 0;
668  same_ns:
669         truncating = 0;
670
671         /* Are we still talking to whom we want to talk to? */
672         if (statp->_vcsock >= 0 && (statp->_flags & RES_F_VC) != 0) {
673 #ifdef _LIBC
674                 struct sockaddr_in6 peer;
675 #else
676                 struct sockaddr_in peer;
677 #endif
678                 int size = sizeof peer;
679
680                 if (getpeername(statp->_vcsock,
681                                 (struct sockaddr *)&peer, &size) < 0 ||
682                     !sock_eq(&peer, nsap)) {
683                         res_nclose(statp);
684                         statp->_flags &= ~RES_F_VC;
685                 }
686         }
687
688         if (statp->_vcsock < 0 || (statp->_flags & RES_F_VC) == 0) {
689                 if (statp->_vcsock >= 0)
690                         res_nclose(statp);
691
692 #ifdef _LIBC
693                 statp->_vcsock = socket(nsap->sin6_family, SOCK_STREAM, 0);
694 #else
695                 statp->_vcsock = socket(PF_INET, SOCK_STREAM, 0);
696                 if (statp->_vcsock > highestFD) {
697                         res_nclose(statp);
698                         __set_errno (ENOTSOCK);
699                 }
700 #endif
701                 if (statp->_vcsock < 0) {
702                         *terrno = errno;
703                         Perror(statp, stderr, "socket(vc)", errno);
704                         return (-1);
705                 }
706                 __set_errno (0);
707                 if (connect(statp->_vcsock, (struct sockaddr *)nsap,
708                             sizeof *nsap) < 0) {
709                         *terrno = errno;
710                         Aerror(statp, stderr, "connect/vc", errno, *nsap);
711                         res_nclose(statp);
712                         return (0);
713                 }
714                 statp->_flags |= RES_F_VC;
715         }
716
717         /*
718          * Send length & message
719          */
720         putshort((u_short)buflen, (u_char*)&len);
721         iov[0] = evConsIovec(&len, INT16SZ);
722         iov[1] = evConsIovec((void*)buf, buflen);
723         if (writev(statp->_vcsock, iov, 2) != (INT16SZ + buflen)) {
724                 *terrno = errno;
725                 Perror(statp, stderr, "write failed", errno);
726                 res_nclose(statp);
727                 return (0);
728         }
729         /*
730          * Receive length & response
731          */
732  read_len:
733         cp = ans;
734         len = INT16SZ;
735         while ((n = read(statp->_vcsock, (char *)cp, (int)len)) > 0) {
736                 cp += n;
737                 if ((len -= n) <= 0)
738                         break;
739         }
740         if (n <= 0) {
741                 *terrno = errno;
742                 Perror(statp, stderr, "read failed", errno);
743                 res_nclose(statp);
744                 /*
745                  * A long running process might get its TCP
746                  * connection reset if the remote server was
747                  * restarted.  Requery the server instead of
748                  * trying a new one.  When there is only one
749                  * server, this means that a query might work
750                  * instead of failing.  We only allow one reset
751                  * per query to prevent looping.
752                  */
753                 if (*terrno == ECONNRESET && !connreset) {
754                         connreset = 1;
755                         res_nclose(statp);
756                         goto same_ns;
757                 }
758                 res_nclose(statp);
759                 return (0);
760         }
761         resplen = ns_get16(ans);
762         if (resplen > anssiz) {
763                 Dprint(statp->options & RES_DEBUG,
764                        (stdout, ";; response truncated\n")
765                        );
766                 truncating = 1;
767                 len = anssiz;
768         } else
769                 len = resplen;
770         if (len < HFIXEDSZ) {
771                 /*
772                  * Undersized message.
773                  */
774                 Dprint(statp->options & RES_DEBUG,
775                        (stdout, ";; undersized: %d\n", len));
776                 *terrno = EMSGSIZE;
777                 res_nclose(statp);
778                 return (0);
779         }
780         cp = ans;
781         while (len != 0 && (n = read(statp->_vcsock, (char *)cp, (int)len)) > 0){
782                 cp += n;
783                 len -= n;
784         }
785         if (n <= 0) {
786                 *terrno = errno;
787                 Perror(statp, stderr, "read(vc)", errno);
788                 res_nclose(statp);
789                 return (0);
790         }
791         if (truncating) {
792                 /*
793                  * Flush rest of answer so connection stays in synch.
794                  */
795                 anhp->tc = 1;
796                 len = resplen - anssiz;
797                 while (len != 0) {
798                         char junk[PACKETSZ];
799
800                         n = read(statp->_vcsock, junk,
801                                  (len > sizeof junk) ? sizeof junk : len);
802                         if (n > 0)
803                                 len -= n;
804                         else
805                                 break;
806                 }
807         }
808         /*
809          * If the calling applicating has bailed out of
810          * a previous call and failed to arrange to have
811          * the circuit closed or the server has got
812          * itself confused, then drop the packet and
813          * wait for the correct one.
814          */
815         if (hp->id != anhp->id) {
816                 DprintQ((statp->options & RES_DEBUG) ||
817                         (statp->pfcode & RES_PRF_REPLY),
818                         (stdout, ";; old answer (unexpected):\n"),
819                         ans, (resplen > anssiz) ? anssiz: resplen);
820                 goto read_len;
821         }
822
823         /*
824          * All is well, or the error is fatal.  Signal that the
825          * next nameserver ought not be tried.
826          */
827         return (resplen);
828 }
829
830 static int
831 send_dg(res_state statp,
832         const u_char *buf, int buflen, u_char *ans, int anssiz,
833         int *terrno, int ns, int *v_circuit, int *gotsomewhere)
834 {
835         const HEADER *hp = (HEADER *) buf;
836         HEADER *anhp = (HEADER *) ans;
837 #ifdef _LIBC
838         struct sockaddr_in6 *nsap = EXT(statp).nsaddrs[ns];
839 #else
840         const struct sockaddr_in *nsap = &statp->nsaddr_list[ns];
841 #endif
842         struct timespec now, timeout, finish;
843 #ifdef _LIBC
844         struct pollfd pfd[1];
845         int ptimeout;
846         struct sockaddr_in6 from;
847         static int socket_pf = 0;
848 #else
849         fd_set dsmask;
850         struct sockaddr_in from;
851 #endif
852         int fromlen, resplen, seconds, n, s;
853
854         if (EXT(statp).nssocks[ns] == -1) {
855 #ifdef _LIBC
856                 /* only try IPv6 if IPv6 NS and if not failed before */
857                 if ((EXT(statp).nscount6 > 0) && (socket_pf != PF_INET)) {
858                         EXT(statp).nssocks[ns] =
859                             socket(PF_INET6, SOCK_DGRAM, 0);
860                         socket_pf = EXT(statp).nssocks[ns] < 0 ? PF_INET
861                                                                : PF_INET6;
862                 }
863                 if (EXT(statp).nssocks[ns] < 0)
864                         EXT(statp).nssocks[ns] = socket(PF_INET, SOCK_DGRAM, 0);
865 #else
866                 EXT(statp).nssocks[ns] = socket(PF_INET, SOCK_DGRAM, 0);
867                 if (EXT(statp).nssocks[ns] > highestFD) {
868                         res_nclose(statp);
869                         __set_errno (ENOTSOCK);
870                 }
871 #endif
872                 if (EXT(statp).nssocks[ns] < 0) {
873                         *terrno = errno;
874                         Perror(statp, stderr, "socket(dg)", errno);
875                         return (-1);
876                 }
877 #ifndef CANNOT_CONNECT_DGRAM
878 #ifdef _LIBC
879                 /* If IPv6 socket and nsap is IPv4, make it IPv4-mapped */
880                 if ((socket_pf == PF_INET6) && (nsap->sin6_family == AF_INET))
881                         convaddr4to6(nsap);
882 #endif
883                 /*
884                  * On a 4.3BSD+ machine (client and server,
885                  * actually), sending to a nameserver datagram
886                  * port with no nameserver will cause an
887                  * ICMP port unreachable message to be returned.
888                  * If our datagram socket is "connected" to the
889                  * server, we get an ECONNREFUSED error on the next
890                  * socket operation, and select returns if the
891                  * error message is received.  We can thus detect
892                  * the absence of a nameserver without timing out.
893                  */
894                 if (connect(EXT(statp).nssocks[ns], (struct sockaddr *)nsap,
895                             sizeof *nsap) < 0) {
896                         Aerror(statp, stderr, "connect(dg)", errno, *nsap);
897                         res_nclose(statp);
898                         return (0);
899                 }
900 #endif /* !CANNOT_CONNECT_DGRAM */
901                 Dprint(statp->options & RES_DEBUG,
902                        (stdout, ";; new DG socket\n"))
903         }
904         s = EXT(statp).nssocks[ns];
905 #ifndef CANNOT_CONNECT_DGRAM
906         if (send(s, (char*)buf, buflen, 0) != buflen) {
907                 Perror(statp, stderr, "send", errno);
908                 res_nclose(statp);
909                 return (0);
910         }
911 #else /* !CANNOT_CONNECT_DGRAM */
912 #ifdef _LIBC
913         /* If IPv6 socket and nsap is IPv4, make it IPv4-mapped */
914         if ((socket_pf == PF_INET6) && (nsap->sin6_family == AF_INET))
915                 convaddr4to6(nsap);
916 #endif
917         if (sendto(s, (char*)buf, buflen, 0,
918                    (struct sockaddr *)nsap, sizeof *nsap) != buflen)
919         {
920                 Aerror(statp, stderr, "sendto", errno, *nsap);
921                 res_nclose(statp);
922                 return (0);
923         }
924 #endif /* !CANNOT_CONNECT_DGRAM */
925
926         /*
927          * Wait for reply.
928          */
929         seconds = (statp->retrans << ns);
930         if (ns > 0)
931                 seconds /= statp->nscount;
932         if (seconds <= 0)
933                 seconds = 1;
934         now = evNowTime();
935         timeout = evConsTime(seconds, 0);
936         finish = evAddTime(now, timeout);
937  wait:
938 #ifdef _LIBC
939         /* Convert struct timespec in milliseconds.  */
940         ptimeout = timeout.tv_sec * 1000 + timeout.tv_nsec / 1000000;
941
942         pfd[0].fd = s;
943         pfd[0].events = POLLIN;
944         n = __poll (pfd, 1, ptimeout);
945 #else
946         FD_ZERO(&dsmask);
947         FD_SET(s, &dsmask);
948         n = pselect(s + 1, &dsmask, NULL, NULL, &timeout, NULL);
949 #endif
950         if (n == 0) {
951                 Dprint(statp->options & RES_DEBUG, (stdout, ";; timeout\n"));
952                 *gotsomewhere = 1;
953                 return (0);
954         }
955         if (n < 0) {
956                 if (errno == EINTR) {
957                         now = evNowTime();
958                         if (evCmpTime(finish, now) > 0) {
959                                 timeout = evSubTime(finish, now);
960                                 goto wait;
961                         }
962                 }
963                 Perror(statp, stderr, "select", errno);
964                 res_nclose(statp);
965                 return (0);
966         }
967         __set_errno (0);
968 #ifdef _LIBC
969         fromlen = sizeof(struct sockaddr_in6);
970 #else
971         fromlen = sizeof(struct sockaddr_in);
972 #endif
973         resplen = recvfrom(s, (char*)ans, anssiz,0,
974                            (struct sockaddr *)&from, &fromlen);
975         if (resplen <= 0) {
976                 Perror(statp, stderr, "recvfrom", errno);
977                 res_nclose(statp);
978                 return (0);
979         }
980         *gotsomewhere = 1;
981         if (resplen < HFIXEDSZ) {
982                 /*
983                  * Undersized message.
984                  */
985                 Dprint(statp->options & RES_DEBUG,
986                        (stdout, ";; undersized: %d\n",
987                         resplen));
988                 *terrno = EMSGSIZE;
989                 res_nclose(statp);
990                 return (0);
991         }
992         if (hp->id != anhp->id) {
993                 /*
994                  * response from old query, ignore it.
995                  * XXX - potential security hazard could
996                  *       be detected here.
997                  */
998                 DprintQ((statp->options & RES_DEBUG) ||
999                         (statp->pfcode & RES_PRF_REPLY),
1000                         (stdout, ";; old answer:\n"),
1001                         ans, (resplen > anssiz) ? anssiz : resplen);
1002                 goto wait;
1003         }
1004         if (!(statp->options & RES_INSECURE1) &&
1005             !res_ourserver_p(statp, &from)) {
1006                 /*
1007                  * response from wrong server? ignore it.
1008                  * XXX - potential security hazard could
1009                  *       be detected here.
1010                  */
1011                 DprintQ((statp->options & RES_DEBUG) ||
1012                         (statp->pfcode & RES_PRF_REPLY),
1013                         (stdout, ";; not our server:\n"),
1014                         ans, (resplen > anssiz) ? anssiz : resplen);
1015                 goto wait;
1016         }
1017         if (!(statp->options & RES_INSECURE2) &&
1018             !res_queriesmatch(buf, buf + buflen,
1019                               ans, ans + anssiz)) {
1020                 /*
1021                  * response contains wrong query? ignore it.
1022                  * XXX - potential security hazard could
1023                  *       be detected here.
1024                  */
1025                 DprintQ((statp->options & RES_DEBUG) ||
1026                         (statp->pfcode & RES_PRF_REPLY),
1027                         (stdout, ";; wrong query name:\n"),
1028                         ans, (resplen > anssiz) ? anssiz : resplen);
1029                 goto wait;
1030         }
1031         if (anhp->rcode == SERVFAIL ||
1032             anhp->rcode == NOTIMP ||
1033             anhp->rcode == REFUSED) {
1034                 DprintQ(statp->options & RES_DEBUG,
1035                         (stdout, "server rejected query:\n"),
1036                         ans, (resplen > anssiz) ? anssiz : resplen);
1037                 res_nclose(statp);
1038                 /* don't retry if called from dig */
1039                 if (!statp->pfcode)
1040                         return (0);
1041         }
1042         if (!(statp->options & RES_IGNTC) && anhp->tc) {
1043                 /*
1044                  * To get the rest of answer,
1045                  * use TCP with same server.
1046                  */
1047                 Dprint(statp->options & RES_DEBUG,
1048                        (stdout, ";; truncated answer\n"));
1049                 *v_circuit = 1;
1050                 res_nclose(statp);
1051                 return (1);
1052         }
1053         /*
1054          * All is well, or the error is fatal.  Signal that the
1055          * next nameserver ought not be tried.
1056          */
1057         return (resplen);
1058 }
1059
1060 #ifdef DEBUG
1061 static void
1062 Aerror(const res_state statp, FILE *file, const char *string, int error,
1063        struct sockaddr_in address)
1064 {
1065         int save = errno;
1066
1067         if ((statp->options & RES_DEBUG) != 0) {
1068                 char tmp[sizeof "255.255.255.255"];
1069
1070                 fprintf(file, "res_send: %s ([%s].%u): %s\n",
1071                         string,
1072                         inet_ntop(address.sin_family, &address.sin_addr,
1073                                   tmp, sizeof tmp),
1074                         ntohs(address.sin_port),
1075                         strerror(error));
1076         }
1077         __set_errno (save);
1078 }
1079
1080 static void
1081 Perror(const res_state statp, FILE *file, const char *string, int error) {
1082         int save = errno;
1083
1084         if ((statp->options & RES_DEBUG) != 0)
1085                 fprintf(file, "res_send: %s: %s\n",
1086                         string, strerror(error));
1087         __set_errno (save);
1088 }
1089 #endif
1090
1091 static int
1092 #ifdef _LIBC
1093 sock_eq(struct sockaddr_in6 *a1, struct sockaddr_in6 *a2) {
1094         if (a1->sin6_family == a2->sin6_family) {
1095                 if (a1->sin6_family == AF_INET)
1096                         return ((((struct sockaddr_in *)a1)->sin_port ==
1097                                  ((struct sockaddr_in *)a2)->sin_port) &&
1098                                 (((struct sockaddr_in *)a1)->sin_addr.s_addr ==
1099                                  ((struct sockaddr_in *)a2)->sin_addr.s_addr));
1100                 else
1101                         return ((a1->sin6_port == a2->sin6_port) &&
1102                                 !memcmp(&a1->sin6_addr, &a2->sin6_addr,
1103                                         sizeof (struct in6_addr)));
1104         }
1105         if (a1->sin6_family == AF_INET) {
1106                 struct sockaddr_in6 *sap = a1;
1107                 a1 = a2;
1108                 a2 = sap;
1109         } /* assumes that AF_INET and AF_INET6 are the only possibilities */
1110         return ((a1->sin6_port == ((struct sockaddr_in *)a2)->sin_port) &&
1111                 IN6_IS_ADDR_V4MAPPED(&a1->sin6_addr) &&
1112                 (a1->sin6_addr.s6_addr32[3] ==
1113                  ((struct sockaddr_in *)a2)->sin_addr.s_addr));
1114 }
1115 #else
1116 sock_eq(struct sockaddr_in *a1, struct sockaddr_in *a2) {
1117         return ((a1->sin_family == a2->sin_family) &&
1118                 (a1->sin_port == a2->sin_port) &&
1119                 (a1->sin_addr.s_addr == a2->sin_addr.s_addr));
1120 }
1121 #endif
1122
1123 #ifdef _LIBC
1124 /*
1125  * Converts IPv4 family, address and port to
1126  * IPv6 family, IPv4-mapped IPv6 address and port.
1127  */
1128 static void
1129 convaddr4to6(struct sockaddr_in6 *sa)
1130 {
1131     struct sockaddr_in *sa4p = (struct sockaddr_in *) sa;
1132     in_port_t port = sa4p->sin_port;
1133     in_addr_t addr = sa4p->sin_addr.s_addr;
1134
1135     sa->sin6_family = AF_INET6;
1136     sa->sin6_port = port;
1137     sa->sin6_addr.s6_addr32[0] = 0;
1138     sa->sin6_addr.s6_addr32[1] = 0;
1139     sa->sin6_addr.s6_addr32[2] = htonl(0xFFFF);
1140     sa->sin6_addr.s6_addr32[3] = addr;
1141 }
1142 #endif
1143
1144 #ifdef NEED_PSELECT
1145 /* XXX needs to move to the porting library. */
1146 static int
1147 pselect(int nfds, void *rfds, void *wfds, void *efds,
1148         struct timespec *tsp, const sigset_t *sigmask)
1149 {
1150         struct timeval tv, *tvp;
1151         sigset_t sigs;
1152         int n;
1153
1154         if (tsp) {
1155                 tvp = &tv;
1156                 tv = evTimeVal(*tsp);
1157         } else
1158                 tvp = NULL;
1159         if (sigmask)
1160                 sigprocmask(SIG_SETMASK, sigmask, &sigs);
1161         n = select(nfds, rfds, wfds, efds, tvp);
1162         if (sigmask)
1163                 sigprocmask(SIG_SETMASK, &sigs, NULL);
1164         if (tsp)
1165                 *tsp = evTimeSpec(tv);
1166         return (n);
1167 }
1168 #endif