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
rpc_poptimod(vnode_t * vp)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
rpc_iptype(char * ipaddr,int * typeval)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
rpc_uaddr2port(int af,char * addr)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
strtoi(char * str,char ** ptr)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
put_inet_port(struct netbuf * addr,ushort_t port)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
put_inet6_port(struct netbuf * addr,ushort_t port)322 put_inet6_port(struct netbuf *addr, ushort_t port)
323 {
324 ((struct sockaddr_in6 *)(addr->buf))->sin6_port = port;
325 }
326
327 void
put_loopback_port(struct netbuf * addr,char * port)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
loopb_u2t(const char * ua,struct netbuf * addr)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 != NULL) {
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
grow_netbuf(struct netbuf * nb,size_t length)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
xdr_pmap(XDR * xdrs,PMAP * objp)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
portmap_getport(struct knetconfig * config,rpcprog_t prog,rpcvers_t vers,struct netbuf * addr,struct timeval tmo)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
rpcbind_getaddr(struct knetconfig * config,rpcprog_t prog,rpcvers_t vers,struct netbuf * addr)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 == NULL) {
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 *
rpc_tpiprim2name(uint_t prim)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 *
rpc_tpierr2name(uint_t err)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 *
kinet_ntop6(src,dst,size)741 kinet_ntop6(src, dst, size)
742 uchar_t *src;
743 char *dst;
744 size_t size;
745 {
746 /*
747 * Note that int32_t and int16_t need only be "at least" large enough
748 * to contain a value of the specified size. On some systems, like
749 * Crays, there is no such thing as an integer variable with 16 bits.
750 * Keep this in mind if you think this function should have been coded
751 * to use pointer overlays. All the world's not a VAX.
752 */
753 char tmp[sizeof ("ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255")];
754 char *tp;
755 struct { int base, len; } best, cur;
756 uint_t words[IN6ADDRSZ / INT16SZ];
757 int i;
758 size_t len; /* this is used to track the sprintf len */
759
760 /*
761 * Preprocess:
762 * Copy the input (bytewise) array into a wordwise array.
763 * Find the longest run of 0x00's in src[] for :: shorthanding.
764 */
765
766 bzero(words, sizeof (words));
767 for (i = 0; i < IN6ADDRSZ; i++)
768 words[i / 2] |= (src[i] << ((1 - (i % 2)) << 3));
769 best.base = -1;
770 cur.base = -1;
771
772 for (i = 0; i < (IN6ADDRSZ / INT16SZ); i++) {
773 if (words[i] == 0) {
774 if (cur.base == -1)
775 cur.base = i, cur.len = 1;
776 else
777 cur.len++;
778 } else {
779 if (cur.base != -1) {
780 if (best.base == -1 || cur.len > best.len)
781 best = cur;
782 cur.base = -1;
783 }
784 }
785 }
786 if (cur.base != -1) {
787 if (best.base == -1 || cur.len > best.len)
788 best = cur;
789 }
790
791 if (best.base != -1 && best.len < 2)
792 best.base = -1;
793
794 /*
795 * Format the result.
796 */
797 tp = tmp;
798 for (i = 0; i < (IN6ADDRSZ / INT16SZ); i++) {
799 /* Are we inside the best run of 0x00's? */
800 if (best.base != -1 && i >= best.base &&
801 i < (best.base + best.len)) {
802 if (i == best.base)
803 *tp++ = ':';
804 continue;
805 }
806 /* Are we following an initial run of 0x00s or any real hex? */
807 if (i != 0)
808 *tp++ = ':';
809 (void) sprintf(tp, "%x", words[i]);
810 len = strlen(tp);
811 tp += len;
812 }
813 /* Was it a trailing run of 0x00's? */
814 if (best.base != -1 && (best.base + best.len) == (IN6ADDRSZ / INT16SZ))
815 *tp++ = ':';
816 *tp++ = '\0';
817
818 /*
819 * Check for overflow, copy, and we're done.
820 */
821 if ((int)(tp - tmp) > size) {
822 return (NULL);
823 }
824 (void) strcpy(dst, tmp);
825 return (dst);
826 }
827