1 /* 2 * Copyright (c) 2004 by Internet Systems Consortium, Inc. ("ISC") 3 * Copyright (c) 1998-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(LIBC_SCCS) && !defined(lint) 19 static const char rcsid[] = "$Id: getnetent_r.c,v 1.6 2005/09/03 12:41:38 marka Exp $"; 20 #endif /* LIBC_SCCS and not lint */ 21 22 #include <port_before.h> 23 #if !defined(_REENTRANT) || !defined(DO_PTHREADS) 24 static int getnetent_r_not_required = 0; 25 #else 26 #include <errno.h> 27 #include <string.h> 28 #include <stdio.h> 29 #include <sys/types.h> 30 #include <netinet/in.h> 31 #include <netdb.h> 32 #include <sys/param.h> 33 #include <port_after.h> 34 35 #ifdef NET_R_RETURN 36 37 static NET_R_RETURN 38 copy_netent(struct netent *, struct netent *, NET_R_COPY_ARGS); 39 40 NET_R_RETURN 41 getnetbyname_r(const char *name, struct netent *nptr, NET_R_ARGS) { 42 struct netent *ne = getnetbyname(name); 43 #ifdef NET_R_SETANSWER 44 int n = 0; 45 46 if (ne == NULL || (n = copy_netent(ne, nptr, NET_R_COPY)) != 0) 47 *answerp = NULL; 48 else 49 *answerp = ne; 50 if (ne == NULL) 51 *h_errnop = h_errno; 52 return (n); 53 #else 54 if (ne == NULL) 55 return (NET_R_BAD); 56 57 return (copy_netent(ne, nptr, NET_R_COPY)); 58 #endif 59 } 60 61 #ifndef GETNETBYADDR_ADDR_T 62 #define GETNETBYADDR_ADDR_T long 63 #endif 64 NET_R_RETURN 65 getnetbyaddr_r(GETNETBYADDR_ADDR_T addr, int type, struct netent *nptr, NET_R_ARGS) { 66 struct netent *ne = getnetbyaddr(addr, type); 67 #ifdef NET_R_SETANSWER 68 int n = 0; 69 70 if (ne == NULL || (n = copy_netent(ne, nptr, NET_R_COPY)) != 0) 71 *answerp = NULL; 72 else 73 *answerp = ne; 74 if (ne == NULL) 75 *h_errnop = h_errno; 76 return (n); 77 #else 78 79 if (ne == NULL) 80 return (NET_R_BAD); 81 82 return (copy_netent(ne, nptr, NET_R_COPY)); 83 #endif 84 } 85 86 /*% 87 * These assume a single context is in operation per thread. 88 * If this is not the case we will need to call irs directly 89 * rather than through the base functions. 90 */ 91 92 NET_R_RETURN 93 getnetent_r(struct netent *nptr, NET_R_ARGS) { 94 struct netent *ne = getnetent(); 95 #ifdef NET_R_SETANSWER 96 int n = 0; 97 98 if (ne == NULL || (n = copy_netent(ne, nptr, NET_R_COPY)) != 0) 99 *answerp = NULL; 100 else 101 *answerp = ne; 102 if (ne == NULL) 103 *h_errnop = h_errno; 104 return (n); 105 #else 106 107 if (ne == NULL) 108 return (NET_R_BAD); 109 110 return (copy_netent(ne, nptr, NET_R_COPY)); 111 #endif 112 } 113 114 NET_R_SET_RETURN 115 #ifdef NET_R_ENT_ARGS 116 setnetent_r(int stay_open, NET_R_ENT_ARGS) 117 #else 118 setnetent_r(int stay_open) 119 #endif 120 { 121 #ifdef NET_R_ENT_ARGS 122 UNUSED(ndptr); 123 #endif 124 setnetent(stay_open); 125 #ifdef NET_R_SET_RESULT 126 return (NET_R_SET_RESULT); 127 #endif 128 } 129 130 NET_R_END_RETURN 131 #ifdef NET_R_ENT_ARGS 132 endnetent_r(NET_R_ENT_ARGS) 133 #else 134 endnetent_r() 135 #endif 136 { 137 #ifdef NET_R_ENT_ARGS 138 UNUSED(ndptr); 139 #endif 140 endnetent(); 141 NET_R_END_RESULT(NET_R_OK); 142 } 143 144 /* Private */ 145 146 #ifndef NETENT_DATA 147 static NET_R_RETURN 148 copy_netent(struct netent *ne, struct netent *nptr, NET_R_COPY_ARGS) { 149 char *cp; 150 int i, n; 151 int numptr, len; 152 153 /* Find out the amount of space required to store the answer. */ 154 numptr = 1; /*%< NULL ptr */ 155 len = (char *)ALIGN(buf) - buf; 156 for (i = 0; ne->n_aliases[i]; i++, numptr++) { 157 len += strlen(ne->n_aliases[i]) + 1; 158 } 159 len += strlen(ne->n_name) + 1; 160 len += numptr * sizeof(char*); 161 162 if (len > (int)buflen) { 163 errno = ERANGE; 164 return (NET_R_BAD); 165 } 166 167 /* copy net value and type */ 168 nptr->n_addrtype = ne->n_addrtype; 169 nptr->n_net = ne->n_net; 170 171 cp = (char *)ALIGN(buf) + numptr * sizeof(char *); 172 173 /* copy official name */ 174 n = strlen(ne->n_name) + 1; 175 strcpy(cp, ne->n_name); 176 nptr->n_name = cp; 177 cp += n; 178 179 /* copy aliases */ 180 nptr->n_aliases = (char **)ALIGN(buf); 181 for (i = 0 ; ne->n_aliases[i]; i++) { 182 n = strlen(ne->n_aliases[i]) + 1; 183 strcpy(cp, ne->n_aliases[i]); 184 nptr->n_aliases[i] = cp; 185 cp += n; 186 } 187 nptr->n_aliases[i] = NULL; 188 189 return (NET_R_OK); 190 } 191 #else /* !NETENT_DATA */ 192 static int 193 copy_netent(struct netent *ne, struct netent *nptr, NET_R_COPY_ARGS) { 194 char *cp, *eob; 195 int i, n; 196 197 /* copy net value and type */ 198 nptr->n_addrtype = ne->n_addrtype; 199 nptr->n_net = ne->n_net; 200 201 /* copy official name */ 202 cp = ndptr->line; 203 eob = ndptr->line + sizeof(ndptr->line); 204 if ((n = strlen(ne->n_name) + 1) < (eob - cp)) { 205 strcpy(cp, ne->n_name); 206 nptr->n_name = cp; 207 cp += n; 208 } else { 209 return (-1); 210 } 211 212 /* copy aliases */ 213 i = 0; 214 nptr->n_aliases = ndptr->net_aliases; 215 while (ne->n_aliases[i] && i < (_MAXALIASES-1)) { 216 if ((n = strlen(ne->n_aliases[i]) + 1) < (eob - cp)) { 217 strcpy(cp, ne->n_aliases[i]); 218 nptr->n_aliases[i] = cp; 219 cp += n; 220 } else { 221 break; 222 } 223 i++; 224 } 225 nptr->n_aliases[i] = NULL; 226 227 return (NET_R_OK); 228 } 229 #endif /* !NETENT_DATA */ 230 #else /* NET_R_RETURN */ 231 static int getnetent_r_unknown_system = 0; 232 #endif /* NET_R_RETURN */ 233 #endif /* !defined(_REENTRANT) || !defined(DO_PTHREADS) */ 234 /*! \file */ 235