2 * Copyright (c) 1994, Garrett Wollman
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
7 * 1. Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution.
13 * THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS ``AS IS'' AND
14 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
16 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
17 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
18 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
19 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
20 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
21 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
22 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25 * $FreeBSD: src/lib/libc/net/getnetnamadr.c,v 1.23 2006/04/28 12:03:35 ume Exp $
28 #include "namespace.h"
29 #include "reentrant.h"
30 #include <sys/param.h>
31 #include <sys/socket.h>
32 #include <netinet/in.h>
33 #include <arpa/inet.h>
42 #include "un-namespace.h"
43 #include "netdb_private.h"
48 extern int _ht_getnetbyname(void *, void *, va_list);
49 extern int _dns_getnetbyname(void *, void *, va_list);
50 extern int _nis_getnetbyname(void *, void *, va_list);
51 extern int _ht_getnetbyaddr(void *, void *, va_list);
52 extern int _dns_getnetbyaddr(void *, void *, va_list);
53 extern int _nis_getnetbyaddr(void *, void *, va_list);
55 /* Network lookup order if nsswitch.conf is broken or nonexistant */
56 static const ns_src default_src[] = {
57 { NSSRC_FILES, NS_SUCCESS },
58 { NSSRC_DNS, NS_SUCCESS },
62 NETDB_THREAD_ALLOC(netent_data)
63 NETDB_THREAD_ALLOC(netdata)
67 net_id_func(char *buffer, size_t *buffer_size, va_list ap, void *cache_mdata)
73 size_t desired_size, size;
74 enum nss_lookup_type lookup_type;
77 lookup_type = (enum nss_lookup_type)cache_mdata;
78 switch (lookup_type) {
80 name = va_arg(ap, char *);
83 desired_size = sizeof(enum nss_lookup_type) + size + 1;
84 if (desired_size > *buffer_size) {
89 memcpy(buffer, &lookup_type, sizeof(enum nss_lookup_type));
90 memcpy(buffer + sizeof(enum nss_lookup_type), name, size + 1);
95 net = va_arg(ap, uint32_t);
96 type = va_arg(ap, int);
98 desired_size = sizeof(enum nss_lookup_type) +
99 sizeof(uint32_t) + sizeof(int);
100 if (desired_size > *buffer_size) {
105 memcpy(buffer, &lookup_type, sizeof(enum nss_lookup_type));
106 memcpy(buffer + sizeof(enum nss_lookup_type), &net,
108 memcpy(buffer + sizeof(enum nss_lookup_type) + sizeof(uint32_t),
114 /* should be unreachable */
119 *buffer_size = desired_size;
125 net_marshal_func(char *buffer, size_t *buffer_size, void *retval __unused,
126 va_list ap, void *cache_mdata)
133 size_t orig_buf_size;
135 struct netent new_ne;
136 size_t desired_size, size, aliases_size;
140 switch ((enum nss_lookup_type)cache_mdata) {
142 name = va_arg(ap, char *);
145 net = va_arg(ap, uint32_t);
146 type = va_arg(ap, int);
151 /* should be unreachable */
155 ne = va_arg(ap, struct netent *);
156 orig_buf = va_arg(ap, char *);
157 orig_buf_size = va_arg(ap, size_t);
159 desired_size = _ALIGNBYTES + sizeof(struct netent) + sizeof(char *);
160 if (ne->n_name != NULL)
161 desired_size += strlen(ne->n_name) + 1;
163 if (ne->n_aliases != NULL) {
165 for (alias = ne->n_aliases; *alias; ++alias) {
166 desired_size += strlen(*alias) + 1;
170 desired_size += _ALIGNBYTES +
171 (aliases_size + 1) * sizeof(char *);
174 if (*buffer_size < desired_size) {
175 /* this assignment is here for future use */
176 *buffer_size = desired_size;
180 memcpy(&new_ne, ne, sizeof(struct netent));
182 *buffer_size = desired_size;
183 memset(buffer, 0, desired_size);
184 p = buffer + sizeof(struct netent) + sizeof(char *);
185 memcpy(buffer + sizeof(struct netent), &p, sizeof(char *));
186 p = (char *)_ALIGN(p);
188 if (new_ne.n_name != NULL) {
189 size = strlen(new_ne.n_name);
190 memcpy(p, new_ne.n_name, size);
195 if (new_ne.n_aliases != NULL) {
196 p = (char *)_ALIGN(p);
197 memcpy(p, new_ne.n_aliases, sizeof(char *) * aliases_size);
198 new_ne.n_aliases = (char **)p;
199 p += sizeof(char *) * (aliases_size + 1);
201 for (alias = new_ne.n_aliases; *alias; ++alias) {
202 size = strlen(*alias);
203 memcpy(p, *alias, size);
209 memcpy(buffer, &new_ne, sizeof(struct netent));
214 net_unmarshal_func(char *buffer, size_t buffer_size, void *retval, va_list ap,
222 size_t orig_buf_size;
228 switch ((enum nss_lookup_type)cache_mdata) {
230 name = va_arg(ap, char *);
233 net = va_arg(ap, uint32_t);
234 type = va_arg(ap, int);
239 /* should be unreachable */
243 ne = va_arg(ap, struct netent *);
244 orig_buf = va_arg(ap, char *);
245 orig_buf_size = va_arg(ap, size_t);
246 ret_errno = va_arg(ap, int *);
249 buffer_size - sizeof(struct netent) - sizeof(char *)) {
254 memcpy(ne, buffer, sizeof(struct netent));
255 memcpy(&p, buffer + sizeof(struct netent), sizeof(char *));
257 orig_buf = (char *)_ALIGN(orig_buf);
258 memcpy(orig_buf, buffer + sizeof(struct netent) + sizeof(char *) +
259 _ALIGN(p) - (size_t)p,
260 buffer_size - sizeof(struct netent) - sizeof(char *) -
261 _ALIGN(p) + (size_t)p);
262 p = (char *)_ALIGN(p);
264 NS_APPLY_OFFSET(ne->n_name, orig_buf, p, char *);
265 if (ne->n_aliases != NULL) {
266 NS_APPLY_OFFSET(ne->n_aliases, orig_buf, p, char **);
268 for (alias = ne->n_aliases; *alias; ++alias)
269 NS_APPLY_OFFSET(*alias, orig_buf, p, char *);
273 *((struct netent **)retval) = ne;
277 #endif /* NS_CACHING */
280 netent_data_free(void *ptr)
282 struct netent_data *ned = ptr;
292 netdata_free(void *ptr)
298 __copy_netent(struct netent *ne, struct netent *nptr, char *buf, size_t buflen)
304 /* Find out the amount of space required to store the answer. */
305 numptr = 1; /* NULL ptr */
306 len = (char *)ALIGN(buf) - buf;
307 for (i = 0; ne->n_aliases[i]; i++, numptr++) {
308 len += strlen(ne->n_aliases[i]) + 1;
310 len += strlen(ne->n_name) + 1;
311 len += numptr * sizeof(char*);
313 if (len > (int)buflen) {
318 /* copy net value and type */
319 nptr->n_addrtype = ne->n_addrtype;
320 nptr->n_net = ne->n_net;
322 cp = (char *)ALIGN(buf) + numptr * sizeof(char *);
324 /* copy official name */
325 n = strlen(ne->n_name) + 1;
326 strcpy(cp, ne->n_name);
331 nptr->n_aliases = (char **)ALIGN(buf);
332 for (i = 0 ; ne->n_aliases[i]; i++) {
333 n = strlen(ne->n_aliases[i]) + 1;
334 strcpy(cp, ne->n_aliases[i]);
335 nptr->n_aliases[i] = cp;
338 nptr->n_aliases[i] = NULL;
344 getnetbyname_r(const char *name, struct netent *ne, char *buffer,
345 size_t buflen, struct netent **result, int *h_errorp)
348 static const nss_cache_info cache_info =
349 NS_COMMON_CACHE_INFO_INITIALIZER(
350 networks, (void *)nss_lt_name,
351 net_id_func, net_marshal_func, net_unmarshal_func);
353 static const ns_dtab dtab[] = {
354 NS_FILES_CB(_ht_getnetbyname, NULL)
355 { NSSRC_DNS, _dns_getnetbyname, NULL },
356 NS_NIS_CB(_nis_getnetbyname, NULL) /* force -DHESIOD */
358 NS_CACHE_CB(&cache_info)
364 rval = _nsdispatch((void *)result, dtab, NSDB_NETWORKS,
365 "getnetbyname_r", default_src, name, ne, buffer, buflen,
366 &ret_errno, h_errorp);
368 return ((rval == NS_SUCCESS) ? 0 : -1);
372 getnetbyaddr_r(uint32_t addr, int af, struct netent *ne, char *buffer,
373 size_t buflen, struct netent **result, int *h_errorp)
376 static const nss_cache_info cache_info =
377 NS_COMMON_CACHE_INFO_INITIALIZER(
378 networks, (void *)nss_lt_id,
379 net_id_func, net_marshal_func, net_unmarshal_func);
381 static const ns_dtab dtab[] = {
382 NS_FILES_CB(_ht_getnetbyaddr, NULL)
383 { NSSRC_DNS, _dns_getnetbyaddr, NULL },
384 NS_NIS_CB(_nis_getnetbyaddr, NULL) /* force -DHESIOD */
386 NS_CACHE_CB(&cache_info)
392 rval = _nsdispatch((void *)result, dtab, NSDB_NETWORKS,
393 "getnetbyaddr_r", default_src, addr, af, ne, buffer, buflen,
394 &ret_errno, h_errorp);
396 return ((rval == NS_SUCCESS) ? 0 : -1);
400 getnetbyname(const char *name)
406 if ((nd = __netdata_init()) == NULL)
408 if (getnetbyname_r(name, &nd->net, nd->data, sizeof(nd->data), &rval,
415 getnetbyaddr(uint32_t addr, int af)
421 if ((nd = __netdata_init()) == NULL)
423 if (getnetbyaddr_r(addr, af, &nd->net, nd->data, sizeof(nd->data),
424 &rval, &ret_h_errno) != 0)
430 setnetent(int stayopen)
432 struct netent_data *ned;
434 if ((ned = __netent_data_init()) == NULL)
436 _setnethtent(stayopen, ned);
437 _setnetdnsent(stayopen);
443 struct netent_data *ned;
445 if ((ned = __netent_data_init()) == NULL)