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