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