Home | History | Annotate | Download | only in ip
      1 /*
      2  * CDDL HEADER START
      3  *
      4  * The contents of this file are subject to the terms of the
      5  * Common Development and Distribution License, Version 1.0 only
      6  * (the "License").  You may not use this file except in compliance
      7  * with the License.
      8  *
      9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
     10  * or http://www.opensolaris.org/os/licensing.
     11  * See the License for the specific language governing permissions
     12  * and limitations under the License.
     13  *
     14  * When distributing Covered Code, include this CDDL HEADER in each
     15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
     16  * If applicable, add the following below this CDDL HEADER, with the
     17  * fields enclosed by brackets "[]" replaced with your own identifying
     18  * information: Portions Copyright [yyyy] [name of copyright owner]
     19  *
     20  * CDDL HEADER END
     21  */
     22 /*
     23  * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
     24  * Use is subject to license terms.
     25  */
     26 
     27 #pragma ident	"%Z%%M%	%I%	%E% SMI"
     28 
     29 #include <sys/types.h>
     30 #include <sys/cmn_err.h>
     31 #include <sys/systm.h>
     32 #include <sys/socket.h>
     33 #include <sys/sunddi.h>
     34 #include <netinet/in.h>
     35 #include <inet/led.h>
     36 
     37 static void	convert2ascii(char *, const in6_addr_t *);
     38 static char	*strchr_w(const char *, int);
     39 static int	str2inet_addr(char *, ipaddr_t *);
     40 
     41 /*
     42  * inet_ntop -- Convert an IPv4 or IPv6 address in binary form into
     43  * printable form, and return a pointer to that string. Caller should
     44  * provide a buffer of correct length to store string into.
     45  * Note: this routine is kernel version of inet_ntop. It has similar
     46  * format as inet_ntop() defined in rfc2553. But it does not do
     47  * error handling operations exactly as rfc2553 defines. This function
     48  * is used by kernel inet directory routines only for debugging.
     49  * This inet_ntop() function, does not return NULL if third argument
     50  * is NULL. The reason is simple that we don't want kernel to panic
     51  * as the output of this function is directly fed to ip<n>dbg macro.
     52  * Instead it uses a local buffer for destination address for
     53  * those calls which purposely pass NULL ptr for the destination
     54  * buffer. This function is thread-safe when the caller passes a non-
     55  * null buffer with the third argument.
     56  */
     57 /* ARGSUSED */
     58 char *
     59 inet_ntop(int af, const void *addr, char *buf, int addrlen)
     60 {
     61 	static char local_buf[INET6_ADDRSTRLEN];
     62 	static char *err_buf1 = "<badaddr>";
     63 	static char *err_buf2 = "<badfamily>";
     64 	in6_addr_t	*v6addr;
     65 	uchar_t		*v4addr;
     66 	char		*caddr;
     67 
     68 	/*
     69 	 * We don't allow thread unsafe inet_ntop calls, they
     70 	 * must pass a non-null buffer pointer. For DEBUG mode
     71 	 * we use the ASSERT() and for non-debug kernel it will
     72 	 * silently allow it for now. Someday we should remove
     73 	 * the static buffer from this function.
     74 	 */
     75 
     76 	ASSERT(buf != NULL);
     77 	if (buf == NULL)
     78 		buf = local_buf;
     79 	buf[0] = '\0';
     80 
     81 	/* Let user know politely not to send NULL or unaligned addr */
     82 	if (addr == NULL || !(OK_32PTR(addr))) {
     83 #ifdef DEBUG
     84 		cmn_err(CE_WARN, "inet_ntop: addr is <null> or unaligned");
     85 #endif
     86 		return (err_buf1);
     87 	}
     88 
     89 
     90 #define	UC(b)	(((int)b) & 0xff)
     91 	switch (af) {
     92 	case AF_INET:
     93 		ASSERT(addrlen >= INET_ADDRSTRLEN);
     94 		v4addr = (uchar_t *)addr;
     95 		(void) sprintf(buf, "%03d.%03d.%03d.%03d",
     96 		    UC(v4addr[0]), UC(v4addr[1]), UC(v4addr[2]), UC(v4addr[3]));
     97 		return (buf);
     98 
     99 	case AF_INET6:
    100 		ASSERT(addrlen >= INET6_ADDRSTRLEN);
    101 		v6addr = (in6_addr_t *)addr;
    102 		if (IN6_IS_ADDR_V4MAPPED(v6addr)) {
    103 			caddr = (char *)addr;
    104 			(void) sprintf(buf, "::ffff:%d.%d.%d.%d",
    105 			    UC(caddr[12]), UC(caddr[13]),
    106 			    UC(caddr[14]), UC(caddr[15]));
    107 		} else if (IN6_IS_ADDR_V4COMPAT(v6addr)) {
    108 			caddr = (char *)addr;
    109 			(void) sprintf(buf, "::%d.%d.%d.%d",
    110 			    UC(caddr[12]), UC(caddr[13]), UC(caddr[14]),
    111 			    UC(caddr[15]));
    112 		} else if (IN6_IS_ADDR_UNSPECIFIED(v6addr)) {
    113 			(void) sprintf(buf, "::");
    114 		} else {
    115 			convert2ascii(buf, v6addr);
    116 		}
    117 		return (buf);
    118 
    119 	default:
    120 		return (err_buf2);
    121 	}
    122 #undef UC
    123 }
    124 
    125 /*
    126  *
    127  * v6 formats supported
    128  * General format xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx
    129  * The short hand notation :: is used for COMPAT addr
    130  * Other forms : fe80::xxxx:xxxx:xxxx:xxxx
    131  */
    132 static void
    133 convert2ascii(char *buf, const in6_addr_t *addr)
    134 {
    135 	int		hexdigits;
    136 	int		head_zero = 0;
    137 	int		tail_zero = 0;
    138 	/* tempbuf must be big enough to hold ffff:\0 */
    139 	char		tempbuf[6];
    140 	char		*ptr;
    141 	uint16_t	*addr_component;
    142 	size_t		len;
    143 	boolean_t	first = B_FALSE;
    144 	boolean_t	med_zero = B_FALSE;
    145 	boolean_t	end_zero = B_FALSE;
    146 
    147 	addr_component = (uint16_t *)addr;
    148 	ptr = buf;
    149 
    150 	/* First count if trailing zeroes higher in number */
    151 	for (hexdigits = 0; hexdigits < 8; hexdigits++) {
    152 		if (*addr_component == 0) {
    153 			if (hexdigits < 4)
    154 				head_zero++;
    155 			else
    156 				tail_zero++;
    157 		}
    158 		addr_component++;
    159 	}
    160 	addr_component = (uint16_t *)addr;
    161 	if (tail_zero > head_zero && (head_zero + tail_zero) != 7)
    162 		end_zero = B_TRUE;
    163 
    164 	for (hexdigits = 0; hexdigits < 8; hexdigits++) {
    165 
    166 		/* if entry is a 0 */
    167 
    168 		if (*addr_component == 0) {
    169 			if (!first && *(addr_component + 1) == 0) {
    170 				if (end_zero && (hexdigits < 4)) {
    171 					*ptr++ = '0';
    172 					*ptr++ = ':';
    173 				} else {
    174 					/*
    175 					 * address starts with 0s ..
    176 					 * stick in leading ':' of pair
    177 					 */
    178 					if (hexdigits == 0)
    179 						*ptr++ = ':';
    180 					/* add another */
    181 					*ptr++ = ':';
    182 					first = B_TRUE;
    183 					med_zero = B_TRUE;
    184 				}
    185 			} else if (first && med_zero) {
    186 				if (hexdigits == 7)
    187 					*ptr++ = ':';
    188 				addr_component++;
    189 				continue;
    190 			} else {
    191 				*ptr++ = '0';
    192 				*ptr++ = ':';
    193 			}
    194 			addr_component++;
    195 			continue;
    196 		}
    197 		if (med_zero)
    198 			med_zero = B_FALSE;
    199 
    200 		tempbuf[0] = '\0';
    201 		(void) sprintf(tempbuf, "%x:", ntohs(*addr_component) & 0xffff);
    202 		len = strlen(tempbuf);
    203 		bcopy(tempbuf, ptr, len);
    204 		ptr = ptr + len;
    205 		addr_component++;
    206 	}
    207 	*--ptr = '\0';
    208 }
    209 
    210 /*
    211  * search for char c, terminate on trailing white space
    212  */
    213 static char *
    214 strchr_w(const char *sp, int c)
    215 {
    216 	/* skip leading white space */
    217 	while (*sp && (*sp == ' ' || *sp == '\t')) {
    218 		sp++;
    219 	}
    220 
    221 	do {
    222 		if (*sp == (char)c)
    223 			return ((char *)sp);
    224 		if (*sp == ' ' || *sp == '\t')
    225 			return (NULL);
    226 	} while (*sp++);
    227 	return (NULL);
    228 }
    229 
    230 static int
    231 str2inet_addr(char *cp, ipaddr_t *addrp)
    232 {
    233 	char *end;
    234 	long byte;
    235 	int i;
    236 	ipaddr_t addr = 0;
    237 
    238 	for (i = 0; i < 4; i++) {
    239 		if (ddi_strtol(cp, &end, 10, &byte) != 0 || byte < 0 ||
    240 		    byte > 255) {
    241 			return (0);
    242 		}
    243 		addr = (addr << 8) | (uint8_t)byte;
    244 		if (i < 3) {
    245 			if (*end != '.') {
    246 				return (0);
    247 			} else {
    248 				cp = end + 1;
    249 			}
    250 		} else {
    251 			cp = end;
    252 		}
    253 	}
    254 	*addrp = addr;
    255 	return (1);
    256 }
    257 
    258 /*
    259  * inet_pton: This function takes string format IPv4 or IPv6 address and
    260  * converts it to binary form. The format of this function corresponds to
    261  * inet_pton() in the socket library.
    262  * It returns 0 for invalid IPv4 and IPv6 address
    263  *            1 when successfully converts ascii to binary
    264  *            -1 when af is not AF_INET or AF_INET6
    265  */
    266 int
    267 inet_pton(int af, char *inp, void *outp)
    268 {
    269 	int i;
    270 	long byte;
    271 	char *end;
    272 
    273 	switch (af) {
    274 	case AF_INET:
    275 		return (str2inet_addr(inp, (ipaddr_t *)outp));
    276 	case AF_INET6: {
    277 		union v6buf_u {
    278 			uint16_t v6words_u[8];
    279 			in6_addr_t v6addr_u;
    280 		} v6buf, *v6outp;
    281 		uint16_t	*dbl_col = NULL;
    282 		char lastbyte = NULL;
    283 
    284 		v6outp = (union v6buf_u *)outp;
    285 
    286 		if (strchr_w(inp, '.') != NULL) {
    287 			/* v4 mapped or v4 compatable */
    288 			if (strncmp(inp, "::ffff:", 7) == 0) {
    289 				ipaddr_t ipv4_all_zeroes = 0;
    290 				/* mapped - first init prefix and then fill */
    291 				IN6_IPADDR_TO_V4MAPPED(ipv4_all_zeroes,
    292 				    &v6outp->v6addr_u);
    293 				return (str2inet_addr(inp + 7,
    294 				    &(v6outp->v6addr_u.s6_addr32[3])));
    295 			} else if (strncmp(inp, "::", 2) == 0) {
    296 				/* v4 compatable - prefix all zeroes */
    297 				bzero(&v6outp->v6addr_u, sizeof (in6_addr_t));
    298 				return (str2inet_addr(inp + 2,
    299 				    &(v6outp->v6addr_u.s6_addr32[3])));
    300 			}
    301 			return (0);
    302 		}
    303 		for (i = 0; i < 8; i++) {
    304 			int error;
    305 			/*
    306 			 * if ddi_strtol() fails it could be because
    307 			 * the string is "::".  That is valid and
    308 			 * checked for below so just set the value to
    309 			 * 0 and continue.
    310 			 */
    311 			if ((error = ddi_strtol(inp, &end, 16, &byte)) != 0) {
    312 				if (error == ERANGE)
    313 					return (0);
    314 				byte = 0;
    315 			}
    316 			if (byte < 0 || byte > 0x0ffff) {
    317 				return (0);
    318 			}
    319 			v6buf.v6words_u[i] = (uint16_t)byte;
    320 			if (*end == NULL || i == 7) {
    321 				inp = end;
    322 				break;
    323 			}
    324 			if (inp == end) {	/* not a number must be */
    325 				if (*inp == ':' &&
    326 				    ((i == 0 && *(inp + 1) == ':') ||
    327 				    lastbyte == ':')) {
    328 					if (dbl_col) {
    329 						return (0);
    330 					}
    331 					if (byte != 0)
    332 						i++;
    333 					dbl_col = &v6buf.v6words_u[i];
    334 					if (i == 0)
    335 						inp++;
    336 				} else if (*inp == NULL || *inp == ' ' ||
    337 				    *inp == '\t') {
    338 					break;
    339 				} else {
    340 					return (0);
    341 				}
    342 			} else {
    343 				inp = end;
    344 			}
    345 			if (*inp != ':') {
    346 				return (0);
    347 			}
    348 			inp++;
    349 			if (*inp == NULL || *inp == ' ' || *inp == '\t') {
    350 				break;
    351 			}
    352 			lastbyte = *inp;
    353 		}
    354 		if (*inp != NULL && *inp != ' ' && *inp != '\t') {
    355 			return (0);
    356 		}
    357 		/*
    358 		 * v6words now contains the bytes we could translate
    359 		 * dbl_col points to the word (should be 0) where
    360 		 * a double colon was found
    361 		 */
    362 		if (i == 7) {
    363 			v6outp->v6addr_u = v6buf.v6addr_u;
    364 		} else {
    365 			int rem;
    366 			int word;
    367 			int next;
    368 			if (dbl_col == NULL) {
    369 				return (0);
    370 			}
    371 			bzero(&v6outp->v6addr_u, sizeof (in6_addr_t));
    372 			rem = dbl_col - &v6buf.v6words_u[0];
    373 			for (next = 0; next < rem; next++) {
    374 				v6outp->v6words_u[next] = v6buf.v6words_u[next];
    375 			}
    376 			next++;	/* skip dbl_col 0 */
    377 			rem = i - rem;
    378 			word = 8 - rem;
    379 			while (rem > 0) {
    380 				v6outp->v6words_u[word] = v6buf.v6words_u[next];
    381 				word++;
    382 				rem--;
    383 				next++;
    384 			}
    385 		}
    386 		return (1);	/* Success */
    387 	}
    388 	}	/* switch */
    389 	return (-1);	/* return -1 for default case */
    390 }
    391