diff options
| author | cmetz <> | 1999-06-23 22:38:52 +0000 |
|---|---|---|
| committer | cmetz <> | 1999-06-23 22:38:52 +0000 |
| commit | db859794a581f4638e6accbed6235a18bc8f74b3 (patch) | |
| tree | 85b56cd6123a97a0a71c1f443b406754eca70df1 /src/lib/libc | |
| parent | bb8e4a1e2b3fa93fc2def309cb510f1734df4d77 (diff) | |
| download | openbsd-db859794a581f4638e6accbed6235a18bc8f74b3.tar.gz openbsd-db859794a581f4638e6accbed6235a18bc8f74b3.tar.bz2 openbsd-db859794a581f4638e6accbed6235a18bc8f74b3.zip | |
Removed portability ifdefs.
Diffstat (limited to 'src/lib/libc')
| -rw-r--r-- | src/lib/libc/net/gai_strerror.c | 45 | ||||
| -rw-r--r-- | src/lib/libc/net/getaddrinfo.c | 576 | ||||
| -rw-r--r-- | src/lib/libc/net/getnameinfo.c | 345 |
3 files changed, 8 insertions, 958 deletions
diff --git a/src/lib/libc/net/gai_strerror.c b/src/lib/libc/net/gai_strerror.c index a758b7449b..37e0b55e8b 100644 --- a/src/lib/libc/net/gai_strerror.c +++ b/src/lib/libc/net/gai_strerror.c | |||
| @@ -30,33 +30,6 @@ | |||
| 30 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | 30 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
| 31 | * SUCH DAMAGE. | 31 | * SUCH DAMAGE. |
| 32 | * | 32 | * |
| 33 | * Redistribution and use in source and binary forms, with or without | ||
| 34 | * modification, are permitted provided that the following conditions | ||
| 35 | * are met: | ||
| 36 | * 1. Redistributions of source code must retain the above copyright | ||
| 37 | * notice, this list of conditions and the following disclaimer. | ||
| 38 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 39 | * notice, this list of conditions and the following disclaimer in the | ||
| 40 | * documentation and/or other materials provided with the distribution. | ||
| 41 | * 3. All advertising materials mentioning features or use of this software | ||
| 42 | * must display the following acknowledgement: | ||
| 43 | * This product includes software developed by Craig Metz and | ||
| 44 | * by other contributors. | ||
| 45 | * 4. Neither the name of the author nor the names of contributors | ||
| 46 | * may be used to endorse or promote products derived from this software | ||
| 47 | * without specific prior written permission. | ||
| 48 | * | ||
| 49 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
| 50 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 51 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
| 52 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
| 53 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
| 54 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
| 55 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 56 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
| 57 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
| 58 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
| 59 | * SUCH DAMAGE. | ||
| 60 | */ | 33 | */ |
| 61 | 34 | ||
| 62 | /* gai_strerror() v1.38 */ | 35 | /* gai_strerror() v1.38 */ |
| @@ -65,12 +38,6 @@ | |||
| 65 | #include <netdb.h> | 38 | #include <netdb.h> |
| 66 | #include <errno.h> | 39 | #include <errno.h> |
| 67 | 40 | ||
| 68 | #define THREAD_SAFE 0 | ||
| 69 | |||
| 70 | #if !THREAD_SAFE | ||
| 71 | static char buffer[256]; | ||
| 72 | #endif /* !THREAD_SAFE */ | ||
| 73 | |||
| 74 | char *gai_strerror(int errnum) | 41 | char *gai_strerror(int errnum) |
| 75 | { | 42 | { |
| 76 | switch(errnum) { | 43 | switch(errnum) { |
| @@ -97,20 +64,8 @@ char *gai_strerror(int errnum) | |||
| 97 | case EAI_MEMORY: | 64 | case EAI_MEMORY: |
| 98 | return "memory allocation failure"; | 65 | return "memory allocation failure"; |
| 99 | case EAI_SYSTEM: | 66 | case EAI_SYSTEM: |
| 100 | #if THREAD_SAFE | ||
| 101 | return "system error"; | 67 | return "system error"; |
| 102 | #else /* THREAD_SAFE */ | ||
| 103 | snprintf(buffer, sizeof(buffer)-1, "system error: %s(%d)", strerror(errno), errno); | ||
| 104 | buffer[sizeof(buffer)-1] = 0; | ||
| 105 | return buffer; | ||
| 106 | #endif /* THREAD_SAFE */ | ||
| 107 | default: | 68 | default: |
| 108 | #if THREAD_SAFE | ||
| 109 | return "unknown/invalid error"; | 69 | return "unknown/invalid error"; |
| 110 | #else /* THREAD_SAFE */ | ||
| 111 | snprintf(buffer, sizeof(buffer)-1, "unknown/invalid error %d", errnum); | ||
| 112 | buffer[sizeof(buffer)-1] = 0; | ||
| 113 | return buffer; | ||
| 114 | #endif /* THREAD_SAFE */ | ||
| 115 | }; | 70 | }; |
| 116 | }; | 71 | }; |
diff --git a/src/lib/libc/net/getaddrinfo.c b/src/lib/libc/net/getaddrinfo.c index a572dbcde0..0e33aa1368 100644 --- a/src/lib/libc/net/getaddrinfo.c +++ b/src/lib/libc/net/getaddrinfo.c | |||
| @@ -30,34 +30,6 @@ | |||
| 30 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | 30 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
| 31 | * SUCH DAMAGE. | 31 | * SUCH DAMAGE. |
| 32 | * | 32 | * |
| 33 | * Redistribution and use in source and binary forms, with or without | ||
| 34 | * modification, are permitted provided that the following conditions | ||
| 35 | * are met: | ||
| 36 | * 1. Redistributions of source code must retain the above copyright | ||
| 37 | * notice, this list of conditions and the following disclaimer. | ||
| 38 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 39 | * notice, this list of conditions and the following disclaimer in the | ||
| 40 | * documentation and/or other materials provided with the distribution. | ||
| 41 | * 3. All advertising materials mentioning features or use of this software | ||
| 42 | * must display the following acknowledgement: | ||
| 43 | * This product includes software developed by Craig Metz and | ||
| 44 | * by other contributors. | ||
| 45 | * 4. Neither the name of the author nor the names of contributors | ||
| 46 | * may be used to endorse or promote products derived from this software | ||
| 47 | * without specific prior written permission. | ||
| 48 | * | ||
| 49 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
| 50 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 51 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
| 52 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
| 53 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
| 54 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
| 55 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 56 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
| 57 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
| 58 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
| 59 | * SUCH DAMAGE. | ||
| 60 | * | ||
| 61 | */ | 33 | */ |
| 62 | 34 | ||
| 63 | /* getaddrinfo() v1.38 */ | 35 | /* getaddrinfo() v1.38 */ |
| @@ -69,74 +41,17 @@ | |||
| 69 | behavior and proposed changes). | 41 | behavior and proposed changes). |
| 70 | */ | 42 | */ |
| 71 | 43 | ||
| 72 | /* | ||
| 73 | Someone merged an earlier version of this code into the GNU libc and | ||
| 74 | added support for getservbyname_r and gethostbyname2_r. The support for | ||
| 75 | those functions in this version of the code was written using that work | ||
| 76 | as a reference. I may have improved on it, or I may have broken it. | ||
| 77 | */ | ||
| 78 | |||
| 79 | /* To do what POSIX says, even when it's broken, define: */ | ||
| 80 | /* #define BROKEN_LIKE_POSIX 1 */ | ||
| 81 | /* Note: real apps will break if you define this, while nothing other than a | ||
| 82 | conformance test suite should have a problem with it undefined. */ | ||
| 83 | |||
| 84 | /* If your C runtime library provides the POSIX p1003.1g D6.6 bit types | ||
| 85 | of the form u?int(16|32)_t, define: */ | ||
| 86 | /* #define HAVE_POSIX1G_TYPES 1 */ | ||
| 87 | /* Note: this implementation tries to guess what the correct values are for | ||
| 88 | your compiler+processor combination but might not always get it right. */ | ||
| 89 | |||
| 90 | /* To enable debugging support (REQUIRES NRL support library), define: */ | ||
| 91 | /* #define DEBUG 1 */ | ||
| 92 | |||
| 93 | #if FOR_GNULIBC | ||
| 94 | #define HAVE_POSIX1G_TYPES 1 | ||
| 95 | #define INET6 1 | ||
| 96 | #define LOCAL 1 | ||
| 97 | #define NETDB 1 | ||
| 98 | #undef RESOLVER | ||
| 99 | #undef HOSTTABLE | ||
| 100 | #undef DEBUG | ||
| 101 | #define HAVE_GETSERVBYNAME_R 1 | ||
| 102 | #define HAVE_GETHOSTBYNAME2_R 1 | ||
| 103 | #define getservbyname_r __getservbyname_r | ||
| 104 | #define gethostbyname2_r __gethostbyname2_r | ||
| 105 | #endif /* FOR_GNULIBC */ | ||
| 106 | |||
| 107 | #ifdef __OpenBSD__ | ||
| 108 | #define HAVE_POSIX1G_TYPES 1 | ||
| 109 | #define INET6 1 | ||
| 110 | #define LOCAL 1 | ||
| 111 | #define NETDB 1 | ||
| 112 | #define SALEN 1 | ||
| 113 | #undef RESOLVER | ||
| 114 | #undef HOSTTABLE | ||
| 115 | #undef DEBUG | ||
| 116 | #undef HAVE_GETSERVBYNAME_R | ||
| 117 | #undef HAVE_GETHOSTBYNAME2_R | ||
| 118 | #endif /* __OpenBSD__ */ | ||
| 119 | |||
| 120 | #include <sys/types.h> | 44 | #include <sys/types.h> |
| 121 | #include <stdlib.h> | 45 | #include <stdlib.h> |
| 122 | #include <unistd.h> | 46 | #include <unistd.h> |
| 123 | #include <sys/socket.h> | 47 | #include <sys/socket.h> |
| 124 | #include <string.h> | 48 | #include <string.h> |
| 125 | #if LOCAL | ||
| 126 | #include <stdio.h> | 49 | #include <stdio.h> |
| 127 | #include <sys/utsname.h> | 50 | #include <sys/utsname.h> |
| 128 | #include <sys/un.h> | 51 | #include <sys/un.h> |
| 129 | #endif /* LOCAL */ | ||
| 130 | #include <netinet/in.h> | 52 | #include <netinet/in.h> |
| 131 | #include <netdb.h> | 53 | #include <netdb.h> |
| 132 | #include <errno.h> | 54 | #include <errno.h> |
| 133 | #if RESOLVER | ||
| 134 | #include <arpa/nameser.h> | ||
| 135 | #include <resolv.h> | ||
| 136 | #endif /* RESOLVER */ | ||
| 137 | #if DEBUG | ||
| 138 | #include <syslog.h> | ||
| 139 | #endif /* DEBUG */ | ||
| 140 | 55 | ||
| 141 | #ifndef AF_LOCAL | 56 | #ifndef AF_LOCAL |
| 142 | #define AF_LOCAL AF_UNIX | 57 | #define AF_LOCAL AF_UNIX |
| @@ -148,47 +63,6 @@ | |||
| 148 | #define UNIX_PATH_MAX 108 | 63 | #define UNIX_PATH_MAX 108 |
| 149 | #endif /* UNIX_PATH_MAX */ | 64 | #endif /* UNIX_PATH_MAX */ |
| 150 | 65 | ||
| 151 | #if !HAVE_POSIX1G_TYPES | ||
| 152 | #if (~0UL) == 0xffffffff | ||
| 153 | #define uint8_t unsigned char | ||
| 154 | #define int16_t short | ||
| 155 | #define uint16_t unsigned short | ||
| 156 | #define int32_t long | ||
| 157 | #define uint32_t unsigned long | ||
| 158 | #else /* (~0UL) == 0xffffffff */ | ||
| 159 | #if (~0UL) == 0xffffffffffffffff | ||
| 160 | #define uint8_t unsigned char | ||
| 161 | #define int16_t short | ||
| 162 | #define uint16_t unsigned short | ||
| 163 | #define int32_t int | ||
| 164 | #define uint32_t unsigned int | ||
| 165 | #else /* (~0UL) == 0xffffffffffffffff */ | ||
| 166 | #error Neither 32 bit nor 64 bit word size detected. | ||
| 167 | #error You need to define the bit types manually. | ||
| 168 | #endif /* (~0UL) == 0xffffffffffffffff */ | ||
| 169 | #endif /* (~0UL) == 0xffffffff */ | ||
| 170 | #endif /* !HAVE_POSIX1G_TYPES */ | ||
| 171 | |||
| 172 | #if defined(INET6) && !defined(AF_INET6) | ||
| 173 | #error Without a definition of AF_INET6, this system cannot support IPv6 | ||
| 174 | #error addresses. | ||
| 175 | #endif /* defined(INET6) && !defined(AF_INET6) */ | ||
| 176 | |||
| 177 | #if INET6 | ||
| 178 | #ifndef T_AAAA | ||
| 179 | #define T_AAAA 28 | ||
| 180 | #endif /* T_AAAA */ | ||
| 181 | #endif /* INET6 */ | ||
| 182 | |||
| 183 | #if DEBUG | ||
| 184 | #if RESOLVER | ||
| 185 | #define DEBUG_MESSAGES (_res.options & RES_DEBUG) | ||
| 186 | #else /* RESOLVER */ | ||
| 187 | int __getaddrinfo_debug = 0; | ||
| 188 | #define DEBUG_MESSAGES (__getaddrinfo_debug) | ||
| 189 | #endif /* RESOLVER */ | ||
| 190 | #endif /* DEBUG */ | ||
| 191 | |||
| 192 | #define GAIH_OKIFUNSPEC 0x0100 | 66 | #define GAIH_OKIFUNSPEC 0x0100 |
| 193 | #define GAIH_EAI ~(GAIH_OKIFUNSPEC) | 67 | #define GAIH_EAI ~(GAIH_OKIFUNSPEC) |
| 194 | 68 | ||
| @@ -224,147 +98,21 @@ struct gaih_typeproto { | |||
| 224 | char *name; | 98 | char *name; |
| 225 | }; | 99 | }; |
| 226 | 100 | ||
| 227 | #if DEBUG | ||
| 228 | #define RETURN_ERROR(x) do { \ | 101 | #define RETURN_ERROR(x) do { \ |
| 229 | if (DEBUG_MESSAGES) \ | ||
| 230 | fprintf(stderr, "%s:%d: returning %s\n", __FILE__, __LINE__, #x); \ | ||
| 231 | rval = (x); \ | 102 | rval = (x); \ |
| 232 | goto ret; \ | 103 | goto ret; \ |
| 233 | } while(0) | 104 | } while(0) |
| 234 | #else /* DEBUG */ | ||
| 235 | #define RETURN_ERROR(x) do { \ | ||
| 236 | rval = (x); \ | ||
| 237 | goto ret; \ | ||
| 238 | } while(0) | ||
| 239 | #endif /* DEBUG */ | ||
| 240 | 105 | ||
| 241 | #if HOSTTABLE | 106 | static int netdb_lookup_addr(const char *name, int af, const struct addrinfo *req, struct gaih_addrtuple **pat) |
| 242 | static int hosttable_lookup_addr(const char *name, const struct addrinfo *req, struct gaih_addrtuple **pat) | ||
| 243 | { | ||
| 244 | FILE *f; | ||
| 245 | char buffer[1024]; | ||
| 246 | char *c, *c2; | ||
| 247 | int rval = 1; | ||
| 248 | char *prevcname = NULL; | ||
| 249 | struct gaih_addrtuple at; | ||
| 250 | |||
| 251 | if (!(f = fopen("/etc/hosts", "r"))) | ||
| 252 | RETURN_ERROR(-EAI_SYSTEM); | ||
| 253 | |||
| 254 | while(fgets(buffer, sizeof(buffer), f)) { | ||
| 255 | if (c = strchr(buffer, '#')) | ||
| 256 | *c = 0; | ||
| 257 | |||
| 258 | c = buffer; | ||
| 259 | while(*c && !isspace(*c)) c++; | ||
| 260 | if (!*c) | ||
| 261 | continue; | ||
| 262 | |||
| 263 | *(c++) = 0; | ||
| 264 | |||
| 265 | while(*c && isspace(*c)) c++; | ||
| 266 | if (!*c) | ||
| 267 | continue; | ||
| 268 | |||
| 269 | if (!(c2 = strstr(c, name))) | ||
| 270 | continue; | ||
| 271 | |||
| 272 | if (*(c2 - 1) && !isspace(*(c2 - 1))) | ||
| 273 | continue; | ||
| 274 | |||
| 275 | c2 += strlen(name); | ||
| 276 | if (*c2 && !isspace(*c2)) | ||
| 277 | continue; | ||
| 278 | |||
| 279 | c2 = c; | ||
| 280 | while(*c2 && !isspace(*c2)) c2++; | ||
| 281 | if (!*c2) | ||
| 282 | continue; | ||
| 283 | *c2 = 0; | ||
| 284 | |||
| 285 | memset(&at, 0, sizeof(struct gaih_addrtuple)); | ||
| 286 | |||
| 287 | if (!req->ai_family || (req->ai_family == AF_INET)) | ||
| 288 | if (inet_pton(AF_INET, buffer, (char *)&at.addr) > 0) { | ||
| 289 | at.family = AF_INET; | ||
| 290 | goto build; | ||
| 291 | }; | ||
| 292 | |||
| 293 | #if INET6 | ||
| 294 | if (!req->ai_family || (req->ai_family == AF_INET6)) | ||
| 295 | if (inet_pton(AF_INET6, buffer, (char *)&at.addr) > 0) { | ||
| 296 | at.family = AF_INET6; | ||
| 297 | goto build; | ||
| 298 | }; | ||
| 299 | #endif /* INET6 */ | ||
| 300 | |||
| 301 | continue; | ||
| 302 | |||
| 303 | build: | ||
| 304 | if (!(*pat = malloc(sizeof(struct gaih_addrtuple)))) | ||
| 305 | RETURN_ERROR(-EAI_MEMORY); | ||
| 306 | |||
| 307 | memcpy(*pat, &at, sizeof(struct gaih_addrtuple)); | ||
| 308 | |||
| 309 | if (req->ai_flags & AI_CANONNAME) | ||
| 310 | if (prevcname && !strcmp(prevcname, c)) | ||
| 311 | (*pat)->cname = prevcname; | ||
| 312 | else | ||
| 313 | prevcname = (*pat)->cname = strdup(c); | ||
| 314 | |||
| 315 | pat = &((*pat)->next); | ||
| 316 | |||
| 317 | rval = 0; | ||
| 318 | }; | ||
| 319 | |||
| 320 | ret: | ||
| 321 | if (f) | ||
| 322 | fclose(f); | ||
| 323 | return rval; | ||
| 324 | }; | ||
| 325 | #endif /* HOSTTABLE */ | ||
| 326 | |||
| 327 | #if NETDB | ||
| 328 | int netdb_lookup_addr(const char *name, int af, const struct addrinfo *req, struct gaih_addrtuple **pat) | ||
| 329 | { | 107 | { |
| 330 | int rval, herrno, i; | 108 | int rval, herrno, i; |
| 331 | char *prevcname = NULL; | 109 | char *prevcname = NULL; |
| 332 | struct hostent *h; | 110 | struct hostent *h; |
| 333 | 111 | ||
| 334 | #if HAVE_GETHOSTBYNAME2_R | ||
| 335 | void *buf; | ||
| 336 | int buflen = 1024; | ||
| 337 | struct hostent th; | ||
| 338 | int herrno, j; | ||
| 339 | |||
| 340 | do { | ||
| 341 | if (!(buf = malloc(buflen))) | ||
| 342 | RETURN_ERROR(-EAI_MEMORY); | ||
| 343 | |||
| 344 | if (!gethostbyname2_r(name, af, &th, buf, buflen, &h, &herrno)) | ||
| 345 | break; | ||
| 346 | |||
| 347 | free(buf); | ||
| 348 | buf = NULL; | ||
| 349 | |||
| 350 | if ((herrno == NETDB_INTERNAL) && (errno == ERANGE)) { | ||
| 351 | if (buflen >= 65536) | ||
| 352 | RETURN_ERROR(-EAI_MEMORY); | ||
| 353 | |||
| 354 | buflen = buflen << 1; | ||
| 355 | continue; | ||
| 356 | }; | ||
| 357 | } while(0); | ||
| 358 | #else /* HAVE_GETHOSTBYNAME2_R */ | ||
| 359 | h = gethostbyname2(name, af); | 112 | h = gethostbyname2(name, af); |
| 360 | herrno = h_errno; | 113 | herrno = h_errno; |
| 361 | #endif /* HAVE_GETHOSTBYNAME2_R */ | ||
| 362 | 114 | ||
| 363 | if (!h) { | 115 | if (!h) { |
| 364 | #if DEBUG | ||
| 365 | if (DEBUG_MESSAGES) | ||
| 366 | fprintf(stderr, "getaddrinfo: gethostbyname2 failed, h_errno=%d\n", herrno); | ||
| 367 | #endif /* DEBUG */ | ||
| 368 | switch(herrno) { | 116 | switch(herrno) { |
| 369 | case NETDB_INTERNAL: | 117 | case NETDB_INTERNAL: |
| 370 | RETURN_ERROR(-EAI_SYSTEM); | 118 | RETURN_ERROR(-EAI_SYSTEM); |
| @@ -394,11 +142,9 @@ int netdb_lookup_addr(const char *name, int af, const struct addrinfo *req, stru | |||
| 394 | case AF_INET: | 142 | case AF_INET: |
| 395 | memcpy((*pat)->addr, h->h_addr_list[i], sizeof(struct in_addr)); | 143 | memcpy((*pat)->addr, h->h_addr_list[i], sizeof(struct in_addr)); |
| 396 | break; | 144 | break; |
| 397 | #if INET6 | ||
| 398 | case AF_INET6: | 145 | case AF_INET6: |
| 399 | memcpy((*pat)->addr, h->h_addr_list[i], sizeof(struct in6_addr)); | 146 | memcpy((*pat)->addr, h->h_addr_list[i], sizeof(struct in6_addr)); |
| 400 | break; | 147 | break; |
| 401 | #endif /* INET6 */ | ||
| 402 | default: | 148 | default: |
| 403 | RETURN_ERROR(-EAI_FAIL); | 149 | RETURN_ERROR(-EAI_FAIL); |
| 404 | }; | 150 | }; |
| @@ -416,140 +162,9 @@ int netdb_lookup_addr(const char *name, int af, const struct addrinfo *req, stru | |||
| 416 | rval = 0; | 162 | rval = 0; |
| 417 | 163 | ||
| 418 | ret: | 164 | ret: |
| 419 | #if HAVE_GETHOSTBYNAME2_R | ||
| 420 | free(buf); | ||
| 421 | #endif /* HAVE_GETHOSTBYNAME2_R */ | ||
| 422 | return rval; | 165 | return rval; |
| 423 | }; | 166 | }; |
| 424 | #endif /* NETDB */ | ||
| 425 | |||
| 426 | #if RESOLVER | ||
| 427 | #define RRHEADER_SZ 10 | ||
| 428 | 167 | ||
| 429 | int resolver_lookup_addr(const char *name, int type, const struct addrinfo *req, struct gaih_addrtuple **pat) | ||
| 430 | { | ||
| 431 | int rval; | ||
| 432 | char answer[PACKETSZ]; | ||
| 433 | int answerlen; | ||
| 434 | char dn[MAXDNAME]; | ||
| 435 | char *prevcname = NULL; | ||
| 436 | void *p, *ep; | ||
| 437 | int answers, i, j; | ||
| 438 | uint16_t rtype, rclass; | ||
| 439 | |||
| 440 | if ((answerlen = res_search(name, C_IN, type, answer, sizeof(answer))) < 0) { | ||
| 441 | #if DEBUG | ||
| 442 | if (DEBUG_MESSAGES) | ||
| 443 | fprintf(stderr, "getaddrinfo: res_search failed, h_errno=%d\n", h_errno); | ||
| 444 | #endif /* DEBUG */ | ||
| 445 | switch(h_errno) { | ||
| 446 | case NETDB_INTERNAL: | ||
| 447 | RETURN_ERROR(-EAI_SYSTEM); | ||
| 448 | case HOST_NOT_FOUND: | ||
| 449 | RETURN_ERROR(1); | ||
| 450 | case TRY_AGAIN: | ||
| 451 | RETURN_ERROR(-EAI_AGAIN); | ||
| 452 | case NO_RECOVERY: | ||
| 453 | RETURN_ERROR(-EAI_FAIL); | ||
| 454 | case NO_DATA: | ||
| 455 | RETURN_ERROR(1); | ||
| 456 | default: | ||
| 457 | RETURN_ERROR(-EAI_FAIL); | ||
| 458 | }; | ||
| 459 | }; | ||
| 460 | |||
| 461 | p = answer; | ||
| 462 | ep = answer + answerlen; | ||
| 463 | |||
| 464 | if (answerlen < RRHEADER_SZ) | ||
| 465 | RETURN_ERROR(-EAI_FAIL); | ||
| 466 | |||
| 467 | { | ||
| 468 | HEADER *h = (HEADER *)p; | ||
| 469 | if (!h->qr || (h->opcode != QUERY) || (h->qdcount != htons(1)) || | ||
| 470 | !h->ancount) | ||
| 471 | RETURN_ERROR(-EAI_FAIL); | ||
| 472 | answers = ntohs(h->ancount); | ||
| 473 | }; | ||
| 474 | p += sizeof(HEADER); | ||
| 475 | |||
| 476 | if ((i = dn_expand(answer, ep, p, dn, sizeof(dn))) < 0) | ||
| 477 | RETURN_ERROR(-EAI_FAIL); | ||
| 478 | p += i; | ||
| 479 | |||
| 480 | if (p + 2*sizeof(uint16_t) >= ep) | ||
| 481 | RETURN_ERROR(-EAI_FAIL); | ||
| 482 | |||
| 483 | GETSHORT(rtype, p); | ||
| 484 | GETSHORT(rclass, p); | ||
| 485 | |||
| 486 | if ((rtype != type) || (rclass != C_IN)) | ||
| 487 | RETURN_ERROR(-EAI_FAIL); | ||
| 488 | |||
| 489 | while(answers--) { | ||
| 490 | if ((i = dn_expand(answer, ep, p, dn, sizeof(dn))) < 0) | ||
| 491 | RETURN_ERROR(-EAI_FAIL); | ||
| 492 | p += i; | ||
| 493 | |||
| 494 | if (p + RRHEADER_SZ >= ep) | ||
| 495 | RETURN_ERROR(-EAI_FAIL); | ||
| 496 | |||
| 497 | GETSHORT(rtype, p); | ||
| 498 | GETSHORT(rclass, p); | ||
| 499 | p += sizeof(uint32_t); | ||
| 500 | if (rclass != C_IN) | ||
| 501 | RETURN_ERROR(-EAI_FAIL); | ||
| 502 | GETSHORT(rclass, p); | ||
| 503 | i = rclass; | ||
| 504 | |||
| 505 | if (p + i > ep) | ||
| 506 | RETURN_ERROR(-EAI_FAIL); | ||
| 507 | |||
| 508 | if (rtype == type) { | ||
| 509 | while(*pat) | ||
| 510 | pat = &((*pat)->next); | ||
| 511 | |||
| 512 | if (!(*pat = malloc(sizeof(struct gaih_addrtuple)))) | ||
| 513 | RETURN_ERROR(-EAI_MEMORY); | ||
| 514 | |||
| 515 | memset(*pat, 0, sizeof(struct gaih_addrtuple)); | ||
| 516 | |||
| 517 | switch(type) { | ||
| 518 | case T_A: | ||
| 519 | if (i != sizeof(struct in_addr)) | ||
| 520 | RETURN_ERROR(-EAI_FAIL); | ||
| 521 | (*pat)->family = AF_INET; | ||
| 522 | break; | ||
| 523 | #if INET6 | ||
| 524 | case T_AAAA: | ||
| 525 | if (i != sizeof(struct in6_addr)) | ||
| 526 | RETURN_ERROR(-EAI_FAIL); | ||
| 527 | (*pat)->family = AF_INET6; | ||
| 528 | break; | ||
| 529 | #endif /* INET6 */ | ||
| 530 | default: | ||
| 531 | RETURN_ERROR(-EAI_FAIL); | ||
| 532 | }; | ||
| 533 | |||
| 534 | memcpy((*pat)->addr, p, i); | ||
| 535 | |||
| 536 | if (req->ai_flags & AI_CANONNAME) | ||
| 537 | if (prevcname && !strcmp(prevcname, dn)) | ||
| 538 | (*pat)->cname = prevcname; | ||
| 539 | else | ||
| 540 | prevcname = (*pat)->cname = strdup(dn); | ||
| 541 | }; | ||
| 542 | p += i; | ||
| 543 | }; | ||
| 544 | |||
| 545 | rval = 0; | ||
| 546 | |||
| 547 | ret: | ||
| 548 | return rval; | ||
| 549 | }; | ||
| 550 | #endif /* RESOLVER */ | ||
| 551 | |||
| 552 | #if LOCAL | ||
| 553 | static int gaih_local(const char *name, const struct gaih_service *service, | 168 | static int gaih_local(const char *name, const struct gaih_service *service, |
| 554 | const struct addrinfo *req, struct addrinfo **pai) | 169 | const struct addrinfo *req, struct addrinfo **pai) |
| 555 | { | 170 | { |
| @@ -574,9 +189,7 @@ static int gaih_local(const char *name, const struct gaih_service *service, | |||
| 574 | (*pai)->ai_protocol = req->ai_protocol; | 189 | (*pai)->ai_protocol = req->ai_protocol; |
| 575 | (*pai)->ai_addrlen = sizeof(struct sockaddr_un); | 190 | (*pai)->ai_addrlen = sizeof(struct sockaddr_un); |
| 576 | (*pai)->ai_addr = (void *)(*pai) + sizeof(struct addrinfo); | 191 | (*pai)->ai_addr = (void *)(*pai) + sizeof(struct addrinfo); |
| 577 | #if SALEN | ||
| 578 | ((struct sockaddr_un *)(*pai)->ai_addr)->sun_len = sizeof(struct sockaddr_un); | 192 | ((struct sockaddr_un *)(*pai)->ai_addr)->sun_len = sizeof(struct sockaddr_un); |
| 579 | #endif /* SALEN */ | ||
| 580 | ((struct sockaddr_un *)(*pai)->ai_addr)->sun_family = AF_LOCAL; | 193 | ((struct sockaddr_un *)(*pai)->ai_addr)->sun_family = AF_LOCAL; |
| 581 | memset(((struct sockaddr_un *)(*pai)->ai_addr)->sun_path, 0, UNIX_PATH_MAX); | 194 | memset(((struct sockaddr_un *)(*pai)->ai_addr)->sun_path, 0, UNIX_PATH_MAX); |
| 582 | if (service) { | 195 | if (service) { |
| @@ -610,7 +223,6 @@ static int gaih_local(const char *name, const struct gaih_service *service, | |||
| 610 | ret: | 223 | ret: |
| 611 | return rval; | 224 | return rval; |
| 612 | }; | 225 | }; |
| 613 | #endif /* LOCAL */ | ||
| 614 | 226 | ||
| 615 | static struct gaih_typeproto gaih_inet_typeproto[] = { | 227 | static struct gaih_typeproto gaih_inet_typeproto[] = { |
| 616 | { 0, 0, NULL }, | 228 | { 0, 0, NULL }, |
| @@ -623,34 +235,9 @@ static int gaih_inet_serv(char *servicename, struct gaih_typeproto *tp, struct g | |||
| 623 | { | 235 | { |
| 624 | int rval; | 236 | int rval; |
| 625 | struct servent *s; | 237 | struct servent *s; |
| 626 | #if HAVE_GETSERVBYNAME_R | ||
| 627 | int i; | ||
| 628 | void *buf; | ||
| 629 | int buflen = 1024; | ||
| 630 | struct servent ts; | ||
| 631 | 238 | ||
| 632 | do { | ||
| 633 | if (!(buf = malloc(buflen))) | ||
| 634 | RETURN_ERROR(-EAI_MEMORY); | ||
| 635 | |||
| 636 | if (!getservbyname_r(servicename, tp->name, &ts, buf, buflen, &s)) | ||
| 637 | break; | ||
| 638 | |||
| 639 | free(buf); | ||
| 640 | buf = NULL; | ||
| 641 | |||
| 642 | if (errno != ERANGE) | ||
| 643 | RETURN_ERROR(GAIH_OKIFUNSPEC | -EAI_SERVICE); | ||
| 644 | |||
| 645 | if (buflen >= 65536) | ||
| 646 | RETURN_ERROR(-EAI_MEMORY); | ||
| 647 | |||
| 648 | buflen = buflen << 1; | ||
| 649 | } while(1); | ||
| 650 | #else /* HAVE_GETSERVBYNAME_R */ | ||
| 651 | if (!(s = getservbyname(servicename, tp->name))) | 239 | if (!(s = getservbyname(servicename, tp->name))) |
| 652 | RETURN_ERROR(GAIH_OKIFUNSPEC | -EAI_SERVICE); | 240 | RETURN_ERROR(GAIH_OKIFUNSPEC | -EAI_SERVICE); |
| 653 | #endif /* HAVE_GETSERVBYNAME_R */ | ||
| 654 | 241 | ||
| 655 | if (!(*st = malloc(sizeof(struct gaih_servtuple)))) | 242 | if (!(*st = malloc(sizeof(struct gaih_servtuple)))) |
| 656 | RETURN_ERROR(-EAI_MEMORY); | 243 | RETURN_ERROR(-EAI_MEMORY); |
| @@ -663,10 +250,6 @@ static int gaih_inet_serv(char *servicename, struct gaih_typeproto *tp, struct g | |||
| 663 | rval = 0; | 250 | rval = 0; |
| 664 | 251 | ||
| 665 | ret: | 252 | ret: |
| 666 | #if HAVE_GETSERVBYNAME_R | ||
| 667 | if (buf) | ||
| 668 | free(buf); | ||
| 669 | #endif /* HAVE_GETSERVBYNAME_R */ | ||
| 670 | return rval; | 253 | return rval; |
| 671 | } | 254 | } |
| 672 | 255 | ||
| @@ -727,7 +310,6 @@ static int gaih_inet(const char *name, const struct gaih_service *service, | |||
| 727 | 310 | ||
| 728 | memset(at, 0, sizeof(struct gaih_addrtuple)); | 311 | memset(at, 0, sizeof(struct gaih_addrtuple)); |
| 729 | 312 | ||
| 730 | #if INET6 | ||
| 731 | if (req->ai_family) | 313 | if (req->ai_family) |
| 732 | at->family = req->ai_family; | 314 | at->family = req->ai_family; |
| 733 | else { | 315 | else { |
| @@ -739,9 +321,6 @@ static int gaih_inet(const char *name, const struct gaih_service *service, | |||
| 739 | memset(at->next, 0, sizeof(struct gaih_addrtuple)); | 321 | memset(at->next, 0, sizeof(struct gaih_addrtuple)); |
| 740 | at->next->family = AF_INET; | 322 | at->next->family = AF_INET; |
| 741 | }; | 323 | }; |
| 742 | #else /* INET6 */ | ||
| 743 | at->family = AF_INET; | ||
| 744 | #endif /* INET6 */ | ||
| 745 | 324 | ||
| 746 | goto build; | 325 | goto build; |
| 747 | }; | 326 | }; |
| @@ -760,7 +339,6 @@ static int gaih_inet(const char *name, const struct gaih_service *service, | |||
| 760 | }; | 339 | }; |
| 761 | }; | 340 | }; |
| 762 | 341 | ||
| 763 | #if INET6 | ||
| 764 | if (!req->ai_family || (req->ai_family == AF_INET6)) { | 342 | if (!req->ai_family || (req->ai_family == AF_INET6)) { |
| 765 | struct in6_addr in6_addr; | 343 | struct in6_addr in6_addr; |
| 766 | if (inet_pton(AF_INET6, name, &in6_addr) > 0) { | 344 | if (inet_pton(AF_INET6, name, &in6_addr) > 0) { |
| @@ -774,56 +352,17 @@ static int gaih_inet(const char *name, const struct gaih_service *service, | |||
| 774 | goto build; | 352 | goto build; |
| 775 | }; | 353 | }; |
| 776 | }; | 354 | }; |
| 777 | #endif /* INET6 */ | ||
| 778 | 355 | ||
| 779 | if (!(req->ai_flags & AI_NUMERICHOST)) { | 356 | if (!(req->ai_flags & AI_NUMERICHOST)) { |
| 780 | #if NETDB | ||
| 781 | #if INET6 | ||
| 782 | if (!req->ai_family || (req->ai_family == AF_INET6)) | 357 | if (!req->ai_family || (req->ai_family == AF_INET6)) |
| 783 | if ((rval = netdb_lookup_addr(name, AF_INET6, req, &at)) < 0) | 358 | if ((rval = netdb_lookup_addr(name, AF_INET6, req, &at)) < 0) |
| 784 | goto ret; | 359 | goto ret; |
| 785 | #endif /* INET6 */ | ||
| 786 | if (!req->ai_family || (req->ai_family == AF_INET)) | 360 | if (!req->ai_family || (req->ai_family == AF_INET)) |
| 787 | if ((rval = netdb_lookup_addr(name, AF_INET, req, &at)) < 0) | 361 | if ((rval = netdb_lookup_addr(name, AF_INET, req, &at)) < 0) |
| 788 | goto ret; | 362 | goto ret; |
| 789 | 363 | ||
| 790 | if (!rval) | 364 | if (!rval) |
| 791 | goto build; | 365 | goto build; |
| 792 | #else /* NETDB */ | ||
| 793 | #if HOSTTABLE | ||
| 794 | if ((rval = hosttable_lookup_addr(name, req, &at)) < 0) | ||
| 795 | goto ret; | ||
| 796 | |||
| 797 | if (!rval) | ||
| 798 | goto build; | ||
| 799 | #endif /* HOSTTABLE */ | ||
| 800 | |||
| 801 | #if RESOLVER | ||
| 802 | #if INET6 | ||
| 803 | { | ||
| 804 | int rval2; | ||
| 805 | |||
| 806 | if (!req->ai_family || (req->ai_family == AF_INET6)) | ||
| 807 | if ((rval2 = resolver_lookup_addr(name, T_AAAA, req, &at)) < 0) { | ||
| 808 | rval = rval2; | ||
| 809 | goto ret; | ||
| 810 | }; | ||
| 811 | #endif /* INET6 */ | ||
| 812 | |||
| 813 | if (!req->ai_family || (req->ai_family == AF_INET)) | ||
| 814 | if ((rval = resolver_lookup_addr(name, T_A, req, &at)) < 0) | ||
| 815 | goto ret; | ||
| 816 | |||
| 817 | #if INET6 | ||
| 818 | if (!rval || !rval2) | ||
| 819 | goto build; | ||
| 820 | }; | ||
| 821 | #else /* INET6 */ | ||
| 822 | if (!rval) | ||
| 823 | goto build; | ||
| 824 | #endif /* INET6 */ | ||
| 825 | #endif /* RESOLVER */ | ||
| 826 | #endif /* NETDB */ | ||
| 827 | }; | 366 | }; |
| 828 | 367 | ||
| 829 | if (!at) | 368 | if (!at) |
| @@ -848,11 +387,9 @@ build: | |||
| 848 | } else | 387 | } else |
| 849 | j = 0; | 388 | j = 0; |
| 850 | 389 | ||
| 851 | #if INET6 | ||
| 852 | if (at2->family == AF_INET6) | 390 | if (at2->family == AF_INET6) |
| 853 | i = sizeof(struct sockaddr_in6); | 391 | i = sizeof(struct sockaddr_in6); |
| 854 | else | 392 | else |
| 855 | #endif /* INET6 */ | ||
| 856 | i = sizeof(struct sockaddr_in); | 393 | i = sizeof(struct sockaddr_in); |
| 857 | 394 | ||
| 858 | st2 = st; | 395 | st2 = st; |
| @@ -868,17 +405,13 @@ build: | |||
| 868 | (*pai)->ai_protocol = st2->protocol; | 405 | (*pai)->ai_protocol = st2->protocol; |
| 869 | (*pai)->ai_addrlen = i; | 406 | (*pai)->ai_addrlen = i; |
| 870 | (*pai)->ai_addr = (void *)(*pai) + sizeof(struct addrinfo); | 407 | (*pai)->ai_addr = (void *)(*pai) + sizeof(struct addrinfo); |
| 871 | #if SALEN | ||
| 872 | ((struct sockaddr_in *)(*pai)->ai_addr)->sin_len = i; | 408 | ((struct sockaddr_in *)(*pai)->ai_addr)->sin_len = i; |
| 873 | #endif /* SALEN */ | ||
| 874 | ((struct sockaddr_in *)(*pai)->ai_addr)->sin_family = at2->family; | 409 | ((struct sockaddr_in *)(*pai)->ai_addr)->sin_family = at2->family; |
| 875 | ((struct sockaddr_in *)(*pai)->ai_addr)->sin_port = st2->port; | 410 | ((struct sockaddr_in *)(*pai)->ai_addr)->sin_port = st2->port; |
| 876 | 411 | ||
| 877 | #if INET6 | ||
| 878 | if (at2->family == AF_INET6) | 412 | if (at2->family == AF_INET6) |
| 879 | memcpy(&((struct sockaddr_in6 *)(*pai)->ai_addr)->sin6_addr, at2->addr, sizeof(struct in6_addr)); | 413 | memcpy(&((struct sockaddr_in6 *)(*pai)->ai_addr)->sin6_addr, at2->addr, sizeof(struct in6_addr)); |
| 880 | else | 414 | else |
| 881 | #endif /* INET6 */ | ||
| 882 | memcpy(&((struct sockaddr_in *)(*pai)->ai_addr)->sin_addr, at2->addr, sizeof(struct in_addr)); | 415 | memcpy(&((struct sockaddr_in *)(*pai)->ai_addr)->sin_addr, at2->addr, sizeof(struct in_addr)); |
| 883 | 416 | ||
| 884 | if (j) { | 417 | if (j) { |
| @@ -933,86 +466,12 @@ struct gaih { | |||
| 933 | }; | 466 | }; |
| 934 | 467 | ||
| 935 | static struct gaih gaih[] = { | 468 | static struct gaih gaih[] = { |
| 936 | #if INET6 | ||
| 937 | { PF_INET6, "inet6", gaih_inet }, | 469 | { PF_INET6, "inet6", gaih_inet }, |
| 938 | #endif /* INET6 */ | ||
| 939 | { PF_INET, "inet", gaih_inet }, | 470 | { PF_INET, "inet", gaih_inet }, |
| 940 | #if LOCAL | ||
| 941 | { PF_LOCAL, "local", gaih_local }, | 471 | { PF_LOCAL, "local", gaih_local }, |
| 942 | #endif /* LOCAL */ | ||
| 943 | { -1, NULL, NULL } | 472 | { -1, NULL, NULL } |
| 944 | }; | 473 | }; |
| 945 | 474 | ||
| 946 | #if DEBUG | ||
| 947 | static void dump_addrinfo(const struct addrinfo *ai, int follownext) | ||
| 948 | { | ||
| 949 | char *c; | ||
| 950 | |||
| 951 | loop: | ||
| 952 | fprintf(stderr, "addrinfo at "); | ||
| 953 | if (!ai) { | ||
| 954 | fprintf(stderr, "NULL\n"); | ||
| 955 | return; | ||
| 956 | }; | ||
| 957 | fprintf(stderr, "%08x:\n", (unsigned int)ai); | ||
| 958 | fprintf(stderr, " flags=%x(", ai->ai_flags); | ||
| 959 | c = ""; | ||
| 960 | if (ai->ai_flags & AI_PASSIVE) { | ||
| 961 | fprintf(stderr, "passive"); | ||
| 962 | c = " "; | ||
| 963 | }; | ||
| 964 | if (ai->ai_flags & AI_CANONNAME) { | ||
| 965 | fprintf(stderr, "%scanonname", c); | ||
| 966 | c = " "; | ||
| 967 | }; | ||
| 968 | if (ai->ai_flags & AI_NUMERICHOST) { | ||
| 969 | fprintf(stderr, "%snumerichost", c); | ||
| 970 | c = " "; | ||
| 971 | }; | ||
| 972 | if (ai->ai_flags & AI_EXT) { | ||
| 973 | fprintf(stderr, "%sext", c); | ||
| 974 | }; | ||
| 975 | fprintf(stderr, ")\n"); | ||
| 976 | fprintf(stderr, " family=%x(%s)\n", ai->ai_family, nrl_afnumtoname(ai->ai_family)); | ||
| 977 | fprintf(stderr, " socktype=%x(%s)\n", ai->ai_socktype, nrl_socktypenumtoname(ai->ai_socktype)); | ||
| 978 | fprintf(stderr, " protocol=%x\n", ai->ai_protocol); | ||
| 979 | fprintf(stderr, " addrlen=%x\n", ai->ai_addrlen); | ||
| 980 | fprintf(stderr, " addr=%08x", (unsigned int)ai->ai_addr); | ||
| 981 | if (ai->ai_addr) { | ||
| 982 | fprintf(stderr, ":\n"); | ||
| 983 | #if SALEN | ||
| 984 | fprintf(stderr, " len=%x\n", ai->ai_addr->sa_len); | ||
| 985 | #endif /* SALEN */ | ||
| 986 | fprintf(stderr, " family=%x(%s)\n", ai->ai_addr->sa_family, nrl_afnumtoname(ai->ai_addr->sa_family)); | ||
| 987 | fprintf(stderr, " data="); | ||
| 988 | |||
| 989 | #if SALEN | ||
| 990 | if (ai->ai_addrlen != ai->ai_addr->sa_len) { | ||
| 991 | fprintf(stderr, " (addrlen != len, skipping)"); | ||
| 992 | } else | ||
| 993 | #endif /* SALEN */ | ||
| 994 | { | ||
| 995 | uint8_t *p; | ||
| 996 | int i; | ||
| 997 | |||
| 998 | p = (uint8_t *)ai->ai_addr->sa_data; | ||
| 999 | i = ai->ai_addrlen - ((void *)ai->ai_addr->sa_data - (void *)ai->ai_addr); | ||
| 1000 | while (i-- > 0) | ||
| 1001 | fprintf(stderr, "%02x", *(p++)); | ||
| 1002 | }; | ||
| 1003 | }; | ||
| 1004 | fprintf(stderr, "\n canonname=%08x", (unsigned int)ai->ai_canonname); | ||
| 1005 | if (ai->ai_canonname) | ||
| 1006 | fprintf(stderr, "(%s)", ai->ai_canonname); | ||
| 1007 | fprintf(stderr, "\n next=%08x\n", (unsigned int)ai->ai_next); | ||
| 1008 | |||
| 1009 | if (follownext && ai->ai_next) { | ||
| 1010 | ai = ai->ai_next; | ||
| 1011 | goto loop; | ||
| 1012 | }; | ||
| 1013 | }; | ||
| 1014 | #endif /* DEBUG */ | ||
| 1015 | |||
| 1016 | int getaddrinfo(const char *name, const char *service, | 475 | int getaddrinfo(const char *name, const char *service, |
| 1017 | const struct addrinfo *req, struct addrinfo **pai) | 476 | const struct addrinfo *req, struct addrinfo **pai) |
| 1018 | { | 477 | { |
| @@ -1022,47 +481,24 @@ int getaddrinfo(const char *name, const char *service, | |||
| 1022 | struct gaih *g = gaih, *pg = NULL; | 481 | struct gaih *g = gaih, *pg = NULL; |
| 1023 | struct gaih_service gaih_service, *pservice; | 482 | struct gaih_service gaih_service, *pservice; |
| 1024 | 483 | ||
| 1025 | #if DEBUG | ||
| 1026 | if (DEBUG_MESSAGES) { | ||
| 1027 | fprintf(stderr, "getaddrinfo(name=%s, service=%s, req=%p, pai=%p)\n req: ", name ? name : "NULL", service ? service : "NULL", req, pai); | ||
| 1028 | |||
| 1029 | dump_addrinfo(req, 0); | ||
| 1030 | }; | ||
| 1031 | #endif /* DEBUG */ | ||
| 1032 | |||
| 1033 | if (name && (name[0] == '*') && !name[1]) | 484 | if (name && (name[0] == '*') && !name[1]) |
| 1034 | name = NULL; | 485 | name = NULL; |
| 1035 | 486 | ||
| 1036 | if (service && (service[0] == '*') && !service[1]) | 487 | if (service && (service[0] == '*') && !service[1]) |
| 1037 | service = NULL; | 488 | service = NULL; |
| 1038 | 489 | ||
| 1039 | #if BROKEN_LIKE_POSIX | ||
| 1040 | if (!name && !service && !(req.ai_flags & AI_EXT)) | ||
| 1041 | RETURN_ERROR(EAI_NONAME); | ||
| 1042 | #endif /* BROKEN_LIKE_POSIX */ | ||
| 1043 | |||
| 1044 | if (!req) | 490 | if (!req) |
| 1045 | req = &nullreq; | 491 | req = &nullreq; |
| 1046 | 492 | ||
| 1047 | if (req->ai_flags & ~(AI_CANONNAME | AI_PASSIVE | AI_NUMERICHOST | AI_EXT)) | 493 | if (req->ai_flags & ~(AI_CANONNAME | AI_PASSIVE | AI_NUMERICHOST | AI_EXT)) |
| 1048 | RETURN_ERROR(EAI_BADFLAGS); | 494 | RETURN_ERROR(EAI_BADFLAGS); |
| 1049 | 495 | ||
| 1050 | #if BROKEN_LIKE_POSIX | ||
| 1051 | if ((req->ai_flags & AI_CANONNAME) && !name && !(req.ai_flags & AI_EXT)) | ||
| 1052 | RETURN_ERROR(EAI_BADFLAGS); | ||
| 1053 | #endif /* BROKEN_LIKE_POSIX */ | ||
| 1054 | |||
| 1055 | if (service && *service) { | 496 | if (service && *service) { |
| 1056 | char *c; | 497 | char *c; |
| 1057 | gaih_service.num = strtoul(gaih_service.name = (void *)service, &c, 10); | 498 | gaih_service.num = strtoul(gaih_service.name = (void *)service, &c, 10); |
| 1058 | if (*c) { | 499 | if (*c) { |
| 1059 | gaih_service.num = -1; | 500 | gaih_service.num = -1; |
| 1060 | } | 501 | } |
| 1061 | #if BROKEN_LIKE_POSIX | ||
| 1062 | else | ||
| 1063 | if (!req->ai_socktype && !(req.ai_flags & AI_EXT)) | ||
| 1064 | RETURN_ERROR(EAI_SERVICE); | ||
| 1065 | #endif /* BROKEN_LIKE_POSIX */ | ||
| 1066 | 502 | ||
| 1067 | pservice = &gaih_service; | 503 | pservice = &gaih_service; |
| 1068 | } else | 504 | } else |
| @@ -1100,12 +536,6 @@ int getaddrinfo(const char *name, const char *service, | |||
| 1100 | 536 | ||
| 1101 | if (p) { | 537 | if (p) { |
| 1102 | *pai = p; | 538 | *pai = p; |
| 1103 | #if DEBUG | ||
| 1104 | if (DEBUG_MESSAGES) { | ||
| 1105 | fprintf(stderr, "getaddrinfo: Success. *pai:\n"); | ||
| 1106 | dump_addrinfo(p, 1); | ||
| 1107 | }; | ||
| 1108 | #endif /* DEBUG */ | ||
| 1109 | rval = 0; | 539 | rval = 0; |
| 1110 | goto ret; | 540 | goto ret; |
| 1111 | } | 541 | } |
| @@ -1118,10 +548,6 @@ int getaddrinfo(const char *name, const char *service, | |||
| 1118 | RETURN_ERROR(EAI_NONAME); | 548 | RETURN_ERROR(EAI_NONAME); |
| 1119 | 549 | ||
| 1120 | ret: | 550 | ret: |
| 1121 | #if DEBUG | ||
| 1122 | if (DEBUG_MESSAGES) | ||
| 1123 | fprintf(stderr, "getaddrinfo=%d\n", rval); | ||
| 1124 | #endif /* DEBUG */ | ||
| 1125 | return rval; | 551 | return rval; |
| 1126 | } | 552 | } |
| 1127 | 553 | ||
diff --git a/src/lib/libc/net/getnameinfo.c b/src/lib/libc/net/getnameinfo.c index 15aa67d464..95b27a7006 100644 --- a/src/lib/libc/net/getnameinfo.c +++ b/src/lib/libc/net/getnameinfo.c | |||
| @@ -30,98 +30,19 @@ | |||
| 30 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | 30 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
| 31 | * SUCH DAMAGE. | 31 | * SUCH DAMAGE. |
| 32 | * | 32 | * |
| 33 | * Redistribution and use in source and binary forms, with or without | ||
| 34 | * modification, are permitted provided that the following conditions | ||
| 35 | * are met: | ||
| 36 | * 1. Redistributions of source code must retain the above copyright | ||
| 37 | * notice, this list of conditions and the following disclaimer. | ||
| 38 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 39 | * notice, this list of conditions and the following disclaimer in the | ||
| 40 | * documentation and/or other materials provided with the distribution. | ||
| 41 | * 3. All advertising materials mentioning features or use of this software | ||
| 42 | * must display the following acknowledgement: | ||
| 43 | * This product includes software developed by Craig Metz and | ||
| 44 | * by other contributors. | ||
| 45 | * 4. Neither the name of the author nor the names of contributors | ||
| 46 | * may be used to endorse or promote products derived from this software | ||
| 47 | * without specific prior written permission. | ||
| 48 | * | ||
| 49 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
| 50 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 51 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
| 52 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
| 53 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
| 54 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
| 55 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 56 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
| 57 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
| 58 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
| 59 | * SUCH DAMAGE. | ||
| 60 | * | ||
| 61 | * Redistribution and use in source and binary forms, with or without | ||
| 62 | * modification, are permitted provided that the following conditions | ||
| 63 | * are met: | ||
| 64 | * 1. Redistributions of source code must retain the above copyright | ||
| 65 | * notice, this list of conditions and the following disclaimer. | ||
| 66 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 67 | * notice, this list of conditions and the following disclaimer in the | ||
| 68 | * documentation and/or other materials provided with the distribution. | ||
| 69 | * 3. All advertising materials mentioning features or use of this software | ||
| 70 | * must display the following acknowledgement: | ||
| 71 | * This product includes software developed by Craig Metz and | ||
| 72 | * by other contributors. | ||
| 73 | * 4. Neither the name of the author nor the names of contributors | ||
| 74 | * may be used to endorse or promote products derived from this software | ||
| 75 | * without specific prior written permission. | ||
| 76 | * | ||
| 77 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
| 78 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 79 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
| 80 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
| 81 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
| 82 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
| 83 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 84 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
| 85 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
| 86 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
| 87 | * SUCH DAMAGE. | ||
| 88 | */ | 33 | */ |
| 89 | 34 | ||
| 90 | /* getnameinfo() v1.38 */ | 35 | /* getnameinfo() v1.38 */ |
| 91 | 36 | ||
| 92 | /* To enable debugging support (REQUIRES NRL support library), define: */ | ||
| 93 | /* #define DEBUG 1 */ | ||
| 94 | |||
| 95 | #ifdef __OpenBSD__ | ||
| 96 | #define HAVE_POSIX1G_TYPES 1 | ||
| 97 | #define INET6 1 | ||
| 98 | #define LOCAL 1 | ||
| 99 | #define NETDB 1 | ||
| 100 | #define SALEN 1 | ||
| 101 | #undef RESOLVER | ||
| 102 | #undef HOSTTABLE | ||
| 103 | #undef DEBUG | ||
| 104 | #undef HAVE_GETSERVBYNAME_R | ||
| 105 | #undef HAVE_GETHOSTBYNAME2_R | ||
| 106 | #endif /* __OpenBSD__ */ | ||
| 107 | |||
| 108 | #include <sys/types.h> | 37 | #include <sys/types.h> |
| 109 | #include <sys/socket.h> | 38 | #include <sys/socket.h> |
| 110 | 39 | ||
| 111 | #include <netinet/in.h> | 40 | #include <netinet/in.h> |
| 112 | #if LOCAL | ||
| 113 | #include <sys/un.h> | 41 | #include <sys/un.h> |
| 114 | #include <sys/utsname.h> | 42 | #include <sys/utsname.h> |
| 115 | #endif /* LOCAL */ | ||
| 116 | #include <netdb.h> | 43 | #include <netdb.h> |
| 117 | #include <errno.h> | 44 | #include <errno.h> |
| 118 | #include <string.h> | 45 | #include <string.h> |
| 119 | #if RESOLVER | ||
| 120 | #include <arpa/nameser.h> | ||
| 121 | #include <resolv.h> | ||
| 122 | #endif /* RESOLVER */ | ||
| 123 | |||
| 124 | #include "support.h" | ||
| 125 | 46 | ||
| 126 | #ifndef AF_LOCAL | 47 | #ifndef AF_LOCAL |
| 127 | #define AF_LOCAL AF_UNIX | 48 | #define AF_LOCAL AF_UNIX |
| @@ -131,214 +52,11 @@ | |||
| 131 | #define min(x,y) (((x) > (y)) ? (y) : (x)) | 52 | #define min(x,y) (((x) > (y)) ? (y) : (x)) |
| 132 | #endif /* min */ | 53 | #endif /* min */ |
| 133 | 54 | ||
| 134 | #if DEBUG | ||
| 135 | #if RESOLVER | ||
| 136 | #define DEBUG_MESSAGES (_res.options & RES_DEBUG) | ||
| 137 | #else /* RESOLVER */ | ||
| 138 | int __getnameinfo_debug = 0; | ||
| 139 | #define DEBUG_MESSAGES (__getnameinfo_debug) | ||
| 140 | #endif /* RESOLVER */ | ||
| 141 | #endif /* DEBUG */ | ||
| 142 | |||
| 143 | #if DEBUG | ||
| 144 | #define RETURN_ERROR(x) do { \ | 55 | #define RETURN_ERROR(x) do { \ |
| 145 | if (DEBUG_MESSAGES) \ | ||
| 146 | fprintf(stderr, "%s:%d: returning %s\n", __FILE__, __LINE__, #x); \ | ||
| 147 | rval = (x); \ | 56 | rval = (x); \ |
| 148 | goto ret; \ | 57 | goto ret; \ |
| 149 | } while(0) | 58 | } while(0) |
| 150 | #else /* DEBUG */ | ||
| 151 | #define RETURN_ERROR(x) do { \ | ||
| 152 | rval = (x); \ | ||
| 153 | goto ret; \ | ||
| 154 | } while(0) | ||
| 155 | #endif /* DEBUG */ | ||
| 156 | |||
| 157 | #if HOSTTABLE | ||
| 158 | static int hosttable_lookup_name(int family, void *addr, char *name, int namelen, int flags) | ||
| 159 | { | ||
| 160 | int rval; | ||
| 161 | FILE *f; | ||
| 162 | char buffer[1024]; | ||
| 163 | char addrbuf[16]; | ||
| 164 | char *c, *c2; | ||
| 165 | int i; | ||
| 166 | char *prevcname = NULL; | ||
| 167 | |||
| 168 | if (!(f = fopen("/etc/hosts", "r"))) | ||
| 169 | RETURN_ERROR(EAI_SYSTEM); | ||
| 170 | |||
| 171 | while(fgets(buffer, sizeof(buffer), f)) { | ||
| 172 | if (c = strchr(buffer, '#')) | ||
| 173 | *c = 0; | ||
| 174 | |||
| 175 | c = buffer; | ||
| 176 | while(*c && !isspace(*c)) c++; | ||
| 177 | if (!*c) | ||
| 178 | continue; | ||
| 179 | |||
| 180 | *(c++) = 0; | ||
| 181 | |||
| 182 | if (family == AF_INET) | ||
| 183 | if (inet_pton(AF_INET, buffer, addrbuf) > 0) | ||
| 184 | if (!memcmp(addrbuf, addr, sizeof(struct in_addr))) | ||
| 185 | goto build; | ||
| 186 | |||
| 187 | #if INET6 | ||
| 188 | if (family == AF_INET6) | ||
| 189 | if (inet_pton(AF_INET6, buffer, addrbuf) > 0) | ||
| 190 | if (!memcmp(addrbuf, addr, sizeof(struct in6_addr))) | ||
| 191 | goto build; | ||
| 192 | #endif /* INET6 */ | ||
| 193 | |||
| 194 | continue; | ||
| 195 | |||
| 196 | build: | ||
| 197 | while(*c && isspace(*c)) c++; | ||
| 198 | if (!*c) | ||
| 199 | continue; | ||
| 200 | 59 | ||
| 201 | c2 = c; | ||
| 202 | while(*c2 && !isspace(*c2)) c2++; | ||
| 203 | if (!*c2) | ||
| 204 | continue; | ||
| 205 | *c2 = 0; | ||
| 206 | |||
| 207 | if ((flags & NI_NOFQDN) && (_res.options & RES_INIT) && _res.defdname[0] && (c2 = strstr(c + 1, _res.defdname)) && (*(--c2) == '.')) { | ||
| 208 | *c2 = 0; | ||
| 209 | i = min(c2 - c, namelen) - 1; | ||
| 210 | strncpy(name, c, i); | ||
| 211 | } else | ||
| 212 | strncpy(name, c, namelen - 1); | ||
| 213 | |||
| 214 | rval = 0; | ||
| 215 | goto ret; | ||
| 216 | }; | ||
| 217 | |||
| 218 | RETURN_ERROR(1); | ||
| 219 | |||
| 220 | ret: | ||
| 221 | fclose(f); | ||
| 222 | return rval; | ||
| 223 | }; | ||
| 224 | #endif /* HOSTTABLE */ | ||
| 225 | |||
| 226 | #if RESOLVER | ||
| 227 | #if INET6 | ||
| 228 | static char hextab[] = { '0', '1', '2', '3', '4', '5', '6', '7', | ||
| 229 | '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' }; | ||
| 230 | #endif /* INET6 */ | ||
| 231 | |||
| 232 | struct rrheader { | ||
| 233 | int16_t type; | ||
| 234 | int16_t class; | ||
| 235 | u_int32_t ttl; | ||
| 236 | int16_t size; | ||
| 237 | }; | ||
| 238 | #define RRHEADER_SZ 10 | ||
| 239 | |||
| 240 | int resolver_lookup_name(const char *ptrname, char *name, int namelen, int flags) | ||
| 241 | { | ||
| 242 | int rval; | ||
| 243 | char answer[PACKETSZ]; | ||
| 244 | int answerlen; | ||
| 245 | char dn[MAXDNAME]; | ||
| 246 | char *prevcname = NULL; | ||
| 247 | void *p, *ep; | ||
| 248 | int answers, i; | ||
| 249 | uint16_t rtype, rclass; | ||
| 250 | |||
| 251 | if ((answerlen = res_search(ptrname, C_IN, T_PTR, answer, sizeof(answer))) < 0) { | ||
| 252 | switch(h_errno) { | ||
| 253 | case NETDB_INTERNAL: | ||
| 254 | RETURN_ERROR(EAI_SYSTEM); | ||
| 255 | case HOST_NOT_FOUND: | ||
| 256 | RETURN_ERROR(1); | ||
| 257 | case TRY_AGAIN: | ||
| 258 | RETURN_ERROR(EAI_AGAIN); | ||
| 259 | case NO_RECOVERY: | ||
| 260 | RETURN_ERROR(EAI_FAIL); | ||
| 261 | case NO_DATA: | ||
| 262 | RETURN_ERROR(1); | ||
| 263 | default: | ||
| 264 | RETURN_ERROR(EAI_FAIL); | ||
| 265 | }; | ||
| 266 | }; | ||
| 267 | |||
| 268 | p = answer; | ||
| 269 | ep = answer + answerlen; | ||
| 270 | |||
| 271 | if (answerlen < sizeof(HEADER)) | ||
| 272 | RETURN_ERROR(EAI_FAIL); | ||
| 273 | |||
| 274 | { | ||
| 275 | HEADER *h = (HEADER *)p; | ||
| 276 | if (!h->qr || (h->opcode != QUERY) || (h->qdcount != htons(1)) || !h->ancount) | ||
| 277 | RETURN_ERROR(EAI_FAIL); | ||
| 278 | |||
| 279 | answers = ntohs(h->ancount); | ||
| 280 | }; | ||
| 281 | p += sizeof(HEADER); | ||
| 282 | |||
| 283 | if ((i = dn_expand(answer, ep, p, dn, sizeof(dn))) < 0) | ||
| 284 | RETURN_ERROR(EAI_FAIL); | ||
| 285 | |||
| 286 | p += i; | ||
| 287 | |||
| 288 | if (p + 2*sizeof(u_int16_t) >= ep) | ||
| 289 | RETURN_ERROR(EAI_FAIL); | ||
| 290 | |||
| 291 | GETSHORT(rtype, p); | ||
| 292 | GETSHORT(rclass, p); | ||
| 293 | |||
| 294 | if ((rtype != T_PTR) || (rclass != C_IN)) | ||
| 295 | RETURN_ERROR(EAI_FAIL); | ||
| 296 | |||
| 297 | while(answers--) { | ||
| 298 | if ((i = dn_expand(answer, ep, p, dn, sizeof(dn))) < 0) | ||
| 299 | RETURN_ERROR(EAI_FAIL); | ||
| 300 | |||
| 301 | p += i; | ||
| 302 | |||
| 303 | if (p + RRHEADER_SZ >= ep) | ||
| 304 | RETURN_ERROR(EAI_FAIL); | ||
| 305 | |||
| 306 | GETSHORT(rtype, p); | ||
| 307 | GETSHORT(rclass, p); | ||
| 308 | p += sizeof(uint32_t); | ||
| 309 | if (rclass != C_IN) | ||
| 310 | RETURN_ERROR(EAI_FAIL); | ||
| 311 | GETSHORT(rclass, p); | ||
| 312 | i = rclass; | ||
| 313 | |||
| 314 | if (p + i > ep) | ||
| 315 | RETURN_ERROR(EAI_FAIL); | ||
| 316 | |||
| 317 | if (rtype == T_PTR) { | ||
| 318 | if (dn_expand(answer, ep, p, dn, sizeof(dn)) != i) | ||
| 319 | RETURN_ERROR(EAI_FAIL); | ||
| 320 | |||
| 321 | { | ||
| 322 | char *c2; | ||
| 323 | |||
| 324 | if ((flags & NI_NOFQDN) && (_res.options & RES_INIT) && _res.defdname[0] && (c2 = strstr(dn + 1, _res.defdname)) && (*(--c2) == '.')) { | ||
| 325 | *c2 = 0; | ||
| 326 | strncpy(name, dn, min(c2 - dn, namelen) - 1); | ||
| 327 | } else | ||
| 328 | strncpy(name, dn, namelen - 1); | ||
| 329 | }; | ||
| 330 | }; | ||
| 331 | p += i; | ||
| 332 | }; | ||
| 333 | |||
| 334 | rval = 0; | ||
| 335 | |||
| 336 | ret: | ||
| 337 | return rval; | ||
| 338 | }; | ||
| 339 | #endif /* RESOLVER */ | ||
| 340 | |||
| 341 | #if NETDB | ||
| 342 | static int netdb_lookup_name(int family, void *addr, int addrlen, char *name, | 60 | static int netdb_lookup_name(int family, void *addr, int addrlen, char *name, |
| 343 | int namelen) | 61 | int namelen) |
| 344 | { | 62 | { |
| @@ -379,7 +97,6 @@ static int netdb_lookup_name(int family, void *addr, int addrlen, char *name, | |||
| 379 | ret: | 97 | ret: |
| 380 | return rval; | 98 | return rval; |
| 381 | } | 99 | } |
| 382 | #endif /* NETDB */ | ||
| 383 | 100 | ||
| 384 | int getnameinfo(const struct sockaddr *sa, size_t addrlen, char *host, size_t hostlen, char *serv, size_t servlen, int flags) | 101 | int getnameinfo(const struct sockaddr *sa, size_t addrlen, char *host, size_t hostlen, char *serv, size_t servlen, int flags) |
| 385 | { | 102 | { |
| @@ -391,7 +108,6 @@ int getnameinfo(const struct sockaddr *sa, size_t addrlen, char *host, size_t ho | |||
| 391 | 108 | ||
| 392 | if (host && (hostlen > 0)) | 109 | if (host && (hostlen > 0)) |
| 393 | switch(sa->sa_family) { | 110 | switch(sa->sa_family) { |
| 394 | #if INET6 | ||
| 395 | case AF_INET6: | 111 | case AF_INET6: |
| 396 | if (IN6_IS_ADDR_UNSPECIFIED(&((struct sockaddr_in6 *)sa)->sin6_addr)) { | 112 | if (IN6_IS_ADDR_UNSPECIFIED(&((struct sockaddr_in6 *)sa)->sin6_addr)) { |
| 397 | if (flags & NI_NUMERICHOST) | 113 | if (flags & NI_NUMERICHOST) |
| @@ -404,9 +120,7 @@ int getnameinfo(const struct sockaddr *sa, size_t addrlen, char *host, size_t ho | |||
| 404 | if (IN6_IS_ADDR_V4MAPPED(&((struct sockaddr_in6 *)sa)->sin6_addr)) { | 120 | if (IN6_IS_ADDR_V4MAPPED(&((struct sockaddr_in6 *)sa)->sin6_addr)) { |
| 405 | struct sockaddr_in sin; | 121 | struct sockaddr_in sin; |
| 406 | memset(&sin, 0, sizeof(struct sockaddr_in)); | 122 | memset(&sin, 0, sizeof(struct sockaddr_in)); |
| 407 | #if SALEN | ||
| 408 | sin.sin_len = sizeof(struct sockaddr_in); | 123 | sin.sin_len = sizeof(struct sockaddr_in); |
| 409 | #endif /* SALEN */ | ||
| 410 | sin.sin_family = AF_INET; | 124 | sin.sin_family = AF_INET; |
| 411 | sin.sin_port = ((struct sockaddr_in6 *)sa)->sin6_port; | 125 | sin.sin_port = ((struct sockaddr_in6 *)sa)->sin6_port; |
| 412 | sin.sin_addr.s_addr = ((u_int32_t *)&((struct sockaddr_in6 *)sa)->sin6_addr)[3]; | 126 | sin.sin_addr.s_addr = ((u_int32_t *)&((struct sockaddr_in6 *)sa)->sin6_addr)[3]; |
| @@ -420,37 +134,13 @@ int getnameinfo(const struct sockaddr *sa, size_t addrlen, char *host, size_t ho | |||
| 420 | if (flags & NI_NUMERICHOST) | 134 | if (flags & NI_NUMERICHOST) |
| 421 | goto inet6_noname; | 135 | goto inet6_noname; |
| 422 | 136 | ||
| 423 | #if HOSTTABLE | 137 | if ((rval = netdb_lookup_name(AF_INET6, |
| 424 | if ((rval = hosttable_lookup_name(AF_INET6, &((struct sockaddr_in6 *)sa)->sin6_addr, host, hostlen, flags)) < 0) | 138 | &((struct sockaddr_in6 *)sa)->sin6_addr, sizeof(struct in6_addr), |
| 139 | host, hostlen, flags)) < 0) | ||
| 425 | goto ret; | 140 | goto ret; |
| 426 | 141 | ||
| 427 | if (!rval) | 142 | if (!rval) |
| 428 | break; | 143 | break; |
| 429 | #endif /* HOSTTABLE */ | ||
| 430 | #if RESOLVER | ||
| 431 | { | ||
| 432 | char ptrname[sizeof("0.1.2.3.4.5.6.7.8.9.a.b.c.d.e.f.0.1.2.3.4.5.6.7.8.9.a.b.c.d.e.f.ip6.int.")]; | ||
| 433 | { | ||
| 434 | int i; | ||
| 435 | char *c = ptrname; | ||
| 436 | u_int8_t *p = (u_int8_t *)&((struct sockaddr_in6 *)sa)->sin6_addr + sizeof(struct in6_addr) - 1; | ||
| 437 | |||
| 438 | for (i = sizeof(struct in6_addr) / sizeof(u_int8_t); i > 0; i--, p--) { | ||
| 439 | *(c++) = hextab[*p & 0x0f]; | ||
| 440 | *(c++) = '.'; | ||
| 441 | *(c++) = hextab[(*p & 0xf0) >> 4]; | ||
| 442 | *(c++) = '.'; | ||
| 443 | }; | ||
| 444 | strcpy(c, "ip6.int."); | ||
| 445 | }; | ||
| 446 | |||
| 447 | if ((rval = resolver_lookup_name(ptrname, host, hostlen, flags)) < 0) | ||
| 448 | goto ret; | ||
| 449 | |||
| 450 | if (!rval) | ||
| 451 | break; | ||
| 452 | }; | ||
| 453 | #endif /* RESOLVER */ | ||
| 454 | 144 | ||
| 455 | inet6_noname: | 145 | inet6_noname: |
| 456 | if (flags & NI_NAMEREQD) | 146 | if (flags & NI_NAMEREQD) |
| @@ -460,7 +150,6 @@ inet6_noname: | |||
| 460 | RETURN_ERROR(EAI_NONAME); | 150 | RETURN_ERROR(EAI_NONAME); |
| 461 | 151 | ||
| 462 | break; | 152 | break; |
| 463 | #endif /* INET6 */ | ||
| 464 | case AF_INET: | 153 | case AF_INET: |
| 465 | if (flags & NI_NUMERICHOST) | 154 | if (flags & NI_NUMERICHOST) |
| 466 | goto inet_noname; | 155 | goto inet_noname; |
| @@ -470,27 +159,13 @@ inet6_noname: | |||
| 470 | break; | 159 | break; |
| 471 | }; | 160 | }; |
| 472 | 161 | ||
| 473 | #if HOSTTABLE | 162 | if ((rval = netdb_lookup_name(AF_INET, |
| 474 | if ((rval = hosttable_lookup_name(AF_INET, &((struct sockaddr_in *)sa)->sin_addr, host, hostlen, flags)) < 0) | 163 | &((struct sockaddr_in *)sa)->sin_addr, sizeof(struct in_addr), |
| 164 | host, hostlen, flags)) < 0) | ||
| 475 | goto ret; | 165 | goto ret; |
| 476 | 166 | ||
| 477 | if (!rval) | 167 | if (!rval) |
| 478 | break; | 168 | break; |
| 479 | #endif /* HOSTTABLE */ | ||
| 480 | #if RESOLVER | ||
| 481 | { | ||
| 482 | char ptrname[30]; | ||
| 483 | u_int8_t *p = (u_int8_t *)&((struct sockaddr_in *)sa)->sin_addr; | ||
| 484 | sprintf(ptrname, "%d.%d.%d.%d.in-addr.arpa.", p[3], p[2], p[1], p[0]); | ||
| 485 | |||
| 486 | if ((rval = resolver_lookup_name(ptrname, host, hostlen, flags)) < 0) | ||
| 487 | goto ret; | ||
| 488 | |||
| 489 | if (!rval) | ||
| 490 | break; | ||
| 491 | }; | ||
| 492 | #endif /* RESOLVER */ | ||
| 493 | |||
| 494 | inet_noname: | 169 | inet_noname: |
| 495 | if (flags & NI_NAMEREQD) | 170 | if (flags & NI_NAMEREQD) |
| 496 | RETURN_ERROR(EAI_NONAME); | 171 | RETURN_ERROR(EAI_NONAME); |
| @@ -499,7 +174,6 @@ inet_noname: | |||
| 499 | RETURN_ERROR(EAI_NONAME); | 174 | RETURN_ERROR(EAI_NONAME); |
| 500 | 175 | ||
| 501 | break; | 176 | break; |
| 502 | #if LOCAL | ||
| 503 | case AF_LOCAL: | 177 | case AF_LOCAL: |
| 504 | if (!(flags & NI_NUMERICHOST)) { | 178 | if (!(flags & NI_NUMERICHOST)) { |
| 505 | struct utsname utsname; | 179 | struct utsname utsname; |
| @@ -515,7 +189,6 @@ inet_noname: | |||
| 515 | 189 | ||
| 516 | strncpy(host, "localhost", hostlen - 1); | 190 | strncpy(host, "localhost", hostlen - 1); |
| 517 | break; | 191 | break; |
| 518 | #endif /* LOCAL */ | ||
| 519 | default: | 192 | default: |
| 520 | RETURN_ERROR(EAI_FAMILY); | 193 | RETURN_ERROR(EAI_FAMILY); |
| 521 | }; | 194 | }; |
| @@ -523,9 +196,7 @@ inet_noname: | |||
| 523 | if (serv && (servlen > 0)) | 196 | if (serv && (servlen > 0)) |
| 524 | switch(sa->sa_family) { | 197 | switch(sa->sa_family) { |
| 525 | case AF_INET: | 198 | case AF_INET: |
| 526 | #if INET6 | ||
| 527 | case AF_INET6: | 199 | case AF_INET6: |
| 528 | #endif /* INET6 */ | ||
| 529 | if (!(flags & NI_NUMERICSERV)) { | 200 | if (!(flags & NI_NUMERICSERV)) { |
| 530 | struct servent *s; | 201 | struct servent *s; |
| 531 | if (s = getservbyport(((struct sockaddr_in *)sa)->sin_port, (flags & NI_DGRAM) ? "udp" : "tcp")) { | 202 | if (s = getservbyport(((struct sockaddr_in *)sa)->sin_port, (flags & NI_DGRAM) ? "udp" : "tcp")) { |
| @@ -539,11 +210,9 @@ inet_noname: | |||
| 539 | }; | 210 | }; |
| 540 | snprintf(serv, servlen - 1, "%d", ntohs(((struct sockaddr_in *)sa)->sin_port)); | 211 | snprintf(serv, servlen - 1, "%d", ntohs(((struct sockaddr_in *)sa)->sin_port)); |
| 541 | break; | 212 | break; |
| 542 | #if LOCAL | ||
| 543 | case AF_LOCAL: | 213 | case AF_LOCAL: |
| 544 | strncpy(serv, ((struct sockaddr_un *)sa)->sun_path, servlen - 1); | 214 | strncpy(serv, ((struct sockaddr_un *)sa)->sun_path, servlen - 1); |
| 545 | break; | 215 | break; |
| 546 | #endif /* LOCAL */ | ||
| 547 | }; | 216 | }; |
| 548 | 217 | ||
| 549 | if (host && (hostlen > 0)) | 218 | if (host && (hostlen > 0)) |
