165e96449SHajimu UMEMOTO /* 265e96449SHajimu UMEMOTO * Copyright (c) 2004 by Internet Systems Consortium, Inc. ("ISC") 365e96449SHajimu UMEMOTO * Copyright (c) 1996-1999 by Internet Software Consortium. 465e96449SHajimu UMEMOTO * 565e96449SHajimu UMEMOTO * Permission to use, copy, modify, and distribute this software for any 665e96449SHajimu UMEMOTO * purpose with or without fee is hereby granted, provided that the above 765e96449SHajimu UMEMOTO * copyright notice and this permission notice appear in all copies. 865e96449SHajimu UMEMOTO * 965e96449SHajimu UMEMOTO * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES 1065e96449SHajimu UMEMOTO * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 1165e96449SHajimu UMEMOTO * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR 1265e96449SHajimu UMEMOTO * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 1365e96449SHajimu UMEMOTO * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 1465e96449SHajimu UMEMOTO * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT 1565e96449SHajimu UMEMOTO * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 1665e96449SHajimu UMEMOTO */ 1765e96449SHajimu UMEMOTO 1865e96449SHajimu UMEMOTO #if defined(LIBC_SCCS) && !defined(lint) 19dde4a85dSHajimu UMEMOTO static const char rcsid[] = "$Id: inet_ntop.c,v 1.3.18.2 2005/11/03 23:02:22 marka Exp $"; 2065e96449SHajimu UMEMOTO #endif /* LIBC_SCCS and not lint */ 21ab96eeabSHajimu UMEMOTO #include <sys/cdefs.h> 22ab96eeabSHajimu UMEMOTO __FBSDID("$FreeBSD$"); 2365e96449SHajimu UMEMOTO 2465e96449SHajimu UMEMOTO #include "port_before.h" 2565e96449SHajimu UMEMOTO 2665e96449SHajimu UMEMOTO #include <sys/param.h> 2765e96449SHajimu UMEMOTO #include <sys/types.h> 2865e96449SHajimu UMEMOTO #include <sys/socket.h> 2965e96449SHajimu UMEMOTO 3065e96449SHajimu UMEMOTO #include <netinet/in.h> 3165e96449SHajimu UMEMOTO #include <arpa/inet.h> 3265e96449SHajimu UMEMOTO #include <arpa/nameser.h> 3365e96449SHajimu UMEMOTO 3465e96449SHajimu UMEMOTO #include <errno.h> 3565e96449SHajimu UMEMOTO #include <stdio.h> 3665e96449SHajimu UMEMOTO #include <string.h> 3765e96449SHajimu UMEMOTO 3865e96449SHajimu UMEMOTO #include "port_after.h" 3965e96449SHajimu UMEMOTO 40dde4a85dSHajimu UMEMOTO /*% 4165e96449SHajimu UMEMOTO * WARNING: Don't even consider trying to compile this on a system where 4265e96449SHajimu UMEMOTO * sizeof(int) < 4. sizeof(int) > 4 is fine; all the world's not a VAX. 4365e96449SHajimu UMEMOTO */ 4465e96449SHajimu UMEMOTO 45ab96eeabSHajimu UMEMOTO static const char *inet_ntop4(const u_char *src, char *dst, socklen_t size); 46ab96eeabSHajimu UMEMOTO static const char *inet_ntop6(const u_char *src, char *dst, socklen_t size); 4765e96449SHajimu UMEMOTO 48*71099ec5SKevin Lo /* const char * 4965e96449SHajimu UMEMOTO * inet_ntop(af, src, dst, size) 5065e96449SHajimu UMEMOTO * convert a network format address to presentation format. 5165e96449SHajimu UMEMOTO * return: 5265e96449SHajimu UMEMOTO * pointer to presentation format address (`dst'), or NULL (see errno). 5365e96449SHajimu UMEMOTO * author: 5465e96449SHajimu UMEMOTO * Paul Vixie, 1996. 5565e96449SHajimu UMEMOTO */ 5665e96449SHajimu UMEMOTO const char * 57ab96eeabSHajimu UMEMOTO inet_ntop(int af, const void * __restrict src, char * __restrict dst, 58ab96eeabSHajimu UMEMOTO socklen_t size) 5965e96449SHajimu UMEMOTO { 6065e96449SHajimu UMEMOTO switch (af) { 6165e96449SHajimu UMEMOTO case AF_INET: 6265e96449SHajimu UMEMOTO return (inet_ntop4(src, dst, size)); 6365e96449SHajimu UMEMOTO case AF_INET6: 6465e96449SHajimu UMEMOTO return (inet_ntop6(src, dst, size)); 6565e96449SHajimu UMEMOTO default: 6665e96449SHajimu UMEMOTO errno = EAFNOSUPPORT; 6765e96449SHajimu UMEMOTO return (NULL); 6865e96449SHajimu UMEMOTO } 6965e96449SHajimu UMEMOTO /* NOTREACHED */ 7065e96449SHajimu UMEMOTO } 7165e96449SHajimu UMEMOTO 7265e96449SHajimu UMEMOTO /* const char * 7365e96449SHajimu UMEMOTO * inet_ntop4(src, dst, size) 7465e96449SHajimu UMEMOTO * format an IPv4 address 7565e96449SHajimu UMEMOTO * return: 7665e96449SHajimu UMEMOTO * `dst' (as a const) 7765e96449SHajimu UMEMOTO * notes: 7865e96449SHajimu UMEMOTO * (1) uses no statics 7965e96449SHajimu UMEMOTO * (2) takes a u_char* not an in_addr as input 8065e96449SHajimu UMEMOTO * author: 8165e96449SHajimu UMEMOTO * Paul Vixie, 1996. 8265e96449SHajimu UMEMOTO */ 8365e96449SHajimu UMEMOTO static const char * 84ab96eeabSHajimu UMEMOTO inet_ntop4(const u_char *src, char *dst, socklen_t size) 8565e96449SHajimu UMEMOTO { 8665e96449SHajimu UMEMOTO static const char fmt[] = "%u.%u.%u.%u"; 8765e96449SHajimu UMEMOTO char tmp[sizeof "255.255.255.255"]; 88ab96eeabSHajimu UMEMOTO int l; 8965e96449SHajimu UMEMOTO 90ab96eeabSHajimu UMEMOTO l = snprintf(tmp, sizeof(tmp), fmt, src[0], src[1], src[2], src[3]); 91ab96eeabSHajimu UMEMOTO if (l <= 0 || (socklen_t) l >= size) { 9265e96449SHajimu UMEMOTO errno = ENOSPC; 9365e96449SHajimu UMEMOTO return (NULL); 9465e96449SHajimu UMEMOTO } 95ab96eeabSHajimu UMEMOTO strlcpy(dst, tmp, size); 9665e96449SHajimu UMEMOTO return (dst); 9765e96449SHajimu UMEMOTO } 9865e96449SHajimu UMEMOTO 9965e96449SHajimu UMEMOTO /* const char * 10065e96449SHajimu UMEMOTO * inet_ntop6(src, dst, size) 10165e96449SHajimu UMEMOTO * convert IPv6 binary address into presentation (printable) format 10265e96449SHajimu UMEMOTO * author: 10365e96449SHajimu UMEMOTO * Paul Vixie, 1996. 10465e96449SHajimu UMEMOTO */ 10565e96449SHajimu UMEMOTO static const char * 106ab96eeabSHajimu UMEMOTO inet_ntop6(const u_char *src, char *dst, socklen_t size) 10765e96449SHajimu UMEMOTO { 10865e96449SHajimu UMEMOTO /* 10965e96449SHajimu UMEMOTO * Note that int32_t and int16_t need only be "at least" large enough 11065e96449SHajimu UMEMOTO * to contain a value of the specified size. On some systems, like 11165e96449SHajimu UMEMOTO * Crays, there is no such thing as an integer variable with 16 bits. 11265e96449SHajimu UMEMOTO * Keep this in mind if you think this function should have been coded 11365e96449SHajimu UMEMOTO * to use pointer overlays. All the world's not a VAX. 11465e96449SHajimu UMEMOTO */ 11565e96449SHajimu UMEMOTO char tmp[sizeof "ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255"], *tp; 11665e96449SHajimu UMEMOTO struct { int base, len; } best, cur; 11765e96449SHajimu UMEMOTO u_int words[NS_IN6ADDRSZ / NS_INT16SZ]; 11865e96449SHajimu UMEMOTO int i; 11965e96449SHajimu UMEMOTO 12065e96449SHajimu UMEMOTO /* 12165e96449SHajimu UMEMOTO * Preprocess: 12265e96449SHajimu UMEMOTO * Copy the input (bytewise) array into a wordwise array. 12365e96449SHajimu UMEMOTO * Find the longest run of 0x00's in src[] for :: shorthanding. 12465e96449SHajimu UMEMOTO */ 12565e96449SHajimu UMEMOTO memset(words, '\0', sizeof words); 12665e96449SHajimu UMEMOTO for (i = 0; i < NS_IN6ADDRSZ; i++) 12765e96449SHajimu UMEMOTO words[i / 2] |= (src[i] << ((1 - (i % 2)) << 3)); 12865e96449SHajimu UMEMOTO best.base = -1; 12965e96449SHajimu UMEMOTO best.len = 0; 13065e96449SHajimu UMEMOTO cur.base = -1; 13165e96449SHajimu UMEMOTO cur.len = 0; 13265e96449SHajimu UMEMOTO for (i = 0; i < (NS_IN6ADDRSZ / NS_INT16SZ); i++) { 13365e96449SHajimu UMEMOTO if (words[i] == 0) { 13465e96449SHajimu UMEMOTO if (cur.base == -1) 13565e96449SHajimu UMEMOTO cur.base = i, cur.len = 1; 13665e96449SHajimu UMEMOTO else 13765e96449SHajimu UMEMOTO cur.len++; 13865e96449SHajimu UMEMOTO } else { 13965e96449SHajimu UMEMOTO if (cur.base != -1) { 14065e96449SHajimu UMEMOTO if (best.base == -1 || cur.len > best.len) 14165e96449SHajimu UMEMOTO best = cur; 14265e96449SHajimu UMEMOTO cur.base = -1; 14365e96449SHajimu UMEMOTO } 14465e96449SHajimu UMEMOTO } 14565e96449SHajimu UMEMOTO } 14665e96449SHajimu UMEMOTO if (cur.base != -1) { 14765e96449SHajimu UMEMOTO if (best.base == -1 || cur.len > best.len) 14865e96449SHajimu UMEMOTO best = cur; 14965e96449SHajimu UMEMOTO } 15065e96449SHajimu UMEMOTO if (best.base != -1 && best.len < 2) 15165e96449SHajimu UMEMOTO best.base = -1; 15265e96449SHajimu UMEMOTO 15365e96449SHajimu UMEMOTO /* 15465e96449SHajimu UMEMOTO * Format the result. 15565e96449SHajimu UMEMOTO */ 15665e96449SHajimu UMEMOTO tp = tmp; 15765e96449SHajimu UMEMOTO for (i = 0; i < (NS_IN6ADDRSZ / NS_INT16SZ); i++) { 15865e96449SHajimu UMEMOTO /* Are we inside the best run of 0x00's? */ 15965e96449SHajimu UMEMOTO if (best.base != -1 && i >= best.base && 16065e96449SHajimu UMEMOTO i < (best.base + best.len)) { 16165e96449SHajimu UMEMOTO if (i == best.base) 16265e96449SHajimu UMEMOTO *tp++ = ':'; 16365e96449SHajimu UMEMOTO continue; 16465e96449SHajimu UMEMOTO } 16565e96449SHajimu UMEMOTO /* Are we following an initial run of 0x00s or any real hex? */ 16665e96449SHajimu UMEMOTO if (i != 0) 16765e96449SHajimu UMEMOTO *tp++ = ':'; 16865e96449SHajimu UMEMOTO /* Is this address an encapsulated IPv4? */ 16965e96449SHajimu UMEMOTO if (i == 6 && best.base == 0 && (best.len == 6 || 17065e96449SHajimu UMEMOTO (best.len == 7 && words[7] != 0x0001) || 17165e96449SHajimu UMEMOTO (best.len == 5 && words[5] == 0xffff))) { 172*71099ec5SKevin Lo if (!inet_ntop4(src+12, tp, sizeof tmp - (tp - tmp))) { 173*71099ec5SKevin Lo errno = ENOSPC; 17465e96449SHajimu UMEMOTO return (NULL); 175*71099ec5SKevin Lo } 17665e96449SHajimu UMEMOTO tp += strlen(tp); 17765e96449SHajimu UMEMOTO break; 17865e96449SHajimu UMEMOTO } 179ab96eeabSHajimu UMEMOTO tp += sprintf(tp, "%x", words[i]); 18065e96449SHajimu UMEMOTO } 18165e96449SHajimu UMEMOTO /* Was it a trailing run of 0x00's? */ 18265e96449SHajimu UMEMOTO if (best.base != -1 && (best.base + best.len) == 18365e96449SHajimu UMEMOTO (NS_IN6ADDRSZ / NS_INT16SZ)) 18465e96449SHajimu UMEMOTO *tp++ = ':'; 18565e96449SHajimu UMEMOTO *tp++ = '\0'; 18665e96449SHajimu UMEMOTO 18765e96449SHajimu UMEMOTO /* 18865e96449SHajimu UMEMOTO * Check for overflow, copy, and we're done. 18965e96449SHajimu UMEMOTO */ 190ab96eeabSHajimu UMEMOTO if ((socklen_t)(tp - tmp) > size) { 19165e96449SHajimu UMEMOTO errno = ENOSPC; 19265e96449SHajimu UMEMOTO return (NULL); 19365e96449SHajimu UMEMOTO } 19465e96449SHajimu UMEMOTO strcpy(dst, tmp); 19565e96449SHajimu UMEMOTO return (dst); 19665e96449SHajimu UMEMOTO } 197ab96eeabSHajimu UMEMOTO 198ab96eeabSHajimu UMEMOTO /* 199ab96eeabSHajimu UMEMOTO * Weak aliases for applications that use certain private entry points, 200ab96eeabSHajimu UMEMOTO * and fail to include <arpa/inet.h>. 201ab96eeabSHajimu UMEMOTO */ 202ab96eeabSHajimu UMEMOTO #undef inet_ntop 203ab96eeabSHajimu UMEMOTO __weak_reference(__inet_ntop, inet_ntop); 204dde4a85dSHajimu UMEMOTO 205dde4a85dSHajimu UMEMOTO /*! \file */ 206