BIND: update vendor tree to 9.5.2-P2
[dragonfly.git] / contrib / bind / lib / bind / irs / irs_data.c
1 /*
2  * Copyright (c) 2004 by Internet Systems Consortium, Inc. ("ISC")
3  * Copyright (c) 1996,1999 by Internet Software Consortium.
4  *
5  * Permission to use, copy, modify, and distribute this software for any
6  * purpose with or without fee is hereby granted, provided that the above
7  * copyright notice and this permission notice appear in all copies.
8  *
9  * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES
10  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11  * MERCHANTABILITY AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR
12  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
15  * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16  */
17
18 #if !defined(LINT) && !defined(CODECENTER)
19 static const char rcsid[] = "$Id: irs_data.c,v 1.12 2007/08/27 03:32:26 marka Exp $";
20 #endif
21
22 #include "port_before.h"
23
24 #ifndef __BIND_NOSTATIC
25
26 #include <sys/types.h>
27
28 #include <netinet/in.h>
29 #include <arpa/nameser.h>
30
31 #include <resolv.h>
32 #include <stdio.h>
33 #include <string.h>
34 #include <isc/memcluster.h>
35
36 #ifdef DO_PTHREADS
37 #include <pthread.h>
38 #endif
39
40 #include <irs.h>
41 #include <stdlib.h>
42
43 #include "port_after.h"
44
45 #include "irs_data.h"
46 #undef _res
47 #if !(__GLIBC__ > 2 || __GLIBC__ == 2 &&  __GLIBC_MINOR__ >= 3)
48 #undef h_errno
49 extern int h_errno;
50 #endif
51
52 extern struct __res_state _res;
53
54 #ifdef  DO_PTHREADS
55 static pthread_key_t    key;
56 static int              once = 0;
57 #else
58 static struct net_data  *net_data;
59 #endif
60
61 void
62 irs_destroy(void) {
63 #ifndef DO_PTHREADS
64         if (net_data != NULL)
65                 net_data_destroy(net_data);
66         net_data = NULL;
67 #endif
68 }
69
70 void
71 net_data_destroy(void *p) {
72         struct net_data *net_data = p;
73
74         res_ndestroy(net_data->res);
75         if (net_data->gr != NULL) {
76                 (*net_data->gr->close)(net_data->gr);
77                 net_data->gr = NULL;
78         }
79         if (net_data->pw != NULL) {
80                 (*net_data->pw->close)(net_data->pw);
81                 net_data->pw = NULL;
82         }
83         if (net_data->sv != NULL) {
84                 (*net_data->sv->close)(net_data->sv);
85                 net_data->sv = NULL;
86         }
87         if (net_data->pr != NULL) {
88                 (*net_data->pr->close)(net_data->pr);
89                 net_data->pr = NULL;
90         }
91         if (net_data->ho != NULL) {
92                 (*net_data->ho->close)(net_data->ho);
93                 net_data->ho = NULL;
94         }
95         if (net_data->nw != NULL) {
96                 (*net_data->nw->close)(net_data->nw);
97                 net_data->nw = NULL;
98         }
99         if (net_data->ng != NULL) {
100                 (*net_data->ng->close)(net_data->ng);
101                 net_data->ng = NULL;
102         }
103         if (net_data->ho_data != NULL) {
104                 free(net_data->ho_data);
105                 net_data->ho_data = NULL;
106         }
107         if (net_data->nw_data != NULL) {
108                 free(net_data->nw_data);
109                 net_data->nw_data = NULL;
110         }
111
112         (*net_data->irs->close)(net_data->irs);
113         memput(net_data, sizeof *net_data);
114 }
115
116 /*%
117  *  applications that need a specific config file other than
118  * _PATH_IRS_CONF should call net_data_init directly rather than letting
119  *   the various wrapper functions make the first call. - brister
120  */
121
122 struct net_data *
123 net_data_init(const char *conf_file) {
124 #ifdef  DO_PTHREADS
125 #ifndef LIBBIND_MUTEX_INITIALIZER
126 #define LIBBIND_MUTEX_INITIALIZER PTHREAD_MUTEX_INITIALIZER
127 #endif
128         static pthread_mutex_t keylock = LIBBIND_MUTEX_INITIALIZER;
129         struct net_data *net_data;
130
131         if (!once) {
132                 if (pthread_mutex_lock(&keylock) != 0)
133                         return (NULL);
134                 if (!once) {
135                         if (pthread_key_create(&key, net_data_destroy) != 0) {
136                                 (void)pthread_mutex_unlock(&keylock);
137                                 return (NULL);
138                         }
139                         once = 1;
140                 }
141                 if (pthread_mutex_unlock(&keylock) != 0)
142                         return (NULL);
143         }
144         net_data = pthread_getspecific(key);
145 #endif
146
147         if (net_data == NULL) {
148                 net_data = net_data_create(conf_file);
149                 if (net_data == NULL)
150                         return (NULL);
151 #ifdef  DO_PTHREADS
152                 if (pthread_setspecific(key, net_data) != 0) {
153                         net_data_destroy(net_data);
154                         return (NULL);
155                 }
156 #endif
157         }
158
159         return (net_data);
160 }
161
162 struct net_data *
163 net_data_create(const char *conf_file) {
164         struct net_data *net_data;
165
166         net_data = memget(sizeof (struct net_data));
167         if (net_data == NULL)
168                 return (NULL);
169         memset(net_data, 0, sizeof (struct net_data));
170
171         if ((net_data->irs = irs_gen_acc("", conf_file)) == NULL) {
172                 memput(net_data, sizeof (struct net_data));
173                 return (NULL);
174         }
175 #ifndef DO_PTHREADS
176         (*net_data->irs->res_set)(net_data->irs, &_res, NULL);
177 #endif
178
179         net_data->res = (*net_data->irs->res_get)(net_data->irs);
180         if (net_data->res == NULL) {
181                 (*net_data->irs->close)(net_data->irs);
182                 memput(net_data, sizeof (struct net_data));
183                 return (NULL);
184         }
185
186         if ((net_data->res->options & RES_INIT) == 0U &&
187             res_ninit(net_data->res) == -1) {
188                 (*net_data->irs->close)(net_data->irs);
189                 memput(net_data, sizeof (struct net_data));
190                 return (NULL);
191         }
192
193         return (net_data);
194 }
195
196 void
197 net_data_minimize(struct net_data *net_data) {
198         res_nclose(net_data->res);
199 }
200
201 #ifdef _REENTRANT
202 struct __res_state *
203 __res_state(void) {
204         /* NULL param here means use the default config file. */
205         struct net_data *net_data = net_data_init(NULL);
206         if (net_data && net_data->res)
207                 return (net_data->res);
208
209         return (&_res);
210 }
211 #else
212 #ifdef __linux
213 struct __res_state *
214 __res_state(void) {
215         return (&_res);
216 }
217 #endif
218 #endif
219
220 int *
221 __h_errno(void) {
222         /* NULL param here means use the default config file. */
223         struct net_data *net_data = net_data_init(NULL);
224         if (net_data && net_data->res)
225                 return (&net_data->res->res_h_errno);
226 #if !(__GLIBC__ > 2 || __GLIBC__ == 2 &&  __GLIBC_MINOR__ >= 3)
227         return(&_res.res_h_errno);
228 #else
229         return (&h_errno);
230 #endif
231 }
232
233 void
234 __h_errno_set(struct __res_state *res, int err) {
235
236
237 #if (__GLIBC__ > 2 || __GLIBC__ == 2 &&  __GLIBC_MINOR__ >= 3)
238         res->res_h_errno = err;
239 #else
240         h_errno = res->res_h_errno = err;
241 #endif
242 }
243
244 #endif /*__BIND_NOSTATIC*/
245
246 /*! \file */