Add cast to avoid warning.
[kopensolaris-gnu/glibc.git] / resolv / res_data.c
1 /*
2  * Copyright (c) 1995-1999 by Internet Software Consortium.
3  *
4  * Permission to use, copy, modify, and distribute this software for any
5  * purpose with or without fee is hereby granted, provided that the above
6  * copyright notice and this permission notice appear in all copies.
7  *
8  * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM DISCLAIMS
9  * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
10  * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE
11  * CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
12  * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
13  * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
14  * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
15  * SOFTWARE.
16  */
17
18 #if defined(LIBC_SCCS) && !defined(lint)
19 static const char rcsid[] = "$BINDId: res_data.c,v 8.17 1999/10/13 17:11:31 vixie Exp $";
20 #endif /* LIBC_SCCS and not lint */
21
22 #include <sys/types.h>
23 #include <sys/param.h>
24 #include <sys/socket.h>
25 #include <sys/time.h>
26
27 #include <netinet/in.h>
28 #include <arpa/inet.h>
29 #include <arpa/nameser.h>
30
31 #include <ctype.h>
32 #include <netdb.h>
33 #include <resolv.h>
34 #ifdef BIND_UPDATE
35 #include <res_update.h>
36 #endif
37 #include <stdio.h>
38 #include <stdlib.h>
39 #include <string.h>
40 #include <unistd.h>
41
42 #undef _res
43
44 const char *_res_opcodes[] = {
45         "QUERY",
46         "IQUERY",
47         "CQUERYM",
48         "CQUERYU",      /* experimental */
49         "NOTIFY",       /* experimental */
50         "UPDATE",
51         "6",
52         "7",
53         "8",
54         "9",
55         "10",
56         "11",
57         "12",
58         "13",
59         "ZONEINIT",
60         "ZONEREF",
61 };
62
63 #ifdef BIND_UPDATE
64 const char *_res_sectioncodes[] = {
65         "ZONE",
66         "PREREQUISITES",
67         "UPDATE",
68         "ADDITIONAL",
69 };
70 #endif
71
72 #ifndef __BIND_NOSTATIC
73 #ifdef _LIBC
74 extern struct __res_state _res;
75 #else
76 /* The definition has been moved to res_libc.c.  */
77 struct __res_state _res
78 # if defined(__BIND_RES_TEXT)
79         = { RES_TIMEOUT, }      /* Motorola, et al. */
80 # endif
81         ;
82 #endif
83
84 /* Proto. */
85 #ifndef _LIBC
86 int  res_ourserver_p(const res_state, const struct sockaddr_in *);
87 void res_pquery(const res_state, const u_char *, int, FILE *);
88 #endif
89
90 #ifndef _LIBC
91 /* Moved to res_libc.c since res_init() should go into libc.so but the
92    rest of this file not.  */
93 int
94 res_init(void) {
95         extern int __res_vinit(res_state, int);
96
97         /*
98          * These three fields used to be statically initialized.  This made
99          * it hard to use this code in a shared library.  It is necessary,
100          * now that we're doing dynamic initialization here, that we preserve
101          * the old semantics: if an application modifies one of these three
102          * fields of _res before res_init() is called, res_init() will not
103          * alter them.  Of course, if an application is setting them to
104          * _zero_ before calling res_init(), hoping to override what used
105          * to be the static default, we can't detect it and unexpected results
106          * will follow.  Zero for any of these fields would make no sense,
107          * so one can safely assume that the applications were already getting
108          * unexpected results.
109          *
110          * _res.options is tricky since some apps were known to diddle the bits
111          * before res_init() was first called. We can't replicate that semantic
112          * with dynamic initialization (they may have turned bits off that are
113          * set in RES_DEFAULT).  Our solution is to declare such applications
114          * "broken".  They could fool us by setting RES_INIT but none do (yet).
115          */
116         if (!_res.retrans)
117                 _res.retrans = RES_TIMEOUT;
118         if (!_res.retry)
119                 _res.retry = 4;
120         if (!(_res.options & RES_INIT))
121                 _res.options = RES_DEFAULT;
122
123         /*
124          * This one used to initialize implicitly to zero, so unless the app
125          * has set it to something in particular, we can randomize it now.
126          */
127         if (!_res.id)
128                 _res.id = res_randomid();
129
130         return (__res_vinit(&_res, 1));
131 }
132 #endif
133
134 void
135 p_query(const u_char *msg) {
136         fp_query(msg, stdout);
137 }
138
139 void
140 fp_query(const u_char *msg, FILE *file) {
141         fp_nquery(msg, PACKETSZ, file);
142 }
143
144 void
145 fp_nquery(const u_char *msg, int len, FILE *file) {
146         if ((_res.options & RES_INIT) == 0 && res_init() == -1)
147                 return;
148
149         res_pquery(&_res, msg, len, file);
150 }
151
152 int
153 res_mkquery(int op,                     /* opcode of query */
154             const char *dname,          /* domain name */
155             int class, int type,        /* class and type of query */
156             const u_char *data,         /* resource record data */
157             int datalen,                /* length of data */
158             const u_char *newrr_in,     /* new rr for modify or append */
159             u_char *buf,                /* buffer to put query */
160             int buflen)                 /* size of buffer */
161 {
162         if ((_res.options & RES_INIT) == 0 && res_init() == -1) {
163                 RES_SET_H_ERRNO(&_res, NETDB_INTERNAL);
164                 return (-1);
165         }
166         return (res_nmkquery(&_res, op, dname, class, type,
167                              data, datalen,
168                              newrr_in, buf, buflen));
169 }
170
171 #ifdef BIND_UPDATE
172 int
173 res_mkupdate(ns_updrec *rrecp_in, u_char *buf, int buflen) {
174         if ((_res.options & RES_INIT) == 0 && res_init() == -1) {
175                 RES_SET_H_ERRNO(&_res, NETDB_INTERNAL);
176                 return (-1);
177         }
178
179         return (res_nmkupdate(&_res, rrecp_in, buf, buflen));
180 }
181 #endif
182
183 int
184 res_query(const char *name,     /* domain name */
185           int class, int type,  /* class and type of query */
186           u_char *answer,       /* buffer to put answer */
187           int anslen)           /* size of answer buffer */
188 {
189         if ((_res.options & RES_INIT) == 0 && res_init() == -1) {
190                 RES_SET_H_ERRNO(&_res, NETDB_INTERNAL);
191                 return (-1);
192         }
193         return (res_nquery(&_res, name, class, type, answer, anslen));
194 }
195
196 void
197 res_send_setqhook(res_send_qhook hook) {
198         _res.qhook = hook;
199 }
200
201 void
202 res_send_setrhook(res_send_rhook hook) {
203         _res.rhook = hook;
204 }
205
206 int
207 res_isourserver(const struct sockaddr_in *inp) {
208         return (res_ourserver_p((const struct sockaddr_in6 *) &_res, inp));
209 }
210
211 int
212 res_send(const u_char *buf, int buflen, u_char *ans, int anssiz) {
213         if ((_res.options & RES_INIT) == 0 && res_init() == -1) {
214                 /* errno should have been set by res_init() in this case. */
215                 return (-1);
216         }
217
218         return (res_nsend(&_res, buf, buflen, ans, anssiz));
219 }
220
221 #ifndef _LIBC
222 int
223 res_sendsigned(const u_char *buf, int buflen, ns_tsig_key *key,
224                u_char *ans, int anssiz)
225 {
226         if ((_res.options & RES_INIT) == 0 && res_init() == -1) {
227                 /* errno should have been set by res_init() in this case. */
228                 return (-1);
229         }
230
231         return (res_nsendsigned(&_res, buf, buflen, key, ans, anssiz));
232 }
233 #endif
234
235 void
236 res_close(void) {
237 #ifdef _LIBC
238         /*
239          * Some stupid programs out there call res_close() before res_init().
240          * Since _res._vcsock isn't explicitly initialized, these means that
241          * we could do a close(0), which might lead to some security problems.
242          * Therefore we check if res_init() was called before by looking at
243          * the RES_INIT bit in _res.options.  If it hasn't been set we bail out
244          * early.  */
245         if ((_res.options & RES_INIT) == 0)
246           return;
247 #endif
248         res_nclose(&_res);
249 }
250
251 #ifdef BIND_UPDATE
252 int
253 res_update(ns_updrec *rrecp_in) {
254         if ((_res.options & RES_INIT) == 0 && res_init() == -1) {
255                 RES_SET_H_ERRNO(&_res, NETDB_INTERNAL);
256                 return (-1);
257         }
258
259         return (res_nupdate(&_res, rrecp_in, NULL));
260 }
261 #endif
262
263 int
264 res_search(const char *name,    /* domain name */
265            int class, int type, /* class and type of query */
266            u_char *answer,      /* buffer to put answer */
267            int anslen)          /* size of answer */
268 {
269         if ((_res.options & RES_INIT) == 0 && res_init() == -1) {
270                 RES_SET_H_ERRNO(&_res, NETDB_INTERNAL);
271                 return (-1);
272         }
273
274         return (res_nsearch(&_res, name, class, type, answer, anslen));
275 }
276
277 int
278 res_querydomain(const char *name,
279                 const char *domain,
280                 int class, int type,    /* class and type of query */
281                 u_char *answer,         /* buffer to put answer */
282                 int anslen)             /* size of answer */
283 {
284         if ((_res.options & RES_INIT) == 0 && res_init() == -1) {
285                 RES_SET_H_ERRNO(&_res, NETDB_INTERNAL);
286                 return (-1);
287         }
288
289         return (res_nquerydomain(&_res, name, domain,
290                                  class, type,
291                                  answer, anslen));
292 }
293
294 const char *
295 hostalias(const char *name) {
296         static char abuf[MAXDNAME];
297
298         return (res_hostalias(&_res, name, abuf, sizeof abuf));
299 }
300
301 #ifdef ultrix
302 int
303 local_hostname_length(const char *hostname) {
304         int len_host, len_domain;
305
306         if (!*_res.defdname)
307                 res_init();
308         len_host = strlen(hostname);
309         len_domain = strlen(_res.defdname);
310         if (len_host > len_domain &&
311             !strcasecmp(hostname + len_host - len_domain, _res.defdname) &&
312             hostname[len_host - len_domain - 1] == '.')
313                 return (len_host - len_domain - 1);
314         return (0);
315 }
316 #endif /*ultrix*/
317
318 #endif
319 \f
320
321 #include <shlib-compat.h>
322
323 #if SHLIB_COMPAT(libresolv, GLIBC_2_0, GLIBC_2_2)
324 # undef res_mkquery
325 # undef res_query
326 # undef res_querydomain
327 # undef res_search
328 weak_alias (__res_mkquery, res_mkquery);
329 weak_alias (__res_query, res_query);
330 weak_alias (__res_querydomain, res_querydomain);
331 weak_alias (__res_search, res_search);
332 #endif