?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
3882 Remove xmod & friends
[illumos-gate.git] / usr / src / uts / common / inet / ip / conn_opt.c
blobbcbc1c49497585ff4bbbbcaa425e4bd2be704c4d
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 (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
24 */
25 /* Copyright (c) 1990 Mentat Inc. */
26
27 #include <sys/types.h>
28 #include <sys/stream.h>
29 #include <sys/strsun.h>
30 #define _SUN_TPI_VERSION 2
31 #include <sys/tihdr.h>
32 #include <sys/xti_inet.h>
33 #include <sys/ucred.h>
34 #include <sys/zone.h>
35 #include <sys/ddi.h>
36 #include <sys/sunddi.h>
37 #include <sys/cmn_err.h>
38 #include <sys/debug.h>
39 #include <sys/atomic.h>
40 #include <sys/policy.h>
41
42 #include <sys/systm.h>
43 #include <sys/param.h>
44 #include <sys/kmem.h>
45 #include <sys/sdt.h>
46 #include <sys/socket.h>
47 #include <sys/ethernet.h>
48 #include <sys/mac.h>
49 #include <net/if.h>
50 #include <net/if_types.h>
51 #include <net/if_arp.h>
52 #include <net/route.h>
53 #include <sys/sockio.h>
54 #include <netinet/in.h>
55 #include <net/if_dl.h>
56
57 #include <inet/common.h>
58 #include <inet/mi.h>
59 #include <inet/mib2.h>
60 #include <inet/nd.h>
61 #include <inet/arp.h>
62 #include <inet/snmpcom.h>
63 #include <inet/kstatcom.h>
64
65 #include <netinet/igmp_var.h>
66 #include <netinet/ip6.h>
67 #include <netinet/icmp6.h>
68 #include <netinet/sctp.h>
69
70 #include <inet/ip.h>
71 #include <inet/ip_impl.h>
72 #include <inet/ip6.h>
73 #include <inet/ip6_asp.h>
74 #include <inet/tcp.h>
75 #include <inet/ip_multi.h>
76 #include <inet/ip_if.h>
77 #include <inet/ip_ire.h>
78 #include <inet/ip_ftable.h>
79 #include <inet/ip_rts.h>
80 #include <inet/optcom.h>
81 #include <inet/ip_ndp.h>
82 #include <inet/ip_listutils.h>
83 #include <netinet/igmp.h>
84 #include <netinet/ip_mroute.h>
85 #include <netinet/udp.h>
86 #include <inet/ipp_common.h>
87
88 #include <net/pfkeyv2.h>
89 #include <inet/sadb.h>
90 #include <inet/ipsec_impl.h>
91 #include <inet/ipdrop.h>
92 #include <inet/ip_netinfo.h>
93
94 #include <inet/ipclassifier.h>
95 #include <inet/sctp_ip.h>
96 #include <inet/sctp/sctp_impl.h>
97 #include <inet/udp_impl.h>
98 #include <sys/sunddi.h>
99
100 #include <sys/tsol/label.h>
101 #include <sys/tsol/tnet.h>
102
103 /*
104 * Return how much size is needed for the different ancillary data items
105 */
106 uint_t
107 conn_recvancillary_size(conn_t *connp, crb_t recv_ancillary,
108 ip_recv_attr_t *ira, mblk_t *mp, ip_pkt_t *ipp)
109 {
110 uint_t ancil_size;
111 ip_stack_t *ipst = connp->conn_netstack->netstack_ip;
112
113 /*
114 * If IP_RECVDSTADDR is set we include the destination IP
115 * address as an option. With IP_RECVOPTS we include all
116 * the IP options.
117 */
118 ancil_size = 0;
119 if (recv_ancillary.crb_recvdstaddr &&
120 (ira->ira_flags & IRAF_IS_IPV4)) {
121 ancil_size += sizeof (struct T_opthdr) +
122 sizeof (struct in_addr);
123 IP_STAT(ipst, conn_in_recvdstaddr);
124 }
125
126 /*
127 * ip_recvpktinfo is used for both AF_INET and AF_INET6 but
128 * are different
129 */
130 if (recv_ancillary.crb_ip_recvpktinfo &&
131 connp->conn_family == AF_INET) {
132 ancil_size += sizeof (struct T_opthdr) +
133 sizeof (struct in_pktinfo);
134 IP_STAT(ipst, conn_in_recvpktinfo);
135 }
136
137 if ((recv_ancillary.crb_recvopts) &&
138 (ipp->ipp_fields & IPPF_IPV4_OPTIONS)) {
139 ancil_size += sizeof (struct T_opthdr) +
140 ipp->ipp_ipv4_options_len;
141 IP_STAT(ipst, conn_in_recvopts);
142 }
143
144 if (recv_ancillary.crb_recvslla) {
145 ip_stack_t *ipst = connp->conn_netstack->netstack_ip;
146 ill_t *ill;
147
148 /* Make sure ira_l2src is setup if not already */
149 if (!(ira->ira_flags & IRAF_L2SRC_SET)) {
150 ill = ill_lookup_on_ifindex(ira->ira_rifindex, B_FALSE,
151 ipst);
152 if (ill != NULL) {
153 ip_setl2src(mp, ira, ill);
154 ill_refrele(ill);
155 }
156 }
157 ancil_size += sizeof (struct T_opthdr) +
158 sizeof (struct sockaddr_dl);
159 IP_STAT(ipst, conn_in_recvslla);
160 }
161
162 if (recv_ancillary.crb_recvif) {
163 ancil_size += sizeof (struct T_opthdr) + sizeof (uint_t);
164 IP_STAT(ipst, conn_in_recvif);
165 }
166
167 /*
168 * ip_recvpktinfo is used for both AF_INET and AF_INET6 but
169 * are different
170 */
171 if (recv_ancillary.crb_ip_recvpktinfo &&
172 connp->conn_family == AF_INET6) {
173 ancil_size += sizeof (struct T_opthdr) +
174 sizeof (struct in6_pktinfo);
175 IP_STAT(ipst, conn_in_recvpktinfo);
176 }
177
178 if (recv_ancillary.crb_ipv6_recvhoplimit) {
179 ancil_size += sizeof (struct T_opthdr) + sizeof (int);
180 IP_STAT(ipst, conn_in_recvhoplimit);
181 }
182
183 if (recv_ancillary.crb_ipv6_recvtclass) {
184 ancil_size += sizeof (struct T_opthdr) + sizeof (int);
185 IP_STAT(ipst, conn_in_recvtclass);
186 }
187
188 if (recv_ancillary.crb_ipv6_recvhopopts &&
189 (ipp->ipp_fields & IPPF_HOPOPTS)) {
190 ancil_size += sizeof (struct T_opthdr) + ipp->ipp_hopoptslen;
191 IP_STAT(ipst, conn_in_recvhopopts);
192 }
193 /*
194 * To honor RFC3542 when an application asks for both IPV6_RECVDSTOPTS
195 * and IPV6_RECVRTHDR, we pass up the item rthdrdstopts (the destination
196 * options that appear before a routing header.
197 * We also pass them up if IPV6_RECVRTHDRDSTOPTS is set.
198 */
199 if (ipp->ipp_fields & IPPF_RTHDRDSTOPTS) {
200 if (recv_ancillary.crb_ipv6_recvrthdrdstopts ||
201 (recv_ancillary.crb_ipv6_recvdstopts &&
202 recv_ancillary.crb_ipv6_recvrthdr)) {
203 ancil_size += sizeof (struct T_opthdr) +
204 ipp->ipp_rthdrdstoptslen;
205 IP_STAT(ipst, conn_in_recvrthdrdstopts);
206 }
207 }
208 if ((recv_ancillary.crb_ipv6_recvrthdr) &&
209 (ipp->ipp_fields & IPPF_RTHDR)) {
210 ancil_size += sizeof (struct T_opthdr) + ipp->ipp_rthdrlen;
211 IP_STAT(ipst, conn_in_recvrthdr);
212 }
213 if ((recv_ancillary.crb_ipv6_recvdstopts ||
214 recv_ancillary.crb_old_ipv6_recvdstopts) &&
215 (ipp->ipp_fields & IPPF_DSTOPTS)) {
216 ancil_size += sizeof (struct T_opthdr) + ipp->ipp_dstoptslen;
217 IP_STAT(ipst, conn_in_recvdstopts);
218 }
219 if (recv_ancillary.crb_recvucred && ira->ira_cred != NULL) {
220 ancil_size += sizeof (struct T_opthdr) +
221 ucredminsize(ira->ira_cred);
222 IP_STAT(ipst, conn_in_recvucred);
223 }
224
225 /*
226 * If SO_TIMESTAMP is set allocate the appropriate sized
227 * buffer. Since gethrestime() expects a pointer aligned
228 * argument, we allocate space necessary for extra
229 * alignment (even though it might not be used).
230 */
231 if (recv_ancillary.crb_timestamp) {
232 ancil_size += sizeof (struct T_opthdr) +
233 sizeof (timestruc_t) + _POINTER_ALIGNMENT;
234 IP_STAT(ipst, conn_in_timestamp);
235 }
236
237 /*
238 * If IP_RECVTTL is set allocate the appropriate sized buffer
239 */
240 if (recv_ancillary.crb_recvttl &&
241 (ira->ira_flags & IRAF_IS_IPV4)) {
242 ancil_size += sizeof (struct T_opthdr) + sizeof (uint8_t);
243 IP_STAT(ipst, conn_in_recvttl);
244 }
245
246 return (ancil_size);
247 }
248
249 /*
250 * Lay down the ancillary data items at "ancil_buf".
251 * Assumes caller has used conn_recvancillary_size to allocate a sufficiently
252 * large buffer - ancil_size.
253 */
254 void
255 conn_recvancillary_add(conn_t *connp, crb_t recv_ancillary,
256 ip_recv_attr_t *ira, ip_pkt_t *ipp, uchar_t *ancil_buf, uint_t ancil_size)
257 {
258 /*
259 * Copy in destination address before options to avoid
260 * any padding issues.
261 */
262 if (recv_ancillary.crb_recvdstaddr &&
263 (ira->ira_flags & IRAF_IS_IPV4)) {
264 struct T_opthdr *toh;
265 ipaddr_t *dstptr;
266
267 toh = (struct T_opthdr *)ancil_buf;
268 toh->level = IPPROTO_IP;
269 toh->name = IP_RECVDSTADDR;
270 toh->len = sizeof (struct T_opthdr) + sizeof (ipaddr_t);
271 toh->status = 0;
272 ancil_buf += sizeof (struct T_opthdr);
273 dstptr = (ipaddr_t *)ancil_buf;
274 *dstptr = ipp->ipp_addr_v4;
275 ancil_buf += sizeof (ipaddr_t);
276 ancil_size -= toh->len;
277 }
278
279 /*
280 * ip_recvpktinfo is used for both AF_INET and AF_INET6 but
281 * are different
282 */
283 if (recv_ancillary.crb_ip_recvpktinfo &&
284 connp->conn_family == AF_INET) {
285 ip_stack_t *ipst = connp->conn_netstack->netstack_ip;
286 struct T_opthdr *toh;
287 struct in_pktinfo *pktinfop;
288 ill_t *ill;
289 ipif_t *ipif;
290
291 toh = (struct T_opthdr *)ancil_buf;
292 toh->level = IPPROTO_IP;
293 toh->name = IP_PKTINFO;
294 toh->len = sizeof (struct T_opthdr) + sizeof (*pktinfop);
295 toh->status = 0;
296 ancil_buf += sizeof (struct T_opthdr);
297 pktinfop = (struct in_pktinfo *)ancil_buf;
298
299 pktinfop->ipi_ifindex = ira->ira_ruifindex;
300 pktinfop->ipi_spec_dst.s_addr = INADDR_ANY;
301
302 /* Find a good address to report */
303 ill = ill_lookup_on_ifindex(ira->ira_ruifindex, B_FALSE, ipst);
304 if (ill != NULL) {
305 ipif = ipif_good_addr(ill, IPCL_ZONEID(connp));
306 if (ipif != NULL) {
307 pktinfop->ipi_spec_dst.s_addr =
308 ipif->ipif_lcl_addr;
309 ipif_refrele(ipif);
310 }
311 ill_refrele(ill);
312 }
313 pktinfop->ipi_addr.s_addr = ipp->ipp_addr_v4;
314 ancil_buf += sizeof (struct in_pktinfo);
315 ancil_size -= toh->len;
316 }
317
318 if ((recv_ancillary.crb_recvopts) &&
319 (ipp->ipp_fields & IPPF_IPV4_OPTIONS)) {
320 struct T_opthdr *toh;
321
322 toh = (struct T_opthdr *)ancil_buf;
323 toh->level = IPPROTO_IP;
324 toh->name = IP_RECVOPTS;
325 toh->len = sizeof (struct T_opthdr) + ipp->ipp_ipv4_options_len;
326 toh->status = 0;
327 ancil_buf += sizeof (struct T_opthdr);
328 bcopy(ipp->ipp_ipv4_options, ancil_buf,
329 ipp->ipp_ipv4_options_len);
330 ancil_buf += ipp->ipp_ipv4_options_len;
331 ancil_size -= toh->len;
332 }
333
334 if (recv_ancillary.crb_recvslla) {
335 ip_stack_t *ipst = connp->conn_netstack->netstack_ip;
336 struct T_opthdr *toh;
337 struct sockaddr_dl *dstptr;
338 ill_t *ill;
339 int alen = 0;
340
341 ill = ill_lookup_on_ifindex(ira->ira_rifindex, B_FALSE, ipst);
342 if (ill != NULL)
343 alen = ill->ill_phys_addr_length;
344
345 /*
346 * For loopback multicast and broadcast the packet arrives
347 * with ira_ruifdex being the physical interface, but
348 * ira_l2src is all zero since ip_postfrag_loopback doesn't
349 * know our l2src. We don't report the address in that case.
350 */
351 if (ira->ira_flags & IRAF_LOOPBACK)
352 alen = 0;
353
354 toh = (struct T_opthdr *)ancil_buf;
355 toh->level = IPPROTO_IP;
356 toh->name = IP_RECVSLLA;
357 toh->len = sizeof (struct T_opthdr) +
358 sizeof (struct sockaddr_dl);
359 toh->status = 0;
360 ancil_buf += sizeof (struct T_opthdr);
361 dstptr = (struct sockaddr_dl *)ancil_buf;
362 dstptr->sdl_family = AF_LINK;
363 dstptr->sdl_index = ira->ira_ruifindex;
364 if (ill != NULL)
365 dstptr->sdl_type = ill->ill_type;
366 else
367 dstptr->sdl_type = 0;
368 dstptr->sdl_nlen = 0;
369 dstptr->sdl_alen = alen;
370 dstptr->sdl_slen = 0;
371 bcopy(ira->ira_l2src, dstptr->sdl_data, alen);
372 ancil_buf += sizeof (struct sockaddr_dl);
373 ancil_size -= toh->len;
374 if (ill != NULL)
375 ill_refrele(ill);
376 }
377
378 if (recv_ancillary.crb_recvif) {
379 struct T_opthdr *toh;
380 uint_t *dstptr;
381
382 toh = (struct T_opthdr *)ancil_buf;
383 toh->level = IPPROTO_IP;
384 toh->name = IP_RECVIF;
385 toh->len = sizeof (struct T_opthdr) + sizeof (uint_t);
386 toh->status = 0;
387 ancil_buf += sizeof (struct T_opthdr);
388 dstptr = (uint_t *)ancil_buf;
389 *dstptr = ira->ira_ruifindex;
390 ancil_buf += sizeof (uint_t);
391 ancil_size -= toh->len;
392 }
393
394 /*
395 * ip_recvpktinfo is used for both AF_INET and AF_INET6 but
396 * are different
397 */
398 if (recv_ancillary.crb_ip_recvpktinfo &&
399 connp->conn_family == AF_INET6) {
400 struct T_opthdr *toh;
401 struct in6_pktinfo *pkti;
402
403 toh = (struct T_opthdr *)ancil_buf;
404 toh->level = IPPROTO_IPV6;
405 toh->name = IPV6_PKTINFO;
406 toh->len = sizeof (struct T_opthdr) + sizeof (*pkti);
407 toh->status = 0;
408 ancil_buf += sizeof (struct T_opthdr);
409 pkti = (struct in6_pktinfo *)ancil_buf;
410 if (ira->ira_flags & IRAF_IS_IPV4) {
411 IN6_IPADDR_TO_V4MAPPED(ipp->ipp_addr_v4,
412 &pkti->ipi6_addr);
413 } else {
414 pkti->ipi6_addr = ipp->ipp_addr;
415 }
416 pkti->ipi6_ifindex = ira->ira_ruifindex;
417
418 ancil_buf += sizeof (*pkti);
419 ancil_size -= toh->len;
420 }
421 if (recv_ancillary.crb_ipv6_recvhoplimit) {
422 struct T_opthdr *toh;
423
424 toh = (struct T_opthdr *)ancil_buf;
425 toh->level = IPPROTO_IPV6;
426 toh->name = IPV6_HOPLIMIT;
427 toh->len = sizeof (struct T_opthdr) + sizeof (uint_t);
428 toh->status = 0;
429 ancil_buf += sizeof (struct T_opthdr);
430 *(uint_t *)ancil_buf = ipp->ipp_hoplimit;
431 ancil_buf += sizeof (uint_t);
432 ancil_size -= toh->len;
433 }
434 if (recv_ancillary.crb_ipv6_recvtclass) {
435 struct T_opthdr *toh;
436
437 toh = (struct T_opthdr *)ancil_buf;
438 toh->level = IPPROTO_IPV6;
439 toh->name = IPV6_TCLASS;
440 toh->len = sizeof (struct T_opthdr) + sizeof (uint_t);
441 toh->status = 0;
442 ancil_buf += sizeof (struct T_opthdr);
443
444 if (ira->ira_flags & IRAF_IS_IPV4)
445 *(uint_t *)ancil_buf = ipp->ipp_type_of_service;
446 else
447 *(uint_t *)ancil_buf = ipp->ipp_tclass;
448 ancil_buf += sizeof (uint_t);
449 ancil_size -= toh->len;
450 }
451 if (recv_ancillary.crb_ipv6_recvhopopts &&
452 (ipp->ipp_fields & IPPF_HOPOPTS)) {
453 struct T_opthdr *toh;
454
455 toh = (struct T_opthdr *)ancil_buf;
456 toh->level = IPPROTO_IPV6;
457 toh->name = IPV6_HOPOPTS;
458 toh->len = sizeof (struct T_opthdr) + ipp->ipp_hopoptslen;
459 toh->status = 0;
460 ancil_buf += sizeof (struct T_opthdr);
461 bcopy(ipp->ipp_hopopts, ancil_buf, ipp->ipp_hopoptslen);
462 ancil_buf += ipp->ipp_hopoptslen;
463 ancil_size -= toh->len;
464 }
465 /*
466 * To honor RFC3542 when an application asks for both IPV6_RECVDSTOPTS
467 * and IPV6_RECVRTHDR, we pass up the item rthdrdstopts (the destination
468 * options that appear before a routing header.
469 * We also pass them up if IPV6_RECVRTHDRDSTOPTS is set.
470 */
471 if (ipp->ipp_fields & IPPF_RTHDRDSTOPTS) {
472 if (recv_ancillary.crb_ipv6_recvrthdrdstopts ||
473 (recv_ancillary.crb_ipv6_recvdstopts &&
474 recv_ancillary.crb_ipv6_recvrthdr)) {
475 struct T_opthdr *toh;
476
477 toh = (struct T_opthdr *)ancil_buf;
478 toh->level = IPPROTO_IPV6;
479 toh->name = IPV6_DSTOPTS;
480 toh->len = sizeof (struct T_opthdr) +
481 ipp->ipp_rthdrdstoptslen;
482 toh->status = 0;
483 ancil_buf += sizeof (struct T_opthdr);
484 bcopy(ipp->ipp_rthdrdstopts, ancil_buf,
485 ipp->ipp_rthdrdstoptslen);
486 ancil_buf += ipp->ipp_rthdrdstoptslen;
487 ancil_size -= toh->len;
488 }
489 }
490 if (recv_ancillary.crb_ipv6_recvrthdr &&
491 (ipp->ipp_fields & IPPF_RTHDR)) {
492 struct T_opthdr *toh;
493
494 toh = (struct T_opthdr *)ancil_buf;
495 toh->level = IPPROTO_IPV6;
496 toh->name = IPV6_RTHDR;
497 toh->len = sizeof (struct T_opthdr) + ipp->ipp_rthdrlen;
498 toh->status = 0;
499 ancil_buf += sizeof (struct T_opthdr);
500 bcopy(ipp->ipp_rthdr, ancil_buf, ipp->ipp_rthdrlen);
501 ancil_buf += ipp->ipp_rthdrlen;
502 ancil_size -= toh->len;
503 }
504 if ((recv_ancillary.crb_ipv6_recvdstopts ||
505 recv_ancillary.crb_old_ipv6_recvdstopts) &&
506 (ipp->ipp_fields & IPPF_DSTOPTS)) {
507 struct T_opthdr *toh;
508
509 toh = (struct T_opthdr *)ancil_buf;
510 toh->level = IPPROTO_IPV6;
511 toh->name = IPV6_DSTOPTS;
512 toh->len = sizeof (struct T_opthdr) + ipp->ipp_dstoptslen;
513 toh->status = 0;
514 ancil_buf += sizeof (struct T_opthdr);
515 bcopy(ipp->ipp_dstopts, ancil_buf, ipp->ipp_dstoptslen);
516 ancil_buf += ipp->ipp_dstoptslen;
517 ancil_size -= toh->len;
518 }
519
520 if (recv_ancillary.crb_recvucred && ira->ira_cred != NULL) {
521 struct T_opthdr *toh;
522 cred_t *rcr = connp->conn_cred;
523
524 toh = (struct T_opthdr *)ancil_buf;
525 toh->level = SOL_SOCKET;
526 toh->name = SCM_UCRED;
527 toh->len = sizeof (struct T_opthdr) +
528 ucredminsize(ira->ira_cred);
529 toh->status = 0;
530 (void) cred2ucred(ira->ira_cred, ira->ira_cpid, &toh[1], rcr);
531 ancil_buf += toh->len;
532 ancil_size -= toh->len;
533 }
534 if (recv_ancillary.crb_timestamp) {
535 struct T_opthdr *toh;
536
537 toh = (struct T_opthdr *)ancil_buf;
538 toh->level = SOL_SOCKET;
539 toh->name = SCM_TIMESTAMP;
540 toh->len = sizeof (struct T_opthdr) +
541 sizeof (timestruc_t) + _POINTER_ALIGNMENT;
542 toh->status = 0;
543 ancil_buf += sizeof (struct T_opthdr);
544 /* Align for gethrestime() */
545 ancil_buf = (uchar_t *)P2ROUNDUP((intptr_t)ancil_buf,
546 sizeof (intptr_t));
547 gethrestime((timestruc_t *)ancil_buf);
548 ancil_buf = (uchar_t *)toh + toh->len;
549 ancil_size -= toh->len;
550 }
551
552 /*
553 * CAUTION:
554 * Due to aligment issues
555 * Processing of IP_RECVTTL option
556 * should always be the last. Adding
557 * any option processing after this will
558 * cause alignment panic.
559 */
560 if (recv_ancillary.crb_recvttl &&
561 (ira->ira_flags & IRAF_IS_IPV4)) {
562 struct T_opthdr *toh;
563 uint8_t *dstptr;
564
565 toh = (struct T_opthdr *)ancil_buf;
566 toh->level = IPPROTO_IP;
567 toh->name = IP_RECVTTL;
568 toh->len = sizeof (struct T_opthdr) + sizeof (uint8_t);
569 toh->status = 0;
570 ancil_buf += sizeof (struct T_opthdr);
571 dstptr = (uint8_t *)ancil_buf;
572 *dstptr = ipp->ipp_hoplimit;
573 ancil_buf += sizeof (uint8_t);
574 ancil_size -= toh->len;
575 }
576
577 /* Consumed all of allocated space */
578 ASSERT(ancil_size == 0);
579
580 }
581
582 /*
583 * This routine retrieves the current status of socket options.
584 * It returns the size of the option retrieved, or -1.
585 */
586 int
587 conn_opt_get(conn_opt_arg_t *coa, t_scalar_t level, t_scalar_t name,
588 uchar_t *ptr)
589 {
590 int *i1 = (int *)ptr;
591 conn_t *connp = coa->coa_connp;
592 ip_xmit_attr_t *ixa = coa->coa_ixa;
593 ip_pkt_t *ipp = coa->coa_ipp;
594 ip_stack_t *ipst = ixa->ixa_ipst;
595 uint_t len;
596
597 ASSERT(MUTEX_HELD(&coa->coa_connp->conn_lock));
598
599 switch (level) {
600 case SOL_SOCKET:
601 switch (name) {
602 case SO_DEBUG:
603 *i1 = connp->conn_debug ? SO_DEBUG : 0;
604 break; /* goto sizeof (int) option return */
605 case SO_KEEPALIVE:
606 *i1 = connp->conn_keepalive ? SO_KEEPALIVE : 0;
607 break;
608 case SO_LINGER: {
609 struct linger *lgr = (struct linger *)ptr;
610
611 lgr->l_onoff = connp->conn_linger ? SO_LINGER : 0;
612 lgr->l_linger = connp->conn_lingertime;
613 }
614 return (sizeof (struct linger));
615
616 case SO_OOBINLINE:
617 *i1 = connp->conn_oobinline ? SO_OOBINLINE : 0;
618 break;
619 case SO_REUSEADDR:
620 *i1 = connp->conn_reuseaddr ? SO_REUSEADDR : 0;
621 break; /* goto sizeof (int) option return */
622 case SO_TYPE:
623 *i1 = connp->conn_so_type;
624 break; /* goto sizeof (int) option return */
625 case SO_DONTROUTE:
626 *i1 = (ixa->ixa_flags & IXAF_DONTROUTE) ?
627 SO_DONTROUTE : 0;
628 break; /* goto sizeof (int) option return */
629 case SO_USELOOPBACK:
630 *i1 = connp->conn_useloopback ? SO_USELOOPBACK : 0;
631 break; /* goto sizeof (int) option return */
632 case SO_BROADCAST:
633 *i1 = connp->conn_broadcast ? SO_BROADCAST : 0;
634 break; /* goto sizeof (int) option return */
635
636 case SO_SNDBUF:
637 *i1 = connp->conn_sndbuf;
638 break; /* goto sizeof (int) option return */
639 case SO_RCVBUF:
640 *i1 = connp->conn_rcvbuf;
641 break; /* goto sizeof (int) option return */
642 case SO_RCVTIMEO:
643 case SO_SNDTIMEO:
644 /*
645 * Pass these two options in order for third part
646 * protocol usage. Here just return directly.
647 */
648 *i1 = 0;
649 break;
650 case SO_DGRAM_ERRIND:
651 *i1 = connp->conn_dgram_errind ? SO_DGRAM_ERRIND : 0;
652 break; /* goto sizeof (int) option return */
653 case SO_RECVUCRED:
654 *i1 = connp->conn_recv_ancillary.crb_recvucred;
655 break; /* goto sizeof (int) option return */
656 case SO_TIMESTAMP:
657 *i1 = connp->conn_recv_ancillary.crb_timestamp;
658 break; /* goto sizeof (int) option return */
659 case SO_VRRP:
660 *i1 = connp->conn_isvrrp;
661 break; /* goto sizeof (int) option return */
662 case SO_ANON_MLP:
663 *i1 = connp->conn_anon_mlp;
664 break; /* goto sizeof (int) option return */
665 case SO_MAC_EXEMPT:
666 *i1 = (connp->conn_mac_mode == CONN_MAC_AWARE);
667 break; /* goto sizeof (int) option return */
668 case SO_MAC_IMPLICIT:
669 *i1 = (connp->conn_mac_mode == CONN_MAC_IMPLICIT);
670 break; /* goto sizeof (int) option return */
671 case SO_ALLZONES:
672 *i1 = connp->conn_allzones;
673 break; /* goto sizeof (int) option return */
674 case SO_EXCLBIND:
675 *i1 = connp->conn_exclbind ? SO_EXCLBIND : 0;
676 break;
677 case SO_PROTOTYPE:
678 *i1 = connp->conn_proto;
679 break;
680
681 case SO_DOMAIN:
682 *i1 = connp->conn_family;
683 break;
684 default:
685 return (-1);
686 }
687 break;
688 case IPPROTO_IP:
689 if (connp->conn_family != AF_INET)
690 return (-1);
691 switch (name) {
692 case IP_OPTIONS:
693 case T_IP_OPTIONS:
694 if (!(ipp->ipp_fields & IPPF_IPV4_OPTIONS))
695 return (0);
696
697 len = ipp->ipp_ipv4_options_len;
698 if (len > 0) {
699 bcopy(ipp->ipp_ipv4_options, ptr, len);
700 }
701 return (len);
702
703 case IP_PKTINFO: {
704 /*
705 * This also handles IP_RECVPKTINFO.
706 * IP_PKTINFO and IP_RECVPKTINFO have same value.
707 * Differentiation is based on the size of the
708 * argument passed in.
709 */
710 struct in_pktinfo *pktinfo;
711
712 #ifdef notdef
713 /* optcom doesn't provide a length with "get" */
714 if (inlen == sizeof (int)) {
715 /* This is IP_RECVPKTINFO option. */
716 *i1 = connp->conn_recv_ancillary.
717 crb_ip_recvpktinfo;
718 return (sizeof (int));
719 }
720 #endif
721 /* XXX assumes that caller has room for max size! */
722
723 pktinfo = (struct in_pktinfo *)ptr;
724 pktinfo->ipi_ifindex = ixa->ixa_ifindex;
725 if (ipp->ipp_fields & IPPF_ADDR)
726 pktinfo->ipi_spec_dst.s_addr = ipp->ipp_addr_v4;
727 else
728 pktinfo->ipi_spec_dst.s_addr = INADDR_ANY;
729 return (sizeof (struct in_pktinfo));
730 }
731 case IP_DONTFRAG:
732 *i1 = (ixa->ixa_flags & IXAF_DONTFRAG) != 0;
733 return (sizeof (int));
734 case IP_TOS:
735 case T_IP_TOS:
736 *i1 = (int)ipp->ipp_type_of_service;
737 break; /* goto sizeof (int) option return */
738 case IP_TTL:
739 *i1 = (int)ipp->ipp_unicast_hops;
740 break; /* goto sizeof (int) option return */
741 case IP_DHCPINIT_IF:
742 return (-1);
743 case IP_NEXTHOP:
744 if (ixa->ixa_flags & IXAF_NEXTHOP_SET) {
745 *(ipaddr_t *)ptr = ixa->ixa_nexthop_v4;
746 return (sizeof (ipaddr_t));
747 } else {
748 return (0);
749 }
750
751 case IP_MULTICAST_IF:
752 /* 0 address if not set */
753 *(ipaddr_t *)ptr = ixa->ixa_multicast_ifaddr;
754 return (sizeof (ipaddr_t));
755 case IP_MULTICAST_TTL:
756 *(uchar_t *)ptr = ixa->ixa_multicast_ttl;
757 return (sizeof (uchar_t));
758 case IP_MULTICAST_LOOP:
759 *ptr = (ixa->ixa_flags & IXAF_MULTICAST_LOOP) ? 1 : 0;
760 return (sizeof (uint8_t));
761 case IP_RECVOPTS:
762 *i1 = connp->conn_recv_ancillary.crb_recvopts;
763 break; /* goto sizeof (int) option return */
764 case IP_RECVDSTADDR:
765 *i1 = connp->conn_recv_ancillary.crb_recvdstaddr;
766 break; /* goto sizeof (int) option return */
767 case IP_RECVIF:
768 *i1 = connp->conn_recv_ancillary.crb_recvif;
769 break; /* goto sizeof (int) option return */
770 case IP_RECVSLLA:
771 *i1 = connp->conn_recv_ancillary.crb_recvslla;
772 break; /* goto sizeof (int) option return */
773 case IP_RECVTTL:
774 *i1 = connp->conn_recv_ancillary.crb_recvttl;
775 break; /* goto sizeof (int) option return */
776 case IP_ADD_MEMBERSHIP:
777 case IP_DROP_MEMBERSHIP:
778 case MCAST_JOIN_GROUP:
779 case MCAST_LEAVE_GROUP:
780 case IP_BLOCK_SOURCE:
781 case IP_UNBLOCK_SOURCE:
782 case IP_ADD_SOURCE_MEMBERSHIP:
783 case IP_DROP_SOURCE_MEMBERSHIP:
784 case MCAST_BLOCK_SOURCE:
785 case MCAST_UNBLOCK_SOURCE:
786 case MCAST_JOIN_SOURCE_GROUP:
787 case MCAST_LEAVE_SOURCE_GROUP:
788 case MRT_INIT:
789 case MRT_DONE:
790 case MRT_ADD_VIF:
791 case MRT_DEL_VIF:
792 case MRT_ADD_MFC:
793 case MRT_DEL_MFC:
794 /* cannot "get" the value for these */
795 return (-1);
796 case MRT_VERSION:
797 case MRT_ASSERT:
798 (void) ip_mrouter_get(name, connp, ptr);
799 return (sizeof (int));
800 case IP_SEC_OPT:
801 return (ipsec_req_from_conn(connp, (ipsec_req_t *)ptr,
802 IPSEC_AF_V4));
803 case IP_BOUND_IF:
804 /* Zero if not set */
805 *i1 = connp->conn_bound_if;
806 break; /* goto sizeof (int) option return */
807 case IP_UNSPEC_SRC:
808 *i1 = connp->conn_unspec_src;
809 break; /* goto sizeof (int) option return */
810 case IP_BROADCAST_TTL:
811 if (ixa->ixa_flags & IXAF_BROADCAST_TTL_SET)
812 *(uchar_t *)ptr = ixa->ixa_broadcast_ttl;
813 else
814 *(uchar_t *)ptr = ipst->ips_ip_broadcast_ttl;
815 return (sizeof (uchar_t));
816 default:
817 return (-1);
818 }
819 break;
820 case IPPROTO_IPV6:
821 if (connp->conn_family != AF_INET6)
822 return (-1);
823 switch (name) {
824 case IPV6_UNICAST_HOPS:
825 *i1 = (int)ipp->ipp_unicast_hops;
826 break; /* goto sizeof (int) option return */
827 case IPV6_MULTICAST_IF:
828 /* 0 index if not set */
829 *i1 = ixa->ixa_multicast_ifindex;
830 break; /* goto sizeof (int) option return */
831 case IPV6_MULTICAST_HOPS:
832 *i1 = ixa->ixa_multicast_ttl;
833 break; /* goto sizeof (int) option return */
834 case IPV6_MULTICAST_LOOP:
835 *i1 = (ixa->ixa_flags & IXAF_MULTICAST_LOOP) ? 1 : 0;
836 break; /* goto sizeof (int) option return */
837 case IPV6_JOIN_GROUP:
838 case IPV6_LEAVE_GROUP:
839 case MCAST_JOIN_GROUP:
840 case MCAST_LEAVE_GROUP:
841 case MCAST_BLOCK_SOURCE:
842 case MCAST_UNBLOCK_SOURCE:
843 case MCAST_JOIN_SOURCE_GROUP:
844 case MCAST_LEAVE_SOURCE_GROUP:
845 /* cannot "get" the value for these */
846 return (-1);
847 case IPV6_BOUND_IF:
848 /* Zero if not set */
849 *i1 = connp->conn_bound_if;
850 break; /* goto sizeof (int) option return */
851 case IPV6_UNSPEC_SRC:
852 *i1 = connp->conn_unspec_src;
853 break; /* goto sizeof (int) option return */
854 case IPV6_RECVPKTINFO:
855 *i1 = connp->conn_recv_ancillary.crb_ip_recvpktinfo;
856 break; /* goto sizeof (int) option return */
857 case IPV6_RECVTCLASS:
858 *i1 = connp->conn_recv_ancillary.crb_ipv6_recvtclass;
859 break; /* goto sizeof (int) option return */
860 case IPV6_RECVPATHMTU:
861 *i1 = connp->conn_ipv6_recvpathmtu;
862 break; /* goto sizeof (int) option return */
863 case IPV6_RECVHOPLIMIT:
864 *i1 = connp->conn_recv_ancillary.crb_ipv6_recvhoplimit;
865 break; /* goto sizeof (int) option return */
866 case IPV6_RECVHOPOPTS:
867 *i1 = connp->conn_recv_ancillary.crb_ipv6_recvhopopts;
868 break; /* goto sizeof (int) option return */
869 case IPV6_RECVDSTOPTS:
870 *i1 = connp->conn_recv_ancillary.crb_ipv6_recvdstopts;
871 break; /* goto sizeof (int) option return */
872 case _OLD_IPV6_RECVDSTOPTS:
873 *i1 =
874 connp->conn_recv_ancillary.crb_old_ipv6_recvdstopts;
875 break; /* goto sizeof (int) option return */
876 case IPV6_RECVRTHDRDSTOPTS:
877 *i1 = connp->conn_recv_ancillary.
878 crb_ipv6_recvrthdrdstopts;
879 break; /* goto sizeof (int) option return */
880 case IPV6_RECVRTHDR:
881 *i1 = connp->conn_recv_ancillary.crb_ipv6_recvrthdr;
882 break; /* goto sizeof (int) option return */
883 case IPV6_PKTINFO: {
884 /* XXX assumes that caller has room for max size! */
885 struct in6_pktinfo *pkti;
886
887 pkti = (struct in6_pktinfo *)ptr;
888 pkti->ipi6_ifindex = ixa->ixa_ifindex;
889 if (ipp->ipp_fields & IPPF_ADDR)
890 pkti->ipi6_addr = ipp->ipp_addr;
891 else
892 pkti->ipi6_addr = ipv6_all_zeros;
893 return (sizeof (struct in6_pktinfo));
894 }
895 case IPV6_TCLASS:
896 *i1 = ipp->ipp_tclass;
897 break; /* goto sizeof (int) option return */
898 case IPV6_NEXTHOP: {
899 sin6_t *sin6 = (sin6_t *)ptr;
900
901 if (ixa->ixa_flags & IXAF_NEXTHOP_SET)
902 return (0);
903
904 *sin6 = sin6_null;
905 sin6->sin6_family = AF_INET6;
906 sin6->sin6_addr = ixa->ixa_nexthop_v6;
907
908 return (sizeof (sin6_t));
909 }
910 case IPV6_HOPOPTS:
911 if (!(ipp->ipp_fields & IPPF_HOPOPTS))
912 return (0);
913 bcopy(ipp->ipp_hopopts, ptr,
914 ipp->ipp_hopoptslen);
915 return (ipp->ipp_hopoptslen);
916 case IPV6_RTHDRDSTOPTS:
917 if (!(ipp->ipp_fields & IPPF_RTHDRDSTOPTS))
918 return (0);
919 bcopy(ipp->ipp_rthdrdstopts, ptr,
920 ipp->ipp_rthdrdstoptslen);
921 return (ipp->ipp_rthdrdstoptslen);
922 case IPV6_RTHDR:
923 if (!(ipp->ipp_fields & IPPF_RTHDR))
924 return (0);
925 bcopy(ipp->ipp_rthdr, ptr, ipp->ipp_rthdrlen);
926 return (ipp->ipp_rthdrlen);
927 case IPV6_DSTOPTS:
928 if (!(ipp->ipp_fields & IPPF_DSTOPTS))
929 return (0);
930 bcopy(ipp->ipp_dstopts, ptr, ipp->ipp_dstoptslen);
931 return (ipp->ipp_dstoptslen);
932 case IPV6_PATHMTU:
933 return (ip_fill_mtuinfo(connp, ixa,
934 (struct ip6_mtuinfo *)ptr));
935 case IPV6_SEC_OPT:
936 return (ipsec_req_from_conn(connp, (ipsec_req_t *)ptr,
937 IPSEC_AF_V6));
938 case IPV6_SRC_PREFERENCES:
939 return (ip6_get_src_preferences(ixa, (uint32_t *)ptr));
940 case IPV6_DONTFRAG:
941 *i1 = (ixa->ixa_flags & IXAF_DONTFRAG) != 0;
942 return (sizeof (int));
943 case IPV6_USE_MIN_MTU:
944 if (ixa->ixa_flags & IXAF_USE_MIN_MTU)
945 *i1 = ixa->ixa_use_min_mtu;
946 else
947 *i1 = IPV6_USE_MIN_MTU_MULTICAST;
948 break;
949 case IPV6_V6ONLY:
950 *i1 = connp->conn_ipv6_v6only;
951 return (sizeof (int));
952 default:
953 return (-1);
954 }
955 break;
956 case IPPROTO_UDP:
957 switch (name) {
958 case UDP_ANONPRIVBIND:
959 *i1 = connp->conn_anon_priv_bind;
960 break;
961 case UDP_EXCLBIND:
962 *i1 = connp->conn_exclbind ? UDP_EXCLBIND : 0;
963 break;
964 default:
965 return (-1);
966 }
967 break;
968 case IPPROTO_TCP:
969 switch (name) {
970 case TCP_RECVDSTADDR:
971 *i1 = connp->conn_recv_ancillary.crb_recvdstaddr;
972 break;
973 case TCP_ANONPRIVBIND:
974 *i1 = connp->conn_anon_priv_bind;
975 break;
976 case TCP_EXCLBIND:
977 *i1 = connp->conn_exclbind ? TCP_EXCLBIND : 0;
978 break;
979 default:
980 return (-1);
981 }
982 break;
983 default:
984 return (-1);
985 }
986 return (sizeof (int));
987 }
988
989 static int conn_opt_set_socket(conn_opt_arg_t *coa, t_scalar_t name,
990 uint_t inlen, uchar_t *invalp, boolean_t checkonly, cred_t *cr);
991 static int conn_opt_set_ip(conn_opt_arg_t *coa, t_scalar_t name,
992 uint_t inlen, uchar_t *invalp, boolean_t checkonly, cred_t *cr);
993 static int conn_opt_set_ipv6(conn_opt_arg_t *coa, t_scalar_t name,
994 uint_t inlen, uchar_t *invalp, boolean_t checkonly, cred_t *cr);
995 static int conn_opt_set_udp(conn_opt_arg_t *coa, t_scalar_t name,
996 uint_t inlen, uchar_t *invalp, boolean_t checkonly, cred_t *cr);
997 static int conn_opt_set_tcp(conn_opt_arg_t *coa, t_scalar_t name,
998 uint_t inlen, uchar_t *invalp, boolean_t checkonly, cred_t *cr);
999
1000 /*
1001 * This routine sets the most common socket options including some
1002 * that are transport/ULP specific.
1003 * It returns errno or zero.
1004 *
1005 * For fixed length options, there is no sanity check
1006 * of passed in length is done. It is assumed *_optcom_req()
1007 * routines do the right thing.
1008 */
1009 int
1010 conn_opt_set(conn_opt_arg_t *coa, t_scalar_t level, t_scalar_t name,
1011 uint_t inlen, uchar_t *invalp, boolean_t checkonly, cred_t *cr)
1012 {
1013 ASSERT(MUTEX_NOT_HELD(&coa->coa_connp->conn_lock));
1014
1015 /* We have different functions for different levels */
1016 switch (level) {
1017 case SOL_SOCKET:
1018 return (conn_opt_set_socket(coa, name, inlen, invalp,
1019 checkonly, cr));
1020 case IPPROTO_IP:
1021 return (conn_opt_set_ip(coa, name, inlen, invalp,
1022 checkonly, cr));
1023 case IPPROTO_IPV6:
1024 return (conn_opt_set_ipv6(coa, name, inlen, invalp,
1025 checkonly, cr));
1026 case IPPROTO_UDP:
1027 return (conn_opt_set_udp(coa, name, inlen, invalp,
1028 checkonly, cr));
1029 case IPPROTO_TCP:
1030 return (conn_opt_set_tcp(coa, name, inlen, invalp,
1031 checkonly, cr));
1032 default:
1033 return (0);
1034 }
1035 }
1036
1037 /*
1038 * Handle SOL_SOCKET
1039 * Note that we do not handle SO_PROTOTYPE here. The ULPs that support
1040 * it implement their own checks and setting of conn_proto.
1041 */
1042 /* ARGSUSED1 */
1043 static int
1044 conn_opt_set_socket(conn_opt_arg_t *coa, t_scalar_t name, uint_t inlen,
1045 uchar_t *invalp, boolean_t checkonly, cred_t *cr)
1046 {
1047 conn_t *connp = coa->coa_connp;
1048 ip_xmit_attr_t *ixa = coa->coa_ixa;
1049 int *i1 = (int *)invalp;
1050 boolean_t onoff = (*i1 == 0) ? 0 : 1;
1051
1052 switch (name) {
1053 case SO_ALLZONES:
1054 if (IPCL_IS_BOUND(connp))
1055 return (EINVAL);
1056 break;
1057 case SO_VRRP:
1058 if (secpolicy_ip_config(cr, checkonly) != 0)
1059 return (EACCES);
1060 break;
1061 case SO_MAC_EXEMPT:
1062 if (secpolicy_net_mac_aware(cr) != 0)
1063 return (EACCES);
1064 if (IPCL_IS_BOUND(connp))
1065 return (EINVAL);
1066 break;
1067 case SO_MAC_IMPLICIT:
1068 if (secpolicy_net_mac_implicit(cr) != 0)
1069 return (EACCES);
1070 break;
1071 }
1072 if (checkonly)
1073 return (0);
1074
1075 mutex_enter(&connp->conn_lock);
1076 /* Here we set the actual option value */
1077 switch (name) {
1078 case SO_DEBUG:
1079 connp->conn_debug = onoff;
1080 break;
1081 case SO_KEEPALIVE:
1082 connp->conn_keepalive = onoff;
1083 break;
1084 case SO_LINGER: {
1085 struct linger *lgr = (struct linger *)invalp;
1086
1087 if (lgr->l_onoff) {
1088 connp->conn_linger = 1;
1089 connp->conn_lingertime = lgr->l_linger;
1090 } else {
1091 connp->conn_linger = 0;
1092 connp->conn_lingertime = 0;
1093 }
1094 break;
1095 }
1096 case SO_OOBINLINE:
1097 connp->conn_oobinline = onoff;
1098 coa->coa_changed |= COA_OOBINLINE_CHANGED;
1099 break;
1100 case SO_REUSEADDR:
1101 connp->conn_reuseaddr = onoff;
1102 break;
1103 case SO_DONTROUTE:
1104 if (onoff)
1105 ixa->ixa_flags |= IXAF_DONTROUTE;
1106 else
1107 ixa->ixa_flags &= ~IXAF_DONTROUTE;
1108 coa->coa_changed |= COA_ROUTE_CHANGED;
1109 break;
1110 case SO_USELOOPBACK:
1111 connp->conn_useloopback = onoff;
1112 break;
1113 case SO_BROADCAST:
1114 connp->conn_broadcast = onoff;
1115 break;
1116 case SO_SNDBUF:
1117 /* ULP has range checked the value */
1118 connp->conn_sndbuf = *i1;
1119 coa->coa_changed |= COA_SNDBUF_CHANGED;
1120 break;
1121 case SO_RCVBUF:
1122 /* ULP has range checked the value */
1123 connp->conn_rcvbuf = *i1;
1124 coa->coa_changed |= COA_RCVBUF_CHANGED;
1125 break;
1126 case SO_RCVTIMEO:
1127 case SO_SNDTIMEO:
1128 /*
1129 * Pass these two options in order for third part
1130 * protocol usage.
1131 */
1132 break;
1133 case SO_DGRAM_ERRIND:
1134 connp->conn_dgram_errind = onoff;
1135 break;
1136 case SO_RECVUCRED:
1137 connp->conn_recv_ancillary.crb_recvucred = onoff;
1138 break;
1139 case SO_ALLZONES:
1140 connp->conn_allzones = onoff;
1141 coa->coa_changed |= COA_ROUTE_CHANGED;
1142 if (onoff)
1143 ixa->ixa_zoneid = ALL_ZONES;
1144 else
1145 ixa->ixa_zoneid = connp->conn_zoneid;
1146 break;
1147 case SO_TIMESTAMP:
1148 connp->conn_recv_ancillary.crb_timestamp = onoff;
1149 break;
1150 case SO_VRRP:
1151 connp->conn_isvrrp = onoff;
1152 break;
1153 case SO_ANON_MLP:
1154 connp->conn_anon_mlp = onoff;
1155 break;
1156 case SO_MAC_EXEMPT:
1157 connp->conn_mac_mode = onoff ?
1158 CONN_MAC_AWARE : CONN_MAC_DEFAULT;
1159 break;
1160 case SO_MAC_IMPLICIT:
1161 connp->conn_mac_mode = onoff ?
1162 CONN_MAC_IMPLICIT : CONN_MAC_DEFAULT;
1163 break;
1164 case SO_EXCLBIND:
1165 connp->conn_exclbind = onoff;
1166 break;
1167 }
1168 mutex_exit(&connp->conn_lock);
1169 return (0);
1170 }
1171
1172 /* Handle IPPROTO_IP */
1173 static int
1174 conn_opt_set_ip(conn_opt_arg_t *coa, t_scalar_t name, uint_t inlen,
1175 uchar_t *invalp, boolean_t checkonly, cred_t *cr)
1176 {
1177 conn_t *connp = coa->coa_connp;
1178 ip_xmit_attr_t *ixa = coa->coa_ixa;
1179 ip_pkt_t *ipp = coa->coa_ipp;
1180 int *i1 = (int *)invalp;
1181 boolean_t onoff = (*i1 == 0) ? 0 : 1;
1182 ipaddr_t addr = (ipaddr_t)*i1;
1183 uint_t ifindex;
1184 zoneid_t zoneid = IPCL_ZONEID(connp);
1185 ipif_t *ipif;
1186 ip_stack_t *ipst = connp->conn_netstack->netstack_ip;
1187 int error;
1188
1189 if (connp->conn_family != AF_INET)
1190 return (EINVAL);
1191
1192 switch (name) {
1193 case IP_TTL:
1194 /* Don't allow zero */
1195 if (*i1 < 1 || *i1 > 255)
1196 return (EINVAL);
1197 break;
1198 case IP_MULTICAST_IF:
1199 if (addr == INADDR_ANY) {
1200 /* Clear */
1201 ifindex = 0;
1202 break;
1203 }
1204 ipif = ipif_lookup_addr(addr, NULL, zoneid, ipst);
1205 if (ipif == NULL)
1206 return (EHOSTUNREACH);
1207 /* not supported by the virtual network iface */
1208 if (IS_VNI(ipif->ipif_ill)) {
1209 ipif_refrele(ipif);
1210 return (EINVAL);
1211 }
1212 ifindex = ipif->ipif_ill->ill_phyint->phyint_ifindex;
1213 ipif_refrele(ipif);
1214 break;
1215 case IP_NEXTHOP: {
1216 ire_t *ire;
1217
1218 if (addr == INADDR_ANY) {
1219 /* Clear */
1220 break;
1221 }
1222 /* Verify that the next-hop is on-link */
1223 ire = ire_ftable_lookup_v4(addr, 0, 0, IRE_ONLINK, NULL, zoneid,
1224 NULL, MATCH_IRE_TYPE, 0, ipst, NULL);
1225 if (ire == NULL)
1226 return (EHOSTUNREACH);
1227 ire_refrele(ire);
1228 break;
1229 }
1230 case IP_OPTIONS:
1231 case T_IP_OPTIONS: {
1232 uint_t newlen;
1233
1234 if (ipp->ipp_fields & IPPF_LABEL_V4)
1235 newlen = inlen + (ipp->ipp_label_len_v4 + 3) & ~3;
1236 else
1237 newlen = inlen;
1238 if ((inlen & 0x3) || newlen > IP_MAX_OPT_LENGTH) {
1239 return (EINVAL);
1240 }
1241 break;
1242 }
1243 case IP_PKTINFO: {
1244 struct in_pktinfo *pktinfo;
1245
1246 /* Two different valid lengths */
1247 if (inlen != sizeof (int) &&
1248 inlen != sizeof (struct in_pktinfo))
1249 return (EINVAL);
1250 if (inlen == sizeof (int))
1251 break;
1252
1253 pktinfo = (struct in_pktinfo *)invalp;
1254 if (pktinfo->ipi_spec_dst.s_addr != INADDR_ANY) {
1255 switch (ip_laddr_verify_v4(pktinfo->ipi_spec_dst.s_addr,
1256 zoneid, ipst, B_FALSE)) {
1257 case IPVL_UNICAST_UP:
1258 case IPVL_UNICAST_DOWN:
1259 break;
1260 default:
1261 return (EADDRNOTAVAIL);
1262 }
1263 }
1264 if (!ip_xmit_ifindex_valid(pktinfo->ipi_ifindex, zoneid,
1265 B_FALSE, ipst))
1266 return (ENXIO);
1267 break;
1268 }
1269 case IP_BOUND_IF:
1270 ifindex = *(uint_t *)i1;
1271
1272 /* Just check it is ok. */
1273 if (!ip_xmit_ifindex_valid(ifindex, zoneid, B_FALSE, ipst))
1274 return (ENXIO);
1275 break;
1276 }
1277 if (checkonly)
1278 return (0);
1279
1280 /* Here we set the actual option value */
1281 /*
1282 * conn_lock protects the bitfields, and is used to
1283 * set the fields atomically. Not needed for ixa settings since
1284 * the caller has an exclusive copy of the ixa.
1285 * We can not hold conn_lock across the multicast options though.
1286 */
1287 switch (name) {
1288 case IP_OPTIONS:
1289 case T_IP_OPTIONS:
1290 /* Save options for use by IP. */
1291 mutex_enter(&connp->conn_lock);
1292 error = optcom_pkt_set(invalp, inlen,
1293 (uchar_t **)&ipp->ipp_ipv4_options,
1294 &ipp->ipp_ipv4_options_len);
1295 if (error != 0) {
1296 mutex_exit(&connp->conn_lock);
1297 return (error);
1298 }
1299 if (ipp->ipp_ipv4_options_len == 0) {
1300 ipp->ipp_fields &= ~IPPF_IPV4_OPTIONS;
1301 } else {
1302 ipp->ipp_fields |= IPPF_IPV4_OPTIONS;
1303 }
1304 mutex_exit(&connp->conn_lock);
1305 coa->coa_changed |= COA_HEADER_CHANGED;
1306 coa->coa_changed |= COA_WROFF_CHANGED;
1307 break;
1308
1309 case IP_TTL:
1310 mutex_enter(&connp->conn_lock);
1311 ipp->ipp_unicast_hops = *i1;
1312 mutex_exit(&connp->conn_lock);
1313 coa->coa_changed |= COA_HEADER_CHANGED;
1314 break;
1315 case IP_TOS:
1316 case T_IP_TOS:
1317 mutex_enter(&connp->conn_lock);
1318 if (*i1 == -1) {
1319 ipp->ipp_type_of_service = 0;
1320 } else {
1321 ipp->ipp_type_of_service = *i1;
1322 }
1323 mutex_exit(&connp->conn_lock);
1324 coa->coa_changed |= COA_HEADER_CHANGED;
1325 break;
1326 case IP_MULTICAST_IF:
1327 ixa->ixa_multicast_ifindex = ifindex;
1328 ixa->ixa_multicast_ifaddr = addr;
1329 coa->coa_changed |= COA_ROUTE_CHANGED;
1330 break;
1331 case IP_MULTICAST_TTL:
1332 ixa->ixa_multicast_ttl = *invalp;
1333 /* Handled automatically by ip_output */
1334 break;
1335 case IP_MULTICAST_LOOP:
1336 if (*invalp != 0)
1337 ixa->ixa_flags |= IXAF_MULTICAST_LOOP;
1338 else
1339 ixa->ixa_flags &= ~IXAF_MULTICAST_LOOP;
1340 /* Handled automatically by ip_output */
1341 break;
1342 case IP_RECVOPTS:
1343 mutex_enter(&connp->conn_lock);
1344 connp->conn_recv_ancillary.crb_recvopts = onoff;
1345 mutex_exit(&connp->conn_lock);
1346 break;
1347 case IP_RECVDSTADDR:
1348 mutex_enter(&connp->conn_lock);
1349 connp->conn_recv_ancillary.crb_recvdstaddr = onoff;
1350 mutex_exit(&connp->conn_lock);
1351 break;
1352 case IP_RECVIF:
1353 mutex_enter(&connp->conn_lock);
1354 connp->conn_recv_ancillary.crb_recvif = onoff;
1355 mutex_exit(&connp->conn_lock);
1356 break;
1357 case IP_RECVSLLA:
1358 mutex_enter(&connp->conn_lock);
1359 connp->conn_recv_ancillary.crb_recvslla = onoff;
1360 mutex_exit(&connp->conn_lock);
1361 break;
1362 case IP_RECVTTL:
1363 mutex_enter(&connp->conn_lock);
1364 connp->conn_recv_ancillary.crb_recvttl = onoff;
1365 mutex_exit(&connp->conn_lock);
1366 break;
1367 case IP_PKTINFO: {
1368 /*
1369 * This also handles IP_RECVPKTINFO.
1370 * IP_PKTINFO and IP_RECVPKTINFO have same value.
1371 * Differentiation is based on the size of the
1372 * argument passed in.
1373 */
1374 struct in_pktinfo *pktinfo;
1375
1376 if (inlen == sizeof (int)) {
1377 /* This is IP_RECVPKTINFO option. */
1378 mutex_enter(&connp->conn_lock);
1379 connp->conn_recv_ancillary.crb_ip_recvpktinfo =
1380 onoff;
1381 mutex_exit(&connp->conn_lock);
1382 break;
1383 }
1384
1385 /* This is IP_PKTINFO option. */
1386 mutex_enter(&connp->conn_lock);
1387 pktinfo = (struct in_pktinfo *)invalp;
1388 if (pktinfo->ipi_spec_dst.s_addr != INADDR_ANY) {
1389 ipp->ipp_fields |= IPPF_ADDR;
1390 IN6_INADDR_TO_V4MAPPED(&pktinfo->ipi_spec_dst,
1391 &ipp->ipp_addr);
1392 } else {
1393 ipp->ipp_fields &= ~IPPF_ADDR;
1394 ipp->ipp_addr = ipv6_all_zeros;
1395 }
1396 mutex_exit(&connp->conn_lock);
1397 ixa->ixa_ifindex = pktinfo->ipi_ifindex;
1398 coa->coa_changed |= COA_ROUTE_CHANGED;
1399 coa->coa_changed |= COA_HEADER_CHANGED;
1400 break;
1401 }
1402 case IP_DONTFRAG:
1403 if (onoff) {
1404 ixa->ixa_flags |= (IXAF_DONTFRAG | IXAF_PMTU_IPV4_DF);
1405 ixa->ixa_flags &= ~IXAF_PMTU_DISCOVERY;
1406 } else {
1407 ixa->ixa_flags &= ~(IXAF_DONTFRAG | IXAF_PMTU_IPV4_DF);
1408 ixa->ixa_flags |= IXAF_PMTU_DISCOVERY;
1409 }
1410 /* Need to redo ip_attr_connect */
1411 coa->coa_changed |= COA_ROUTE_CHANGED;
1412 break;
1413 case IP_ADD_MEMBERSHIP:
1414 case IP_DROP_MEMBERSHIP:
1415 case MCAST_JOIN_GROUP:
1416 case MCAST_LEAVE_GROUP:
1417 return (ip_opt_set_multicast_group(connp, name,
1418 invalp, B_FALSE, checkonly));
1419
1420 case IP_BLOCK_SOURCE:
1421 case IP_UNBLOCK_SOURCE:
1422 case IP_ADD_SOURCE_MEMBERSHIP:
1423 case IP_DROP_SOURCE_MEMBERSHIP:
1424 case MCAST_BLOCK_SOURCE:
1425 case MCAST_UNBLOCK_SOURCE:
1426 case MCAST_JOIN_SOURCE_GROUP:
1427 case MCAST_LEAVE_SOURCE_GROUP:
1428 return (ip_opt_set_multicast_sources(connp, name,
1429 invalp, B_FALSE, checkonly));
1430
1431 case IP_SEC_OPT:
1432 mutex_enter(&connp->conn_lock);
1433 error = ipsec_set_req(cr, connp, (ipsec_req_t *)invalp);
1434 mutex_exit(&connp->conn_lock);
1435 if (error != 0) {
1436 return (error);
1437 }
1438 /* This is an IPsec policy change - redo ip_attr_connect */
1439 coa->coa_changed |= COA_ROUTE_CHANGED;
1440 break;
1441 case IP_NEXTHOP:
1442 ixa->ixa_nexthop_v4 = addr;
1443 if (addr != INADDR_ANY)
1444 ixa->ixa_flags |= IXAF_NEXTHOP_SET;
1445 else
1446 ixa->ixa_flags &= ~IXAF_NEXTHOP_SET;
1447 coa->coa_changed |= COA_ROUTE_CHANGED;
1448 break;
1449
1450 case IP_BOUND_IF:
1451 ixa->ixa_ifindex = ifindex; /* Send */
1452 mutex_enter(&connp->conn_lock);
1453 connp->conn_incoming_ifindex = ifindex; /* Receive */
1454 connp->conn_bound_if = ifindex; /* getsockopt */
1455 mutex_exit(&connp->conn_lock);
1456 coa->coa_changed |= COA_ROUTE_CHANGED;
1457 break;
1458 case IP_UNSPEC_SRC:
1459 mutex_enter(&connp->conn_lock);
1460 connp->conn_unspec_src = onoff;
1461 if (onoff)
1462 ixa->ixa_flags &= ~IXAF_VERIFY_SOURCE;
1463 else
1464 ixa->ixa_flags |= IXAF_VERIFY_SOURCE;
1465
1466 mutex_exit(&connp->conn_lock);
1467 break;
1468 case IP_BROADCAST_TTL:
1469 ixa->ixa_broadcast_ttl = *invalp;
1470 ixa->ixa_flags |= IXAF_BROADCAST_TTL_SET;
1471 /* Handled automatically by ip_output */
1472 break;
1473 case MRT_INIT:
1474 case MRT_DONE:
1475 case MRT_ADD_VIF:
1476 case MRT_DEL_VIF:
1477 case MRT_ADD_MFC:
1478 case MRT_DEL_MFC:
1479 case MRT_ASSERT:
1480 if ((error = secpolicy_ip_config(cr, B_FALSE)) != 0) {
1481 return (error);
1482 }
1483 error = ip_mrouter_set((int)name, connp, checkonly,
1484 (uchar_t *)invalp, inlen);
1485 if (error) {
1486 return (error);
1487 }
1488 return (0);
1489
1490 }
1491 return (0);
1492 }
1493
1494 /* Handle IPPROTO_IPV6 */
1495 static int
1496 conn_opt_set_ipv6(conn_opt_arg_t *coa, t_scalar_t name, uint_t inlen,
1497 uchar_t *invalp, boolean_t checkonly, cred_t *cr)
1498 {
1499 conn_t *connp = coa->coa_connp;
1500 ip_xmit_attr_t *ixa = coa->coa_ixa;
1501 ip_pkt_t *ipp = coa->coa_ipp;
1502 int *i1 = (int *)invalp;
1503 boolean_t onoff = (*i1 == 0) ? 0 : 1;
1504 uint_t ifindex;
1505 zoneid_t zoneid = IPCL_ZONEID(connp);
1506 ip_stack_t *ipst = connp->conn_netstack->netstack_ip;
1507 int error;
1508
1509 if (connp->conn_family != AF_INET6)
1510 return (EINVAL);
1511
1512 switch (name) {
1513 case IPV6_MULTICAST_IF:
1514 /*
1515 * The only possible error is EINVAL.
1516 * We call this option on both V4 and V6
1517 * If both fail, then this call returns
1518 * EINVAL. If at least one of them succeeds we
1519 * return success.
1520 */
1521 ifindex = *(uint_t *)i1;
1522
1523 if (!ip_xmit_ifindex_valid(ifindex, zoneid, B_TRUE, ipst) &&
1524 !ip_xmit_ifindex_valid(ifindex, zoneid, B_FALSE, ipst))
1525 return (EINVAL);
1526 break;
1527 case IPV6_UNICAST_HOPS:
1528 /* Don't allow zero. -1 means to use default */
1529 if (*i1 < -1 || *i1 == 0 || *i1 > IPV6_MAX_HOPS)
1530 return (EINVAL);
1531 break;
1532 case IPV6_MULTICAST_HOPS:
1533 /* -1 means use default */
1534 if (*i1 < -1 || *i1 > IPV6_MAX_HOPS)
1535 return (EINVAL);
1536 break;
1537 case IPV6_MULTICAST_LOOP:
1538 if (*i1 != 0 && *i1 != 1)
1539 return (EINVAL);
1540 break;
1541 case IPV6_BOUND_IF:
1542 ifindex = *(uint_t *)i1;
1543
1544 if (!ip_xmit_ifindex_valid(ifindex, zoneid, B_TRUE, ipst))
1545 return (ENXIO);
1546 break;
1547 case IPV6_PKTINFO: {
1548 struct in6_pktinfo *pkti;
1549 boolean_t isv6;
1550
1551 if (inlen != 0 && inlen != sizeof (struct in6_pktinfo))
1552 return (EINVAL);
1553 if (inlen == 0)
1554 break; /* Clear values below */
1555
1556 /*
1557 * Verify the source address and ifindex. Privileged users
1558 * can use any source address.
1559 */
1560 pkti = (struct in6_pktinfo *)invalp;
1561
1562 /*
1563 * For link-local addresses we use the ipi6_ifindex when
1564 * we verify the local address.
1565 * If net_rawaccess then any source address can be used.
1566 */
1567 if (!IN6_IS_ADDR_UNSPECIFIED(&pkti->ipi6_addr) &&
1568 secpolicy_net_rawaccess(cr) != 0) {
1569 uint_t scopeid = 0;
1570 in6_addr_t *v6src = &pkti->ipi6_addr;
1571 ipaddr_t v4src;
1572 ip_laddr_t laddr_type = IPVL_UNICAST_UP;
1573
1574 if (IN6_IS_ADDR_V4MAPPED(v6src)) {
1575 IN6_V4MAPPED_TO_IPADDR(v6src, v4src);
1576 if (v4src != INADDR_ANY) {
1577 laddr_type = ip_laddr_verify_v4(v4src,
1578 zoneid, ipst, B_FALSE);
1579 }
1580 } else {
1581 if (IN6_IS_ADDR_LINKSCOPE(v6src))
1582 scopeid = pkti->ipi6_ifindex;
1583
1584 laddr_type = ip_laddr_verify_v6(v6src, zoneid,
1585 ipst, B_FALSE, scopeid);
1586 }
1587 switch (laddr_type) {
1588 case IPVL_UNICAST_UP:
1589 case IPVL_UNICAST_DOWN:
1590 break;
1591 default:
1592 return (EADDRNOTAVAIL);
1593 }
1594 ixa->ixa_flags |= IXAF_VERIFY_SOURCE;
1595 } else if (!IN6_IS_ADDR_UNSPECIFIED(&pkti->ipi6_addr)) {
1596 /* Allow any source */
1597 ixa->ixa_flags &= ~IXAF_VERIFY_SOURCE;
1598 }
1599 isv6 = !(IN6_IS_ADDR_V4MAPPED(&pkti->ipi6_addr));
1600 if (!ip_xmit_ifindex_valid(pkti->ipi6_ifindex, zoneid, isv6,
1601 ipst))
1602 return (ENXIO);
1603 break;
1604 }
1605 case IPV6_HOPLIMIT:
1606 /* It is only allowed as ancilary data */
1607 if (!coa->coa_ancillary)
1608 return (EINVAL);
1609
1610 if (inlen != 0 && inlen != sizeof (int))
1611 return (EINVAL);
1612 if (inlen == sizeof (int)) {
1613 if (*i1 > 255 || *i1 < -1 || *i1 == 0)
1614 return (EINVAL);
1615 }
1616 break;
1617 case IPV6_TCLASS:
1618 if (inlen != 0 && inlen != sizeof (int))
1619 return (EINVAL);
1620 if (inlen == sizeof (int)) {
1621 if (*i1 > 255 || *i1 < -1)
1622 return (EINVAL);
1623 }
1624 break;
1625 case IPV6_NEXTHOP:
1626 if (inlen != 0 && inlen != sizeof (sin6_t))
1627 return (EINVAL);
1628 if (inlen == sizeof (sin6_t)) {
1629 sin6_t *sin6 = (sin6_t *)invalp;
1630 ire_t *ire;
1631
1632 if (sin6->sin6_family != AF_INET6)
1633 return (EAFNOSUPPORT);
1634 if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr))
1635 return (EADDRNOTAVAIL);
1636
1637 /* Verify that the next-hop is on-link */
1638 ire = ire_ftable_lookup_v6(&sin6->sin6_addr,
1639 0, 0, IRE_ONLINK, NULL, zoneid,
1640 NULL, MATCH_IRE_TYPE, 0, ipst, NULL);
1641 if (ire == NULL)
1642 return (EHOSTUNREACH);
1643 ire_refrele(ire);
1644 break;
1645 }
1646 break;
1647 case IPV6_RTHDR:
1648 case IPV6_DSTOPTS:
1649 case IPV6_RTHDRDSTOPTS:
1650 case IPV6_HOPOPTS: {
1651 /* All have the length field in the same place */
1652 ip6_hbh_t *hopts = (ip6_hbh_t *)invalp;
1653 /*
1654 * Sanity checks - minimum size, size a multiple of
1655 * eight bytes, and matching size passed in.
1656 */
1657 if (inlen != 0 &&
1658 inlen != (8 * (hopts->ip6h_len + 1)))
1659 return (EINVAL);
1660 break;
1661 }
1662 case IPV6_PATHMTU:
1663 /* Can't be set */
1664 return (EINVAL);
1665
1666 case IPV6_USE_MIN_MTU:
1667 if (inlen != sizeof (int))
1668 return (EINVAL);
1669 if (*i1 < -1 || *i1 > 1)
1670 return (EINVAL);
1671 break;
1672 case IPV6_SRC_PREFERENCES:
1673 if (inlen != sizeof (uint32_t))
1674 return (EINVAL);
1675 break;
1676 case IPV6_V6ONLY:
1677 if (*i1 < 0 || *i1 > 1) {
1678 return (EINVAL);
1679 }
1680 break;
1681 }
1682 if (checkonly)
1683 return (0);
1684
1685 /* Here we set the actual option value */
1686 /*
1687 * conn_lock protects the bitfields, and is used to
1688 * set the fields atomically. Not needed for ixa settings since
1689 * the caller has an exclusive copy of the ixa.
1690 * We can not hold conn_lock across the multicast options though.
1691 */
1692 ASSERT(MUTEX_NOT_HELD(&coa->coa_connp->conn_lock));
1693 switch (name) {
1694 case IPV6_MULTICAST_IF:
1695 ixa->ixa_multicast_ifindex = ifindex;
1696 /* Need to redo ip_attr_connect */
1697 coa->coa_changed |= COA_ROUTE_CHANGED;
1698 break;
1699 case IPV6_UNICAST_HOPS:
1700 /* -1 means use default */
1701 mutex_enter(&connp->conn_lock);
1702 if (*i1 == -1) {
1703 ipp->ipp_unicast_hops = connp->conn_default_ttl;
1704 } else {
1705 ipp->ipp_unicast_hops = (uint8_t)*i1;
1706 }
1707 mutex_exit(&connp->conn_lock);
1708 coa->coa_changed |= COA_HEADER_CHANGED;
1709 break;
1710 case IPV6_MULTICAST_HOPS:
1711 /* -1 means use default */
1712 if (*i1 == -1) {
1713 ixa->ixa_multicast_ttl = IP_DEFAULT_MULTICAST_TTL;
1714 } else {
1715 ixa->ixa_multicast_ttl = (uint8_t)*i1;
1716 }
1717 /* Handled automatically by ip_output */
1718 break;
1719 case IPV6_MULTICAST_LOOP:
1720 if (*i1 != 0)
1721 ixa->ixa_flags |= IXAF_MULTICAST_LOOP;
1722 else
1723 ixa->ixa_flags &= ~IXAF_MULTICAST_LOOP;
1724 /* Handled automatically by ip_output */
1725 break;
1726 case IPV6_JOIN_GROUP:
1727 case IPV6_LEAVE_GROUP:
1728 case MCAST_JOIN_GROUP:
1729 case MCAST_LEAVE_GROUP:
1730 return (ip_opt_set_multicast_group(connp, name,
1731 invalp, B_TRUE, checkonly));
1732
1733 case MCAST_BLOCK_SOURCE:
1734 case MCAST_UNBLOCK_SOURCE:
1735 case MCAST_JOIN_SOURCE_GROUP:
1736 case MCAST_LEAVE_SOURCE_GROUP:
1737 return (ip_opt_set_multicast_sources(connp, name,
1738 invalp, B_TRUE, checkonly));
1739
1740 case IPV6_BOUND_IF:
1741 ixa->ixa_ifindex = ifindex; /* Send */
1742 mutex_enter(&connp->conn_lock);
1743 connp->conn_incoming_ifindex = ifindex; /* Receive */
1744 connp->conn_bound_if = ifindex; /* getsockopt */
1745 mutex_exit(&connp->conn_lock);
1746 coa->coa_changed |= COA_ROUTE_CHANGED;
1747 break;
1748 case IPV6_UNSPEC_SRC:
1749 mutex_enter(&connp->conn_lock);
1750 connp->conn_unspec_src = onoff;
1751 if (onoff)
1752 ixa->ixa_flags &= ~IXAF_VERIFY_SOURCE;
1753 else
1754 ixa->ixa_flags |= IXAF_VERIFY_SOURCE;
1755 mutex_exit(&connp->conn_lock);
1756 break;
1757 case IPV6_RECVPKTINFO:
1758 mutex_enter(&connp->conn_lock);
1759 connp->conn_recv_ancillary.crb_ip_recvpktinfo = onoff;
1760 mutex_exit(&connp->conn_lock);
1761 break;
1762 case IPV6_RECVTCLASS:
1763 mutex_enter(&connp->conn_lock);
1764 connp->conn_recv_ancillary.crb_ipv6_recvtclass = onoff;
1765 mutex_exit(&connp->conn_lock);
1766 break;
1767 case IPV6_RECVPATHMTU:
1768 mutex_enter(&connp->conn_lock);
1769 connp->conn_ipv6_recvpathmtu = onoff;
1770 mutex_exit(&connp->conn_lock);
1771 break;
1772 case IPV6_RECVHOPLIMIT:
1773 mutex_enter(&connp->conn_lock);
1774 connp->conn_recv_ancillary.crb_ipv6_recvhoplimit =
1775 onoff;
1776 mutex_exit(&connp->conn_lock);
1777 break;
1778 case IPV6_RECVHOPOPTS:
1779 mutex_enter(&connp->conn_lock);
1780 connp->conn_recv_ancillary.crb_ipv6_recvhopopts = onoff;
1781 mutex_exit(&connp->conn_lock);
1782 break;
1783 case IPV6_RECVDSTOPTS:
1784 mutex_enter(&connp->conn_lock);
1785 connp->conn_recv_ancillary.crb_ipv6_recvdstopts = onoff;
1786 mutex_exit(&connp->conn_lock);
1787 break;
1788 case _OLD_IPV6_RECVDSTOPTS:
1789 mutex_enter(&connp->conn_lock);
1790 connp->conn_recv_ancillary.crb_old_ipv6_recvdstopts =
1791 onoff;
1792 mutex_exit(&connp->conn_lock);
1793 break;
1794 case IPV6_RECVRTHDRDSTOPTS:
1795 mutex_enter(&connp->conn_lock);
1796 connp->conn_recv_ancillary.crb_ipv6_recvrthdrdstopts =
1797 onoff;
1798 mutex_exit(&connp->conn_lock);
1799 break;
1800 case IPV6_RECVRTHDR:
1801 mutex_enter(&connp->conn_lock);
1802 connp->conn_recv_ancillary.crb_ipv6_recvrthdr = onoff;
1803 mutex_exit(&connp->conn_lock);
1804 break;
1805 case IPV6_PKTINFO:
1806 mutex_enter(&connp->conn_lock);
1807 if (inlen == 0) {
1808 ipp->ipp_fields &= ~IPPF_ADDR;
1809 ipp->ipp_addr = ipv6_all_zeros;
1810 ixa->ixa_ifindex = 0;
1811 } else {
1812 struct in6_pktinfo *pkti;
1813
1814 pkti = (struct in6_pktinfo *)invalp;
1815 ipp->ipp_addr = pkti->ipi6_addr;
1816 if (!IN6_IS_ADDR_UNSPECIFIED(&ipp->ipp_addr))
1817 ipp->ipp_fields |= IPPF_ADDR;
1818 else
1819 ipp->ipp_fields &= ~IPPF_ADDR;
1820 ixa->ixa_ifindex = pkti->ipi6_ifindex;
1821 }
1822 mutex_exit(&connp->conn_lock);
1823 /* Source and ifindex might have changed */
1824 coa->coa_changed |= COA_HEADER_CHANGED;
1825 coa->coa_changed |= COA_ROUTE_CHANGED;
1826 break;
1827 case IPV6_HOPLIMIT:
1828 mutex_enter(&connp->conn_lock);
1829 if (inlen == 0 || *i1 == -1) {
1830 /* Revert to default */
1831 ipp->ipp_fields &= ~IPPF_HOPLIMIT;
1832 ixa->ixa_flags &= ~IXAF_NO_TTL_CHANGE;
1833 } else {
1834 ipp->ipp_hoplimit = *i1;
1835 ipp->ipp_fields |= IPPF_HOPLIMIT;
1836 /* Ensure that it sticks for multicast packets */
1837 ixa->ixa_flags |= IXAF_NO_TTL_CHANGE;
1838 }
1839 mutex_exit(&connp->conn_lock);
1840 coa->coa_changed |= COA_HEADER_CHANGED;
1841 break;
1842 case IPV6_TCLASS:
1843 /*
1844 * IPV6_TCLASS accepts -1 as use kernel default
1845 * and [0, 255] as the actualy traffic class.
1846 */
1847 mutex_enter(&connp->conn_lock);
1848 if (inlen == 0 || *i1 == -1) {
1849 ipp->ipp_tclass = 0;
1850 ipp->ipp_fields &= ~IPPF_TCLASS;
1851 } else {
1852 ipp->ipp_tclass = *i1;
1853 ipp->ipp_fields |= IPPF_TCLASS;
1854 }
1855 mutex_exit(&connp->conn_lock);
1856 coa->coa_changed |= COA_HEADER_CHANGED;
1857 break;
1858 case IPV6_NEXTHOP:
1859 if (inlen == 0) {
1860 ixa->ixa_flags &= ~IXAF_NEXTHOP_SET;
1861 } else {
1862 sin6_t *sin6 = (sin6_t *)invalp;
1863
1864 ixa->ixa_nexthop_v6 = sin6->sin6_addr;
1865 if (!IN6_IS_ADDR_UNSPECIFIED(&ixa->ixa_nexthop_v6))
1866 ixa->ixa_flags |= IXAF_NEXTHOP_SET;
1867 else
1868 ixa->ixa_flags &= ~IXAF_NEXTHOP_SET;
1869 }
1870 coa->coa_changed |= COA_ROUTE_CHANGED;
1871 break;
1872 case IPV6_HOPOPTS:
1873 mutex_enter(&connp->conn_lock);
1874 error = optcom_pkt_set(invalp, inlen,
1875 (uchar_t **)&ipp->ipp_hopopts, &ipp->ipp_hopoptslen);
1876 if (error != 0) {
1877 mutex_exit(&connp->conn_lock);
1878 return (error);
1879 }
1880 if (ipp->ipp_hopoptslen == 0) {
1881 ipp->ipp_fields &= ~IPPF_HOPOPTS;
1882 } else {
1883 ipp->ipp_fields |= IPPF_HOPOPTS;
1884 }
1885 mutex_exit(&connp->conn_lock);
1886 coa->coa_changed |= COA_HEADER_CHANGED;
1887 coa->coa_changed |= COA_WROFF_CHANGED;
1888 break;
1889 case IPV6_RTHDRDSTOPTS:
1890 mutex_enter(&connp->conn_lock);
1891 error = optcom_pkt_set(invalp, inlen,
1892 (uchar_t **)&ipp->ipp_rthdrdstopts,
1893 &ipp->ipp_rthdrdstoptslen);
1894 if (error != 0) {
1895 mutex_exit(&connp->conn_lock);
1896 return (error);
1897 }
1898 if (ipp->ipp_rthdrdstoptslen == 0) {
1899 ipp->ipp_fields &= ~IPPF_RTHDRDSTOPTS;
1900 } else {
1901 ipp->ipp_fields |= IPPF_RTHDRDSTOPTS;
1902 }
1903 mutex_exit(&connp->conn_lock);
1904 coa->coa_changed |= COA_HEADER_CHANGED;
1905 coa->coa_changed |= COA_WROFF_CHANGED;
1906 break;
1907 case IPV6_DSTOPTS:
1908 mutex_enter(&connp->conn_lock);
1909 error = optcom_pkt_set(invalp, inlen,
1910 (uchar_t **)&ipp->ipp_dstopts, &ipp->ipp_dstoptslen);
1911 if (error != 0) {
1912 mutex_exit(&connp->conn_lock);
1913 return (error);
1914 }
1915 if (ipp->ipp_dstoptslen == 0) {
1916 ipp->ipp_fields &= ~IPPF_DSTOPTS;
1917 } else {
1918 ipp->ipp_fields |= IPPF_DSTOPTS;
1919 }
1920 mutex_exit(&connp->conn_lock);
1921 coa->coa_changed |= COA_HEADER_CHANGED;
1922 coa->coa_changed |= COA_WROFF_CHANGED;
1923 break;
1924 case IPV6_RTHDR:
1925 mutex_enter(&connp->conn_lock);
1926 error = optcom_pkt_set(invalp, inlen,
1927 (uchar_t **)&ipp->ipp_rthdr, &ipp->ipp_rthdrlen);
1928 if (error != 0) {
1929 mutex_exit(&connp->conn_lock);
1930 return (error);
1931 }
1932 if (ipp->ipp_rthdrlen == 0) {
1933 ipp->ipp_fields &= ~IPPF_RTHDR;
1934 } else {
1935 ipp->ipp_fields |= IPPF_RTHDR;
1936 }
1937 mutex_exit(&connp->conn_lock);
1938 coa->coa_changed |= COA_HEADER_CHANGED;
1939 coa->coa_changed |= COA_WROFF_CHANGED;
1940 break;
1941
1942 case IPV6_DONTFRAG:
1943 if (onoff) {
1944 ixa->ixa_flags |= IXAF_DONTFRAG;
1945 ixa->ixa_flags &= ~IXAF_PMTU_DISCOVERY;
1946 } else {
1947 ixa->ixa_flags &= ~IXAF_DONTFRAG;
1948 ixa->ixa_flags |= IXAF_PMTU_DISCOVERY;
1949 }
1950 /* Need to redo ip_attr_connect */
1951 coa->coa_changed |= COA_ROUTE_CHANGED;
1952 break;
1953
1954 case IPV6_USE_MIN_MTU:
1955 ixa->ixa_flags |= IXAF_USE_MIN_MTU;
1956 ixa->ixa_use_min_mtu = *i1;
1957 /* Need to redo ip_attr_connect */
1958 coa->coa_changed |= COA_ROUTE_CHANGED;
1959 break;
1960
1961 case IPV6_SEC_OPT:
1962 mutex_enter(&connp->conn_lock);
1963 error = ipsec_set_req(cr, connp, (ipsec_req_t *)invalp);
1964 mutex_exit(&connp->conn_lock);
1965 if (error != 0) {
1966 return (error);
1967 }
1968 /* This is an IPsec policy change - redo ip_attr_connect */
1969 coa->coa_changed |= COA_ROUTE_CHANGED;
1970 break;
1971 case IPV6_SRC_PREFERENCES:
1972 /*
1973 * This socket option only affects connected
1974 * sockets that haven't already bound to a specific
1975 * IPv6 address. In other words, sockets that
1976 * don't call bind() with an address other than the
1977 * unspecified address and that call connect().
1978 * ip_set_destination_v6() passes these preferences
1979 * to the ipif_select_source_v6() function.
1980 */
1981 mutex_enter(&connp->conn_lock);
1982 error = ip6_set_src_preferences(ixa, *(uint32_t *)invalp);
1983 mutex_exit(&connp->conn_lock);
1984 if (error != 0) {
1985 return (error);
1986 }
1987 break;
1988 case IPV6_V6ONLY:
1989 mutex_enter(&connp->conn_lock);
1990 connp->conn_ipv6_v6only = onoff;
1991 mutex_exit(&connp->conn_lock);
1992 break;
1993 }
1994 return (0);
1995 }
1996
1997 /* Handle IPPROTO_UDP */
1998 /* ARGSUSED1 */
1999 static int
2000 conn_opt_set_udp(conn_opt_arg_t *coa, t_scalar_t name, uint_t inlen,
2001 uchar_t *invalp, boolean_t checkonly, cred_t *cr)
2002 {
2003 conn_t *connp = coa->coa_connp;
2004 int *i1 = (int *)invalp;
2005 boolean_t onoff = (*i1 == 0) ? 0 : 1;
2006 int error;
2007
2008 switch (name) {
2009 case UDP_ANONPRIVBIND:
2010 if ((error = secpolicy_net_privaddr(cr, 0, IPPROTO_UDP)) != 0) {
2011 return (error);
2012 }
2013 break;
2014 }
2015 if (checkonly)
2016 return (0);
2017
2018 /* Here we set the actual option value */
2019 mutex_enter(&connp->conn_lock);
2020 switch (name) {
2021 case UDP_ANONPRIVBIND:
2022 connp->conn_anon_priv_bind = onoff;
2023 break;
2024 case UDP_EXCLBIND:
2025 connp->conn_exclbind = onoff;
2026 break;
2027 }
2028 mutex_exit(&connp->conn_lock);
2029 return (0);
2030 }
2031
2032 /* Handle IPPROTO_TCP */
2033 /* ARGSUSED1 */
2034 static int
2035 conn_opt_set_tcp(conn_opt_arg_t *coa, t_scalar_t name, uint_t inlen,
2036 uchar_t *invalp, boolean_t checkonly, cred_t *cr)
2037 {
2038 conn_t *connp = coa->coa_connp;
2039 int *i1 = (int *)invalp;
2040 boolean_t onoff = (*i1 == 0) ? 0 : 1;
2041 int error;
2042
2043 switch (name) {
2044 case TCP_ANONPRIVBIND:
2045 if ((error = secpolicy_net_privaddr(cr, 0, IPPROTO_TCP)) != 0) {
2046 return (error);
2047 }
2048 break;
2049 }
2050 if (checkonly)
2051 return (0);
2052
2053 /* Here we set the actual option value */
2054 mutex_enter(&connp->conn_lock);
2055 switch (name) {
2056 case TCP_ANONPRIVBIND:
2057 connp->conn_anon_priv_bind = onoff;
2058 break;
2059 case TCP_EXCLBIND:
2060 connp->conn_exclbind = onoff;
2061 break;
2062 case TCP_RECVDSTADDR:
2063 connp->conn_recv_ancillary.crb_recvdstaddr = onoff;
2064 break;
2065 }
2066 mutex_exit(&connp->conn_lock);
2067 return (0);
2068 }
2069
2070 int
2071 conn_getsockname(conn_t *connp, struct sockaddr *sa, uint_t *salenp)
2072 {
2073 sin_t *sin;
2074 sin6_t *sin6;
2075
2076 if (connp->conn_family == AF_INET) {
2077 if (*salenp < sizeof (sin_t))
2078 return (EINVAL);
2079
2080 *salenp = sizeof (sin_t);
2081 /* Fill zeroes and then initialize non-zero fields */
2082 sin = (sin_t *)sa;
2083 *sin = sin_null;
2084 sin->sin_family = AF_INET;
2085 if (!IN6_IS_ADDR_V4MAPPED_ANY(&connp->conn_saddr_v6) &&
2086 !IN6_IS_ADDR_UNSPECIFIED(&connp->conn_saddr_v6)) {
2087 sin->sin_addr.s_addr = connp->conn_saddr_v4;
2088 } else {
2089 /*
2090 * INADDR_ANY
2091 * conn_saddr is not set, we might be bound to
2092 * broadcast/multicast. Use conn_bound_addr as
2093 * local address instead (that could
2094 * also still be INADDR_ANY)
2095 */
2096 sin->sin_addr.s_addr = connp->conn_bound_addr_v4;
2097 }
2098 sin->sin_port = connp->conn_lport;
2099 } else {
2100 if (*salenp < sizeof (sin6_t))
2101 return (EINVAL);
2102
2103 *salenp = sizeof (sin6_t);
2104 /* Fill zeroes and then initialize non-zero fields */
2105 sin6 = (sin6_t *)sa;
2106 *sin6 = sin6_null;
2107 sin6->sin6_family = AF_INET6;
2108 if (!IN6_IS_ADDR_UNSPECIFIED(&connp->conn_saddr_v6)) {
2109 sin6->sin6_addr = connp->conn_saddr_v6;
2110 } else {
2111 /*
2112 * conn_saddr is not set, we might be bound to
2113 * broadcast/multicast. Use conn_bound_addr as
2114 * local address instead (which could
2115 * also still be unspecified)
2116 */
2117 sin6->sin6_addr = connp->conn_bound_addr_v6;
2118 }
2119 sin6->sin6_port = connp->conn_lport;
2120 if (IN6_IS_ADDR_LINKSCOPE(&sin6->sin6_addr) &&
2121 (connp->conn_ixa->ixa_flags & IXAF_SCOPEID_SET))
2122 sin6->sin6_scope_id = connp->conn_ixa->ixa_scopeid;
2123 }
2124 return (0);
2125 }
2126
2127 int
2128 conn_getpeername(conn_t *connp, struct sockaddr *sa, uint_t *salenp)
2129 {
2130 struct sockaddr_in *sin;
2131 struct sockaddr_in6 *sin6;
2132
2133 if (connp->conn_family == AF_INET) {
2134 if (*salenp < sizeof (sin_t))
2135 return (EINVAL);
2136
2137 *salenp = sizeof (sin_t);
2138 /* initialize */
2139 sin = (sin_t *)sa;
2140 *sin = sin_null;
2141 sin->sin_family = AF_INET;
2142 sin->sin_addr.s_addr = connp->conn_faddr_v4;
2143 sin->sin_port = connp->conn_fport;
2144 } else {
2145 if (*salenp < sizeof (sin6_t))
2146 return (EINVAL);
2147
2148 *salenp = sizeof (sin6_t);
2149 /* initialize */
2150 sin6 = (sin6_t *)sa;
2151 *sin6 = sin6_null;
2152 sin6->sin6_family = AF_INET6;
2153 sin6->sin6_addr = connp->conn_faddr_v6;
2154 sin6->sin6_port = connp->conn_fport;
2155 sin6->sin6_flowinfo = connp->conn_flowinfo;
2156 if (IN6_IS_ADDR_LINKSCOPE(&sin6->sin6_addr) &&
2157 (connp->conn_ixa->ixa_flags & IXAF_SCOPEID_SET))
2158 sin6->sin6_scope_id = connp->conn_ixa->ixa_scopeid;
2159 }
2160 return (0);
2161 }
2162
2163 static uint32_t cksum_massage_options_v4(ipha_t *, netstack_t *);
2164 static uint32_t cksum_massage_options_v6(ip6_t *, uint_t, netstack_t *);
2165
2166 /*
2167 * Allocate and fill in conn_ht_iphc based on the current information
2168 * in the conn.
2169 * Normally used when we bind() and connect().
2170 * Returns failure if can't allocate memory, or if there is a problem
2171 * with a routing header/option.
2172 *
2173 * We allocate space for the transport header (ulp_hdr_len + extra) and
2174 * indicate the offset of the ulp header by setting ixa_ip_hdr_length.
2175 * The extra is there for transports that want some spare room for future
2176 * options. conn_ht_iphc_allocated is what was allocated; conn_ht_iphc_len
2177 * excludes the extra part.
2178 *
2179 * We massage an routing option/header and store the ckecksum difference
2180 * in conn_sum.
2181 *
2182 * Caller needs to update conn_wroff if desired.
2183 */
2184 int
2185 conn_build_hdr_template(conn_t *connp, uint_t ulp_hdr_length, uint_t extra,
2186 const in6_addr_t *v6src, const in6_addr_t *v6dst, uint32_t flowinfo)
2187 {
2188 ip_xmit_attr_t *ixa = connp->conn_ixa;
2189 ip_pkt_t *ipp = &connp->conn_xmit_ipp;
2190 uint_t ip_hdr_length;
2191 uchar_t *hdrs;
2192 uint_t hdrs_len;
2193
2194 ASSERT(MUTEX_HELD(&connp->conn_lock));
2195
2196 if (ixa->ixa_flags & IXAF_IS_IPV4) {
2197 ip_hdr_length = ip_total_hdrs_len_v4(ipp);
2198 /* In case of TX label and IP options it can be too much */
2199 if (ip_hdr_length > IP_MAX_HDR_LENGTH) {
2200 /* Preserves existing TX errno for this */
2201 return (EHOSTUNREACH);
2202 }
2203 } else {
2204 ip_hdr_length = ip_total_hdrs_len_v6(ipp);
2205 }
2206 ixa->ixa_ip_hdr_length = ip_hdr_length;
2207 hdrs_len = ip_hdr_length + ulp_hdr_length + extra;
2208 ASSERT(hdrs_len != 0);
2209
2210 if (hdrs_len != connp->conn_ht_iphc_allocated) {
2211 /* Allocate new before we free any old */
2212 hdrs = kmem_alloc(hdrs_len, KM_NOSLEEP);
2213 if (hdrs == NULL)
2214 return (ENOMEM);
2215
2216 if (connp->conn_ht_iphc != NULL) {
2217 kmem_free(connp->conn_ht_iphc,
2218 connp->conn_ht_iphc_allocated);
2219 }
2220 connp->conn_ht_iphc = hdrs;
2221 connp->conn_ht_iphc_allocated = hdrs_len;
2222 } else {
2223 hdrs = connp->conn_ht_iphc;
2224 }
2225 hdrs_len -= extra;
2226 connp->conn_ht_iphc_len = hdrs_len;
2227
2228 connp->conn_ht_ulp = hdrs + ip_hdr_length;
2229 connp->conn_ht_ulp_len = ulp_hdr_length;
2230
2231 if (ixa->ixa_flags & IXAF_IS_IPV4) {
2232 ipha_t *ipha = (ipha_t *)hdrs;
2233
2234 IN6_V4MAPPED_TO_IPADDR(v6src, ipha->ipha_src);
2235 IN6_V4MAPPED_TO_IPADDR(v6dst, ipha->ipha_dst);
2236 ip_build_hdrs_v4(hdrs, ip_hdr_length, ipp, connp->conn_proto);
2237 ipha->ipha_length = htons(hdrs_len);
2238 if (ixa->ixa_flags & IXAF_PMTU_IPV4_DF)
2239 ipha->ipha_fragment_offset_and_flags |= IPH_DF_HTONS;
2240 else
2241 ipha->ipha_fragment_offset_and_flags &= ~IPH_DF_HTONS;
2242
2243 if (ipp->ipp_fields & IPPF_IPV4_OPTIONS) {
2244 connp->conn_sum = cksum_massage_options_v4(ipha,
2245 connp->conn_netstack);
2246 } else {
2247 connp->conn_sum = 0;
2248 }
2249 } else {
2250 ip6_t *ip6h = (ip6_t *)hdrs;
2251
2252 ip6h->ip6_src = *v6src;
2253 ip6h->ip6_dst = *v6dst;
2254 ip_build_hdrs_v6(hdrs, ip_hdr_length, ipp, connp->conn_proto,
2255 flowinfo);
2256 ip6h->ip6_plen = htons(hdrs_len - IPV6_HDR_LEN);
2257
2258 if (ipp->ipp_fields & IPPF_RTHDR) {
2259 connp->conn_sum = cksum_massage_options_v6(ip6h,
2260 ip_hdr_length, connp->conn_netstack);
2261
2262 /*
2263 * Verify that the first hop isn't a mapped address.
2264 * Routers along the path need to do this verification
2265 * for subsequent hops.
2266 */
2267 if (IN6_IS_ADDR_V4MAPPED(&ip6h->ip6_dst))
2268 return (EADDRNOTAVAIL);
2269
2270 } else {
2271 connp->conn_sum = 0;
2272 }
2273 }
2274 return (0);
2275 }
2276
2277 /*
2278 * Prepend a header template to data_mp based on the ip_pkt_t
2279 * and the passed in source, destination and protocol.
2280 *
2281 * Returns failure if can't allocate memory, in which case data_mp is freed.
2282 * We allocate space for the transport header (ulp_hdr_len) and
2283 * indicate the offset of the ulp header by setting ixa_ip_hdr_length.
2284 *
2285 * We massage an routing option/header and return the ckecksum difference
2286 * in *sump. This is in host byte order.
2287 *
2288 * Caller needs to update conn_wroff if desired.
2289 */
2290 mblk_t *
2291 conn_prepend_hdr(ip_xmit_attr_t *ixa, const ip_pkt_t *ipp,
2292 const in6_addr_t *v6src, const in6_addr_t *v6dst,
2293 uint8_t protocol, uint32_t flowinfo, uint_t ulp_hdr_length, mblk_t *data_mp,
2294 uint_t data_length, uint_t wroff_extra, uint32_t *sump, int *errorp)
2295 {
2296 uint_t ip_hdr_length;
2297 uchar_t *hdrs;
2298 uint_t hdrs_len;
2299 mblk_t *mp;
2300
2301 if (ixa->ixa_flags & IXAF_IS_IPV4) {
2302 ip_hdr_length = ip_total_hdrs_len_v4(ipp);
2303 ASSERT(ip_hdr_length <= IP_MAX_HDR_LENGTH);
2304 } else {
2305 ip_hdr_length = ip_total_hdrs_len_v6(ipp);
2306 }
2307 hdrs_len = ip_hdr_length + ulp_hdr_length;
2308 ASSERT(hdrs_len != 0);
2309
2310 ixa->ixa_ip_hdr_length = ip_hdr_length;
2311
2312 /* Can we prepend to data_mp? */
2313 if (data_mp != NULL &&
2314 data_mp->b_rptr - data_mp->b_datap->db_base >= hdrs_len &&
2315 data_mp->b_datap->db_ref == 1) {
2316 hdrs = data_mp->b_rptr - hdrs_len;
2317 data_mp->b_rptr = hdrs;
2318 mp = data_mp;
2319 } else {
2320 mp = allocb(hdrs_len + wroff_extra, BPRI_MED);
2321 if (mp == NULL) {
2322 freemsg(data_mp);
2323 *errorp = ENOMEM;
2324 return (NULL);
2325 }
2326 mp->b_wptr = mp->b_datap->db_lim;
2327 hdrs = mp->b_rptr = mp->b_wptr - hdrs_len;
2328 mp->b_cont = data_mp;
2329 }
2330
2331 /*
2332 * Set the source in the header. ip_build_hdrs_v4/v6 will overwrite it
2333 * if PKTINFO (aka IPPF_ADDR) was set.
2334 */
2335 if (ixa->ixa_flags & IXAF_IS_IPV4) {
2336 ipha_t *ipha = (ipha_t *)hdrs;
2337
2338 ASSERT(IN6_IS_ADDR_V4MAPPED(v6dst));
2339 IN6_V4MAPPED_TO_IPADDR(v6src, ipha->ipha_src);
2340 IN6_V4MAPPED_TO_IPADDR(v6dst, ipha->ipha_dst);
2341 ip_build_hdrs_v4(hdrs, ip_hdr_length, ipp, protocol);
2342 ipha->ipha_length = htons(hdrs_len + data_length);
2343 if (ixa->ixa_flags & IXAF_PMTU_IPV4_DF)
2344 ipha->ipha_fragment_offset_and_flags |= IPH_DF_HTONS;
2345 else
2346 ipha->ipha_fragment_offset_and_flags &= ~IPH_DF_HTONS;
2347
2348 if (ipp->ipp_fields & IPPF_IPV4_OPTIONS) {
2349 *sump = cksum_massage_options_v4(ipha,
2350 ixa->ixa_ipst->ips_netstack);
2351 } else {
2352 *sump = 0;
2353 }
2354 } else {
2355 ip6_t *ip6h = (ip6_t *)hdrs;
2356
2357 ip6h->ip6_src = *v6src;
2358 ip6h->ip6_dst = *v6dst;
2359 ip_build_hdrs_v6(hdrs, ip_hdr_length, ipp, protocol, flowinfo);
2360 ip6h->ip6_plen = htons(hdrs_len + data_length - IPV6_HDR_LEN);
2361
2362 if (ipp->ipp_fields & IPPF_RTHDR) {
2363 *sump = cksum_massage_options_v6(ip6h,
2364 ip_hdr_length, ixa->ixa_ipst->ips_netstack);
2365
2366 /*
2367 * Verify that the first hop isn't a mapped address.
2368 * Routers along the path need to do this verification
2369 * for subsequent hops.
2370 */
2371 if (IN6_IS_ADDR_V4MAPPED(&ip6h->ip6_dst)) {
2372 *errorp = EADDRNOTAVAIL;
2373 freemsg(mp);
2374 return (NULL);
2375 }
2376 } else {
2377 *sump = 0;
2378 }
2379 }
2380 return (mp);
2381 }
2382
2383 /*
2384 * Massage a source route if any putting the first hop
2385 * in ipha_dst. Compute a starting value for the checksum which
2386 * takes into account that the original ipha_dst should be
2387 * included in the checksum but that IP will include the
2388 * first hop from the source route in the tcp checksum.
2389 */
2390 static uint32_t
2391 cksum_massage_options_v4(ipha_t *ipha, netstack_t *ns)
2392 {
2393 in_addr_t dst;
2394 uint32_t cksum;
2395
2396 /* Get last hop then diff against first hop */
2397 cksum = ip_massage_options(ipha, ns);
2398 cksum = (cksum & 0xFFFF) + (cksum >> 16);
2399 dst = ipha->ipha_dst;
2400 cksum -= ((dst >> 16) + (dst & 0xffff));
2401 if ((int)cksum < 0)
2402 cksum--;
2403 cksum = (cksum & 0xFFFF) + (cksum >> 16);
2404 cksum = (cksum & 0xFFFF) + (cksum >> 16);
2405 ASSERT(cksum < 0x10000);
2406 return (ntohs(cksum));
2407 }
2408
2409 static uint32_t
2410 cksum_massage_options_v6(ip6_t *ip6h, uint_t ip_hdr_len, netstack_t *ns)
2411 {
2412 uint8_t *end;
2413 ip6_rthdr_t *rth;
2414 uint32_t cksum;
2415
2416 end = (uint8_t *)ip6h + ip_hdr_len;
2417 rth = ip_find_rthdr_v6(ip6h, end);
2418 if (rth == NULL)
2419 return (0);
2420
2421 cksum = ip_massage_options_v6(ip6h, rth, ns);
2422 cksum = (cksum & 0xFFFF) + (cksum >> 16);
2423 ASSERT(cksum < 0x10000);
2424 return (ntohs(cksum));
2425 }
2426
2427 /*
2428 * ULPs that change the destination address need to call this for each
2429 * change to discard any state about a previous destination that might
2430 * have been multicast or multirt.
2431 */
2432 void
2433 ip_attr_newdst(ip_xmit_attr_t *ixa)
2434 {
2435 ixa->ixa_flags &= ~(IXAF_LOOPBACK_COPY | IXAF_NO_HW_CKSUM |
2436 IXAF_NO_TTL_CHANGE | IXAF_IPV6_ADD_FRAGHDR |
2437 IXAF_NO_LOOP_ZONEID_SET);
2438 }
2439
2440 /*
2441 * Determine the nexthop which will be used.
2442 * Normally this is just the destination, but if a IPv4 source route, or
2443 * IPv6 routing header, is in the ip_pkt_t then we extract the nexthop from
2444 * there.
2445 */
2446 void
2447 ip_attr_nexthop(const ip_pkt_t *ipp, const ip_xmit_attr_t *ixa,
2448 const in6_addr_t *dst, in6_addr_t *nexthop)
2449 {
2450 if (!(ipp->ipp_fields & (IPPF_IPV4_OPTIONS|IPPF_RTHDR))) {
2451 *nexthop = *dst;
2452 return;
2453 }
2454 if (ixa->ixa_flags & IXAF_IS_IPV4) {
2455 ipaddr_t v4dst;
2456 ipaddr_t v4nexthop;
2457
2458 IN6_V4MAPPED_TO_IPADDR(dst, v4dst);
2459 v4nexthop = ip_pkt_source_route_v4(ipp);
2460 if (v4nexthop == INADDR_ANY)
2461 v4nexthop = v4dst;
2462
2463 IN6_IPADDR_TO_V4MAPPED(v4nexthop, nexthop);
2464 } else {
2465 const in6_addr_t *v6nexthop;
2466
2467 v6nexthop = ip_pkt_source_route_v6(ipp);
2468 if (v6nexthop == NULL)
2469 v6nexthop = dst;
2470
2471 *nexthop = *v6nexthop;
2472 }
2473 }
2474
2475 /*
2476 * Update the ip_xmit_attr_t based the addresses, conn_xmit_ipp and conn_ixa.
2477 * If IPDF_IPSEC is set we cache the IPsec policy to handle the unconnected
2478 * case (connected latching is done in conn_connect).
2479 * Note that IPsec policy lookup requires conn_proto and conn_laddr to be
2480 * set, but doesn't otherwise use the conn_t.
2481 *
2482 * Caller must set/clear IXAF_IS_IPV4 as appropriately.
2483 * Caller must use ip_attr_nexthop() to determine the nexthop argument.
2484 *
2485 * The caller must NOT hold conn_lock (to avoid problems with ill_refrele
2486 * causing the squeue to run doing ipcl_walk grabbing conn_lock.)
2487 *
2488 * Updates laddrp and uinfo if they are non-NULL.
2489 *
2490 * TSOL notes: The callers if ip_attr_connect must check if the destination
2491 * is different than before and in that case redo conn_update_label.
2492 * The callers of conn_connect do not need that since conn_connect
2493 * performs the conn_update_label.
2494 */
2495 int
2496 ip_attr_connect(const conn_t *connp, ip_xmit_attr_t *ixa,
2497 const in6_addr_t *v6src, const in6_addr_t *v6dst,
2498 const in6_addr_t *v6nexthop, in_port_t dstport, in6_addr_t *laddrp,
2499 iulp_t *uinfo, uint32_t flags)
2500 {
2501 in6_addr_t laddr = *v6src;
2502 int error;
2503
2504 ASSERT(MUTEX_NOT_HELD(&connp->conn_lock));
2505
2506 if (connp->conn_zone_is_global)
2507 flags |= IPDF_ZONE_IS_GLOBAL;
2508 else
2509 flags &= ~IPDF_ZONE_IS_GLOBAL;
2510
2511 /*
2512 * Lookup the route to determine a source address and the uinfo.
2513 * If the ULP has a source route option then the caller will
2514 * have set v6nexthop to be the first hop.
2515 */
2516 if (ixa->ixa_flags & IXAF_IS_IPV4) {
2517 ipaddr_t v4dst;
2518 ipaddr_t v4src, v4nexthop;
2519
2520 IN6_V4MAPPED_TO_IPADDR(v6dst, v4dst);
2521 IN6_V4MAPPED_TO_IPADDR(v6nexthop, v4nexthop);
2522 IN6_V4MAPPED_TO_IPADDR(v6src, v4src);
2523
2524 if (connp->conn_unspec_src || v4src != INADDR_ANY)
2525 flags &= ~IPDF_SELECT_SRC;
2526 else
2527 flags |= IPDF_SELECT_SRC;
2528
2529 error = ip_set_destination_v4(&v4src, v4dst, v4nexthop, ixa,
2530 uinfo, flags, connp->conn_mac_mode);
2531 IN6_IPADDR_TO_V4MAPPED(v4src, &laddr);
2532 } else {
2533 if (connp->conn_unspec_src || !IN6_IS_ADDR_UNSPECIFIED(v6src))
2534 flags &= ~IPDF_SELECT_SRC;
2535 else
2536 flags |= IPDF_SELECT_SRC;
2537
2538 error = ip_set_destination_v6(&laddr, v6dst, v6nexthop, ixa,
2539 uinfo, flags, connp->conn_mac_mode);
2540 }
2541 /* Pass out some address even if we hit a RTF_REJECT etc */
2542 if (laddrp != NULL)
2543 *laddrp = laddr;
2544
2545 if (error != 0)
2546 return (error);
2547
2548 if (flags & IPDF_IPSEC) {
2549 /*
2550 * Set any IPsec policy in ixa. Routine also looks at ULP
2551 * ports.
2552 */
2553 ipsec_cache_outbound_policy(connp, v6src, v6dst, dstport, ixa);
2554 }
2555 return (0);
2556 }
2557
2558 /*
2559 * Connect the conn based on the addresses, conn_xmit_ipp and conn_ixa.
2560 * Assumes that conn_faddr and conn_fport are already set. As such it is not
2561 * usable for SCTP, since SCTP has multiple faddrs.
2562 *
2563 * Caller must hold conn_lock to provide atomic constency between the
2564 * conn_t's addresses and the ixa.
2565 * NOTE: this function drops and reaquires conn_lock since it can't be
2566 * held across ip_attr_connect/ip_set_destination.
2567 *
2568 * The caller needs to handle inserting in the receive-side fanout when
2569 * appropriate after conn_connect returns.
2570 */
2571 int
2572 conn_connect(conn_t *connp, iulp_t *uinfo, uint32_t flags)
2573 {
2574 ip_xmit_attr_t *ixa = connp->conn_ixa;
2575 in6_addr_t nexthop;
2576 in6_addr_t saddr, faddr;
2577 in_port_t fport;
2578 int error;
2579
2580 ASSERT(MUTEX_HELD(&connp->conn_lock));
2581
2582 if (connp->conn_ipversion == IPV4_VERSION)
2583 ixa->ixa_flags |= IXAF_IS_IPV4;
2584 else
2585 ixa->ixa_flags &= ~IXAF_IS_IPV4;
2586
2587 /* We do IPsec latching below - hence no caching in ip_attr_connect */
2588 flags &= ~IPDF_IPSEC;
2589
2590 /* In case we had previously done an ip_attr_connect */
2591 ip_attr_newdst(ixa);
2592
2593 /*
2594 * Determine the nexthop and copy the addresses before dropping
2595 * conn_lock.
2596 */
2597 ip_attr_nexthop(&connp->conn_xmit_ipp, connp->conn_ixa,
2598 &connp->conn_faddr_v6, &nexthop);
2599 saddr = connp->conn_saddr_v6;
2600 faddr = connp->conn_faddr_v6;
2601 fport = connp->conn_fport;
2602
2603 mutex_exit(&connp->conn_lock);
2604 error = ip_attr_connect(connp, ixa, &saddr, &faddr, &nexthop, fport,
2605 &saddr, uinfo, flags | IPDF_VERIFY_DST);
2606 mutex_enter(&connp->conn_lock);
2607
2608 /* Could have changed even if an error */
2609 connp->conn_saddr_v6 = saddr;
2610 if (error != 0)
2611 return (error);
2612
2613 /*
2614 * Check whether Trusted Solaris policy allows communication with this
2615 * host, and pretend that the destination is unreachable if not.
2616 * Compute any needed label and place it in ipp_label_v4/v6.
2617 *
2618 * Later conn_build_hdr_template() takes ipp_label_v4/v6 to form
2619 * the packet.
2620 *
2621 * TSOL Note: Any concurrent threads would pick a different ixa
2622 * (and ipp if they are to change the ipp) so we
2623 * don't have to worry about concurrent threads.
2624 */
2625 if (is_system_labeled()) {
2626 if (connp->conn_mlp_type != mlptSingle)
2627 return (ECONNREFUSED);
2628
2629 /*
2630 * conn_update_label will set ipp_label* which will later
2631 * be used by conn_build_hdr_template.
2632 */
2633 error = conn_update_label(connp, ixa,
2634 &connp->conn_faddr_v6, &connp->conn_xmit_ipp);
2635 if (error != 0)
2636 return (error);
2637 }
2638
2639 /*
2640 * Ensure that we match on the selected local address.
2641 * This overrides conn_laddr in the case we had earlier bound to a
2642 * multicast or broadcast address.
2643 */
2644 connp->conn_laddr_v6 = connp->conn_saddr_v6;
2645
2646 /*
2647 * Allow setting new policies.
2648 * The addresses/ports are already set, thus the IPsec policy calls
2649 * can handle their passed-in conn's.
2650 */
2651 connp->conn_policy_cached = B_FALSE;
2652
2653 /*
2654 * Cache IPsec policy in this conn. If we have per-socket policy,
2655 * we'll cache that. If we don't, we'll inherit global policy.
2656 *
2657 * This is done before the caller inserts in the receive-side fanout.
2658 * Note that conn_policy_cached is set by ipsec_conn_cache_policy() even
2659 * for connections where we don't have a policy. This is to prevent
2660 * global policy lookups in the inbound path.
2661 *
2662 * If we insert before we set conn_policy_cached,
2663 * CONN_INBOUND_POLICY_PRESENT() check can still evaluate true
2664 * because global policy cound be non-empty. We normally call
2665 * ipsec_check_policy() for conn_policy_cached connections only if
2666 * conn_in_enforce_policy is set. But in this case,
2667 * conn_policy_cached can get set anytime since we made the
2668 * CONN_INBOUND_POLICY_PRESENT() check and ipsec_check_policy() is
2669 * called, which will make the above assumption false. Thus, we
2670 * need to insert after we set conn_policy_cached.
2671 */
2672 error = ipsec_conn_cache_policy(connp,
2673 connp->conn_ipversion == IPV4_VERSION);
2674 if (error != 0)
2675 return (error);
2676
2677 /*
2678 * We defer to do LSO check until here since now we have better idea
2679 * whether IPsec is present. If the underlying ill is LSO capable,
2680 * copy its capability in so the ULP can decide whether to enable LSO
2681 * on this connection. So far, only TCP/IPv4 is implemented, so won't
2682 * claim LSO for IPv6.
2683 *
2684 * Currently, won't enable LSO for IRE_LOOPBACK or IRE_LOCAL, because
2685 * the receiver can not handle it. Also not to enable LSO for MULTIRT.
2686 */
2687 ixa->ixa_flags &= ~IXAF_LSO_CAPAB;
2688
2689 ASSERT(ixa->ixa_ire != NULL);
2690 if (ixa->ixa_ipst->ips_ip_lso_outbound && (flags & IPDF_LSO) &&
2691 !(ixa->ixa_flags & IXAF_IPSEC_SECURE) &&
2692 !(ixa->ixa_ire->ire_type & (IRE_LOCAL | IRE_LOOPBACK)) &&
2693 !(ixa->ixa_ire->ire_flags & RTF_MULTIRT) &&
2694 (ixa->ixa_nce != NULL) &&
2695 ((ixa->ixa_flags & IXAF_IS_IPV4) ?
2696 ILL_LSO_TCP_IPV4_USABLE(ixa->ixa_nce->nce_ill) :
2697 ILL_LSO_TCP_IPV6_USABLE(ixa->ixa_nce->nce_ill))) {
2698 ixa->ixa_lso_capab = *ixa->ixa_nce->nce_ill->ill_lso_capab;
2699 ixa->ixa_flags |= IXAF_LSO_CAPAB;
2700 }
2701
2702 /* Check whether ZEROCOPY capability is usable for this connection. */
2703 ixa->ixa_flags &= ~IXAF_ZCOPY_CAPAB;
2704
2705 if ((flags & IPDF_ZCOPY) &&
2706 !(ixa->ixa_flags & IXAF_IPSEC_SECURE) &&
2707 !(ixa->ixa_ire->ire_type & (IRE_LOCAL | IRE_LOOPBACK)) &&
2708 !(ixa->ixa_ire->ire_flags & RTF_MULTIRT) &&
2709 (ixa->ixa_nce != NULL) &&
2710 ILL_ZCOPY_USABLE(ixa->ixa_nce->nce_ill)) {
2711 ixa->ixa_flags |= IXAF_ZCOPY_CAPAB;
2712 }
2713 return (0);
2714 }
2715
2716 /*
2717 * Predicates to check if the addresses match conn_last*
2718 */
2719
2720 /*
2721 * Compare the conn against an address.
2722 * If using mapped addresses on AF_INET6 sockets, use the _v6 function
2723 */
2724 boolean_t
2725 conn_same_as_last_v4(conn_t *connp, sin_t *sin)
2726 {
2727 ASSERT(connp->conn_family == AF_INET);
2728 return (sin->sin_addr.s_addr == connp->conn_v4lastdst &&
2729 sin->sin_port == connp->conn_lastdstport);
2730 }
2731
2732 /*
2733 * Compare, including for mapped addresses
2734 */
2735 boolean_t
2736 conn_same_as_last_v6(conn_t *connp, sin6_t *sin6)
2737 {
2738 return (IN6_ARE_ADDR_EQUAL(&connp->conn_v6lastdst, &sin6->sin6_addr) &&
2739 sin6->sin6_port == connp->conn_lastdstport &&
2740 sin6->sin6_flowinfo == connp->conn_lastflowinfo &&
2741 sin6->sin6_scope_id == connp->conn_lastscopeid);
2742 }
2743
2744 /*
2745 * Compute a label and place it in the ip_packet_t.
2746 * Handles IPv4 and IPv6.
2747 * The caller should have a correct ixa_tsl and ixa_zoneid and have
2748 * already called conn_connect or ip_attr_connect to ensure that tsol_check_dest
2749 * has been called.
2750 */
2751 int
2752 conn_update_label(const conn_t *connp, const ip_xmit_attr_t *ixa,
2753 const in6_addr_t *v6dst, ip_pkt_t *ipp)
2754 {
2755 int err;
2756 ipaddr_t v4dst;
2757
2758 if (IN6_IS_ADDR_V4MAPPED(v6dst)) {
2759 uchar_t opt_storage[IP_MAX_OPT_LENGTH];
2760
2761 IN6_V4MAPPED_TO_IPADDR(v6dst, v4dst);
2762
2763 err = tsol_compute_label_v4(ixa->ixa_tsl, ixa->ixa_zoneid,
2764 v4dst, opt_storage, ixa->ixa_ipst);
2765 if (err == 0) {
2766 /* Length contained in opt_storage[IPOPT_OLEN] */
2767 err = optcom_pkt_set(opt_storage,
2768 opt_storage[IPOPT_OLEN],
2769 (uchar_t **)&ipp->ipp_label_v4,
2770 &ipp->ipp_label_len_v4);
2771 }
2772 if (err != 0) {
2773 DTRACE_PROBE4(tx__ip__log__info__updatelabel,
2774 char *, "conn(1) failed to update options(2) "
2775 "on ixa(3)",
2776 conn_t *, connp, char *, opt_storage,
2777 ip_xmit_attr_t *, ixa);
2778 }
2779 if (ipp->ipp_label_len_v4 != 0)
2780 ipp->ipp_fields |= IPPF_LABEL_V4;
2781 else
2782 ipp->ipp_fields &= ~IPPF_LABEL_V4;
2783 } else {
2784 uchar_t opt_storage[TSOL_MAX_IPV6_OPTION];
2785 uint_t optlen;
2786
2787 err = tsol_compute_label_v6(ixa->ixa_tsl, ixa->ixa_zoneid,
2788 v6dst, opt_storage, ixa->ixa_ipst);
2789 if (err == 0) {
2790 /*
2791 * Note that ipp_label_v6 is just the option - not
2792 * the hopopts extension header.
2793 *
2794 * Length contained in opt_storage[IPOPT_OLEN], but
2795 * that doesn't include the two byte options header.
2796 */
2797 optlen = opt_storage[IPOPT_OLEN];
2798 if (optlen != 0)
2799 optlen += 2;
2800
2801 err = optcom_pkt_set(opt_storage, optlen,
2802 (uchar_t **)&ipp->ipp_label_v6,
2803 &ipp->ipp_label_len_v6);
2804 }
2805 if (err != 0) {
2806 DTRACE_PROBE4(tx__ip__log__info__updatelabel,
2807 char *, "conn(1) failed to update options(2) "
2808 "on ixa(3)",
2809 conn_t *, connp, char *, opt_storage,
2810 ip_xmit_attr_t *, ixa);
2811 }
2812 if (ipp->ipp_label_len_v6 != 0)
2813 ipp->ipp_fields |= IPPF_LABEL_V6;
2814 else
2815 ipp->ipp_fields &= ~IPPF_LABEL_V6;
2816 }
2817 return (err);
2818 }
2819
2820 /*
2821 * Inherit all options settings from the parent/listener to the eager.
2822 * Returns zero on success; ENOMEM if memory allocation failed.
2823 *
2824 * We assume that the eager has not had any work done i.e., the conn_ixa
2825 * and conn_xmit_ipp are all zero.
2826 * Furthermore we assume that no other thread can access the eager (because
2827 * it isn't inserted in any fanout list).
2828 */
2829 int
2830 conn_inherit_parent(conn_t *lconnp, conn_t *econnp)
2831 {
2832 cred_t *credp;
2833 int err;
2834 void *notify_cookie;
2835 uint32_t xmit_hint;
2836
2837 econnp->conn_family = lconnp->conn_family;
2838 econnp->conn_ipv6_v6only = lconnp->conn_ipv6_v6only;
2839 econnp->conn_wq = lconnp->conn_wq;
2840 econnp->conn_rq = lconnp->conn_rq;
2841
2842 /*
2843 * Make a safe copy of the transmit attributes.
2844 * conn_connect will later be used by the caller to setup the ire etc.
2845 */
2846 ASSERT(econnp->conn_ixa->ixa_refcnt == 1);
2847 ASSERT(econnp->conn_ixa->ixa_ire == NULL);
2848 ASSERT(econnp->conn_ixa->ixa_dce == NULL);
2849 ASSERT(econnp->conn_ixa->ixa_nce == NULL);
2850
2851 /* Preserve ixa_notify_cookie and xmit_hint */
2852 notify_cookie = econnp->conn_ixa->ixa_notify_cookie;
2853 xmit_hint = econnp->conn_ixa->ixa_xmit_hint;
2854 ixa_safe_copy(lconnp->conn_ixa, econnp->conn_ixa);
2855 econnp->conn_ixa->ixa_notify_cookie = notify_cookie;
2856 econnp->conn_ixa->ixa_xmit_hint = xmit_hint;
2857
2858 econnp->conn_bound_if = lconnp->conn_bound_if;
2859 econnp->conn_incoming_ifindex = lconnp->conn_incoming_ifindex;
2860
2861 /* Inherit all RECV options */
2862 econnp->conn_recv_ancillary = lconnp->conn_recv_ancillary;
2863
2864 err = ip_pkt_copy(&lconnp->conn_xmit_ipp, &econnp->conn_xmit_ipp,
2865 KM_NOSLEEP);
2866 if (err != 0)
2867 return (err);
2868
2869 econnp->conn_zoneid = lconnp->conn_zoneid;
2870 econnp->conn_allzones = lconnp->conn_allzones;
2871
2872 /* This is odd. Pick a flowlabel for each connection instead? */
2873 econnp->conn_flowinfo = lconnp->conn_flowinfo;
2874
2875 econnp->conn_default_ttl = lconnp->conn_default_ttl;
2876
2877 /*
2878 * TSOL: tsol_input_proc() needs the eager's cred before the
2879 * eager is accepted
2880 */
2881 ASSERT(lconnp->conn_cred != NULL);
2882 econnp->conn_cred = credp = lconnp->conn_cred;
2883 crhold(credp);
2884 econnp->conn_cpid = lconnp->conn_cpid;
2885 econnp->conn_open_time = ddi_get_lbolt64();
2886
2887 /*
2888 * Cache things in the ixa without any refhold.
2889 * Listener might not have set up ixa_cred
2890 */
2891 ASSERT(!(econnp->conn_ixa->ixa_free_flags & IXA_FREE_CRED));
2892 econnp->conn_ixa->ixa_cred = econnp->conn_cred;
2893 econnp->conn_ixa->ixa_cpid = econnp->conn_cpid;
2894 if (is_system_labeled())
2895 econnp->conn_ixa->ixa_tsl = crgetlabel(econnp->conn_cred);
2896
2897 /*
2898 * If the caller has the process-wide flag set, then default to MAC
2899 * exempt mode. This allows read-down to unlabeled hosts.
2900 */
2901 if (getpflags(NET_MAC_AWARE, credp) != 0)
2902 econnp->conn_mac_mode = CONN_MAC_AWARE;
2903
2904 econnp->conn_zone_is_global = lconnp->conn_zone_is_global;
2905
2906 /*
2907 * We eliminate the need for sockfs to send down a T_SVR4_OPTMGMT_REQ
2908 * via soaccept()->soinheritoptions() which essentially applies
2909 * all the listener options to the new connection. The options that we
2910 * need to take care of are:
2911 * SO_DEBUG, SO_REUSEADDR, SO_KEEPALIVE, SO_DONTROUTE, SO_BROADCAST,
2912 * SO_USELOOPBACK, SO_OOBINLINE, SO_DGRAM_ERRIND, SO_LINGER,
2913 * SO_SNDBUF, SO_RCVBUF.
2914 *
2915 * SO_RCVBUF: conn_rcvbuf is set.
2916 * SO_SNDBUF: conn_sndbuf is set.
2917 */
2918
2919 /* Could we define a struct and use a struct copy for this? */
2920 econnp->conn_sndbuf = lconnp->conn_sndbuf;
2921 econnp->conn_rcvbuf = lconnp->conn_rcvbuf;
2922 econnp->conn_sndlowat = lconnp->conn_sndlowat;
2923 econnp->conn_rcvlowat = lconnp->conn_rcvlowat;
2924 econnp->conn_dgram_errind = lconnp->conn_dgram_errind;
2925 econnp->conn_oobinline = lconnp->conn_oobinline;
2926 econnp->conn_debug = lconnp->conn_debug;
2927 econnp->conn_keepalive = lconnp->conn_keepalive;
2928 econnp->conn_linger = lconnp->conn_linger;
2929 econnp->conn_lingertime = lconnp->conn_lingertime;
2930
2931 /* Set the IP options */
2932 econnp->conn_broadcast = lconnp->conn_broadcast;
2933 econnp->conn_useloopback = lconnp->conn_useloopback;
2934 econnp->conn_reuseaddr = lconnp->conn_reuseaddr;
2935 return (0);
2936 }
Community developed and maintained version of the OS/Net consolidation