xref: /freebsd/lib/libc/net/getnetnamadr.c (revision 6671366a55357f11c18837b10d53f8884e7a1251)
11363f04cSPaul Traina /*-
2d915a14eSPedro F. Giffuni  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3d915a14eSPedro F. Giffuni  *
41363f04cSPaul Traina  * Copyright (c) 1994, Garrett Wollman
51363f04cSPaul Traina  *
61363f04cSPaul Traina  * Redistribution and use in source and binary forms, with or without
71363f04cSPaul Traina  * modification, are permitted provided that the following conditions
81363f04cSPaul Traina  * are met:
91363f04cSPaul Traina  * 1. Redistributions of source code must retain the above copyright
101363f04cSPaul Traina  *    notice, this list of conditions and the following disclaimer.
111363f04cSPaul Traina  * 2. Redistributions in binary form must reproduce the above copyright
121363f04cSPaul Traina  *    notice, this list of conditions and the following disclaimer in the
131363f04cSPaul Traina  *    documentation and/or other materials provided with the distribution.
141363f04cSPaul Traina  *
151363f04cSPaul Traina  * THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS ``AS IS'' AND
161363f04cSPaul Traina  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
171363f04cSPaul Traina  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
181363f04cSPaul Traina  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
191363f04cSPaul Traina  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
201363f04cSPaul Traina  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
211363f04cSPaul Traina  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
221363f04cSPaul Traina  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
231363f04cSPaul Traina  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
241363f04cSPaul Traina  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
251363f04cSPaul Traina  * SUCH DAMAGE.
261363f04cSPaul Traina  */
271363f04cSPaul Traina 
28333fc21eSDavid E. O'Brien #include <sys/cdefs.h>
29333fc21eSDavid E. O'Brien __FBSDID("$FreeBSD$");
301363f04cSPaul Traina 
31c5774e2dSJacques Vidrine #include "namespace.h"
32a2a77501SHajimu UMEMOTO #include "reentrant.h"
331363f04cSPaul Traina #include <sys/param.h>
341363f04cSPaul Traina #include <sys/socket.h>
351363f04cSPaul Traina #include <netinet/in.h>
361363f04cSPaul Traina #include <arpa/inet.h>
371363f04cSPaul Traina #include <netdb.h>
381363f04cSPaul Traina #include <stdio.h>
391363f04cSPaul Traina #include <ctype.h>
40d3ac2b30SHajimu UMEMOTO #include <errno.h>
41a2a77501SHajimu UMEMOTO #include <stdlib.h>
421363f04cSPaul Traina #include <string.h>
43248aee62SJacques Vidrine #include <stdarg.h>
44248aee62SJacques Vidrine #include <nsswitch.h>
45c5774e2dSJacques Vidrine #include "un-namespace.h"
46bcb131aaSHajimu UMEMOTO #include "netdb_private.h"
4706a99fe3SHajimu UMEMOTO #ifdef NS_CACHING
4806a99fe3SHajimu UMEMOTO #include "nscache.h"
4906a99fe3SHajimu UMEMOTO #endif
501363f04cSPaul Traina 
5132223c1bSPedro F. Giffuni /* Network lookup order if nsswitch.conf is broken or nonexistent */
52248aee62SJacques Vidrine static const ns_src default_src[] = {
53248aee62SJacques Vidrine 	{ NSSRC_FILES, NS_SUCCESS },
54248aee62SJacques Vidrine 	{ NSSRC_DNS, NS_SUCCESS },
55248aee62SJacques Vidrine 	{ 0 }
561363f04cSPaul Traina };
571363f04cSPaul Traina 
58d3ac2b30SHajimu UMEMOTO NETDB_THREAD_ALLOC(netent_data)
59d3ac2b30SHajimu UMEMOTO NETDB_THREAD_ALLOC(netdata)
60d3ac2b30SHajimu UMEMOTO 
6106a99fe3SHajimu UMEMOTO #ifdef NS_CACHING
6206a99fe3SHajimu UMEMOTO static int
6306a99fe3SHajimu UMEMOTO net_id_func(char *buffer, size_t *buffer_size, va_list ap, void *cache_mdata)
6406a99fe3SHajimu UMEMOTO {
6506a99fe3SHajimu UMEMOTO 	char *name;
6606a99fe3SHajimu UMEMOTO 	uint32_t net;
6706a99fe3SHajimu UMEMOTO 	int type;
6806a99fe3SHajimu UMEMOTO 
6906a99fe3SHajimu UMEMOTO 	size_t desired_size, size;
7006a99fe3SHajimu UMEMOTO 	enum nss_lookup_type lookup_type;
7106a99fe3SHajimu UMEMOTO 	int res = NS_UNAVAIL;
7206a99fe3SHajimu UMEMOTO 
73*6671366aSBrooks Davis 	lookup_type = (enum nss_lookup_type)(uintptr_t)cache_mdata;
7406a99fe3SHajimu UMEMOTO 	switch (lookup_type) {
7506a99fe3SHajimu UMEMOTO 	case nss_lt_name:
7606a99fe3SHajimu UMEMOTO 		name = va_arg(ap, char *);
7706a99fe3SHajimu UMEMOTO 
7806a99fe3SHajimu UMEMOTO 		size = strlen(name);
7906a99fe3SHajimu UMEMOTO 		desired_size = sizeof(enum nss_lookup_type) + size + 1;
8006a99fe3SHajimu UMEMOTO 		if (desired_size > *buffer_size) {
8106a99fe3SHajimu UMEMOTO 			res = NS_RETURN;
8206a99fe3SHajimu UMEMOTO 			goto fin;
8306a99fe3SHajimu UMEMOTO 		}
8406a99fe3SHajimu UMEMOTO 
8506a99fe3SHajimu UMEMOTO 		memcpy(buffer, &lookup_type, sizeof(enum nss_lookup_type));
8606a99fe3SHajimu UMEMOTO 		memcpy(buffer + sizeof(enum nss_lookup_type), name, size + 1);
8706a99fe3SHajimu UMEMOTO 
8806a99fe3SHajimu UMEMOTO 		res = NS_SUCCESS;
8906a99fe3SHajimu UMEMOTO 		break;
9006a99fe3SHajimu UMEMOTO 	case nss_lt_id:
9106a99fe3SHajimu UMEMOTO 		net = va_arg(ap, uint32_t);
9206a99fe3SHajimu UMEMOTO 		type = va_arg(ap, int);
9306a99fe3SHajimu UMEMOTO 
9406a99fe3SHajimu UMEMOTO 		desired_size = sizeof(enum nss_lookup_type) +
9506a99fe3SHajimu UMEMOTO 		    sizeof(uint32_t) + sizeof(int);
9606a99fe3SHajimu UMEMOTO 		if (desired_size > *buffer_size) {
9706a99fe3SHajimu UMEMOTO 			res = NS_RETURN;
9806a99fe3SHajimu UMEMOTO 			goto fin;
9906a99fe3SHajimu UMEMOTO 		}
10006a99fe3SHajimu UMEMOTO 
10106a99fe3SHajimu UMEMOTO 		memcpy(buffer, &lookup_type, sizeof(enum nss_lookup_type));
10206a99fe3SHajimu UMEMOTO 		memcpy(buffer + sizeof(enum nss_lookup_type), &net,
10306a99fe3SHajimu UMEMOTO 		    sizeof(uint32_t));
10406a99fe3SHajimu UMEMOTO 		memcpy(buffer + sizeof(enum nss_lookup_type) + sizeof(uint32_t),
10506a99fe3SHajimu UMEMOTO 		    &type, sizeof(int));
10606a99fe3SHajimu UMEMOTO 
10706a99fe3SHajimu UMEMOTO 		res = NS_SUCCESS;
10806a99fe3SHajimu UMEMOTO 		break;
10906a99fe3SHajimu UMEMOTO 	default:
11006a99fe3SHajimu UMEMOTO 		/* should be unreachable */
11106a99fe3SHajimu UMEMOTO 		return (NS_UNAVAIL);
11206a99fe3SHajimu UMEMOTO 	}
11306a99fe3SHajimu UMEMOTO 
11406a99fe3SHajimu UMEMOTO fin:
11506a99fe3SHajimu UMEMOTO 	*buffer_size = desired_size;
11606a99fe3SHajimu UMEMOTO 	return (res);
11706a99fe3SHajimu UMEMOTO }
11806a99fe3SHajimu UMEMOTO 
11906a99fe3SHajimu UMEMOTO 
12006a99fe3SHajimu UMEMOTO static int
12106a99fe3SHajimu UMEMOTO net_marshal_func(char *buffer, size_t *buffer_size, void *retval, va_list ap,
12206a99fe3SHajimu UMEMOTO     void *cache_mdata)
12306a99fe3SHajimu UMEMOTO {
12406a99fe3SHajimu UMEMOTO 	char *name;
12506a99fe3SHajimu UMEMOTO 	uint32_t net;
12606a99fe3SHajimu UMEMOTO 	int type;
12706a99fe3SHajimu UMEMOTO 	struct netent *ne;
12806a99fe3SHajimu UMEMOTO 	char *orig_buf;
12906a99fe3SHajimu UMEMOTO 	size_t orig_buf_size;
13006a99fe3SHajimu UMEMOTO 
13106a99fe3SHajimu UMEMOTO 	struct netent new_ne;
13206a99fe3SHajimu UMEMOTO 	size_t desired_size, size, aliases_size;
13306a99fe3SHajimu UMEMOTO 	char *p;
13406a99fe3SHajimu UMEMOTO 	char **alias;
13506a99fe3SHajimu UMEMOTO 
136*6671366aSBrooks Davis 	switch ((enum nss_lookup_type)(uintptr_t)cache_mdata) {
13706a99fe3SHajimu UMEMOTO 	case nss_lt_name:
13806a99fe3SHajimu UMEMOTO 		name = va_arg(ap, char *);
13906a99fe3SHajimu UMEMOTO 		break;
14006a99fe3SHajimu UMEMOTO 	case nss_lt_id:
14106a99fe3SHajimu UMEMOTO 		net = va_arg(ap, uint32_t);
14206a99fe3SHajimu UMEMOTO 		type = va_arg(ap, int);
14306a99fe3SHajimu UMEMOTO 	break;
14406a99fe3SHajimu UMEMOTO 	case nss_lt_all:
14506a99fe3SHajimu UMEMOTO 		break;
14606a99fe3SHajimu UMEMOTO 	default:
14706a99fe3SHajimu UMEMOTO 		/* should be unreachable */
14806a99fe3SHajimu UMEMOTO 		return (NS_UNAVAIL);
14906a99fe3SHajimu UMEMOTO 	}
15006a99fe3SHajimu UMEMOTO 
15106a99fe3SHajimu UMEMOTO 	ne = va_arg(ap, struct netent *);
15206a99fe3SHajimu UMEMOTO 	orig_buf = va_arg(ap, char *);
15306a99fe3SHajimu UMEMOTO 	orig_buf_size = va_arg(ap, size_t);
15406a99fe3SHajimu UMEMOTO 
15506a99fe3SHajimu UMEMOTO 	desired_size = _ALIGNBYTES + sizeof(struct netent) + sizeof(char *);
15606a99fe3SHajimu UMEMOTO 	if (ne->n_name != NULL)
15706a99fe3SHajimu UMEMOTO 		desired_size += strlen(ne->n_name) + 1;
15806a99fe3SHajimu UMEMOTO 
15906a99fe3SHajimu UMEMOTO 	if (ne->n_aliases != NULL) {
16006a99fe3SHajimu UMEMOTO 		aliases_size = 0;
16106a99fe3SHajimu UMEMOTO 		for (alias = ne->n_aliases; *alias; ++alias) {
16206a99fe3SHajimu UMEMOTO 			desired_size += strlen(*alias) + 1;
16306a99fe3SHajimu UMEMOTO 			++aliases_size;
16406a99fe3SHajimu UMEMOTO 		}
16506a99fe3SHajimu UMEMOTO 
16606a99fe3SHajimu UMEMOTO 		desired_size += _ALIGNBYTES +
16706a99fe3SHajimu UMEMOTO 		    (aliases_size + 1) * sizeof(char *);
16806a99fe3SHajimu UMEMOTO 	}
16906a99fe3SHajimu UMEMOTO 
17006a99fe3SHajimu UMEMOTO 	if (*buffer_size < desired_size) {
17106a99fe3SHajimu UMEMOTO 		/* this assignment is here for future use */
17206a99fe3SHajimu UMEMOTO 		*buffer_size = desired_size;
17306a99fe3SHajimu UMEMOTO 		return (NS_RETURN);
17406a99fe3SHajimu UMEMOTO 	}
17506a99fe3SHajimu UMEMOTO 
17606a99fe3SHajimu UMEMOTO 	memcpy(&new_ne, ne, sizeof(struct netent));
17706a99fe3SHajimu UMEMOTO 
17806a99fe3SHajimu UMEMOTO 	*buffer_size = desired_size;
17906a99fe3SHajimu UMEMOTO 	memset(buffer, 0, desired_size);
18006a99fe3SHajimu UMEMOTO 	p = buffer + sizeof(struct netent) + sizeof(char *);
18106a99fe3SHajimu UMEMOTO 	memcpy(buffer + sizeof(struct netent), &p, sizeof(char *));
18206a99fe3SHajimu UMEMOTO 	p = (char *)_ALIGN(p);
18306a99fe3SHajimu UMEMOTO 
18406a99fe3SHajimu UMEMOTO 	if (new_ne.n_name != NULL) {
18506a99fe3SHajimu UMEMOTO 		size = strlen(new_ne.n_name);
18606a99fe3SHajimu UMEMOTO 		memcpy(p, new_ne.n_name, size);
18706a99fe3SHajimu UMEMOTO 		new_ne.n_name = p;
18806a99fe3SHajimu UMEMOTO 		p += size + 1;
18906a99fe3SHajimu UMEMOTO 	}
19006a99fe3SHajimu UMEMOTO 
19106a99fe3SHajimu UMEMOTO 	if (new_ne.n_aliases != NULL) {
19206a99fe3SHajimu UMEMOTO 		p = (char *)_ALIGN(p);
19306a99fe3SHajimu UMEMOTO 		memcpy(p, new_ne.n_aliases, sizeof(char *) * aliases_size);
19406a99fe3SHajimu UMEMOTO 		new_ne.n_aliases = (char **)p;
19506a99fe3SHajimu UMEMOTO 		p += sizeof(char *) * (aliases_size + 1);
19606a99fe3SHajimu UMEMOTO 
19706a99fe3SHajimu UMEMOTO 		for (alias = new_ne.n_aliases; *alias; ++alias) {
19806a99fe3SHajimu UMEMOTO 			size = strlen(*alias);
19906a99fe3SHajimu UMEMOTO 			memcpy(p, *alias, size);
20006a99fe3SHajimu UMEMOTO 			*alias = p;
20106a99fe3SHajimu UMEMOTO 			p += size + 1;
20206a99fe3SHajimu UMEMOTO 		}
20306a99fe3SHajimu UMEMOTO 	}
20406a99fe3SHajimu UMEMOTO 
20506a99fe3SHajimu UMEMOTO 	memcpy(buffer, &new_ne, sizeof(struct netent));
20606a99fe3SHajimu UMEMOTO 	return (NS_SUCCESS);
20706a99fe3SHajimu UMEMOTO }
20806a99fe3SHajimu UMEMOTO 
20906a99fe3SHajimu UMEMOTO static int
21006a99fe3SHajimu UMEMOTO net_unmarshal_func(char *buffer, size_t buffer_size, void *retval, va_list ap,
21106a99fe3SHajimu UMEMOTO     void *cache_mdata)
21206a99fe3SHajimu UMEMOTO {
21306a99fe3SHajimu UMEMOTO 	char *name;
21406a99fe3SHajimu UMEMOTO 	uint32_t net;
21506a99fe3SHajimu UMEMOTO 	int type;
21606a99fe3SHajimu UMEMOTO 	struct netent *ne;
21706a99fe3SHajimu UMEMOTO 	char *orig_buf;
21806a99fe3SHajimu UMEMOTO 	size_t orig_buf_size;
21906a99fe3SHajimu UMEMOTO 	int *ret_errno;
22006a99fe3SHajimu UMEMOTO 
22106a99fe3SHajimu UMEMOTO 	char *p;
22206a99fe3SHajimu UMEMOTO 	char **alias;
22306a99fe3SHajimu UMEMOTO 
224*6671366aSBrooks Davis 	switch ((enum nss_lookup_type)(uintptr_t)cache_mdata) {
22506a99fe3SHajimu UMEMOTO 	case nss_lt_name:
22606a99fe3SHajimu UMEMOTO 		name = va_arg(ap, char *);
22706a99fe3SHajimu UMEMOTO 		break;
22806a99fe3SHajimu UMEMOTO 	case nss_lt_id:
22906a99fe3SHajimu UMEMOTO 		net = va_arg(ap, uint32_t);
23006a99fe3SHajimu UMEMOTO 		type = va_arg(ap, int);
23106a99fe3SHajimu UMEMOTO 		break;
23206a99fe3SHajimu UMEMOTO 	case nss_lt_all:
23306a99fe3SHajimu UMEMOTO 		break;
23406a99fe3SHajimu UMEMOTO 	default:
23506a99fe3SHajimu UMEMOTO 		/* should be unreachable */
23606a99fe3SHajimu UMEMOTO 		return (NS_UNAVAIL);
23706a99fe3SHajimu UMEMOTO 	}
23806a99fe3SHajimu UMEMOTO 
23906a99fe3SHajimu UMEMOTO 	ne = va_arg(ap, struct netent *);
24006a99fe3SHajimu UMEMOTO 	orig_buf = va_arg(ap, char *);
24106a99fe3SHajimu UMEMOTO 	orig_buf_size = va_arg(ap, size_t);
24206a99fe3SHajimu UMEMOTO 	ret_errno = va_arg(ap, int *);
24306a99fe3SHajimu UMEMOTO 
24406a99fe3SHajimu UMEMOTO 	if (orig_buf_size <
24506a99fe3SHajimu UMEMOTO 	    buffer_size - sizeof(struct netent) - sizeof(char *)) {
24606a99fe3SHajimu UMEMOTO 		*ret_errno = ERANGE;
24706a99fe3SHajimu UMEMOTO 		return (NS_RETURN);
24806a99fe3SHajimu UMEMOTO 	}
24906a99fe3SHajimu UMEMOTO 
25006a99fe3SHajimu UMEMOTO 	memcpy(ne, buffer, sizeof(struct netent));
25106a99fe3SHajimu UMEMOTO 	memcpy(&p, buffer + sizeof(struct netent), sizeof(char *));
25206a99fe3SHajimu UMEMOTO 
25306a99fe3SHajimu UMEMOTO 	orig_buf = (char *)_ALIGN(orig_buf);
25406a99fe3SHajimu UMEMOTO 	memcpy(orig_buf, buffer + sizeof(struct netent) + sizeof(char *) +
25506a99fe3SHajimu UMEMOTO 	    _ALIGN(p) - (size_t)p,
25606a99fe3SHajimu UMEMOTO 	    buffer_size - sizeof(struct netent) - sizeof(char *) -
25706a99fe3SHajimu UMEMOTO 	    _ALIGN(p) + (size_t)p);
25806a99fe3SHajimu UMEMOTO 	p = (char *)_ALIGN(p);
25906a99fe3SHajimu UMEMOTO 
26006a99fe3SHajimu UMEMOTO 	NS_APPLY_OFFSET(ne->n_name, orig_buf, p, char *);
26106a99fe3SHajimu UMEMOTO 	if (ne->n_aliases != NULL) {
26206a99fe3SHajimu UMEMOTO 		NS_APPLY_OFFSET(ne->n_aliases, orig_buf, p, char **);
26306a99fe3SHajimu UMEMOTO 
26406a99fe3SHajimu UMEMOTO 		for (alias = ne->n_aliases; *alias; ++alias)
26506a99fe3SHajimu UMEMOTO 			NS_APPLY_OFFSET(*alias, orig_buf, p, char *);
26606a99fe3SHajimu UMEMOTO 	}
26706a99fe3SHajimu UMEMOTO 
26806a99fe3SHajimu UMEMOTO 	if (retval != NULL)
26906a99fe3SHajimu UMEMOTO 		*((struct netent **)retval) = ne;
27006a99fe3SHajimu UMEMOTO 
27106a99fe3SHajimu UMEMOTO 	return (NS_SUCCESS);
27206a99fe3SHajimu UMEMOTO }
27306a99fe3SHajimu UMEMOTO #endif /* NS_CACHING */
27406a99fe3SHajimu UMEMOTO 
275d3ac2b30SHajimu UMEMOTO static void
276d3ac2b30SHajimu UMEMOTO netent_data_free(void *ptr)
277d3ac2b30SHajimu UMEMOTO {
278d3ac2b30SHajimu UMEMOTO 	struct netent_data *ned = ptr;
279d3ac2b30SHajimu UMEMOTO 
280d3ac2b30SHajimu UMEMOTO 	if (ned == NULL)
281d3ac2b30SHajimu UMEMOTO 		return;
282d3ac2b30SHajimu UMEMOTO 	ned->stayopen = 0;
283d3ac2b30SHajimu UMEMOTO 	_endnethtent(ned);
284d3ac2b30SHajimu UMEMOTO 	free(ned);
285d3ac2b30SHajimu UMEMOTO }
286a2a77501SHajimu UMEMOTO 
287a2a77501SHajimu UMEMOTO static void
288a2a77501SHajimu UMEMOTO netdata_free(void *ptr)
2891363f04cSPaul Traina {
290d3ac2b30SHajimu UMEMOTO 	free(ptr);
291a2a77501SHajimu UMEMOTO }
292a2a77501SHajimu UMEMOTO 
293a2a77501SHajimu UMEMOTO int
294d3ac2b30SHajimu UMEMOTO __copy_netent(struct netent *ne, struct netent *nptr, char *buf, size_t buflen)
295a2a77501SHajimu UMEMOTO {
296d3ac2b30SHajimu UMEMOTO 	char *cp;
297d3ac2b30SHajimu UMEMOTO 	int i, n;
298d3ac2b30SHajimu UMEMOTO 	int numptr, len;
2991363f04cSPaul Traina 
300d3ac2b30SHajimu UMEMOTO 	/* Find out the amount of space required to store the answer. */
301d3ac2b30SHajimu UMEMOTO 	numptr = 1; /* NULL ptr */
302d3ac2b30SHajimu UMEMOTO 	len = (char *)ALIGN(buf) - buf;
303d3ac2b30SHajimu UMEMOTO 	for (i = 0; ne->n_aliases[i]; i++, numptr++) {
304d3ac2b30SHajimu UMEMOTO 		len += strlen(ne->n_aliases[i]) + 1;
305d3ac2b30SHajimu UMEMOTO 	}
306d3ac2b30SHajimu UMEMOTO 	len += strlen(ne->n_name) + 1;
307d3ac2b30SHajimu UMEMOTO 	len += numptr * sizeof(char*);
308d3ac2b30SHajimu UMEMOTO 
309d3ac2b30SHajimu UMEMOTO 	if (len > (int)buflen) {
310d3ac2b30SHajimu UMEMOTO 		errno = ERANGE;
311d3ac2b30SHajimu UMEMOTO 		return (-1);
312d3ac2b30SHajimu UMEMOTO 	}
313d3ac2b30SHajimu UMEMOTO 
314d3ac2b30SHajimu UMEMOTO 	/* copy net value and type */
315d3ac2b30SHajimu UMEMOTO 	nptr->n_addrtype = ne->n_addrtype;
316d3ac2b30SHajimu UMEMOTO 	nptr->n_net = ne->n_net;
317d3ac2b30SHajimu UMEMOTO 
318d3ac2b30SHajimu UMEMOTO 	cp = (char *)ALIGN(buf) + numptr * sizeof(char *);
319d3ac2b30SHajimu UMEMOTO 
320d3ac2b30SHajimu UMEMOTO 	/* copy official name */
321d3ac2b30SHajimu UMEMOTO 	n = strlen(ne->n_name) + 1;
322d3ac2b30SHajimu UMEMOTO 	strcpy(cp, ne->n_name);
323d3ac2b30SHajimu UMEMOTO 	nptr->n_name = cp;
324d3ac2b30SHajimu UMEMOTO 	cp += n;
325d3ac2b30SHajimu UMEMOTO 
326d3ac2b30SHajimu UMEMOTO 	/* copy aliases */
327d3ac2b30SHajimu UMEMOTO 	nptr->n_aliases = (char **)ALIGN(buf);
328d3ac2b30SHajimu UMEMOTO 	for (i = 0 ; ne->n_aliases[i]; i++) {
329d3ac2b30SHajimu UMEMOTO 		n = strlen(ne->n_aliases[i]) + 1;
330d3ac2b30SHajimu UMEMOTO 		strcpy(cp, ne->n_aliases[i]);
331d3ac2b30SHajimu UMEMOTO 		nptr->n_aliases[i] = cp;
332d3ac2b30SHajimu UMEMOTO 		cp += n;
333d3ac2b30SHajimu UMEMOTO 	}
334d3ac2b30SHajimu UMEMOTO 	nptr->n_aliases[i] = NULL;
335d3ac2b30SHajimu UMEMOTO 
336d3ac2b30SHajimu UMEMOTO 	return (0);
337d3ac2b30SHajimu UMEMOTO }
338d3ac2b30SHajimu UMEMOTO 
339d3ac2b30SHajimu UMEMOTO int
340d3ac2b30SHajimu UMEMOTO getnetbyname_r(const char *name, struct netent *ne, char *buffer,
341d3ac2b30SHajimu UMEMOTO     size_t buflen, struct netent **result, int *h_errorp)
342d3ac2b30SHajimu UMEMOTO {
34306a99fe3SHajimu UMEMOTO #ifdef NS_CACHING
34406a99fe3SHajimu UMEMOTO 	static const nss_cache_info cache_info =
34506a99fe3SHajimu UMEMOTO     		NS_COMMON_CACHE_INFO_INITIALIZER(
34606a99fe3SHajimu UMEMOTO 		networks, (void *)nss_lt_name,
34706a99fe3SHajimu UMEMOTO 		net_id_func, net_marshal_func, net_unmarshal_func);
34806a99fe3SHajimu UMEMOTO #endif
349248aee62SJacques Vidrine 	static const ns_dtab dtab[] = {
350248aee62SJacques Vidrine 		NS_FILES_CB(_ht_getnetbyname, NULL)
351248aee62SJacques Vidrine 		{ NSSRC_DNS, _dns_getnetbyname, NULL },
352248aee62SJacques Vidrine 		NS_NIS_CB(_nis_getnetbyname, NULL) /* force -DHESIOD */
35306a99fe3SHajimu UMEMOTO #ifdef NS_CACHING
35406a99fe3SHajimu UMEMOTO 		NS_CACHE_CB(&cache_info)
35506a99fe3SHajimu UMEMOTO #endif
356248aee62SJacques Vidrine 		{ 0 }
357248aee62SJacques Vidrine 	};
358225edeacSHajimu UMEMOTO 	int rval, ret_errno = 0;
359248aee62SJacques Vidrine 
360d3ac2b30SHajimu UMEMOTO 	rval = _nsdispatch((void *)result, dtab, NSDB_NETWORKS,
361d3ac2b30SHajimu UMEMOTO 	    "getnetbyname_r", default_src, name, ne, buffer, buflen,
362d3ac2b30SHajimu UMEMOTO 	    &ret_errno, h_errorp);
363248aee62SJacques Vidrine 
364225edeacSHajimu UMEMOTO 	if (rval != NS_SUCCESS) {
365225edeacSHajimu UMEMOTO 		errno = ret_errno;
366225edeacSHajimu UMEMOTO 		return ((ret_errno != 0) ? ret_errno : -1);
367225edeacSHajimu UMEMOTO 	}
368225edeacSHajimu UMEMOTO 	return (0);
3691363f04cSPaul Traina }
3701363f04cSPaul Traina 
371a2a77501SHajimu UMEMOTO int
372d3ac2b30SHajimu UMEMOTO getnetbyaddr_r(uint32_t addr, int af, struct netent *ne, char *buffer,
373d3ac2b30SHajimu UMEMOTO     size_t buflen, struct netent **result, int *h_errorp)
3741363f04cSPaul Traina {
37506a99fe3SHajimu UMEMOTO #ifdef NS_CACHING
37606a99fe3SHajimu UMEMOTO 	static const nss_cache_info cache_info =
37706a99fe3SHajimu UMEMOTO     		NS_COMMON_CACHE_INFO_INITIALIZER(
37806a99fe3SHajimu UMEMOTO 		networks, (void *)nss_lt_id,
37906a99fe3SHajimu UMEMOTO 		net_id_func, net_marshal_func, net_unmarshal_func);
38006a99fe3SHajimu UMEMOTO #endif
381248aee62SJacques Vidrine 	static const ns_dtab dtab[] = {
382248aee62SJacques Vidrine 		NS_FILES_CB(_ht_getnetbyaddr, NULL)
383248aee62SJacques Vidrine 		{ NSSRC_DNS, _dns_getnetbyaddr, NULL },
384248aee62SJacques Vidrine 		NS_NIS_CB(_nis_getnetbyaddr, NULL) /* force -DHESIOD */
38506a99fe3SHajimu UMEMOTO #ifdef NS_CACHING
38606a99fe3SHajimu UMEMOTO 		NS_CACHE_CB(&cache_info)
38706a99fe3SHajimu UMEMOTO #endif
388248aee62SJacques Vidrine 		{ 0 }
389248aee62SJacques Vidrine 	};
390225edeacSHajimu UMEMOTO 	int rval, ret_errno = 0;
3911363f04cSPaul Traina 
392d3ac2b30SHajimu UMEMOTO 	rval = _nsdispatch((void *)result, dtab, NSDB_NETWORKS,
393d3ac2b30SHajimu UMEMOTO 	    "getnetbyaddr_r", default_src, addr, af, ne, buffer, buflen,
394d3ac2b30SHajimu UMEMOTO 	    &ret_errno, h_errorp);
395248aee62SJacques Vidrine 
396225edeacSHajimu UMEMOTO 	if (rval != NS_SUCCESS) {
397225edeacSHajimu UMEMOTO 		errno = ret_errno;
398225edeacSHajimu UMEMOTO 		return ((ret_errno != 0) ? ret_errno : -1);
399225edeacSHajimu UMEMOTO 	}
400225edeacSHajimu UMEMOTO 	return (0);
4011363f04cSPaul Traina }
402a2a77501SHajimu UMEMOTO 
403a2a77501SHajimu UMEMOTO struct netent *
404a2a77501SHajimu UMEMOTO getnetbyname(const char *name)
405a2a77501SHajimu UMEMOTO {
406a2a77501SHajimu UMEMOTO 	struct netdata *nd;
407d3ac2b30SHajimu UMEMOTO 	struct netent *rval;
408d3ac2b30SHajimu UMEMOTO 	int ret_h_errno;
409a2a77501SHajimu UMEMOTO 
410a2a77501SHajimu UMEMOTO 	if ((nd = __netdata_init()) == NULL)
411d3ac2b30SHajimu UMEMOTO 		return (NULL);
412d3ac2b30SHajimu UMEMOTO 	if (getnetbyname_r(name, &nd->net, nd->data, sizeof(nd->data), &rval,
413d3ac2b30SHajimu UMEMOTO 	    &ret_h_errno) != 0)
414d3ac2b30SHajimu UMEMOTO 		return (NULL);
415d3ac2b30SHajimu UMEMOTO 	return (rval);
416a2a77501SHajimu UMEMOTO }
417a2a77501SHajimu UMEMOTO 
418a2a77501SHajimu UMEMOTO struct netent *
419036ae3ddSHajimu UMEMOTO getnetbyaddr(uint32_t addr, int af)
420a2a77501SHajimu UMEMOTO {
421a2a77501SHajimu UMEMOTO 	struct netdata *nd;
422d3ac2b30SHajimu UMEMOTO 	struct netent *rval;
423d3ac2b30SHajimu UMEMOTO 	int ret_h_errno;
424a2a77501SHajimu UMEMOTO 
425a2a77501SHajimu UMEMOTO 	if ((nd = __netdata_init()) == NULL)
426d3ac2b30SHajimu UMEMOTO 		return (NULL);
427d3ac2b30SHajimu UMEMOTO 	if (getnetbyaddr_r(addr, af, &nd->net, nd->data, sizeof(nd->data),
428d3ac2b30SHajimu UMEMOTO 	    &rval, &ret_h_errno) != 0)
429d3ac2b30SHajimu UMEMOTO 		return (NULL);
430d3ac2b30SHajimu UMEMOTO 	return (rval);
431a2a77501SHajimu UMEMOTO }
432a2a77501SHajimu UMEMOTO 
433a2a77501SHajimu UMEMOTO void
434a2a77501SHajimu UMEMOTO setnetent(int stayopen)
435a2a77501SHajimu UMEMOTO {
436d3ac2b30SHajimu UMEMOTO 	struct netent_data *ned;
437a2a77501SHajimu UMEMOTO 
438d3ac2b30SHajimu UMEMOTO 	if ((ned = __netent_data_init()) == NULL)
439a2a77501SHajimu UMEMOTO 		return;
440d3ac2b30SHajimu UMEMOTO 	_setnethtent(stayopen, ned);
441d3ac2b30SHajimu UMEMOTO 	_setnetdnsent(stayopen);
442a2a77501SHajimu UMEMOTO }
443a2a77501SHajimu UMEMOTO 
444a2a77501SHajimu UMEMOTO void
445a2a77501SHajimu UMEMOTO endnetent(void)
446a2a77501SHajimu UMEMOTO {
447d3ac2b30SHajimu UMEMOTO 	struct netent_data *ned;
448a2a77501SHajimu UMEMOTO 
449d3ac2b30SHajimu UMEMOTO 	if ((ned = __netent_data_init()) == NULL)
450a2a77501SHajimu UMEMOTO 		return;
451d3ac2b30SHajimu UMEMOTO 	_endnethtent(ned);
452d3ac2b30SHajimu UMEMOTO 	_endnetdnsent();
453a2a77501SHajimu UMEMOTO }
454