1*6e778a7eSPedro F. Giffuni /*- 2*6e778a7eSPedro F. Giffuni * SPDX-License-Identifier: ISC 3*6e778a7eSPedro F. Giffuni * 465e96449SHajimu UMEMOTO * Copyright (c) 2004 by Internet Systems Consortium, Inc. ("ISC") 565e96449SHajimu UMEMOTO * Copyright (c) 1996,1999 by Internet Software Consortium. 665e96449SHajimu UMEMOTO * 765e96449SHajimu UMEMOTO * Permission to use, copy, modify, and distribute this software for any 865e96449SHajimu UMEMOTO * purpose with or without fee is hereby granted, provided that the above 965e96449SHajimu UMEMOTO * copyright notice and this permission notice appear in all copies. 1065e96449SHajimu UMEMOTO * 1165e96449SHajimu UMEMOTO * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES 1265e96449SHajimu UMEMOTO * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 1365e96449SHajimu UMEMOTO * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR 1465e96449SHajimu UMEMOTO * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 1565e96449SHajimu UMEMOTO * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 1665e96449SHajimu UMEMOTO * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT 1765e96449SHajimu UMEMOTO * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 1865e96449SHajimu UMEMOTO */ 1965e96449SHajimu UMEMOTO 2065e96449SHajimu UMEMOTO #if defined(LIBC_SCCS) && !defined(lint) 21046c3635SPedro F. Giffuni static const char rcsid[] = "$Id: inet_net_ntop.c,v 1.5 2006/06/20 02:50:14 marka Exp $"; 2265e96449SHajimu UMEMOTO #endif 23ab96eeabSHajimu UMEMOTO #include <sys/cdefs.h> 24ab96eeabSHajimu UMEMOTO __FBSDID("$FreeBSD$"); 2565e96449SHajimu UMEMOTO 2665e96449SHajimu UMEMOTO #include "port_before.h" 2765e96449SHajimu UMEMOTO 2865e96449SHajimu UMEMOTO #include <sys/types.h> 2965e96449SHajimu UMEMOTO #include <sys/socket.h> 3065e96449SHajimu UMEMOTO #include <netinet/in.h> 3165e96449SHajimu UMEMOTO #include <arpa/inet.h> 3265e96449SHajimu UMEMOTO 3365e96449SHajimu UMEMOTO #include <errno.h> 3465e96449SHajimu UMEMOTO #include <stdio.h> 3565e96449SHajimu UMEMOTO #include <string.h> 3665e96449SHajimu UMEMOTO #include <stdlib.h> 3765e96449SHajimu UMEMOTO 3865e96449SHajimu UMEMOTO #include "port_after.h" 3965e96449SHajimu UMEMOTO 4065e96449SHajimu UMEMOTO #ifdef SPRINTF_CHAR 4165e96449SHajimu UMEMOTO # define SPRINTF(x) strlen(sprintf/**/x) 4265e96449SHajimu UMEMOTO #else 4365e96449SHajimu UMEMOTO # define SPRINTF(x) ((size_t)sprintf x) 4465e96449SHajimu UMEMOTO #endif 4565e96449SHajimu UMEMOTO 46ab96eeabSHajimu UMEMOTO static char * inet_net_ntop_ipv4(const u_char *src, int bits, char *dst, 47ab96eeabSHajimu UMEMOTO size_t size); 48ab96eeabSHajimu UMEMOTO static char * inet_net_ntop_ipv6(const u_char *src, int bits, char *dst, 49ab96eeabSHajimu UMEMOTO size_t size); 5065e96449SHajimu UMEMOTO 51dde4a85dSHajimu UMEMOTO /*% 5265e96449SHajimu UMEMOTO * char * 5365e96449SHajimu UMEMOTO * inet_net_ntop(af, src, bits, dst, size) 5465e96449SHajimu UMEMOTO * convert network number from network to presentation format. 5565e96449SHajimu UMEMOTO * generates CIDR style result always. 5665e96449SHajimu UMEMOTO * return: 5765e96449SHajimu UMEMOTO * pointer to dst, or NULL if an error occurred (check errno). 5865e96449SHajimu UMEMOTO * author: 5965e96449SHajimu UMEMOTO * Paul Vixie (ISC), July 1996 6065e96449SHajimu UMEMOTO */ 6165e96449SHajimu UMEMOTO char * 62060e5496SCraig Rodrigues inet_net_ntop(int af, const void *src, int bits, char *dst, size_t size) 6365e96449SHajimu UMEMOTO { 6465e96449SHajimu UMEMOTO switch (af) { 6565e96449SHajimu UMEMOTO case AF_INET: 6665e96449SHajimu UMEMOTO return (inet_net_ntop_ipv4(src, bits, dst, size)); 6765e96449SHajimu UMEMOTO case AF_INET6: 6865e96449SHajimu UMEMOTO return (inet_net_ntop_ipv6(src, bits, dst, size)); 6965e96449SHajimu UMEMOTO default: 7065e96449SHajimu UMEMOTO errno = EAFNOSUPPORT; 7165e96449SHajimu UMEMOTO return (NULL); 7265e96449SHajimu UMEMOTO } 7365e96449SHajimu UMEMOTO } 7465e96449SHajimu UMEMOTO 75dde4a85dSHajimu UMEMOTO /*% 7665e96449SHajimu UMEMOTO * static char * 7765e96449SHajimu UMEMOTO * inet_net_ntop_ipv4(src, bits, dst, size) 7865e96449SHajimu UMEMOTO * convert IPv4 network number from network to presentation format. 7965e96449SHajimu UMEMOTO * generates CIDR style result always. 8065e96449SHajimu UMEMOTO * return: 8165e96449SHajimu UMEMOTO * pointer to dst, or NULL if an error occurred (check errno). 8265e96449SHajimu UMEMOTO * note: 8365e96449SHajimu UMEMOTO * network byte order assumed. this means 192.5.5.240/28 has 8465e96449SHajimu UMEMOTO * 0b11110000 in its fourth octet. 8565e96449SHajimu UMEMOTO * author: 8665e96449SHajimu UMEMOTO * Paul Vixie (ISC), July 1996 8765e96449SHajimu UMEMOTO */ 8865e96449SHajimu UMEMOTO static char * 89060e5496SCraig Rodrigues inet_net_ntop_ipv4(const u_char *src, int bits, char *dst, size_t size) 9065e96449SHajimu UMEMOTO { 9165e96449SHajimu UMEMOTO char *odst = dst; 9265e96449SHajimu UMEMOTO char *t; 9365e96449SHajimu UMEMOTO u_int m; 9465e96449SHajimu UMEMOTO int b; 9565e96449SHajimu UMEMOTO 9665e96449SHajimu UMEMOTO if (bits < 0 || bits > 32) { 9765e96449SHajimu UMEMOTO errno = EINVAL; 9865e96449SHajimu UMEMOTO return (NULL); 9965e96449SHajimu UMEMOTO } 10065e96449SHajimu UMEMOTO 10165e96449SHajimu UMEMOTO if (bits == 0) { 10265e96449SHajimu UMEMOTO if (size < sizeof "0") 10365e96449SHajimu UMEMOTO goto emsgsize; 10465e96449SHajimu UMEMOTO *dst++ = '0'; 10565e96449SHajimu UMEMOTO size--; 10665e96449SHajimu UMEMOTO *dst = '\0'; 10765e96449SHajimu UMEMOTO } 10865e96449SHajimu UMEMOTO 10965e96449SHajimu UMEMOTO /* Format whole octets. */ 11065e96449SHajimu UMEMOTO for (b = bits / 8; b > 0; b--) { 11165e96449SHajimu UMEMOTO if (size <= sizeof "255.") 11265e96449SHajimu UMEMOTO goto emsgsize; 11365e96449SHajimu UMEMOTO t = dst; 11465e96449SHajimu UMEMOTO dst += SPRINTF((dst, "%u", *src++)); 11565e96449SHajimu UMEMOTO if (b > 1) { 11665e96449SHajimu UMEMOTO *dst++ = '.'; 11765e96449SHajimu UMEMOTO *dst = '\0'; 11865e96449SHajimu UMEMOTO } 11965e96449SHajimu UMEMOTO size -= (size_t)(dst - t); 12065e96449SHajimu UMEMOTO } 12165e96449SHajimu UMEMOTO 12265e96449SHajimu UMEMOTO /* Format partial octet. */ 12365e96449SHajimu UMEMOTO b = bits % 8; 12465e96449SHajimu UMEMOTO if (b > 0) { 12565e96449SHajimu UMEMOTO if (size <= sizeof ".255") 12665e96449SHajimu UMEMOTO goto emsgsize; 12765e96449SHajimu UMEMOTO t = dst; 12865e96449SHajimu UMEMOTO if (dst != odst) 12965e96449SHajimu UMEMOTO *dst++ = '.'; 13065e96449SHajimu UMEMOTO m = ((1 << b) - 1) << (8 - b); 13165e96449SHajimu UMEMOTO dst += SPRINTF((dst, "%u", *src & m)); 13265e96449SHajimu UMEMOTO size -= (size_t)(dst - t); 13365e96449SHajimu UMEMOTO } 13465e96449SHajimu UMEMOTO 13565e96449SHajimu UMEMOTO /* Format CIDR /width. */ 13665e96449SHajimu UMEMOTO if (size <= sizeof "/32") 13765e96449SHajimu UMEMOTO goto emsgsize; 13865e96449SHajimu UMEMOTO dst += SPRINTF((dst, "/%u", bits)); 13965e96449SHajimu UMEMOTO return (odst); 14065e96449SHajimu UMEMOTO 14165e96449SHajimu UMEMOTO emsgsize: 14265e96449SHajimu UMEMOTO errno = EMSGSIZE; 14365e96449SHajimu UMEMOTO return (NULL); 14465e96449SHajimu UMEMOTO } 14565e96449SHajimu UMEMOTO 146dde4a85dSHajimu UMEMOTO /*% 14765e96449SHajimu UMEMOTO * static char * 14865e96449SHajimu UMEMOTO * inet_net_ntop_ipv6(src, bits, fakebits, dst, size) 14965e96449SHajimu UMEMOTO * convert IPv6 network number from network to presentation format. 15065e96449SHajimu UMEMOTO * generates CIDR style result always. Picks the shortest representation 15165e96449SHajimu UMEMOTO * unless the IP is really IPv4. 15265e96449SHajimu UMEMOTO * always prints specified number of bits (bits). 15365e96449SHajimu UMEMOTO * return: 15465e96449SHajimu UMEMOTO * pointer to dst, or NULL if an error occurred (check errno). 15565e96449SHajimu UMEMOTO * note: 15665e96449SHajimu UMEMOTO * network byte order assumed. this means 192.5.5.240/28 has 157ab96eeabSHajimu UMEMOTO * 0b11110000 in its fourth octet. 15865e96449SHajimu UMEMOTO * author: 15965e96449SHajimu UMEMOTO * Vadim Kogan (UCB), June 2001 16065e96449SHajimu UMEMOTO * Original version (IPv4) by Paul Vixie (ISC), July 1996 16165e96449SHajimu UMEMOTO */ 16265e96449SHajimu UMEMOTO 16365e96449SHajimu UMEMOTO static char * 16465e96449SHajimu UMEMOTO inet_net_ntop_ipv6(const u_char *src, int bits, char *dst, size_t size) { 16565e96449SHajimu UMEMOTO u_int m; 16665e96449SHajimu UMEMOTO int b; 16765e96449SHajimu UMEMOTO int p; 16865e96449SHajimu UMEMOTO int zero_s, zero_l, tmp_zero_s, tmp_zero_l; 16965e96449SHajimu UMEMOTO int i; 17065e96449SHajimu UMEMOTO int is_ipv4 = 0; 17165e96449SHajimu UMEMOTO unsigned char inbuf[16]; 17265e96449SHajimu UMEMOTO char outbuf[sizeof("xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:255.255.255.255/128")]; 17365e96449SHajimu UMEMOTO char *cp; 17465e96449SHajimu UMEMOTO int words; 17565e96449SHajimu UMEMOTO u_char *s; 17665e96449SHajimu UMEMOTO 17765e96449SHajimu UMEMOTO if (bits < 0 || bits > 128) { 17865e96449SHajimu UMEMOTO errno = EINVAL; 17965e96449SHajimu UMEMOTO return (NULL); 18065e96449SHajimu UMEMOTO } 18165e96449SHajimu UMEMOTO 18265e96449SHajimu UMEMOTO cp = outbuf; 18365e96449SHajimu UMEMOTO 18465e96449SHajimu UMEMOTO if (bits == 0) { 18565e96449SHajimu UMEMOTO *cp++ = ':'; 18665e96449SHajimu UMEMOTO *cp++ = ':'; 18765e96449SHajimu UMEMOTO *cp = '\0'; 18865e96449SHajimu UMEMOTO } else { 18965e96449SHajimu UMEMOTO /* Copy src to private buffer. Zero host part. */ 19065e96449SHajimu UMEMOTO p = (bits + 7) / 8; 19165e96449SHajimu UMEMOTO memcpy(inbuf, src, p); 19265e96449SHajimu UMEMOTO memset(inbuf + p, 0, 16 - p); 19365e96449SHajimu UMEMOTO b = bits % 8; 19465e96449SHajimu UMEMOTO if (b != 0) { 19565e96449SHajimu UMEMOTO m = ~0 << (8 - b); 19665e96449SHajimu UMEMOTO inbuf[p-1] &= m; 19765e96449SHajimu UMEMOTO } 19865e96449SHajimu UMEMOTO 19965e96449SHajimu UMEMOTO s = inbuf; 20065e96449SHajimu UMEMOTO 20165e96449SHajimu UMEMOTO /* how many words need to be displayed in output */ 20265e96449SHajimu UMEMOTO words = (bits + 15) / 16; 20365e96449SHajimu UMEMOTO if (words == 1) 20465e96449SHajimu UMEMOTO words = 2; 20565e96449SHajimu UMEMOTO 20665e96449SHajimu UMEMOTO /* Find the longest substring of zero's */ 20765e96449SHajimu UMEMOTO zero_s = zero_l = tmp_zero_s = tmp_zero_l = 0; 20865e96449SHajimu UMEMOTO for (i = 0; i < (words * 2); i += 2) { 20965e96449SHajimu UMEMOTO if ((s[i] | s[i+1]) == 0) { 21065e96449SHajimu UMEMOTO if (tmp_zero_l == 0) 21165e96449SHajimu UMEMOTO tmp_zero_s = i / 2; 21265e96449SHajimu UMEMOTO tmp_zero_l++; 21365e96449SHajimu UMEMOTO } else { 21465e96449SHajimu UMEMOTO if (tmp_zero_l && zero_l < tmp_zero_l) { 21565e96449SHajimu UMEMOTO zero_s = tmp_zero_s; 21665e96449SHajimu UMEMOTO zero_l = tmp_zero_l; 21765e96449SHajimu UMEMOTO tmp_zero_l = 0; 21865e96449SHajimu UMEMOTO } 21965e96449SHajimu UMEMOTO } 22065e96449SHajimu UMEMOTO } 22165e96449SHajimu UMEMOTO 22265e96449SHajimu UMEMOTO if (tmp_zero_l && zero_l < tmp_zero_l) { 22365e96449SHajimu UMEMOTO zero_s = tmp_zero_s; 22465e96449SHajimu UMEMOTO zero_l = tmp_zero_l; 22565e96449SHajimu UMEMOTO } 22665e96449SHajimu UMEMOTO 22765e96449SHajimu UMEMOTO if (zero_l != words && zero_s == 0 && ((zero_l == 6) || 22865e96449SHajimu UMEMOTO ((zero_l == 5 && s[10] == 0xff && s[11] == 0xff) || 22965e96449SHajimu UMEMOTO ((zero_l == 7 && s[14] != 0 && s[15] != 1))))) 23065e96449SHajimu UMEMOTO is_ipv4 = 1; 23165e96449SHajimu UMEMOTO 23265e96449SHajimu UMEMOTO /* Format whole words. */ 23365e96449SHajimu UMEMOTO for (p = 0; p < words; p++) { 23465e96449SHajimu UMEMOTO if (zero_l != 0 && p >= zero_s && p < zero_s + zero_l) { 23565e96449SHajimu UMEMOTO /* Time to skip some zeros */ 23665e96449SHajimu UMEMOTO if (p == zero_s) 23765e96449SHajimu UMEMOTO *cp++ = ':'; 23865e96449SHajimu UMEMOTO if (p == words - 1) 23965e96449SHajimu UMEMOTO *cp++ = ':'; 24065e96449SHajimu UMEMOTO s++; 24165e96449SHajimu UMEMOTO s++; 24265e96449SHajimu UMEMOTO continue; 24365e96449SHajimu UMEMOTO } 24465e96449SHajimu UMEMOTO 24565e96449SHajimu UMEMOTO if (is_ipv4 && p > 5 ) { 24665e96449SHajimu UMEMOTO *cp++ = (p == 6) ? ':' : '.'; 24765e96449SHajimu UMEMOTO cp += SPRINTF((cp, "%u", *s++)); 24865e96449SHajimu UMEMOTO /* we can potentially drop the last octet */ 24965e96449SHajimu UMEMOTO if (p != 7 || bits > 120) { 25065e96449SHajimu UMEMOTO *cp++ = '.'; 25165e96449SHajimu UMEMOTO cp += SPRINTF((cp, "%u", *s++)); 25265e96449SHajimu UMEMOTO } 25365e96449SHajimu UMEMOTO } else { 25465e96449SHajimu UMEMOTO if (cp != outbuf) 25565e96449SHajimu UMEMOTO *cp++ = ':'; 25665e96449SHajimu UMEMOTO cp += SPRINTF((cp, "%x", *s * 256 + s[1])); 25765e96449SHajimu UMEMOTO s += 2; 25865e96449SHajimu UMEMOTO } 25965e96449SHajimu UMEMOTO } 26065e96449SHajimu UMEMOTO } 26165e96449SHajimu UMEMOTO /* Format CIDR /width. */ 2622cd19db2SHajimu UMEMOTO sprintf(cp, "/%u", bits); 26365e96449SHajimu UMEMOTO if (strlen(outbuf) + 1 > size) 26465e96449SHajimu UMEMOTO goto emsgsize; 26565e96449SHajimu UMEMOTO strcpy(dst, outbuf); 26665e96449SHajimu UMEMOTO 26765e96449SHajimu UMEMOTO return (dst); 26865e96449SHajimu UMEMOTO 26965e96449SHajimu UMEMOTO emsgsize: 27065e96449SHajimu UMEMOTO errno = EMSGSIZE; 27165e96449SHajimu UMEMOTO return (NULL); 27265e96449SHajimu UMEMOTO } 273ab96eeabSHajimu UMEMOTO 274ab96eeabSHajimu UMEMOTO /* 275ab96eeabSHajimu UMEMOTO * Weak aliases for applications that use certain private entry points, 276ab96eeabSHajimu UMEMOTO * and fail to include <arpa/inet.h>. 277ab96eeabSHajimu UMEMOTO */ 278ab96eeabSHajimu UMEMOTO #undef inet_net_ntop 279ab96eeabSHajimu UMEMOTO __weak_reference(__inet_net_ntop, inet_net_ntop); 280dde4a85dSHajimu UMEMOTO 281dde4a85dSHajimu UMEMOTO /*! \file */ 282