1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 #pragma ident "%Z%%M% %I% %E% SMI"
28
29 /*
30 * gethostent.c
31 *
32 * In order to avoid duplicating libresolv code here, and since libresolv.so.2
33 * provides res_-equivalents of the getXbyY and {set,get}Xent, lets call
34 * re_gethostbyaddr() and so on from this file. Among other things, this
35 * should help us avoid problems like the one described in bug 1264386,
36 * where the internal getanswer() acquired new functionality in BIND 4.9.3,
37 * but the local copy of getanswer() in this file wasn't updated, so that new
38 * functionality wasn't available to the name service switch.
39 */
40
41 #define gethostbyaddr res_gethostbyaddr
42 #define gethostbyname res_gethostbyname
43 #define gethostbyname2 res_gethostbyname2
44 #define sethostent res_sethostent
45 #define endhostent res_endhostent
46
47 #include "dns_common.h"
48
49 extern char *inet_ntoa(struct in_addr in);
50
51 struct hostent *_gethostbyname(int *h_errnop, const char *name);
52 static struct hostent *_gethostbyaddr(int *h_errnop, const char *addr,
53 int len, int type);
54 struct hostent *_nss_dns_gethostbyname2(int *h_errnop, const char *name);
55
56 #pragma weak res_gethostbyname
57 #pragma weak res_gethostbyname2
58 #pragma weak res_gethostbyaddr
59 #pragma weak res_sethostent
60 #pragma weak res_endhostent
61
62 nss_backend_t *_nss_dns_constr(dns_backend_op_t ops[], int n_ops);
63 nss_status_t __nss_dns_getbyaddr(dns_backend_ptr_t, void *);
64
65 typedef union {
66 long al;
67 char ac;
68 } align;
69
70 /*
71 * Internet Name Domain Server (DNS) only implementation.
72 */
73 static struct hostent *
_gethostbyaddr(int * h_errnop,const char * addr,int len,int type)74 _gethostbyaddr(int *h_errnop, const char *addr, int len, int type)
75 {
76 struct hostent *hp;
77
78 hp = gethostbyaddr(addr, len, type);
79 *h_errnop = *get_h_errno();
80 return (hp);
81 }
82
83 struct hostent *
_nss_dns_gethostbyname2(int * h_errnop,const char * name)84 _nss_dns_gethostbyname2(int *h_errnop, const char *name)
85 {
86 struct hostent *hp;
87
88 hp = gethostbyname2(name, AF_INET6);
89 *h_errnop = *get_h_errno();
90 return (hp);
91 }
92
93 struct hostent *
_gethostbyname(int * h_errnop,const char * name)94 _gethostbyname(int *h_errnop, const char *name)
95 {
96 struct hostent *hp;
97
98 hp = gethostbyname(name);
99 *h_errnop = *get_h_errno();
100 return (hp);
101 }
102
103 static void
_sethostent(errp,stayopen)104 _sethostent(errp, stayopen)
105 nss_status_t *errp;
106 int stayopen;
107 {
108 int ret;
109
110 ret = sethostent(stayopen);
111 if (ret == 0)
112 *errp = NSS_SUCCESS;
113 else
114 *errp = NSS_UNAVAIL;
115 }
116
117 static void
_endhostent(errp)118 _endhostent(errp)
119 nss_status_t *errp;
120 {
121 int ret;
122
123 ret = endhostent();
124 if (ret == 0)
125 *errp = NSS_SUCCESS;
126 else
127 *errp = NSS_UNAVAIL;
128 }
129
130
131 /*ARGSUSED*/
132 static nss_status_t
getbyname(be,a)133 getbyname(be, a)
134 dns_backend_ptr_t be;
135 void *a;
136 {
137 struct hostent *he;
138 nss_XbyY_args_t *argp = (nss_XbyY_args_t *)a;
139 int ret, mt_disabled;
140 int old_retry;
141 sigset_t oldmask;
142
143 switch_resolver_setup(&mt_disabled, &oldmask, &old_retry);
144
145 he = _gethostbyname(&argp->h_errno, argp->key.name);
146 if (he != NULL) {
147 if (argp->buf.result == NULL) {
148 /*
149 * if asked to return data in string,
150 * convert the hostent structure into
151 * string data
152 */
153 ret = ent2str(he, a, AF_INET);
154 if (ret == NSS_STR_PARSE_SUCCESS)
155 argp->returnval = argp->buf.buffer;
156 } else {
157 ret = ent2result(he, a, AF_INET);
158 if (ret == NSS_STR_PARSE_SUCCESS)
159 argp->returnval = argp->buf.result;
160 }
161
162 if (ret != NSS_STR_PARSE_SUCCESS) {
163 argp->h_errno = HOST_NOT_FOUND;
164 if (ret == NSS_STR_PARSE_ERANGE) {
165 argp->erange = 1;
166 }
167 }
168 }
169
170 switch_resolver_reset(mt_disabled, oldmask, old_retry);
171
172 return (_herrno2nss(argp->h_errno));
173 }
174
175
176
177 /*ARGSUSED*/
178 static nss_status_t
getbyaddr(be,a)179 getbyaddr(be, a)
180 dns_backend_ptr_t be;
181 void *a;
182 {
183 return (__nss_dns_getbyaddr(be, a));
184 }
185
186
187 /*
188 * Exposing a DNS backend specific interface so that it doesn't conflict
189 * with other getbyaddr() routines from other switch backends.
190 */
191 /*ARGSUSED*/
192 nss_status_t
__nss_dns_getbyaddr(be,a)193 __nss_dns_getbyaddr(be, a)
194 dns_backend_ptr_t be;
195 void *a;
196 {
197 struct hostent *he;
198 nss_XbyY_args_t *argp = (nss_XbyY_args_t *)a;
199 int ret, mt_disabled;
200 struct in_addr unmapv4;
201 sigset_t oldmask;
202 int af, addrlen;
203 void *addrp;
204 int old_retry;
205
206 switch_resolver_setup(&mt_disabled, &oldmask, &old_retry);
207
208 /* LINTED: E_BAD_PTR_CAST_ALIGN */
209 if (IN6_IS_ADDR_V4MAPPED((struct in6_addr *)argp->key.hostaddr.addr)) {
210 addrp = &unmapv4;
211 addrlen = sizeof (unmapv4);
212 af = AF_INET;
213 (void) memcpy(addrp, &argp->key.hostaddr.addr[12], addrlen);
214 } else {
215 addrp = (void *)argp->key.hostaddr.addr;
216 addrlen = argp->key.hostaddr.len;
217 af = argp->key.hostaddr.type;
218 }
219 he = _gethostbyaddr(&argp->h_errno, addrp, addrlen, af);
220
221 if (he != NULL) {
222 /*
223 * if asked to return data in string, convert
224 * the hostent structure into string data
225 */
226 if (argp->buf.result == NULL)
227 ret = ent2str(he, a, argp->key.hostaddr.type);
228 else
229 ret = ent2result(he, a, argp->key.hostaddr.type);
230
231 if (ret == NSS_STR_PARSE_SUCCESS) {
232 if (argp->buf.result == NULL)
233 argp->returnval = argp->buf.buffer;
234 else
235 argp->returnval = argp->buf.result;
236 } else {
237 argp->h_errno = HOST_NOT_FOUND;
238 if (ret == NSS_STR_PARSE_ERANGE)
239 argp->erange = 1;
240 }
241 }
242
243 switch_resolver_reset(mt_disabled, oldmask, old_retry);
244
245 return (_herrno2nss(argp->h_errno));
246 }
247
248
249 /*ARGSUSED*/
250 static nss_status_t
_nss_dns_getent(be,args)251 _nss_dns_getent(be, args)
252 dns_backend_ptr_t be;
253 void *args;
254 {
255 return (NSS_UNAVAIL);
256 }
257
258
259 /*ARGSUSED*/
260 static nss_status_t
_nss_dns_setent(be,dummy)261 _nss_dns_setent(be, dummy)
262 dns_backend_ptr_t be;
263 void *dummy;
264 {
265 nss_status_t errp;
266
267 sigset_t oldmask, newmask;
268 int mt_disabled = 1;
269
270 /*
271 * Try to enable MT; if not, we have to single-thread libresolv
272 * access
273 */
274 if (enable_mt == 0 || (mt_disabled = (*enable_mt)()) != 0) {
275 (void) sigfillset(&newmask);
276 (void) thr_sigsetmask(SIG_SETMASK, &newmask, &oldmask);
277 (void) mutex_lock(&one_lane);
278 }
279
280 _sethostent(&errp, 1);
281
282 if (mt_disabled) {
283 (void) mutex_unlock(&one_lane);
284 (void) thr_sigsetmask(SIG_SETMASK, &oldmask, NULL);
285 } else {
286 (void) (*disable_mt)();
287 }
288
289 return (errp);
290 }
291
292
293 /*ARGSUSED*/
294 static nss_status_t
_nss_dns_endent(be,dummy)295 _nss_dns_endent(be, dummy)
296 dns_backend_ptr_t be;
297 void *dummy;
298 {
299 nss_status_t errp;
300
301 sigset_t oldmask, newmask;
302 int mt_disabled = 1;
303
304 /*
305 * Try to enable MT; if not, we have to single-thread libresolv
306 * access
307 */
308 if (enable_mt == 0 || (mt_disabled = (*enable_mt)()) != 0) {
309 (void) sigfillset(&newmask);
310 (void) thr_sigsetmask(SIG_SETMASK, &newmask, &oldmask);
311 (void) mutex_lock(&one_lane);
312 }
313
314 _endhostent(&errp);
315
316 if (mt_disabled) {
317 (void) mutex_unlock(&one_lane);
318 (void) thr_sigsetmask(SIG_SETMASK, &oldmask, NULL);
319 } else {
320 (void) (*disable_mt)();
321 }
322
323 return (errp);
324 }
325
326
327 /*ARGSUSED*/
328 static nss_status_t
_nss_dns_destr(be,dummy)329 _nss_dns_destr(be, dummy)
330 dns_backend_ptr_t be;
331 void *dummy;
332 {
333 nss_status_t errp;
334
335 if (be != 0) {
336 /* === Should change to invoke ops[ENDENT] ? */
337 sigset_t oldmask, newmask;
338 int mt_disabled = 1;
339
340 if (enable_mt == 0 || (mt_disabled = (*enable_mt)()) != 0) {
341 (void) sigfillset(&newmask);
342 (void) thr_sigsetmask(SIG_SETMASK, &newmask, &oldmask);
343 (void) mutex_lock(&one_lane);
344 }
345
346 _endhostent(&errp);
347
348 if (mt_disabled) {
349 (void) mutex_unlock(&one_lane);
350 (void) thr_sigsetmask(SIG_SETMASK, &oldmask, NULL);
351 } else {
352 (void) (*disable_mt)();
353 }
354
355 free(be);
356 }
357 return (NSS_SUCCESS); /* In case anyone is dumb enough to check */
358 }
359
360
361 static dns_backend_op_t host_ops[] = {
362 _nss_dns_destr,
363 _nss_dns_endent,
364 _nss_dns_setent,
365 _nss_dns_getent,
366 getbyname,
367 getbyaddr,
368 };
369
370 /*ARGSUSED*/
371 nss_backend_t *
_nss_dns_hosts_constr(dummy1,dummy2,dummy3)372 _nss_dns_hosts_constr(dummy1, dummy2, dummy3)
373 const char *dummy1, *dummy2, *dummy3;
374 {
375 return (_nss_dns_constr(host_ops,
376 sizeof (host_ops) / sizeof (host_ops[0])));
377 }
378
379 /*
380 * optional NSS2 packed backend gethostsbyname with ttl
381 * entry point.
382 *
383 * Returns:
384 * NSS_SUCCESS - successful
385 * NSS_NOTFOUND - successful but nothing found
386 * NSS_ERROR - fallback to NSS backend lookup mode
387 * If successful, buffer will be filled with valid data
388 *
389 */
390
391 /*ARGSUSED*/
392 nss_status_t
_nss_get_dns_hosts_name(dns_backend_ptr_t * be,void ** bufp,size_t * sizep)393 _nss_get_dns_hosts_name(dns_backend_ptr_t *be, void **bufp, size_t *sizep)
394 {
395 return (_nss_dns_gethost_withttl(*bufp, *sizep, 0));
396 }
397