(res_nsend): Use it instead of nscount.
[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).nsinit) {
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).nsinit == 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                 EXT(statp).nsinit = 1;
458 #ifdef _LIBC
459                 /* If holes left, free memory and set to NULL */
460                 while (n < MAXNS) {
461                         if ((EXT(statp).nsaddrs[n] != NULL) &&
462                             ((EXT(statp).nsaddrs[n]->sin6_family != AF_INET6)
463                             || IN6_IS_ADDR_V4MAPPED(
464                                    &EXT(statp).nsaddrs[n]->sin6_addr))) {
465                                 free(EXT(statp).nsaddrs[n]);
466                                 EXT(statp).nsaddrs[n] = NULL;
467                         }
468                         n++;
469                 }
470 #endif
471         }
472
473         /*
474          * Some resolvers want to even out the load on their nameservers.
475          * Note that RES_BLAST overrides RES_ROTATE.
476          */
477         if ((statp->options & RES_ROTATE) != 0 &&
478             (statp->options & RES_BLAST) == 0) {
479 #ifdef _LIBC
480                 struct sockaddr_in6 *ina;
481                 int lastns = statp->nscount + EXT(statp).nscount6 - 1;
482
483                 ina = EXT(statp).nsaddrs[0];
484                 for (ns = 0; ns < lastns; ns++)
485                         EXT(statp).nsaddrs[ns] = EXT(statp).nsaddrs[ns + 1];
486                 EXT(statp).nsaddrs[lastns] = ina;
487 #else
488                 struct sockaddr_in ina;
489                 int lastns = statp->nscount - 1;
490
491                 ina = statp->nsaddr_list[0];
492                 for (ns = 0; ns < lastns; ns++)
493                         statp->nsaddr_list[ns] = statp->nsaddr_list[ns + 1];
494                 statp->nsaddr_list[lastns] = ina;
495 #endif
496         }
497
498         /*
499          * Send request, RETRY times, or until successful.
500          */
501         for (try = 0; try < statp->retry; try++) {
502 #ifdef _LIBC
503             for (ns = 0; ns < MAXNS; ns++)
504 #else
505             for (ns = 0; ns < statp->nscount; ns++)
506 #endif
507             {
508 #ifdef _LIBC
509                 struct sockaddr_in6 *nsap = EXT(statp).nsaddrs[ns];
510
511                 if (nsap == NULL)
512                         goto next_ns;
513 #else
514                 struct sockaddr_in *nsap = &statp->nsaddr_list[ns];
515 #endif
516  same_ns:
517                 if (statp->qhook) {
518                         int done = 0, loops = 0;
519
520                         do {
521                                 res_sendhookact act;
522
523 #ifdef _LIBC
524                                 act = (*statp->qhook)((struct sockaddr_in **)
525                                                       &nsap, &buf, &buflen,
526                                                       ans, anssiz, &resplen);
527 #else
528                                 act = (*statp->qhook)(&nsap, &buf, &buflen,
529                                                       ans, anssiz, &resplen);
530 #endif
531                                 switch (act) {
532                                 case res_goahead:
533                                         done = 1;
534                                         break;
535                                 case res_nextns:
536                                         res_nclose(statp);
537                                         goto next_ns;
538                                 case res_done:
539                                         return (resplen);
540                                 case res_modified:
541                                         /* give the hook another try */
542                                         if (++loops < 42) /*doug adams*/
543                                                 break;
544                                         /*FALLTHROUGH*/
545                                 case res_error:
546                                         /*FALLTHROUGH*/
547                                 default:
548                                         return (-1);
549                                 }
550                         } while (!done);
551                 }
552
553                 Dprint(statp->options & RES_DEBUG,
554                        (stdout, ";; Querying server (# %d) address = %s\n",
555                         ns + 1, inet_ntoa(nsap->sin_addr)));
556
557                 if (v_circuit) {
558                         /* Use VC; at most one attempt per server. */
559                         try = statp->retry;
560                         n = send_vc(statp, buf, buflen, ans, anssiz, &terrno,
561                                     ns);
562                         if (n < 0)
563                                 return (-1);
564                         if (n == 0)
565                                 goto next_ns;
566                         resplen = n;
567                 } else {
568                         /* Use datagrams. */
569                         n = send_dg(statp, buf, buflen, ans, anssiz, &terrno,
570                                     ns, &v_circuit, &gotsomewhere);
571                         if (n < 0)
572                                 return (-1);
573                         if (n == 0)
574                                 goto next_ns;
575                         if (v_circuit)
576                                 goto same_ns;
577                         resplen = n;
578                 }
579
580                 Dprint((statp->options & RES_DEBUG) ||
581                        ((statp->pfcode & RES_PRF_REPLY) &&
582                         (statp->pfcode & RES_PRF_HEAD1)),
583                        (stdout, ";; got answer:\n"));
584
585                 DprintQ((statp->options & RES_DEBUG) ||
586                         (statp->pfcode & RES_PRF_REPLY),
587                         (stdout, ""),
588                         ans, (resplen > anssiz) ? anssiz : resplen);
589
590                 /*
591                  * If we have temporarily opened a virtual circuit,
592                  * or if we haven't been asked to keep a socket open,
593                  * close the socket.
594                  */
595                 if ((v_circuit && (statp->options & RES_USEVC) == 0) ||
596                     (statp->options & RES_STAYOPEN) == 0) {
597                         res_nclose(statp);
598                 }
599                 if (statp->rhook) {
600                         int done = 0, loops = 0;
601
602                         do {
603                                 res_sendhookact act;
604
605 #ifdef _LIBC
606                                 act = (*statp->rhook)((struct sockaddr_in *)
607                                                       nsap, buf, buflen,
608                                                       ans, anssiz, &resplen);
609 #else
610                                 act = (*statp->rhook)(nsap, buf, buflen,
611                                                       ans, anssiz, &resplen);
612 #endif
613                                 switch (act) {
614                                 case res_goahead:
615                                 case res_done:
616                                         done = 1;
617                                         break;
618                                 case res_nextns:
619                                         res_nclose(statp);
620                                         goto next_ns;
621                                 case res_modified:
622                                         /* give the hook another try */
623                                         if (++loops < 42) /*doug adams*/
624                                                 break;
625                                         /*FALLTHROUGH*/
626                                 case res_error:
627                                         /*FALLTHROUGH*/
628                                 default:
629                                         return (-1);
630                                 }
631                         } while (!done);
632
633                 }
634                 return (resplen);
635  next_ns: ;
636            } /*foreach ns*/
637         } /*foreach retry*/
638         res_nclose(statp);
639         if (!v_circuit) {
640                 if (!gotsomewhere)
641                         __set_errno (ECONNREFUSED);     /* no nameservers found */
642                 else
643                         __set_errno (ETIMEDOUT);        /* no answer obtained */
644         } else
645                 __set_errno (terrno);
646         return (-1);
647 }
648
649 /* Private */
650
651 static int
652 send_vc(res_state statp,
653         const u_char *buf, int buflen, u_char *ans, int anssiz,
654         int *terrno, int ns)
655 {
656         const HEADER *hp = (HEADER *) buf;
657         HEADER *anhp = (HEADER *) ans;
658 #ifdef _LIBC
659         struct sockaddr_in6 *nsap = EXT(statp).nsaddrs[ns];
660 #else
661         struct sockaddr_in *nsap = &statp->nsaddr_list[ns];
662 #endif
663         int truncating, connreset, resplen, n;
664         struct iovec iov[2];
665         u_short len;
666         u_char *cp;
667
668         connreset = 0;
669  same_ns:
670         truncating = 0;
671
672         /* Are we still talking to whom we want to talk to? */
673         if (statp->_vcsock >= 0 && (statp->_flags & RES_F_VC) != 0) {
674 #ifdef _LIBC
675                 struct sockaddr_in6 peer;
676 #else
677                 struct sockaddr_in peer;
678 #endif
679                 int size = sizeof peer;
680
681                 if (getpeername(statp->_vcsock,
682                                 (struct sockaddr *)&peer, &size) < 0 ||
683                     !sock_eq(&peer, nsap)) {
684                         res_nclose(statp);
685                         statp->_flags &= ~RES_F_VC;
686                 }
687         }
688
689         if (statp->_vcsock < 0 || (statp->_flags & RES_F_VC) == 0) {
690                 if (statp->_vcsock >= 0)
691                         res_nclose(statp);
692
693 #ifdef _LIBC
694                 statp->_vcsock = socket(nsap->sin6_family, SOCK_STREAM, 0);
695 #else
696                 statp->_vcsock = socket(PF_INET, SOCK_STREAM, 0);
697                 if (statp->_vcsock > highestFD) {
698                         res_nclose(statp);
699                         __set_errno (ENOTSOCK);
700                 }
701 #endif
702                 if (statp->_vcsock < 0) {
703                         *terrno = errno;
704                         Perror(statp, stderr, "socket(vc)", errno);
705                         return (-1);
706                 }
707                 __set_errno (0);
708                 if (connect(statp->_vcsock, (struct sockaddr *)nsap,
709                             sizeof *nsap) < 0) {
710                         *terrno = errno;
711                         Aerror(statp, stderr, "connect/vc", errno, *nsap);
712                         res_nclose(statp);
713                         return (0);
714                 }
715                 statp->_flags |= RES_F_VC;
716         }
717
718         /*
719          * Send length & message
720          */
721         putshort((u_short)buflen, (u_char*)&len);
722         iov[0] = evConsIovec(&len, INT16SZ);
723         iov[1] = evConsIovec((void*)buf, buflen);
724         if (writev(statp->_vcsock, iov, 2) != (INT16SZ + buflen)) {
725                 *terrno = errno;
726                 Perror(statp, stderr, "write failed", errno);
727                 res_nclose(statp);
728                 return (0);
729         }
730         /*
731          * Receive length & response
732          */
733  read_len:
734         cp = ans;
735         len = INT16SZ;
736         while ((n = read(statp->_vcsock, (char *)cp, (int)len)) > 0) {
737                 cp += n;
738                 if ((len -= n) <= 0)
739                         break;
740         }
741         if (n <= 0) {
742                 *terrno = errno;
743                 Perror(statp, stderr, "read failed", errno);
744                 res_nclose(statp);
745                 /*
746                  * A long running process might get its TCP
747                  * connection reset if the remote server was
748                  * restarted.  Requery the server instead of
749                  * trying a new one.  When there is only one
750                  * server, this means that a query might work
751                  * instead of failing.  We only allow one reset
752                  * per query to prevent looping.
753                  */
754                 if (*terrno == ECONNRESET && !connreset) {
755                         connreset = 1;
756                         res_nclose(statp);
757                         goto same_ns;
758                 }
759                 res_nclose(statp);
760                 return (0);
761         }
762         resplen = ns_get16(ans);
763         if (resplen > anssiz) {
764                 Dprint(statp->options & RES_DEBUG,
765                        (stdout, ";; response truncated\n")
766                        );
767                 truncating = 1;
768                 len = anssiz;
769         } else
770                 len = resplen;
771         if (len < HFIXEDSZ) {
772                 /*
773                  * Undersized message.
774                  */
775                 Dprint(statp->options & RES_DEBUG,
776                        (stdout, ";; undersized: %d\n", len));
777                 *terrno = EMSGSIZE;
778                 res_nclose(statp);
779                 return (0);
780         }
781         cp = ans;
782         while (len != 0 && (n = read(statp->_vcsock, (char *)cp, (int)len)) > 0){
783                 cp += n;
784                 len -= n;
785         }
786         if (n <= 0) {
787                 *terrno = errno;
788                 Perror(statp, stderr, "read(vc)", errno);
789                 res_nclose(statp);
790                 return (0);
791         }
792         if (truncating) {
793                 /*
794                  * Flush rest of answer so connection stays in synch.
795                  */
796                 anhp->tc = 1;
797                 len = resplen - anssiz;
798                 while (len != 0) {
799                         char junk[PACKETSZ];
800
801                         n = read(statp->_vcsock, junk,
802                                  (len > sizeof junk) ? sizeof junk : len);
803                         if (n > 0)
804                                 len -= n;
805                         else
806                                 break;
807                 }
808         }
809         /*
810          * If the calling applicating has bailed out of
811          * a previous call and failed to arrange to have
812          * the circuit closed or the server has got
813          * itself confused, then drop the packet and
814          * wait for the correct one.
815          */
816         if (hp->id != anhp->id) {
817                 DprintQ((statp->options & RES_DEBUG) ||
818                         (statp->pfcode & RES_PRF_REPLY),
819                         (stdout, ";; old answer (unexpected):\n"),
820                         ans, (resplen > anssiz) ? anssiz: resplen);
821                 goto read_len;
822         }
823
824         /*
825          * All is well, or the error is fatal.  Signal that the
826          * next nameserver ought not be tried.
827          */
828         return (resplen);
829 }
830
831 static int
832 send_dg(res_state statp,
833         const u_char *buf, int buflen, u_char *ans, int anssiz,
834         int *terrno, int ns, int *v_circuit, int *gotsomewhere)
835 {
836         const HEADER *hp = (HEADER *) buf;
837         HEADER *anhp = (HEADER *) ans;
838 #ifdef _LIBC
839         struct sockaddr_in6 *nsap = EXT(statp).nsaddrs[ns];
840 #else
841         const struct sockaddr_in *nsap = &statp->nsaddr_list[ns];
842 #endif
843         struct timespec now, timeout, finish;
844 #ifdef _LIBC
845         struct pollfd pfd[1];
846         int ptimeout;
847         struct sockaddr_in6 from;
848         static int socket_pf = 0;
849 #else
850         fd_set dsmask;
851         struct sockaddr_in from;
852 #endif
853         int fromlen, resplen, seconds, n, s;
854
855         if (EXT(statp).nssocks[ns] == -1) {
856 #ifdef _LIBC
857                 /* only try IPv6 if IPv6 NS and if not failed before */
858                 if ((EXT(statp).nscount6 > 0) && (socket_pf != PF_INET)) {
859                         EXT(statp).nssocks[ns] =
860                             socket(PF_INET6, SOCK_DGRAM, 0);
861                         socket_pf = EXT(statp).nssocks[ns] < 0 ? PF_INET
862                                                                : PF_INET6;
863                 }
864                 if (EXT(statp).nssocks[ns] < 0)
865                         EXT(statp).nssocks[ns] = socket(PF_INET, SOCK_DGRAM, 0);
866 #else
867                 EXT(statp).nssocks[ns] = socket(PF_INET, SOCK_DGRAM, 0);
868                 if (EXT(statp).nssocks[ns] > highestFD) {
869                         res_nclose(statp);
870                         __set_errno (ENOTSOCK);
871                 }
872 #endif
873                 if (EXT(statp).nssocks[ns] < 0) {
874                         *terrno = errno;
875                         Perror(statp, stderr, "socket(dg)", errno);
876                         return (-1);
877                 }
878 #ifndef CANNOT_CONNECT_DGRAM
879 #ifdef _LIBC
880                 /* If IPv6 socket and nsap is IPv4, make it IPv4-mapped */
881                 if ((socket_pf == PF_INET6) && (nsap->sin6_family == AF_INET))
882                         convaddr4to6(nsap);
883 #endif
884                 /*
885                  * On a 4.3BSD+ machine (client and server,
886                  * actually), sending to a nameserver datagram
887                  * port with no nameserver will cause an
888                  * ICMP port unreachable message to be returned.
889                  * If our datagram socket is "connected" to the
890                  * server, we get an ECONNREFUSED error on the next
891                  * socket operation, and select returns if the
892                  * error message is received.  We can thus detect
893                  * the absence of a nameserver without timing out.
894                  */
895                 if (connect(EXT(statp).nssocks[ns], (struct sockaddr *)nsap,
896                             sizeof *nsap) < 0) {
897                         Aerror(statp, stderr, "connect(dg)", errno, *nsap);
898                         res_nclose(statp);
899                         return (0);
900                 }
901 #endif /* !CANNOT_CONNECT_DGRAM */
902                 Dprint(statp->options & RES_DEBUG,
903                        (stdout, ";; new DG socket\n"))
904         }
905         s = EXT(statp).nssocks[ns];
906 #ifndef CANNOT_CONNECT_DGRAM
907         if (send(s, (char*)buf, buflen, 0) != buflen) {
908                 Perror(statp, stderr, "send", errno);
909                 res_nclose(statp);
910                 return (0);
911         }
912 #else /* !CANNOT_CONNECT_DGRAM */
913 #ifdef _LIBC
914         /* If IPv6 socket and nsap is IPv4, make it IPv4-mapped */
915         if ((socket_pf == PF_INET6) && (nsap->sin6_family == AF_INET))
916                 convaddr4to6(nsap);
917 #endif
918         if (sendto(s, (char*)buf, buflen, 0,
919                    (struct sockaddr *)nsap, sizeof *nsap) != buflen)
920         {
921                 Aerror(statp, stderr, "sendto", errno, *nsap);
922                 res_nclose(statp);
923                 return (0);
924         }
925 #endif /* !CANNOT_CONNECT_DGRAM */
926
927         /*
928          * Wait for reply.
929          */
930         seconds = (statp->retrans << ns);
931         if (ns > 0)
932                 seconds /= statp->nscount;
933         if (seconds <= 0)
934                 seconds = 1;
935         now = evNowTime();
936         timeout = evConsTime(seconds, 0);
937         finish = evAddTime(now, timeout);
938  wait:
939 #ifdef _LIBC
940         /* Convert struct timespec in milliseconds.  */
941         ptimeout = timeout.tv_sec * 1000 + timeout.tv_nsec / 1000000;
942
943         pfd[0].fd = s;
944         pfd[0].events = POLLIN;
945         n = __poll (pfd, 1, ptimeout);
946 #else
947         FD_ZERO(&dsmask);
948         FD_SET(s, &dsmask);
949         n = pselect(s + 1, &dsmask, NULL, NULL, &timeout, NULL);
950 #endif
951         if (n == 0) {
952                 Dprint(statp->options & RES_DEBUG, (stdout, ";; timeout\n"));
953                 *gotsomewhere = 1;
954                 return (0);
955         }
956         if (n < 0) {
957                 if (errno == EINTR) {
958                         now = evNowTime();
959                         if (evCmpTime(finish, now) > 0) {
960                                 timeout = evSubTime(finish, now);
961                                 goto wait;
962                         }
963                 }
964                 Perror(statp, stderr, "select", errno);
965                 res_nclose(statp);
966                 return (0);
967         }
968         __set_errno (0);
969 #ifdef _LIBC
970         fromlen = sizeof(struct sockaddr_in6);
971 #else
972         fromlen = sizeof(struct sockaddr_in);
973 #endif
974         resplen = recvfrom(s, (char*)ans, anssiz,0,
975                            (struct sockaddr *)&from, &fromlen);
976         if (resplen <= 0) {
977                 Perror(statp, stderr, "recvfrom", errno);
978                 res_nclose(statp);
979                 return (0);
980         }
981         *gotsomewhere = 1;
982         if (resplen < HFIXEDSZ) {
983                 /*
984                  * Undersized message.
985                  */
986                 Dprint(statp->options & RES_DEBUG,
987                        (stdout, ";; undersized: %d\n",
988                         resplen));
989                 *terrno = EMSGSIZE;
990                 res_nclose(statp);
991                 return (0);
992         }
993         if (hp->id != anhp->id) {
994                 /*
995                  * response from old query, ignore it.
996                  * XXX - potential security hazard could
997                  *       be detected here.
998                  */
999                 DprintQ((statp->options & RES_DEBUG) ||
1000                         (statp->pfcode & RES_PRF_REPLY),
1001                         (stdout, ";; old answer:\n"),
1002                         ans, (resplen > anssiz) ? anssiz : resplen);
1003                 goto wait;
1004         }
1005         if (!(statp->options & RES_INSECURE1) &&
1006             !res_ourserver_p(statp, &from)) {
1007                 /*
1008                  * response from wrong server? ignore it.
1009                  * XXX - potential security hazard could
1010                  *       be detected here.
1011                  */
1012                 DprintQ((statp->options & RES_DEBUG) ||
1013                         (statp->pfcode & RES_PRF_REPLY),
1014                         (stdout, ";; not our server:\n"),
1015                         ans, (resplen > anssiz) ? anssiz : resplen);
1016                 goto wait;
1017         }
1018         if (!(statp->options & RES_INSECURE2) &&
1019             !res_queriesmatch(buf, buf + buflen,
1020                               ans, ans + anssiz)) {
1021                 /*
1022                  * response contains wrong query? ignore it.
1023                  * XXX - potential security hazard could
1024                  *       be detected here.
1025                  */
1026                 DprintQ((statp->options & RES_DEBUG) ||
1027                         (statp->pfcode & RES_PRF_REPLY),
1028                         (stdout, ";; wrong query name:\n"),
1029                         ans, (resplen > anssiz) ? anssiz : resplen);
1030                 goto wait;
1031         }
1032         if (anhp->rcode == SERVFAIL ||
1033             anhp->rcode == NOTIMP ||
1034             anhp->rcode == REFUSED) {
1035                 DprintQ(statp->options & RES_DEBUG,
1036                         (stdout, "server rejected query:\n"),
1037                         ans, (resplen > anssiz) ? anssiz : resplen);
1038                 res_nclose(statp);
1039                 /* don't retry if called from dig */
1040                 if (!statp->pfcode)
1041                         return (0);
1042         }
1043         if (!(statp->options & RES_IGNTC) && anhp->tc) {
1044                 /*
1045                  * To get the rest of answer,
1046                  * use TCP with same server.
1047                  */
1048                 Dprint(statp->options & RES_DEBUG,
1049                        (stdout, ";; truncated answer\n"));
1050                 *v_circuit = 1;
1051                 res_nclose(statp);
1052                 return (1);
1053         }
1054         /*
1055          * All is well, or the error is fatal.  Signal that the
1056          * next nameserver ought not be tried.
1057          */
1058         return (resplen);
1059 }
1060
1061 #ifdef DEBUG
1062 static void
1063 Aerror(const res_state statp, FILE *file, const char *string, int error,
1064        struct sockaddr_in address)
1065 {
1066         int save = errno;
1067
1068         if ((statp->options & RES_DEBUG) != 0) {
1069                 char tmp[sizeof "255.255.255.255"];
1070
1071                 fprintf(file, "res_send: %s ([%s].%u): %s\n",
1072                         string,
1073                         inet_ntop(address.sin_family, &address.sin_addr,
1074                                   tmp, sizeof tmp),
1075                         ntohs(address.sin_port),
1076                         strerror(error));
1077         }
1078         __set_errno (save);
1079 }
1080
1081 static void
1082 Perror(const res_state statp, FILE *file, const char *string, int error) {
1083         int save = errno;
1084
1085         if ((statp->options & RES_DEBUG) != 0)
1086                 fprintf(file, "res_send: %s: %s\n",
1087                         string, strerror(error));
1088         __set_errno (save);
1089 }
1090 #endif
1091
1092 static int
1093 #ifdef _LIBC
1094 sock_eq(struct sockaddr_in6 *a1, struct sockaddr_in6 *a2) {
1095         if (a1->sin6_family == a2->sin6_family) {
1096                 if (a1->sin6_family == AF_INET)
1097                         return ((((struct sockaddr_in *)a1)->sin_port ==
1098                                  ((struct sockaddr_in *)a2)->sin_port) &&
1099                                 (((struct sockaddr_in *)a1)->sin_addr.s_addr ==
1100                                  ((struct sockaddr_in *)a2)->sin_addr.s_addr));
1101                 else
1102                         return ((a1->sin6_port == a2->sin6_port) &&
1103                                 !memcmp(&a1->sin6_addr, &a2->sin6_addr,
1104                                         sizeof (struct in6_addr)));
1105         }
1106         if (a1->sin6_family == AF_INET) {
1107                 struct sockaddr_in6 *sap = a1;
1108                 a1 = a2;
1109                 a2 = sap;
1110         } /* assumes that AF_INET and AF_INET6 are the only possibilities */
1111         return ((a1->sin6_port == ((struct sockaddr_in *)a2)->sin_port) &&
1112                 IN6_IS_ADDR_V4MAPPED(&a1->sin6_addr) &&
1113                 (a1->sin6_addr.s6_addr32[3] ==
1114                  ((struct sockaddr_in *)a2)->sin_addr.s_addr));
1115 }
1116 #else
1117 sock_eq(struct sockaddr_in *a1, struct sockaddr_in *a2) {
1118         return ((a1->sin_family == a2->sin_family) &&
1119                 (a1->sin_port == a2->sin_port) &&
1120                 (a1->sin_addr.s_addr == a2->sin_addr.s_addr));
1121 }
1122 #endif
1123
1124 #ifdef _LIBC
1125 /*
1126  * Converts IPv4 family, address and port to
1127  * IPv6 family, IPv4-mapped IPv6 address and port.
1128  */
1129 static void
1130 convaddr4to6(struct sockaddr_in6 *sa)
1131 {
1132     struct sockaddr_in *sa4p = (struct sockaddr_in *) sa;
1133     in_port_t port = sa4p->sin_port;
1134     in_addr_t addr = sa4p->sin_addr.s_addr;
1135
1136     sa->sin6_family = AF_INET6;
1137     sa->sin6_port = port;
1138     sa->sin6_addr.s6_addr32[0] = 0;
1139     sa->sin6_addr.s6_addr32[1] = 0;
1140     sa->sin6_addr.s6_addr32[2] = htonl(0xFFFF);
1141     sa->sin6_addr.s6_addr32[3] = addr;
1142 }
1143 #endif
1144
1145 #ifdef NEED_PSELECT
1146 /* XXX needs to move to the porting library. */
1147 static int
1148 pselect(int nfds, void *rfds, void *wfds, void *efds,
1149         struct timespec *tsp, const sigset_t *sigmask)
1150 {
1151         struct timeval tv, *tvp;
1152         sigset_t sigs;
1153         int n;
1154
1155         if (tsp) {
1156                 tvp = &tv;
1157                 tv = evTimeVal(*tsp);
1158         } else
1159                 tvp = NULL;
1160         if (sigmask)
1161                 sigprocmask(SIG_SETMASK, sigmask, &sigs);
1162         n = select(nfds, rfds, wfds, efds, tvp);
1163         if (sigmask)
1164                 sigprocmask(SIG_SETMASK, &sigs, NULL);
1165         if (tsp)
1166                 *tsp = evTimeSpec(tv);
1167         return (n);
1168 }
1169 #endif