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 2015 Nexenta Systems, Inc. All rights reserved. 25 */ 26 27 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */ 28 /* All Rights Reserved */ 29 30 31 /* 32 * Copyright 2005 Sun Microsystems, Inc. All rights reserved. 33 * Use is subject to license terms. 34 */ 35 36 /* SVr4.0 1.1 */ 37 38 /* 39 * Miscellaneous support routines for kernel implementation of RPC. 40 */ 41 42 #include <sys/param.h> 43 #include <sys/t_lock.h> 44 #include <sys/user.h> 45 #include <sys/vnode.h> 46 #include <sys/stream.h> 47 #include <sys/stropts.h> 48 #include <sys/strsubr.h> 49 #include <sys/socket.h> 50 #include <sys/tihdr.h> 51 #include <sys/timod.h> 52 #include <sys/tiuser.h> 53 #include <sys/systm.h> 54 #include <sys/cmn_err.h> 55 #include <sys/debug.h> 56 #include <sys/sdt.h> 57 #include <netinet/in.h> 58 #include <rpc/types.h> 59 #include <rpc/auth.h> 60 #include <rpc/clnt.h> 61 #include <rpc/rpcb_prot.h> 62 #include <rpc/pmap_prot.h> 63 64 static int strtoi(char *, char **); 65 static void grow_netbuf(struct netbuf *, size_t); 66 static void loopb_u2t(const char *, struct netbuf *); 67 68 #define RPC_PMAP_TIMEOUT 15 69 /* 70 * define for max length of an ip address and port address, the value was 71 * calculated using INET6_ADDRSTRLEN (46) + max port address (12) + 72 * seperator "."'s in port address (2) + null (1) = 61. 73 * Then there is IPV6_TOKEN_LEN which is 64, so the value is 64 to be safe. 74 */ 75 #define RPC_MAX_IP_LENGTH 64 76 77 /* 78 * Kernel level debugging aid. The global variable "rpclog" is a bit 79 * mask which allows various types of debugging messages to be printed 80 * out. 81 * 82 * rpclog & 1 will cause actual failures to be printed. 83 * rpclog & 2 will cause informational messages to be 84 * printed on the client side of rpc. 85 * rpclog & 4 will cause informational messages to be 86 * printed on the server side of rpc. 87 * rpclog & 8 will cause informational messages for rare events to be 88 * printed on the client side of rpc. 89 * rpclog & 16 will cause informational messages for rare events to be 90 * printed on the server side of rpc. 91 * rpclog & 32 will cause informational messages for rare events to be 92 * printed on the common client/server code paths of rpc. 93 * rpclog & 64 will cause informational messages for manipulation 94 * client-side COTS dispatch list to be printed. 95 */ 96 97 uint_t rpclog = 0; 98 99 100 void 101 rpc_poptimod(vnode_t *vp) 102 { 103 int error, isfound, ret; 104 105 error = strioctl(vp, I_FIND, (intptr_t)"timod", 0, K_TO_K, kcred, 106 &isfound); 107 if (error) { 108 RPCLOG(1, "rpc_poptimod: I_FIND strioctl error %d\n", error); 109 return; 110 } 111 if (isfound) { 112 /* 113 * Pop timod module 114 */ 115 error = strioctl(vp, I_POP, 0, 0, K_TO_K, kcred, &ret); 116 if (error) { 117 RPCLOG(1, "rpc_poptimod: I_POP strioctl error %d\n", 118 error); 119 return; 120 } 121 } 122 } 123 124 /* 125 * Check the passed in ip address for correctness (limited) and return its 126 * type. 127 * 128 * an ipv4 looks like this: 129 * "IP.IP.IP.IP.PORT[top byte].PORT[bottom byte]" 130 * 131 * an ipv6 looks like this: 132 * fec0:A02::2:202:4FCD 133 * or 134 * ::10.9.2.1 135 */ 136 int 137 rpc_iptype( 138 char *ipaddr, 139 int *typeval) 140 { 141 char *cp; 142 int chcnt = 0; 143 int coloncnt = 0; 144 int dotcnt = 0; 145 int numcnt = 0; 146 int hexnumcnt = 0; 147 int othercnt = 0; 148 149 cp = ipaddr; 150 151 /* search for the different type of characters in the ip address */ 152 while ((*cp != '\0') && (chcnt < RPC_MAX_IP_LENGTH)) { 153 switch (*cp) { 154 case ':': 155 coloncnt++; 156 break; 157 case '.': 158 dotcnt++; 159 break; 160 case '0': 161 case '1': 162 case '2': 163 case '3': 164 case '4': 165 case '5': 166 case '6': 167 case '7': 168 case '8': 169 case '9': 170 numcnt++; 171 break; 172 case 'a': 173 case 'A': 174 case 'b': 175 case 'B': 176 case 'c': 177 case 'C': 178 case 'd': 179 case 'D': 180 case 'e': 181 case 'E': 182 case 'f': 183 case 'F': 184 hexnumcnt++; 185 break; 186 default: 187 othercnt++; 188 break; 189 } 190 chcnt++; 191 cp++; 192 } 193 194 /* check for bad ip strings */ 195 if ((chcnt == RPC_MAX_IP_LENGTH) || (othercnt)) 196 return (-1); 197 198 /* if we have a coloncnt, it can only be an ipv6 address */ 199 if (coloncnt) { 200 if ((coloncnt < 2) || (coloncnt > 7)) 201 return (-1); 202 203 *typeval = AF_INET6; 204 } else { 205 /* since there are no colons, make sure it is ipv4 */ 206 if ((hexnumcnt) || (dotcnt != 5)) 207 return (-1); 208 209 *typeval = AF_INET; 210 } 211 return (0); 212 } 213 214 /* 215 * Return a port number from a sockaddr_in expressed in universal address 216 * format. Note that this routine does not work for address families other 217 * than INET. Eventually, we should replace this routine with one that 218 * contacts the rpcbind running locally. 219 */ 220 int 221 rpc_uaddr2port(int af, char *addr) 222 { 223 int p1; 224 int p2; 225 char *next, *p; 226 227 if (af == AF_INET) { 228 /* 229 * A struct sockaddr_in expressed in universal address 230 * format looks like: 231 * 232 * "IP.IP.IP.IP.PORT[top byte].PORT[bottom byte]" 233 * 234 * Where each component expresses as a character, 235 * the corresponding part of the IP address 236 * and port number. 237 * Thus 127.0.0.1, port 2345 looks like: 238 * 239 * 49 50 55 46 48 46 48 46 49 46 57 46 52 49 240 * 1 2 7 . 0 . 0 . 1 . 9 . 4 1 241 * 242 * 2345 = 929base16 = 9.32+9 = 9.41 243 */ 244 (void) strtoi(addr, &next); 245 (void) strtoi(next, &next); 246 (void) strtoi(next, &next); 247 (void) strtoi(next, &next); 248 p1 = strtoi(next, &next); 249 p2 = strtoi(next, &next); 250 251 } else if (af == AF_INET6) { 252 /* 253 * An IPv6 address is expressed in following two formats 254 * fec0:A02::2:202:4FCD or 255 * ::10.9.2.1 256 * An universal address will have porthi.portlo appended to 257 * v6 address. So always look for the last two dots when 258 * extracting port number. 259 */ 260 next = addr; 261 while (next = strchr(next, '.')) { 262 p = ++next; 263 next = strchr(next, '.'); 264 next++; 265 } 266 p1 = strtoi(p, &p); 267 p2 = strtoi(p, &p); 268 RPCLOG(1, "rpc_uaddr2port: IPv6 port %d\n", ((p1 << 8) + p2)); 269 } 270 271 return ((p1 << 8) + p2); 272 } 273 274 /* 275 * Modified strtol(3). Should we be using mi_strtol() instead? 276 */ 277 static int 278 strtoi(char *str, char **ptr) 279 { 280 int c; 281 int val; 282 283 for (val = 0, c = *str++; c >= '0' && c <= '9'; c = *str++) { 284 val *= 10; 285 val += c - '0'; 286 } 287 *ptr = str; 288 return (val); 289 } 290 291 /* 292 * Utilities for manipulating netbuf's. 293 * 294 * Note that loopback addresses are not null-terminated, so these utilities 295 * typically use the strn* string routines. 296 */ 297 298 /* 299 * Utilities to patch a port number (for NC_INET protocols) or a 300 * port name (for NC_LOOPBACK) into a network address. 301 */ 302 303 304 /* 305 * PSARC 2003/523 Contract Private Interface 306 * put_inet_port 307 * Changes must be reviewed by Solaris File Sharing 308 * Changes must be communicated to contract-2003-523@sun.com 309 */ 310 void 311 put_inet_port(struct netbuf *addr, ushort_t port) 312 { 313 /* 314 * Easy - we always patch an unsigned short on top of an 315 * unsigned short. No changes to addr's len or maxlen are 316 * necessary. 317 */ 318 ((struct sockaddr_in *)(addr->buf))->sin_port = port; 319 } 320 321 void 322 put_inet6_port(struct netbuf *addr, ushort_t port) 323 { 324 ((struct sockaddr_in6 *)(addr->buf))->sin6_port = port; 325 } 326 327 void 328 put_loopback_port(struct netbuf *addr, char *port) 329 { 330 char *dot; 331 char *newbuf; 332 int newlen; 333 334 335 /* 336 * We must make sure the addr has enough space for us, 337 * patch in `port', and then adjust addr's len and maxlen 338 * to reflect the change. 339 */ 340 if ((dot = strnrchr(addr->buf, '.', addr->len)) == (char *)NULL) 341 return; 342 343 newlen = (int)((dot - addr->buf + 1) + strlen(port)); 344 if (newlen > addr->maxlen) { 345 newbuf = kmem_zalloc(newlen, KM_SLEEP); 346 bcopy(addr->buf, newbuf, addr->len); 347 kmem_free(addr->buf, addr->maxlen); 348 addr->buf = newbuf; 349 addr->len = addr->maxlen = newlen; 350 dot = strnrchr(addr->buf, '.', addr->len); 351 } else { 352 addr->len = newlen; 353 } 354 355 (void) strncpy(++dot, port, strlen(port)); 356 } 357 358 /* 359 * Convert a loopback universal address to a loopback transport address. 360 */ 361 static void 362 loopb_u2t(const char *ua, struct netbuf *addr) 363 { 364 size_t stringlen = strlen(ua) + 1; 365 const char *univp; /* ptr into universal addr */ 366 char *transp; /* ptr into transport addr */ 367 368 /* Make sure the netbuf will be big enough. */ 369 if (addr->maxlen < stringlen) { 370 grow_netbuf(addr, stringlen); 371 } 372 373 univp = ua; 374 transp = addr->buf; 375 while (*univp != '\0') { 376 if (*univp == '\\' && *(univp+1) == '\\') { 377 *transp = '\\'; 378 univp += 2; 379 } else if (*univp == '\\') { 380 /* octal character */ 381 *transp = (((*(univp+1) - '0') & 3) << 6) + 382 (((*(univp+2) - '0') & 7) << 3) + 383 ((*(univp+3) - '0') & 7); 384 univp += 4; 385 } else { 386 *transp = *univp; 387 univp++; 388 } 389 transp++; 390 } 391 392 addr->len = (unsigned int)(transp - addr->buf); 393 ASSERT(addr->len <= addr->maxlen); 394 } 395 396 /* 397 * Make sure the given netbuf has a maxlen at least as big as the given 398 * length. 399 */ 400 static void 401 grow_netbuf(struct netbuf *nb, size_t length) 402 { 403 char *newbuf; 404 405 if (nb->maxlen >= length) 406 return; 407 408 newbuf = kmem_zalloc(length, KM_SLEEP); 409 bcopy(nb->buf, newbuf, nb->len); 410 kmem_free(nb->buf, nb->maxlen); 411 nb->buf = newbuf; 412 nb->maxlen = (unsigned int)length; 413 } 414 415 /* 416 * XXX: xdr_pmap is here, because it's the only XDR function 417 * of portmap protocol. If there'll be more portmap functions, 418 * it would be better to put them to a separate file. 419 */ 420 bool_t 421 xdr_pmap(XDR *xdrs, PMAP *objp) 422 { 423 if (!xdr_rpcprog(xdrs, &objp->pm_prog)) 424 return (FALSE); 425 if (!xdr_rpcvers(xdrs, &objp->pm_vers)) 426 return (FALSE); 427 if (!xdr_rpcprot(xdrs, &objp->pm_prot)) 428 return (FALSE); 429 if (!xdr_u_int(xdrs, &objp->pm_port)) 430 return (FALSE); 431 432 return (TRUE); 433 } 434 435 /* 436 * Get remote port via PORTMAP protocol version 2 (works for IPv4 only) 437 * according to RFC 1833, section 3. 438 */ 439 static enum clnt_stat 440 portmap_getport(struct knetconfig *config, rpcprog_t prog, rpcvers_t vers, 441 struct netbuf *addr, struct timeval tmo) 442 { 443 enum clnt_stat status; 444 CLIENT *client = NULL; 445 k_sigset_t oldmask; 446 k_sigset_t newmask; 447 ushort_t port = 0; 448 struct pmap parms; 449 450 ASSERT(strcmp(config->knc_protofmly, NC_INET) == 0); 451 452 bzero(&parms, sizeof (parms)); 453 parms.pm_prog = prog; 454 parms.pm_vers = vers; 455 if (strcmp(config->knc_proto, NC_TCP) == 0) { 456 parms.pm_prot = IPPROTO_TCP; 457 } else { /* NC_UDP */ 458 parms.pm_prot = IPPROTO_UDP; 459 } 460 461 462 /* 463 * Mask all signals before doing RPC network operations 464 * in the same way rpcbind_getaddr() does (see comments 465 * there). 466 */ 467 sigfillset(&newmask); 468 sigreplace(&newmask, &oldmask); 469 470 if (clnt_tli_kcreate(config, addr, PMAPPROG, 471 PMAPVERS, 0, 0, CRED(), &client)) { 472 sigreplace(&oldmask, (k_sigset_t *)NULL); 473 return (RPC_TLIERROR); 474 } 475 476 client->cl_nosignal = 1; 477 status = CLNT_CALL(client, PMAPPROC_GETPORT, 478 xdr_pmap, (char *)&parms, 479 xdr_u_short, (char *)&port, tmo); 480 481 sigreplace(&oldmask, (k_sigset_t *)NULL); 482 if (status != RPC_SUCCESS) 483 goto out; 484 if (port == 0) { 485 status = RPC_PROGNOTREGISTERED; 486 goto out; 487 } 488 489 put_inet_port(addr, ntohs(port)); 490 491 out: 492 auth_destroy(client->cl_auth); 493 clnt_destroy(client); 494 495 return (status); 496 } 497 498 /* 499 * Try to get the address for the desired service by using the rpcbind 500 * protocol. Ignores signals. If addr is a loopback address, it is 501 * expected to be initialized to "localhost.". 502 * rpcbind_getaddr() is able to work with RPCBIND protocol version 3 and 4 503 * and PORTMAP protocol version 2. 504 * It tries version 4 at first, then version 3 and finally (if both failed) 505 * it tries portmapper protocol version 2. 506 */ 507 enum clnt_stat 508 rpcbind_getaddr(struct knetconfig *config, rpcprog_t prog, rpcvers_t vers, 509 struct netbuf *addr) 510 { 511 char *ua = NULL; 512 enum clnt_stat status; 513 RPCB parms; 514 struct timeval tmo; 515 k_sigset_t oldmask; 516 k_sigset_t newmask; 517 ushort_t port; 518 int iptype; 519 rpcvers_t rpcbv; 520 521 /* 522 * Call rpcbind (local or remote) to get an address we can use 523 * in an RPC client handle. 524 */ 525 tmo.tv_sec = RPC_PMAP_TIMEOUT; 526 tmo.tv_usec = 0; 527 parms.r_prog = prog; 528 parms.r_vers = vers; 529 parms.r_addr = parms.r_owner = ""; 530 531 if (strcmp(config->knc_protofmly, NC_INET) == 0) { 532 put_inet_port(addr, htons(PMAPPORT)); 533 534 if (strcmp(config->knc_proto, NC_TCP) == 0) 535 parms.r_netid = "tcp"; 536 else 537 parms.r_netid = "udp"; 538 539 } else if (strcmp(config->knc_protofmly, NC_INET6) == 0) { 540 if (strcmp(config->knc_proto, NC_TCP) == 0) 541 parms.r_netid = "tcp6"; 542 else 543 parms.r_netid = "udp6"; 544 put_inet6_port(addr, htons(PMAPPORT)); 545 } else if (strcmp(config->knc_protofmly, NC_LOOPBACK) == 0) { 546 ASSERT(strnrchr(addr->buf, '.', addr->len) != NULL); 547 if (config->knc_semantics == NC_TPI_COTS_ORD) 548 parms.r_netid = "ticotsord"; 549 else if (config->knc_semantics == NC_TPI_COTS) 550 parms.r_netid = "ticots"; 551 else 552 parms.r_netid = "ticlts"; 553 554 put_loopback_port(addr, "rpc"); 555 } else { 556 status = RPC_UNKNOWNPROTO; 557 goto out; 558 } 559 560 /* 561 * Try RPCBIND versions 4 and 3 (if 4 fails). 562 */ 563 for (rpcbv = RPCBVERS4; rpcbv >= RPCBVERS; rpcbv--) { 564 CLIENT *client = NULL; 565 566 if (ua != NULL) { 567 xdr_free(xdr_wrapstring, (char *)&ua); 568 ua = NULL; 569 } 570 571 /* 572 * Mask signals for the duration of the handle creation and 573 * RPC calls. This allows relatively normal operation with a 574 * signal already posted to our thread (e.g., when we are 575 * sending an NLM_CANCEL in response to catching a signal). 576 * 577 * Any further exit paths from this routine must restore 578 * the original signal mask. 579 */ 580 sigfillset(&newmask); 581 sigreplace(&newmask, &oldmask); 582 583 if (clnt_tli_kcreate(config, addr, RPCBPROG, 584 rpcbv, 0, 0, CRED(), &client)) { 585 status = RPC_TLIERROR; 586 sigreplace(&oldmask, (k_sigset_t *)NULL); 587 continue; 588 } 589 590 client->cl_nosignal = 1; 591 status = CLNT_CALL(client, RPCBPROC_GETADDR, 592 xdr_rpcb, (char *)&parms, 593 xdr_wrapstring, (char *)&ua, tmo); 594 595 sigreplace(&oldmask, (k_sigset_t *)NULL); 596 auth_destroy(client->cl_auth); 597 clnt_destroy(client); 598 599 if (status == RPC_SUCCESS) { 600 if (ua == NULL || *ua == '\0') { 601 status = RPC_PROGNOTREGISTERED; 602 continue; 603 } 604 605 break; 606 } 607 } 608 if (status != RPC_SUCCESS) 609 goto try_portmap; 610 611 /* 612 * Convert the universal address to the transport address. 613 * Theoretically, we should call the local rpcbind to translate 614 * from the universal address to the transport address, but it gets 615 * complicated (e.g., there's no direct way to tell rpcbind that we 616 * want an IP address instead of a loopback address). Note that 617 * the transport address is potentially host-specific, so we can't 618 * just ask the remote rpcbind, because it might give us the wrong 619 * answer. 620 */ 621 if (strcmp(config->knc_protofmly, NC_INET) == 0) { 622 /* make sure that the ip address is the correct type */ 623 if (rpc_iptype(ua, &iptype) != 0) { 624 status = RPC_UNKNOWNADDR; 625 goto try_portmap; 626 } 627 port = rpc_uaddr2port(iptype, ua); 628 put_inet_port(addr, ntohs(port)); 629 } else if (strcmp(config->knc_protofmly, NC_INET6) == 0) { 630 /* make sure that the ip address is the correct type */ 631 if (rpc_iptype(ua, &iptype) != 0) { 632 status = RPC_UNKNOWNADDR; 633 goto try_portmap; 634 } 635 port = rpc_uaddr2port(iptype, ua); 636 put_inet6_port(addr, ntohs(port)); 637 } else if (strcmp(config->knc_protofmly, NC_LOOPBACK) == 0) { 638 loopb_u2t(ua, addr); 639 } else { 640 /* "can't happen" - should have been checked for above */ 641 cmn_err(CE_PANIC, "rpcbind_getaddr: bad protocol family"); 642 } 643 644 try_portmap: 645 if (status != RPC_SUCCESS && 646 strcmp(config->knc_protofmly, NC_INET) == 0) { 647 /* 648 * For IPv4 try to get remote port via PORTMAP protocol. 649 * NOTE: if we're here, then all attempts to get remote 650 * port via RPCBIND protocol failed. 651 */ 652 653 DTRACE_PROBE1(try__portmap, enum clnt_stat, status); 654 status = portmap_getport(config, prog, vers, addr, tmo); 655 } 656 657 out: 658 if (ua != NULL) 659 xdr_free(xdr_wrapstring, (char *)&ua); 660 return (status); 661 } 662 663 static const char *tpiprims[] = { 664 "T_CONN_REQ 0 connection request", 665 "T_CONN_RES 1 connection response", 666 "T_DISCON_REQ 2 disconnect request", 667 "T_DATA_REQ 3 data request", 668 "T_EXDATA_REQ 4 expedited data request", 669 "T_INFO_REQ 5 information request", 670 "T_BIND_REQ 6 bind request", 671 "T_UNBIND_REQ 7 unbind request", 672 "T_UNITDATA_REQ 8 unitdata request", 673 "T_OPTMGMT_REQ 9 manage options req", 674 "T_ORDREL_REQ 10 orderly release req", 675 "T_CONN_IND 11 connection indication", 676 "T_CONN_CON 12 connection confirmation", 677 "T_DISCON_IND 13 disconnect indication", 678 "T_DATA_IND 14 data indication", 679 "T_EXDATA_IND 15 expeditied data indication", 680 "T_INFO_ACK 16 information acknowledgment", 681 "T_BIND_ACK 17 bind acknowledment", 682 "T_ERROR_ACK 18 error acknowledgment", 683 "T_OK_ACK 19 ok acknowledgment", 684 "T_UNITDATA_IND 20 unitdata indication", 685 "T_UDERROR_IND 21 unitdata error indication", 686 "T_OPTMGMT_ACK 22 manage options ack", 687 "T_ORDREL_IND 23 orderly release ind" 688 }; 689 690 691 const char * 692 rpc_tpiprim2name(uint_t prim) 693 { 694 if (prim > (sizeof (tpiprims) / sizeof (tpiprims[0]) - 1)) 695 return ("unknown primitive"); 696 697 return (tpiprims[prim]); 698 } 699 700 static const char *tpierrs[] = { 701 "error zero 0", 702 "TBADADDR 1 incorrect addr format", 703 "TBADOPT 2 incorrect option format", 704 "TACCES 3 incorrect permissions", 705 "TBADF 4 illegal transport fd", 706 "TNOADDR 5 couldn't allocate addr", 707 "TOUTSTATE 6 out of state", 708 "TBADSEQ 7 bad call sequnce number", 709 "TSYSERR 8 system error", 710 "TLOOK 9 event requires attention", 711 "TBADDATA 10 illegal amount of data", 712 "TBUFOVFLW 11 buffer not large enough", 713 "TFLOW 12 flow control", 714 "TNODATA 13 no data", 715 "TNODIS 14 discon_ind not found on q", 716 "TNOUDERR 15 unitdata error not found", 717 "TBADFLAG 16 bad flags", 718 "TNOREL 17 no ord rel found on q", 719 "TNOTSUPPORT 18 primitive not supported", 720 "TSTATECHNG 19 state is in process of changing" 721 }; 722 723 724 const char * 725 rpc_tpierr2name(uint_t err) 726 { 727 if (err > (sizeof (tpierrs) / sizeof (tpierrs[0]) - 1)) 728 return ("unknown error"); 729 730 return (tpierrs[err]); 731 } 732 733 /* 734 * derive the code from user land inet_top6 735 * convert IPv6 binary address into presentation (printable) format 736 */ 737 #define INADDRSZ 4 738 #define IN6ADDRSZ 16 739 #define INT16SZ 2 740 const char * 741 kinet_ntop6(uchar_t *src, char *dst, size_t size) 742 { 743 /* 744 * Note that int32_t and int16_t need only be "at least" large enough 745 * to contain a value of the specified size. On some systems, like 746 * Crays, there is no such thing as an integer variable with 16 bits. 747 * Keep this in mind if you think this function should have been coded 748 * to use pointer overlays. All the world's not a VAX. 749 */ 750 char tmp[sizeof ("ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255")]; 751 char *tp; 752 struct { int base, len; } best, cur; 753 uint_t words[IN6ADDRSZ / INT16SZ]; 754 int i; 755 size_t len; /* this is used to track the sprintf len */ 756 757 /* 758 * Preprocess: 759 * Copy the input (bytewise) array into a wordwise array. 760 * Find the longest run of 0x00's in src[] for :: shorthanding. 761 */ 762 763 bzero(words, sizeof (words)); 764 for (i = 0; i < IN6ADDRSZ; i++) 765 words[i / 2] |= (src[i] << ((1 - (i % 2)) << 3)); 766 best.base = -1; 767 cur.base = -1; 768 769 for (i = 0; i < (IN6ADDRSZ / INT16SZ); i++) { 770 if (words[i] == 0) { 771 if (cur.base == -1) 772 cur.base = i, cur.len = 1; 773 else 774 cur.len++; 775 } else { 776 if (cur.base != -1) { 777 if (best.base == -1 || cur.len > best.len) 778 best = cur; 779 cur.base = -1; 780 } 781 } 782 } 783 if (cur.base != -1) { 784 if (best.base == -1 || cur.len > best.len) 785 best = cur; 786 } 787 788 if (best.base != -1 && best.len < 2) 789 best.base = -1; 790 791 /* 792 * Format the result. 793 */ 794 tp = tmp; 795 for (i = 0; i < (IN6ADDRSZ / INT16SZ); i++) { 796 /* Are we inside the best run of 0x00's? */ 797 if (best.base != -1 && i >= best.base && 798 i < (best.base + best.len)) { 799 if (i == best.base) 800 *tp++ = ':'; 801 continue; 802 } 803 /* Are we following an initial run of 0x00s or any real hex? */ 804 if (i != 0) 805 *tp++ = ':'; 806 (void) sprintf(tp, "%x", words[i]); 807 len = strlen(tp); 808 tp += len; 809 } 810 /* Was it a trailing run of 0x00's? */ 811 if (best.base != -1 && (best.base + best.len) == (IN6ADDRSZ / INT16SZ)) 812 *tp++ = ':'; 813 *tp++ = '\0'; 814 815 /* 816 * Check for overflow, copy, and we're done. 817 */ 818 if ((int)(tp - tmp) > size) { 819 return (NULL); 820 } 821 (void) strcpy(dst, tmp); 822 return (dst); 823 } 824