![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to res_query.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / lib / libc / net|
Return to res_query.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / lib / libc / net |
1.1 root 1: /*
2: * Copyright (c) 1988 Regents of the University of California.
3: * All rights reserved.
4: *
5: * Redistribution and use in source and binary forms are permitted
6: * provided that: (1) source distributions retain this entire copyright
7: * notice and comment, and (2) distributions including binaries display
8: * the following acknowledgement: ``This product includes software
9: * developed by the University of California, Berkeley and its contributors''
10: * in the documentation or other materials provided with the distribution
11: * and in all advertising materials mentioning features or use of this
12: * software. Neither the name of the University nor the names of its
13: * contributors may be used to endorse or promote products derived
14: * from this software without specific prior written permission.
15: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
16: * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
17: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
18: */
19:
20: #if defined(LIBC_SCCS) && !defined(lint)
21: static char sccsid[] = "@(#)res_query.c 5.7 (Berkeley) 6/1/90";
22: #endif /* LIBC_SCCS and not lint */
23:
24: #include <sys/param.h>
25: #include <sys/socket.h>
26: #include <netinet/in.h>
27: #include <ctype.h>
28: #include <netdb.h>
29: #include <stdio.h>
30: #include <errno.h>
31: #include <string.h>
32: #include <arpa/inet.h>
33: #include <arpa/nameser.h>
34: #include <resolv.h>
35:
36: #if PACKETSZ > 1024
37: #define MAXPACKET PACKETSZ
38: #else
39: #define MAXPACKET 1024
40: #endif
41:
42: extern int errno;
43: int h_errno;
44:
45: /*
46: * Formulate a normal query, send, and await answer.
47: * Returned answer is placed in supplied buffer "answer".
48: * Perform preliminary check of answer, returning success only
49: * if no error is indicated and the answer count is nonzero.
50: * Return the size of the response on success, -1 on error.
51: * Error number is left in h_errno.
52: * Caller must parse answer and determine whether it answers the question.
53: */
54: res_query(name, class, type, answer, anslen)
55: char *name; /* domain name */
56: int class, type; /* class and type of query */
57: u_char *answer; /* buffer to put answer */
58: int anslen; /* size of answer buffer */
59: {
60: char buf[MAXPACKET];
61: HEADER *hp;
62: int n;
63:
64: if ((_res.options & RES_INIT) == 0 && res_init() == -1)
65: return (-1);
66: #ifdef DEBUG
67: if (_res.options & RES_DEBUG)
68: printf("res_query(%s, %d, %d)\n", name, class, type);
69: #endif
70: n = res_mkquery(QUERY, name, class, type, (char *)NULL, 0, NULL,
71: buf, sizeof(buf));
72:
73: if (n <= 0) {
74: #ifdef DEBUG
75: if (_res.options & RES_DEBUG)
76: printf("res_query: mkquery failed\n");
77: #endif
78: h_errno = NO_RECOVERY;
79: return (n);
80: }
81: n = res_send(buf, n, answer, anslen);
82: if (n < 0) {
83: #ifdef DEBUG
84: if (_res.options & RES_DEBUG)
85: printf("res_query: send error\n");
86: #endif
87: h_errno = TRY_AGAIN;
88: return(n);
89: }
90:
91: hp = (HEADER *) answer;
92: if (hp->rcode != NOERROR || ntohs(hp->ancount) == 0) {
93: #ifdef DEBUG
94: if (_res.options & RES_DEBUG)
95: printf("rcode = %d, ancount=%d\n", hp->rcode,
96: ntohs(hp->ancount));
97: #endif
98: switch (hp->rcode) {
99: case NXDOMAIN:
100: h_errno = HOST_NOT_FOUND;
101: break;
102: case SERVFAIL:
103: h_errno = TRY_AGAIN;
104: break;
105: case NOERROR:
106: h_errno = NO_DATA;
107: break;
108: case FORMERR:
109: case NOTIMP:
110: case REFUSED:
111: default:
112: h_errno = NO_RECOVERY;
113: break;
114: }
115: return (-1);
116: }
117: return(n);
118: }
119:
120: /*
121: * Formulate a normal query, send, and retrieve answer in supplied buffer.
122: * Return the size of the response on success, -1 on error.
123: * If enabled, implement search rules until answer or unrecoverable failure
124: * is detected. Error number is left in h_errno.
125: * Only useful for queries in the same name hierarchy as the local host
126: * (not, for example, for host address-to-name lookups in domain in-addr.arpa).
127: */
128: res_search(name, class, type, answer, anslen)
129: char *name; /* domain name */
130: int class, type; /* class and type of query */
131: u_char *answer; /* buffer to put answer */
132: int anslen; /* size of answer */
133: {
134: register char *cp, **domain;
135: int n, ret, got_nodata = 0;
136: char *hostalias();
137:
138: if ((_res.options & RES_INIT) == 0 && res_init() == -1)
139: return (-1);
140:
141: errno = 0;
142: h_errno = HOST_NOT_FOUND; /* default, if we never query */
143: for (cp = name, n = 0; *cp; cp++)
144: if (*cp == '.')
145: n++;
146: if (n == 0 && (cp = hostalias(name)))
147: return (res_query(cp, class, type, answer, anslen));
148:
149: /*
150: * We do at least one level of search if
151: * - there is no dot and RES_DEFNAME is set, or
152: * - there is at least one dot, there is no trailing dot,
153: * and RES_DNSRCH is set.
154: */
155: if ((n == 0 && _res.options & RES_DEFNAMES) ||
156: (n != 0 && *--cp != '.' && _res.options & RES_DNSRCH))
157: for (domain = _res.dnsrch; *domain; domain++) {
158: ret = res_querydomain(name, *domain, class, type,
159: answer, anslen);
160: if (ret > 0)
161: return (ret);
162: /*
163: * If no server present, give up.
164: * If name isn't found in this domain,
165: * keep trying higher domains in the search list
166: * (if that's enabled).
167: * On a NO_DATA error, keep trying, otherwise
168: * a wildcard entry of another type could keep us
169: * from finding this entry higher in the domain.
170: * If we get some other error (negative answer or
171: * server failure), then stop searching up,
172: * but try the input name below in case it's fully-qualified.
173: */
174: if (errno == ECONNREFUSED) {
175: h_errno = TRY_AGAIN;
176: return (-1);
177: }
178: if (h_errno == NO_DATA)
179: got_nodata++;
180: if ((h_errno != HOST_NOT_FOUND && h_errno != NO_DATA) ||
181: (_res.options & RES_DNSRCH) == 0)
182: break;
183: }
184: /*
185: * If the search/default failed, try the name as fully-qualified,
186: * but only if it contained at least one dot (even trailing).
187: * This is purely a heuristic; we assume that any reasonable query
188: * about a top-level domain (for servers, SOA, etc) will not use
189: * res_search.
190: */
191: if (n && (ret = res_querydomain(name, (char *)NULL, class, type,
192: answer, anslen)) > 0)
193: return (ret);
194: if (got_nodata)
195: h_errno = NO_DATA;
196: return (-1);
197: }
198:
199: /*
200: * Perform a call on res_query on the concatenation of name and domain,
201: * removing a trailing dot from name if domain is NULL.
202: */
203: res_querydomain(name, domain, class, type, answer, anslen)
204: char *name, *domain;
205: int class, type; /* class and type of query */
206: u_char *answer; /* buffer to put answer */
207: int anslen; /* size of answer */
208: {
209: char nbuf[2*MAXDNAME+2];
210: char *longname = nbuf;
211: int n;
212:
213: #ifdef DEBUG
214: if (_res.options & RES_DEBUG)
215: printf("res_querydomain(%s, %s, %d, %d)\n",
216: name, domain, class, type);
217: #endif
218: if (domain == NULL) {
219: /*
220: * Check for trailing '.';
221: * copy without '.' if present.
222: */
223: n = strlen(name) - 1;
224: if (name[n] == '.' && n < sizeof(nbuf) - 1) {
225: bcopy(name, nbuf, n);
226: nbuf[n] = '\0';
227: } else
228: longname = name;
229: } else
230: (void)sprintf(nbuf, "%.*s.%.*s",
231: MAXDNAME, name, MAXDNAME, domain);
232:
233: return (res_query(longname, class, type, answer, anslen));
234: }
235:
236: char *
237: hostalias(name)
238: register char *name;
239: {
240: register char *C1, *C2;
241: FILE *fp;
242: char *file, *getenv(), *strcpy(), *strncpy();
243: char buf[BUFSIZ];
244: static char abuf[MAXDNAME];
245:
246: file = getenv("HOSTALIASES");
247: if (file == NULL || (fp = fopen(file, "r")) == NULL)
248: return (NULL);
249: buf[sizeof(buf) - 1] = '\0';
250: while (fgets(buf, sizeof(buf), fp)) {
251: for (C1 = buf; *C1 && !isspace(*C1); ++C1);
252: if (!*C1)
253: break;
254: *C1 = '\0';
255: if (!strcasecmp(buf, name)) {
256: while (isspace(*++C1));
257: if (!*C1)
258: break;
259: for (C2 = C1 + 1; *C2 && !isspace(*C2); ++C2);
260: abuf[sizeof(abuf) - 1] = *C2 = '\0';
261: (void)strncpy(abuf, C1, sizeof(abuf) - 1);
262: fclose(fp);
263: return (abuf);
264: }
265: }
266: fclose(fp);
267: return (NULL);
268: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.