![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to send.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / usr.sbin / named / tools / nslookup|
Return to send.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / usr.sbin / named / tools / nslookup |
1.1 root 1: /*
2: * Copyright (c) 1985, 1989 Regents of the University of California.
3: * All rights reserved.
4: *
5: * Redistribution and use in source and binary forms are permitted provided
6: * that: (1) source distributions retain this entire copyright notice and
7: * comment, and (2) distributions including binaries display the following
8: * acknowledgement: ``This product includes software developed by the
9: * University of California, Berkeley and its contributors'' in the
10: * documentation or other materials provided with the distribution and in
11: * all advertising materials mentioning features or use of this software.
12: * Neither the name of the University nor the names of its contributors may
13: * be used to endorse or promote products derived from this software without
14: * specific prior written permission.
15: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
16: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
17: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
18: */
19:
20: #ifndef lint
21: static char sccsid[] = "@(#)send.c 5.17 (Berkeley) 6/29/90";
22: #endif /* not lint */
23:
24: /*
25: *******************************************************************************
26: *
27: * send.c --
28: *
29: * Routine to send request packets to a name server.
30: *
31: * Based on "@(#)res_send.c 6.25 (Berkeley) 6/1/90".
32: *
33: *******************************************************************************
34: */
35:
36:
37: /*
38: * Send query to name server and wait for reply.
39: */
40:
41: #include <sys/param.h>
42: #include <sys/time.h>
43: #include <sys/socket.h>
44: #include <sys/uio.h>
45: #include <netinet/in.h>
46: #include <stdio.h>
47: #include <errno.h>
48: #include <arpa/nameser.h>
49: #include <arpa/inet.h>
50: #include <resolv.h>
51: #include "res.h"
52:
53: extern int errno;
54:
55: static int s = -1; /* socket used for communications */
56:
57:
58: #ifndef FD_SET
59: #define NFDBITS 32
60: #define FD_SETSIZE 32
61: #define FD_SET(n, p) ((p)->fds_bits[(n)/NFDBITS] |= (1 << ((n) % NFDBITS)))
62: #define FD_CLR(n, p) ((p)->fds_bits[(n)/NFDBITS] &= ~(1 << ((n) % NFDBITS)))
63: #define FD_ISSET(n, p) ((p)->fds_bits[(n)/NFDBITS] & (1 << ((n) % NFDBITS)))
64: #define FD_ZERO(p) bzero((char *)(p), sizeof(*(p)))
65: #endif
66:
67: #define SR 1 /* SendRequest style */
68:
69: #ifndef DEBUG
70: #define DEBUG
71: #endif
72:
73: unsigned short nsport = NAMESERVER_PORT;
74:
75:
76:
77: /*
78: *******************************************************************************
79: *
80: * SendRequest --
81: *
82: * Sends a request packet to a name server whose address
83: * is specified by the first argument and returns with
84: * the answer packet.
85: *
86: * Results:
87: * SUCCESS - the request was sent and an answer
88: * was received.
89: * TIME_OUT - the virtual circuit connection timed-out
90: * or a reply to a datagram wasn't received.
91: *
92: *
93: *******************************************************************************
94: */
95:
96: int
97: SendRequest(nsAddrPtr, buf, buflen, answer, anslen, trueLenPtr)
98: struct in_addr *nsAddrPtr;
99: char *buf;
100: int buflen;
101: char *answer;
102: u_int anslen;
103: int *trueLenPtr;
104: {
105: register int n;
106: int try, v_circuit, resplen, ns;
107: int gotsomewhere = 0, connected = 0;
108: int connreset = 0;
109: u_short id, len;
110: char *cp;
111: fd_set dsmask;
112: struct timeval timeout;
113: HEADER *hp = (HEADER *) buf;
114: HEADER *anhp = (HEADER *) answer;
115: struct iovec iov[2];
116: int terrno = ETIMEDOUT;
117: char junk[512];
118:
119: #if SR
120: struct sockaddr_in sin;
121:
122: if (_res.options & RES_DEBUG2) {
123: printf("------------\nSendRequest(), len %d\n", buflen);
124: Print_query(buf, buf+buflen, 1);
125: }
126: sin.sin_family = AF_INET;
127: sin.sin_port = htons(nsport);
128: sin.sin_addr = *nsAddrPtr;
129: #else
130: #ifdef DEBUG
131: if (_res.options & RES_DEBUG) {
132: printf("res_send()\n");
133: p_query(buf);
134: }
135: #endif DEBUG
136: if (!(_res.options & RES_INIT))
137: if (res_init() == -1) {
138: return(-1);
139: }
140: #endif /* SR */
141: v_circuit = (_res.options & RES_USEVC) || buflen > PACKETSZ;
142: id = hp->id;
143: /*
144: * Send request, RETRY times, or until successful
145: */
146: for (try = 0; try < _res.retry; try++) {
147: #if !SR
148: for (ns = 0; ns < _res.nscount; ns++) {
149: #ifdef DEBUG
150: if (_res.options & RES_DEBUG)
151: printf("Querying server (# %d) address = %s\n", ns+1,
152: inet_ntoa(_res.nsaddr_list[ns].sin_addr));
153: #endif DEBUG
154: #endif /* !SR */
155: usevc:
156: if (v_circuit) {
157: int truncated = 0;
158:
159: /*
160: * Use virtual circuit;
161: * at most one attempt per server.
162: */
163: try = _res.retry;
164: if (s < 0) {
165: s = socket(AF_INET, SOCK_STREAM, 0);
166: if (s < 0) {
167: terrno = errno;
168: #ifdef DEBUG
169: if (_res.options & RES_DEBUG)
170: perror("socket (vc) failed");
171: #endif DEBUG
172: continue;
173: }
174: #if SR
175: if (connect(s, &sin,
176: #else
177: if (connect(s, &(_res.nsaddr_list[ns]),
178: #endif
179: sizeof(struct sockaddr)) < 0) {
180: terrno = errno;
181: #ifdef DEBUG
182: if (_res.options & RES_DEBUG)
183: perror("connect failed");
184: #endif DEBUG
185: (void) close(s);
186: s = -1;
187: continue;
188: }
189: }
190: /*
191: * Send length & message
192: */
193: len = htons((u_short)buflen);
194: iov[0].iov_base = (caddr_t)&len;
195: iov[0].iov_len = sizeof(len);
196: iov[1].iov_base = buf;
197: iov[1].iov_len = buflen;
198: if (writev(s, iov, 2) != sizeof(len) + buflen) {
199: terrno = errno;
200: #ifdef DEBUG
201: if (_res.options & RES_DEBUG)
202: perror("write failed");
203: #endif DEBUG
204: (void) close(s);
205: s = -1;
206: continue;
207: }
208: /*
209: * Receive length & response
210: */
211: cp = answer;
212: len = sizeof(short);
213: while (len != 0 &&
214: (n = read(s, (char *)cp, (int)len)) > 0) {
215: cp += n;
216: len -= n;
217: }
218: if (n <= 0) {
219: terrno = errno;
220: #ifdef DEBUG
221: if (_res.options & RES_DEBUG)
222: perror("read failed");
223: #endif DEBUG
224: (void) close(s);
225: s = -1;
226: /*
227: * A long running process might get its TCP
228: * connection reset if the remote server was
229: * restarted. Requery the server instead of
230: * trying a new one. When there is only one
231: * server, this means that a query might work
232: * instead of failing. We only allow one reset
233: * per query to prevent looping.
234: */
235: if (terrno == ECONNRESET && !connreset) {
236: connreset = 1;
237: ns--;
238: }
239: continue;
240: }
241: cp = answer;
242: if ((resplen = ntohs(*(u_short *)cp)) > anslen) {
243: #ifdef DEBUG
244: if (_res.options & RES_DEBUG)
245: fprintf(stderr, "response truncated\n");
246: #endif DEBUG
247: len = anslen;
248: truncated = 1;
249: } else
250: len = resplen;
251: while (len != 0 &&
252: (n = read(s, (char *)cp, (int)len)) > 0) {
253: cp += n;
254: len -= n;
255: }
256: if (n <= 0) {
257: terrno = errno;
258: #ifdef DEBUG
259: if (_res.options & RES_DEBUG)
260: perror("read failed");
261: #endif DEBUG
262: (void) close(s);
263: s = -1;
264: continue;
265: }
266: if (truncated) {
267: /*
268: * Flush rest of answer
269: * so connection stays in synch.
270: */
271: anhp->tc = 1;
272: len = resplen - anslen;
273: while (len != 0) {
274: n = (len > sizeof(junk) ?
275: sizeof(junk) : len);
276: if ((n = read(s, junk, n)) > 0)
277: len -= n;
278: else
279: break;
280: }
281: }
282: } else {
283: /*
284: * Use datagrams.
285: */
286: if (s < 0) {
287: s = socket(AF_INET, SOCK_DGRAM, 0);
288: if (s < 0) {
289: terrno = errno;
290: #ifdef DEBUG
291: if (_res.options & RES_DEBUG)
292: perror("socket (dg) failed");
293: #endif DEBUG
294: continue;
295: }
296: }
297: #if SR
298: /*
299: * Special case the send code below
300: * since we have just 1 server.
301: */
302: #if BSD >= 43
303: if (connected == 0) {
304: if (connect(s, &sin,
305: sizeof(struct sockaddr)) < 0) {
306: if (_res.options & RES_DEBUG)
307: perror("connect");
308: continue;
309: }
310: connected = 1;
311: }
312: if (send(s, buf, buflen, 0) != buflen) {
313: if (_res.options & RES_DEBUG)
314: perror("send");
315: continue;
316: }
317: #else /* BSD */
318: if (sendto(s, buf, buflen, 0, &sin,
319: sizeof(struct sockaddr)) != buflen) {
320: if (_res.options & RES_DEBUG)
321: perror("sendto");
322: continue;
323: }
324: #endif
325: #else /* SR */
326: #if BSD >= 43
327: /*
328: * I'm tired of answering this question, so:
329: * On a 4.3BSD+ machine (client and server,
330: * actually), sending to a nameserver datagram
331: * port with no nameserver will cause an
332: * ICMP port unreachable message to be returned.
333: * If our datagram socket is "connected" to the
334: * server, we get an ECONNREFUSED error on the next
335: * socket operation, and select returns if the
336: * error message is received. We can thus detect
337: * the absence of a nameserver without timing out.
338: * If we have sent queries to at least two servers,
339: * however, we don't want to remain connected,
340: * as we wish to receive answers from the first
341: * server to respond.
342: */
343: if (_res.nscount == 1 || (try == 0 && ns == 0)) {
344: /*
345: * Don't use connect if we might
346: * still receive a response
347: * from another server.
348: */
349: if (connected == 0) {
350: if (connect(s, &_res.nsaddr_list[ns],
351: sizeof(struct sockaddr)) < 0) {
352: #ifdef DEBUG
353: if (_res.options & RES_DEBUG)
354: perror("connect");
355: #endif DEBUG
356: continue;
357: }
358: connected = 1;
359: }
360: if (send(s, buf, buflen, 0) != buflen) {
361: #ifdef DEBUG
362: if (_res.options & RES_DEBUG)
363: perror("send");
364: #endif DEBUG
365: continue;
366: }
367: } else {
368: /*
369: * Disconnect if we want to listen
370: * for responses from more than one server.
371: */
372: if (connected) {
373: (void) connect(s, &no_addr,
374: sizeof(no_addr));
375: connected = 0;
376: }
377: #endif BSD
378: if (sendto(s, buf, buflen, 0,
379: &_res.nsaddr_list[ns],
380: sizeof(struct sockaddr)) != buflen) {
381: #ifdef DEBUG
382: if (_res.options & RES_DEBUG)
383: perror("sendto");
384: #endif DEBUG
385: continue;
386: }
387: #if BSD >= 43
388: }
389: #endif
390: #endif /* SR */
391:
392: /*
393: * Wait for reply
394: */
395: timeout.tv_sec = (_res.retrans << try);
396: #if !SR
397: if (try > 0)
398: timeout.tv_sec /= _res.nscount;
399: #endif /* SR */
400: if (timeout.tv_sec <= 0)
401: timeout.tv_sec = 1;
402: timeout.tv_usec = 0;
403: wait:
404: FD_ZERO(&dsmask);
405: FD_SET(s, &dsmask);
406: n = select(s+1, &dsmask, (fd_set *)NULL,
407: (fd_set *)NULL, &timeout);
408: if (n < 0) {
409: #ifdef DEBUG
410: if (_res.options & RES_DEBUG)
411: perror("select");
412: #endif DEBUG
413: continue;
414: }
415: if (n == 0) {
416: /*
417: * timeout
418: */
419: #ifdef DEBUG
420: if (_res.options & RES_DEBUG)
421: printf("timeout (%d secs)\n",
422: timeout.tv_sec);
423: #endif DEBUG
424: #if BSD >= 43
425: gotsomewhere = 1;
426: #endif
427: continue;
428: }
429: if ((resplen = recv(s, answer, anslen, 0)) <= 0) {
430: #ifdef DEBUG
431: if (_res.options & RES_DEBUG)
432: perror("recvfrom");
433: #endif DEBUG
434: continue;
435: }
436: gotsomewhere = 1;
437: if (id != anhp->id) {
438: /*
439: * response from old query, ignore it
440: */
441: #if SR
442: if (_res.options & RES_DEBUG2) {
443: printf("------------\nOld answer:\n");
444: Print_query(answer, answer+resplen, 1);
445: }
446: #else
447: #ifdef DEBUG
448: if (_res.options & RES_DEBUG) {
449: printf("old answer:\n");
450: p_query(answer);
451: }
452: #endif DEBUG
453: #endif
454: goto wait;
455: }
456: if (!(_res.options & RES_IGNTC) && anhp->tc) {
457: /*
458: * get rest of answer;
459: * use TCP with same server.
460: */
461: #ifdef DEBUG
462: if (_res.options & RES_DEBUG)
463: printf("truncated answer\n");
464: #endif DEBUG
465: (void) close(s);
466: s = -1;
467: v_circuit = 1;
468: goto usevc;
469: }
470: }
471: #if SR
472: if (_res.options & RES_DEBUG) {
473: if (_res.options & RES_DEBUG2)
474: printf("------------\nGot answer (%d bytes):\n",
475: resplen);
476: else
477: printf("------------\nGot answer:\n");
478: Print_query(answer, answer+resplen, 1);
479: }
480: (void) close(s);
481: s = -1;
482: *trueLenPtr = resplen;
483: return (SUCCESS);
484: #else
485: #ifdef DEBUG
486: if (_res.options & RES_DEBUG) {
487: printf("got answer:\n");
488: p_query(answer);
489: }
490: #endif DEBUG
491: /*
492: * If using virtual circuits, we assume that the first server
493: * is preferred * over the rest (i.e. it is on the local
494: * machine) and only keep that one open.
495: * If we have temporarily opened a virtual circuit,
496: * or if we haven't been asked to keep a socket open,
497: * close the socket.
498: */
499: if ((v_circuit &&
500: ((_res.options & RES_USEVC) == 0 || ns != 0)) ||
501: (_res.options & RES_STAYOPEN) == 0) {
502: (void) close(s);
503: s = -1;
504: }
505: return (resplen);
506: }
507: #endif /* SR */
508: }
509: if (s >= 0) {
510: (void) close(s);
511: s = -1;
512: }
513: #if SR
514: if (v_circuit == 0)
515: if (gotsomewhere == 0)
516: return NO_RESPONSE; /* no nameservers found */
517: else
518: return TIME_OUT; /* no answer obtained */
519: else
520: if (errno == ECONNREFUSED)
521: return NO_RESPONSE;
522: else
523: return ERROR;
524: #else
525: if (v_circuit == 0)
526: if (gotsomewhere == 0)
527: errno = ECONNREFUSED; /* no nameservers found */
528: else
529: errno = ETIMEDOUT; /* no answer obtained */
530: else
531: errno = terrno;
532: return (-1);
533: #endif
534: }
535:
536: /*
537: * This routine is for closing the socket if a virtual circuit is used and
538: * the program wants to close it.
539: *
540: * Called from the interrupt handler.
541: */
542: SendRequest_close()
543: {
544: if (s != -1) {
545: (void) close(s);
546: s = -1;
547: }
548: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.