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 /* 24 * Copyright 2004 Sun Microsystems, Inc. All rights reserved. 25 * Use is subject to license terms. 26 * Copyright 2014 Nexenta Systems, Inc. All rights reserved. 27 */ 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 * 263 * Return values: 264 * 0 invalid IPv4 or IPv6 address 265 * 1 successful conversion 266 * -1 af is not AF_INET or AF_INET6 267 */ 268 int 269 __inet_pton(int af, char *inp, void *outp, int compat) 270 { 271 int i; 272 long byte; 273 char *end; 274 275 switch (af) { 276 case AF_INET: 277 if (str2inet_addr(inp, (ipaddr_t *)outp) != 0) { 278 if (!compat) 279 *(uint32_t *)outp = htonl(*(uint32_t *)outp); 280 return (1); 281 } else { 282 return (0); 283 } 284 case AF_INET6: { 285 union v6buf_u { 286 uint16_t v6words_u[8]; 287 in6_addr_t v6addr_u; 288 } v6buf, *v6outp; 289 uint16_t *dbl_col = NULL; 290 char lastbyte = NULL; 291 292 v6outp = (union v6buf_u *)outp; 293 294 if (strchr_w(inp, '.') != NULL) { 295 /* v4 mapped or v4 compatable */ 296 if (strncmp(inp, "::ffff:", 7) == 0) { 297 ipaddr_t ipv4_all_zeroes = 0; 298 /* mapped - first init prefix and then fill */ 299 IN6_IPADDR_TO_V4MAPPED(ipv4_all_zeroes, 300 &v6outp->v6addr_u); 301 return (str2inet_addr(inp + 7, 302 &(v6outp->v6addr_u.s6_addr32[3]))); 303 } else if (strncmp(inp, "::", 2) == 0) { 304 /* v4 compatable - prefix all zeroes */ 305 bzero(&v6outp->v6addr_u, sizeof (in6_addr_t)); 306 return (str2inet_addr(inp + 2, 307 &(v6outp->v6addr_u.s6_addr32[3]))); 308 } 309 return (0); 310 } 311 for (i = 0; i < 8; i++) { 312 int error; 313 /* 314 * if ddi_strtol() fails it could be because 315 * the string is "::". That is valid and 316 * checked for below so just set the value to 317 * 0 and continue. 318 */ 319 if ((error = ddi_strtol(inp, &end, 16, &byte)) != 0) { 320 if (error == ERANGE) 321 return (0); 322 byte = 0; 323 } 324 if (byte < 0 || byte > 0x0ffff) { 325 return (0); 326 } 327 if (compat) { 328 v6buf.v6words_u[i] = (uint16_t)byte; 329 } else { 330 v6buf.v6words_u[i] = htons((uint16_t)byte); 331 } 332 if (*end == NULL || i == 7) { 333 inp = end; 334 break; 335 } 336 if (inp == end) { /* not a number must be */ 337 if (*inp == ':' && 338 ((i == 0 && *(inp + 1) == ':') || 339 lastbyte == ':')) { 340 if (dbl_col) { 341 return (0); 342 } 343 if (byte != 0) 344 i++; 345 dbl_col = &v6buf.v6words_u[i]; 346 if (i == 0) 347 inp++; 348 } else if (*inp == NULL || *inp == ' ' || 349 *inp == '\t') { 350 break; 351 } else { 352 return (0); 353 } 354 } else { 355 inp = end; 356 } 357 if (*inp != ':') { 358 return (0); 359 } 360 inp++; 361 if (*inp == NULL || *inp == ' ' || *inp == '\t') { 362 break; 363 } 364 lastbyte = *inp; 365 } 366 if (*inp != NULL && *inp != ' ' && *inp != '\t') { 367 return (0); 368 } 369 /* 370 * v6words now contains the bytes we could translate 371 * dbl_col points to the word (should be 0) where 372 * a double colon was found 373 */ 374 if (i == 7) { 375 v6outp->v6addr_u = v6buf.v6addr_u; 376 } else { 377 int rem; 378 int word; 379 int next; 380 if (dbl_col == NULL) { 381 return (0); 382 } 383 bzero(&v6outp->v6addr_u, sizeof (in6_addr_t)); 384 rem = dbl_col - &v6buf.v6words_u[0]; 385 for (next = 0; next < rem; next++) { 386 v6outp->v6words_u[next] = v6buf.v6words_u[next]; 387 } 388 next++; /* skip dbl_col 0 */ 389 rem = i - rem; 390 word = 8 - rem; 391 while (rem > 0) { 392 v6outp->v6words_u[word] = v6buf.v6words_u[next]; 393 word++; 394 rem--; 395 next++; 396 } 397 } 398 return (1); /* Success */ 399 } 400 } /* switch */ 401 return (-1); /* return -1 for default case */ 402 } 403 404 /* 405 * Provide fixed inet_pton() implementation. 406 */ 407 int 408 _inet_pton(int af, char *inp, void *outp) 409 { 410 return (__inet_pton(af, inp, outp, 0)); 411 } 412 413 /* 414 * Provide broken inet_pton() implementation by default for binary 415 * compatibility. 416 */ 417 int 418 inet_pton(int af, char *inp, void *outp) 419 { 420 return (__inet_pton(af, inp, outp, 1)); 421 } 422