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 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 #include <sys/param.h> 27 #include <sys/types.h> 28 #include <sys/systm.h> 29 #include <sys/stream.h> 30 #include <sys/strsubr.h> 31 #include <sys/pattr.h> 32 #include <sys/dlpi.h> 33 #include <sys/atomic.h> 34 #include <sys/sunddi.h> 35 #include <sys/socket.h> 36 #include <sys/neti.h> 37 #include <sys/sdt.h> 38 #include <sys/cmn_err.h> 39 40 #include <netinet/in.h> 41 #include <inet/common.h> 42 #include <inet/mib2.h> 43 #include <inet/ip.h> 44 #include <inet/ip6.h> 45 #include <inet/ip_if.h> 46 #include <inet/ip_ire.h> 47 #include <inet/ip_impl.h> 48 #include <inet/ip_ndp.h> 49 #include <inet/ipclassifier.h> 50 #include <inet/ipp_common.h> 51 #include <inet/ip_ftable.h> 52 53 /* 54 * IPv4 netinfo entry point declarations. 55 */ 56 static int ip_getifname(net_handle_t, phy_if_t, char *, 57 const size_t); 58 static int ip_getmtu(net_handle_t, phy_if_t, lif_if_t); 59 static int ip_getpmtuenabled(net_handle_t); 60 static int ip_getlifaddr(net_handle_t, phy_if_t, lif_if_t, 61 size_t, net_ifaddr_t [], void *); 62 static int ip_getlifzone(net_handle_t, phy_if_t, lif_if_t, 63 zoneid_t *); 64 static int ip_getlifflags(net_handle_t, phy_if_t, lif_if_t, 65 uint64_t *); 66 static phy_if_t ip_phygetnext(net_handle_t, phy_if_t); 67 static phy_if_t ip_phylookup(net_handle_t, const char *); 68 static lif_if_t ip_lifgetnext(net_handle_t, phy_if_t, lif_if_t); 69 static int ip_inject(net_handle_t, inject_t, net_inject_t *); 70 static phy_if_t ip_routeto(net_handle_t, struct sockaddr *, 71 struct sockaddr *); 72 static int ip_ispartialchecksum(net_handle_t, mblk_t *); 73 static int ip_isvalidchecksum(net_handle_t, mblk_t *); 74 75 static int ipv6_getifname(net_handle_t, phy_if_t, char *, 76 const size_t); 77 static int ipv6_getmtu(net_handle_t, phy_if_t, lif_if_t); 78 static int ipv6_getlifaddr(net_handle_t, phy_if_t, lif_if_t, 79 size_t, net_ifaddr_t [], void *); 80 static int ipv6_getlifzone(net_handle_t, phy_if_t, lif_if_t, 81 zoneid_t *); 82 static int ipv6_getlifflags(net_handle_t, phy_if_t, lif_if_t, 83 uint64_t *); 84 static phy_if_t ipv6_phygetnext(net_handle_t, phy_if_t); 85 static phy_if_t ipv6_phylookup(net_handle_t, const char *); 86 static lif_if_t ipv6_lifgetnext(net_handle_t, phy_if_t, lif_if_t); 87 static int ipv6_inject(net_handle_t, inject_t, net_inject_t *); 88 static phy_if_t ipv6_routeto(net_handle_t, struct sockaddr *, 89 struct sockaddr *); 90 static int ipv6_isvalidchecksum(net_handle_t, mblk_t *); 91 92 /* Netinfo private functions */ 93 static int ip_getifname_impl(phy_if_t, char *, 94 const size_t, boolean_t, ip_stack_t *); 95 static int ip_getmtu_impl(phy_if_t, lif_if_t, boolean_t, 96 ip_stack_t *); 97 static phy_if_t ip_phylookup_impl(const char *, boolean_t, 98 ip_stack_t *); 99 static lif_if_t ip_lifgetnext_impl(phy_if_t, lif_if_t, boolean_t, 100 ip_stack_t *); 101 static int ip_inject_impl(inject_t, net_inject_t *, boolean_t, 102 ip_stack_t *); 103 static int ip_getifaddr_type(sa_family_t, ipif_t *, lif_if_t, 104 void *); 105 static phy_if_t ip_routeto_impl(struct sockaddr *, struct sockaddr *, 106 ip_stack_t *); 107 static int ip_getlifaddr_impl(sa_family_t, phy_if_t, lif_if_t, 108 size_t, net_ifaddr_t [], struct sockaddr *, 109 ip_stack_t *); 110 static void ip_ni_queue_in_func(void *); 111 static void ip_ni_queue_out_func(void *); 112 static void ip_ni_queue_func_impl(injection_t *, boolean_t); 113 114 115 static net_protocol_t ipv4info = { 116 NETINFO_VERSION, 117 NHF_INET, 118 ip_getifname, 119 ip_getmtu, 120 ip_getpmtuenabled, 121 ip_getlifaddr, 122 ip_getlifzone, 123 ip_getlifflags, 124 ip_phygetnext, 125 ip_phylookup, 126 ip_lifgetnext, 127 ip_inject, 128 ip_routeto, 129 ip_ispartialchecksum, 130 ip_isvalidchecksum 131 }; 132 133 134 static net_protocol_t ipv6info = { 135 NETINFO_VERSION, 136 NHF_INET6, 137 ipv6_getifname, 138 ipv6_getmtu, 139 ip_getpmtuenabled, 140 ipv6_getlifaddr, 141 ipv6_getlifzone, 142 ipv6_getlifflags, 143 ipv6_phygetnext, 144 ipv6_phylookup, 145 ipv6_lifgetnext, 146 ipv6_inject, 147 ipv6_routeto, 148 ip_ispartialchecksum, 149 ipv6_isvalidchecksum 150 }; 151 152 /* 153 * The taskq eventq_queue_in is used to process the upside inject messages. 154 * The taskq eventq_queue_out is used to process the downside inject messages. 155 * The taskq eventq_queue_nic is used to process the nic event messages. 156 */ 157 static ddi_taskq_t *eventq_queue_in = NULL; 158 static ddi_taskq_t *eventq_queue_out = NULL; 159 ddi_taskq_t *eventq_queue_nic = NULL; 160 161 /* 162 * Initialize queues for inject. 163 */ 164 void 165 ip_net_g_init() 166 { 167 if (eventq_queue_out == NULL) { 168 eventq_queue_out = ddi_taskq_create(NULL, 169 "IP_INJECT_QUEUE_OUT", 1, TASKQ_DEFAULTPRI, 0); 170 171 if (eventq_queue_out == NULL) 172 cmn_err(CE_NOTE, "ipv4_net_init: " 173 "ddi_taskq_create failed for IP_INJECT_QUEUE_OUT"); 174 } 175 176 if (eventq_queue_in == NULL) { 177 eventq_queue_in = ddi_taskq_create(NULL, 178 "IP_INJECT_QUEUE_IN", 1, TASKQ_DEFAULTPRI, 0); 179 180 if (eventq_queue_in == NULL) 181 cmn_err(CE_NOTE, "ipv4_net_init: " 182 "ddi_taskq_create failed for IP_INJECT_QUEUE_IN"); 183 } 184 185 if (eventq_queue_nic == NULL) { 186 eventq_queue_nic = ddi_taskq_create(NULL, 187 "IP_NIC_EVENT_QUEUE", 1, TASKQ_DEFAULTPRI, 0); 188 189 if (eventq_queue_nic == NULL) 190 cmn_err(CE_NOTE, "ipv4_net_init: " 191 "ddi_taskq_create failed for IP_NIC_EVENT_QUEUE"); 192 } 193 } 194 195 /* 196 * Destroy inject queues 197 */ 198 void 199 ip_net_g_destroy() 200 { 201 if (eventq_queue_nic != NULL) { 202 ddi_taskq_destroy(eventq_queue_nic); 203 eventq_queue_nic = NULL; 204 } 205 206 if (eventq_queue_in != NULL) { 207 ddi_taskq_destroy(eventq_queue_in); 208 eventq_queue_in = NULL; 209 } 210 211 if (eventq_queue_out != NULL) { 212 ddi_taskq_destroy(eventq_queue_out); 213 eventq_queue_out = NULL; 214 } 215 } 216 217 /* 218 * Register IPv4 and IPv6 netinfo functions and initialize queues for inject. 219 */ 220 void 221 ip_net_init(ip_stack_t *ipst, netstack_t *ns) 222 { 223 netid_t id; 224 225 id = net_getnetidbynetstackid(ns->netstack_stackid); 226 ASSERT(id != -1); 227 228 ipst->ips_ipv4_net_data = net_protocol_register(id, &ipv4info); 229 ASSERT(ipst->ips_ipv4_net_data != NULL); 230 231 ipst->ips_ipv6_net_data = net_protocol_register(id, &ipv6info); 232 ASSERT(ipst->ips_ipv6_net_data != NULL); 233 } 234 235 236 /* 237 * Unregister IPv4 and IPv6 functions. 238 */ 239 void 240 ip_net_destroy(ip_stack_t *ipst) 241 { 242 if (ipst->ips_ipv4_net_data != NULL) { 243 if (net_protocol_unregister(ipst->ips_ipv4_net_data) == 0) 244 ipst->ips_ipv4_net_data = NULL; 245 } 246 247 if (ipst->ips_ipv6_net_data != NULL) { 248 if (net_protocol_unregister(ipst->ips_ipv6_net_data) == 0) 249 ipst->ips_ipv6_net_data = NULL; 250 } 251 } 252 253 /* 254 * Initialize IPv4 hooks family the event 255 */ 256 void 257 ipv4_hook_init(ip_stack_t *ipst) 258 { 259 HOOK_FAMILY_INIT(&ipst->ips_ipv4root, Hn_IPV4); 260 if (net_family_register(ipst->ips_ipv4_net_data, &ipst->ips_ipv4root) 261 != 0) { 262 cmn_err(CE_NOTE, "ipv4_hook_init: " 263 "net_family_register failed for ipv4"); 264 } 265 266 HOOK_EVENT_INIT(&ipst->ips_ip4_physical_in_event, NH_PHYSICAL_IN); 267 ipst->ips_ipv4firewall_physical_in = net_event_register( 268 ipst->ips_ipv4_net_data, &ipst->ips_ip4_physical_in_event); 269 if (ipst->ips_ipv4firewall_physical_in == NULL) { 270 cmn_err(CE_NOTE, "ipv4_hook_init: " 271 "net_event_register failed for ipv4/physical_in"); 272 } 273 274 HOOK_EVENT_INIT(&ipst->ips_ip4_physical_out_event, NH_PHYSICAL_OUT); 275 ipst->ips_ipv4firewall_physical_out = net_event_register( 276 ipst->ips_ipv4_net_data, &ipst->ips_ip4_physical_out_event); 277 if (ipst->ips_ipv4firewall_physical_out == NULL) { 278 cmn_err(CE_NOTE, "ipv4_hook_init: " 279 "net_event_register failed for ipv4/physical_out"); 280 } 281 282 HOOK_EVENT_INIT(&ipst->ips_ip4_forwarding_event, NH_FORWARDING); 283 ipst->ips_ipv4firewall_forwarding = net_event_register( 284 ipst->ips_ipv4_net_data, &ipst->ips_ip4_forwarding_event); 285 if (ipst->ips_ipv4firewall_forwarding == NULL) { 286 cmn_err(CE_NOTE, "ipv4_hook_init: " 287 "net_event_register failed for ipv4/forwarding"); 288 } 289 290 HOOK_EVENT_INIT(&ipst->ips_ip4_loopback_in_event, NH_LOOPBACK_IN); 291 ipst->ips_ipv4firewall_loopback_in = net_event_register( 292 ipst->ips_ipv4_net_data, &ipst->ips_ip4_loopback_in_event); 293 if (ipst->ips_ipv4firewall_loopback_in == NULL) { 294 cmn_err(CE_NOTE, "ipv4_hook_init: " 295 "net_event_register failed for ipv4/loopback_in"); 296 } 297 298 HOOK_EVENT_INIT(&ipst->ips_ip4_loopback_out_event, NH_LOOPBACK_OUT); 299 ipst->ips_ipv4firewall_loopback_out = net_event_register( 300 ipst->ips_ipv4_net_data, &ipst->ips_ip4_loopback_out_event); 301 if (ipst->ips_ipv4firewall_loopback_out == NULL) { 302 cmn_err(CE_NOTE, "ipv4_hook_init: " 303 "net_event_register failed for ipv4/loopback_out"); 304 } 305 306 HOOK_EVENT_INIT(&ipst->ips_ip4_nic_events, NH_NIC_EVENTS); 307 ipst->ips_ip4_nic_events.he_flags = HOOK_RDONLY; 308 ipst->ips_ipv4nicevents = net_event_register( 309 ipst->ips_ipv4_net_data, &ipst->ips_ip4_nic_events); 310 if (ipst->ips_ipv4nicevents == NULL) { 311 cmn_err(CE_NOTE, "ipv4_hook_init: " 312 "net_event_register failed for ipv4/nic_events"); 313 } 314 315 HOOK_EVENT_INIT(&ipst->ips_ip4_observe, NH_OBSERVE); 316 ipst->ips_ip4_observe.he_flags = HOOK_RDONLY; 317 ipst->ips_ipv4observing = net_event_register( 318 ipst->ips_ipv4_net_data, &ipst->ips_ip4_observe); 319 if (ipst->ips_ipv4observing == NULL) { 320 cmn_err(CE_NOTE, "ipv4_hook_init: " 321 "net_event_register failed for ipv4/observe"); 322 } 323 324 } 325 326 void 327 ipv4_hook_shutdown(ip_stack_t *ipst) 328 { 329 if (ipst->ips_ipv4firewall_forwarding != NULL) { 330 (void) net_event_shutdown(ipst->ips_ipv4_net_data, 331 &ipst->ips_ip4_forwarding_event); 332 } 333 334 if (ipst->ips_ipv4firewall_physical_in != NULL) { 335 (void) net_event_shutdown(ipst->ips_ipv4_net_data, 336 &ipst->ips_ip4_physical_in_event); 337 } 338 339 if (ipst->ips_ipv4firewall_physical_out != NULL) { 340 (void) net_event_shutdown(ipst->ips_ipv4_net_data, 341 &ipst->ips_ip4_physical_out_event); 342 } 343 344 if (ipst->ips_ipv4firewall_loopback_in != NULL) { 345 (void) net_event_shutdown(ipst->ips_ipv4_net_data, 346 &ipst->ips_ip4_loopback_in_event); 347 } 348 349 if (ipst->ips_ipv4firewall_loopback_out != NULL) { 350 (void) net_event_shutdown(ipst->ips_ipv4_net_data, 351 &ipst->ips_ip4_loopback_out_event); 352 } 353 354 if (ipst->ips_ipv4nicevents != NULL) { 355 (void) net_event_shutdown(ipst->ips_ipv4_net_data, 356 &ipst->ips_ip4_nic_events); 357 } 358 359 if (ipst->ips_ipv4observing != NULL) { 360 (void) net_event_shutdown(ipst->ips_ipv4_net_data, 361 &ipst->ips_ip4_observe); 362 } 363 364 (void) net_family_shutdown(ipst->ips_ipv4_net_data, 365 &ipst->ips_ipv4root); 366 } 367 368 void 369 ipv4_hook_destroy(ip_stack_t *ipst) 370 { 371 if (ipst->ips_ipv4firewall_forwarding != NULL) { 372 if (net_event_unregister(ipst->ips_ipv4_net_data, 373 &ipst->ips_ip4_forwarding_event) == 0) 374 ipst->ips_ipv4firewall_forwarding = NULL; 375 } 376 377 if (ipst->ips_ipv4firewall_physical_in != NULL) { 378 if (net_event_unregister(ipst->ips_ipv4_net_data, 379 &ipst->ips_ip4_physical_in_event) == 0) 380 ipst->ips_ipv4firewall_physical_in = NULL; 381 } 382 383 if (ipst->ips_ipv4firewall_physical_out != NULL) { 384 if (net_event_unregister(ipst->ips_ipv4_net_data, 385 &ipst->ips_ip4_physical_out_event) == 0) 386 ipst->ips_ipv4firewall_physical_out = NULL; 387 } 388 389 if (ipst->ips_ipv4firewall_loopback_in != NULL) { 390 if (net_event_unregister(ipst->ips_ipv4_net_data, 391 &ipst->ips_ip4_loopback_in_event) == 0) 392 ipst->ips_ipv4firewall_loopback_in = NULL; 393 } 394 395 if (ipst->ips_ipv4firewall_loopback_out != NULL) { 396 if (net_event_unregister(ipst->ips_ipv4_net_data, 397 &ipst->ips_ip4_loopback_out_event) == 0) 398 ipst->ips_ipv4firewall_loopback_out = NULL; 399 } 400 401 if (ipst->ips_ipv4nicevents != NULL) { 402 if (net_event_unregister(ipst->ips_ipv4_net_data, 403 &ipst->ips_ip4_nic_events) == 0) 404 ipst->ips_ipv4nicevents = NULL; 405 } 406 407 if (ipst->ips_ipv4observing != NULL) { 408 if (net_event_unregister(ipst->ips_ipv4_net_data, 409 &ipst->ips_ip4_observe) == 0) 410 ipst->ips_ipv4observing = NULL; 411 } 412 413 (void) net_family_unregister(ipst->ips_ipv4_net_data, 414 &ipst->ips_ipv4root); 415 } 416 417 /* 418 * Initialize IPv6 hooks family and event 419 */ 420 void 421 ipv6_hook_init(ip_stack_t *ipst) 422 { 423 424 HOOK_FAMILY_INIT(&ipst->ips_ipv6root, Hn_IPV6); 425 if (net_family_register(ipst->ips_ipv6_net_data, &ipst->ips_ipv6root) 426 != 0) { 427 cmn_err(CE_NOTE, "ipv6_hook_init: " 428 "net_family_register failed for ipv6"); 429 } 430 431 HOOK_EVENT_INIT(&ipst->ips_ip6_physical_in_event, NH_PHYSICAL_IN); 432 ipst->ips_ipv6firewall_physical_in = net_event_register( 433 ipst->ips_ipv6_net_data, &ipst->ips_ip6_physical_in_event); 434 if (ipst->ips_ipv6firewall_physical_in == NULL) { 435 cmn_err(CE_NOTE, "ipv6_hook_init: " 436 "net_event_register failed for ipv6/physical_in"); 437 } 438 439 HOOK_EVENT_INIT(&ipst->ips_ip6_physical_out_event, NH_PHYSICAL_OUT); 440 ipst->ips_ipv6firewall_physical_out = net_event_register( 441 ipst->ips_ipv6_net_data, &ipst->ips_ip6_physical_out_event); 442 if (ipst->ips_ipv6firewall_physical_out == NULL) { 443 cmn_err(CE_NOTE, "ipv6_hook_init: " 444 "net_event_register failed for ipv6/physical_out"); 445 } 446 447 HOOK_EVENT_INIT(&ipst->ips_ip6_forwarding_event, NH_FORWARDING); 448 ipst->ips_ipv6firewall_forwarding = net_event_register( 449 ipst->ips_ipv6_net_data, &ipst->ips_ip6_forwarding_event); 450 if (ipst->ips_ipv6firewall_forwarding == NULL) { 451 cmn_err(CE_NOTE, "ipv6_hook_init: " 452 "net_event_register failed for ipv6/forwarding"); 453 } 454 455 HOOK_EVENT_INIT(&ipst->ips_ip6_loopback_in_event, NH_LOOPBACK_IN); 456 ipst->ips_ipv6firewall_loopback_in = net_event_register( 457 ipst->ips_ipv6_net_data, &ipst->ips_ip6_loopback_in_event); 458 if (ipst->ips_ipv6firewall_loopback_in == NULL) { 459 cmn_err(CE_NOTE, "ipv6_hook_init: " 460 "net_event_register failed for ipv6/loopback_in"); 461 } 462 463 HOOK_EVENT_INIT(&ipst->ips_ip6_loopback_out_event, NH_LOOPBACK_OUT); 464 ipst->ips_ipv6firewall_loopback_out = net_event_register( 465 ipst->ips_ipv6_net_data, &ipst->ips_ip6_loopback_out_event); 466 if (ipst->ips_ipv6firewall_loopback_out == NULL) { 467 cmn_err(CE_NOTE, "ipv6_hook_init: " 468 "net_event_register failed for ipv6/loopback_out"); 469 } 470 471 HOOK_EVENT_INIT(&ipst->ips_ip6_nic_events, NH_NIC_EVENTS); 472 ipst->ips_ip6_nic_events.he_flags = HOOK_RDONLY; 473 ipst->ips_ipv6nicevents = net_event_register( 474 ipst->ips_ipv6_net_data, &ipst->ips_ip6_nic_events); 475 if (ipst->ips_ipv6nicevents == NULL) { 476 cmn_err(CE_NOTE, "ipv6_hook_init: " 477 "net_event_register failed for ipv6/nic_events"); 478 } 479 480 HOOK_EVENT_INIT(&ipst->ips_ip6_observe, NH_OBSERVE); 481 ipst->ips_ip6_observe.he_flags = HOOK_RDONLY; 482 ipst->ips_ipv6observing = net_event_register( 483 ipst->ips_ipv6_net_data, &ipst->ips_ip6_observe); 484 if (ipst->ips_ipv6observing == NULL) { 485 cmn_err(CE_NOTE, "ipv6_hook_init: " 486 "net_event_register failed for ipv6/observe"); 487 } 488 } 489 490 void 491 ipv6_hook_shutdown(ip_stack_t *ipst) 492 { 493 if (ipst->ips_ipv6firewall_forwarding != NULL) { 494 (void) net_event_shutdown(ipst->ips_ipv6_net_data, 495 &ipst->ips_ip6_forwarding_event); 496 } 497 498 if (ipst->ips_ipv6firewall_physical_in != NULL) { 499 (void) net_event_shutdown(ipst->ips_ipv6_net_data, 500 &ipst->ips_ip6_physical_in_event); 501 } 502 503 if (ipst->ips_ipv6firewall_physical_out != NULL) { 504 (void) net_event_shutdown(ipst->ips_ipv6_net_data, 505 &ipst->ips_ip6_physical_out_event); 506 } 507 508 if (ipst->ips_ipv6firewall_loopback_in != NULL) { 509 (void) net_event_shutdown(ipst->ips_ipv6_net_data, 510 &ipst->ips_ip6_loopback_in_event); 511 } 512 513 if (ipst->ips_ipv6firewall_loopback_out != NULL) { 514 (void) net_event_shutdown(ipst->ips_ipv6_net_data, 515 &ipst->ips_ip6_loopback_out_event); 516 } 517 518 if (ipst->ips_ipv6nicevents != NULL) { 519 (void) net_event_shutdown(ipst->ips_ipv6_net_data, 520 &ipst->ips_ip6_nic_events); 521 } 522 523 if (ipst->ips_ipv6observing != NULL) { 524 (void) net_event_shutdown(ipst->ips_ipv6_net_data, 525 &ipst->ips_ip6_observe); 526 } 527 528 (void) net_family_shutdown(ipst->ips_ipv6_net_data, 529 &ipst->ips_ipv6root); 530 } 531 532 void 533 ipv6_hook_destroy(ip_stack_t *ipst) 534 { 535 if (ipst->ips_ipv6firewall_forwarding != NULL) { 536 if (net_event_unregister(ipst->ips_ipv6_net_data, 537 &ipst->ips_ip6_forwarding_event) == 0) 538 ipst->ips_ipv6firewall_forwarding = NULL; 539 } 540 541 if (ipst->ips_ipv6firewall_physical_in != NULL) { 542 if (net_event_unregister(ipst->ips_ipv6_net_data, 543 &ipst->ips_ip6_physical_in_event) == 0) 544 ipst->ips_ipv6firewall_physical_in = NULL; 545 } 546 547 if (ipst->ips_ipv6firewall_physical_out != NULL) { 548 if (net_event_unregister(ipst->ips_ipv6_net_data, 549 &ipst->ips_ip6_physical_out_event) == 0) 550 ipst->ips_ipv6firewall_physical_out = NULL; 551 } 552 553 if (ipst->ips_ipv6firewall_loopback_in != NULL) { 554 if (net_event_unregister(ipst->ips_ipv6_net_data, 555 &ipst->ips_ip6_loopback_in_event) == 0) 556 ipst->ips_ipv6firewall_loopback_in = NULL; 557 } 558 559 if (ipst->ips_ipv6firewall_loopback_out != NULL) { 560 if (net_event_unregister(ipst->ips_ipv6_net_data, 561 &ipst->ips_ip6_loopback_out_event) == 0) 562 ipst->ips_ipv6firewall_loopback_out = NULL; 563 } 564 565 if (ipst->ips_ipv6nicevents != NULL) { 566 if (net_event_unregister(ipst->ips_ipv6_net_data, 567 &ipst->ips_ip6_nic_events) == 0) 568 ipst->ips_ipv6nicevents = NULL; 569 } 570 571 if (ipst->ips_ipv6observing != NULL) { 572 if (net_event_unregister(ipst->ips_ipv6_net_data, 573 &ipst->ips_ip6_observe) == 0) 574 ipst->ips_ipv6observing = NULL; 575 } 576 577 (void) net_family_unregister(ipst->ips_ipv6_net_data, 578 &ipst->ips_ipv6root); 579 } 580 581 /* 582 * Determine the name of an IPv4 interface 583 */ 584 static int 585 ip_getifname(net_handle_t neti, phy_if_t phy_ifdata, char *buffer, 586 const size_t buflen) 587 { 588 return (ip_getifname_impl(phy_ifdata, buffer, buflen, B_FALSE, 589 neti->netd_stack->nts_netstack->netstack_ip)); 590 } 591 592 /* 593 * Determine the name of an IPv6 interface 594 */ 595 static int 596 ipv6_getifname(net_handle_t neti, phy_if_t phy_ifdata, char *buffer, 597 const size_t buflen) 598 { 599 return (ip_getifname_impl(phy_ifdata, buffer, buflen, B_TRUE, 600 neti->netd_stack->nts_netstack->netstack_ip)); 601 } 602 603 /* 604 * Shared implementation to determine the name of a given network interface 605 */ 606 /* ARGSUSED */ 607 static int 608 ip_getifname_impl(phy_if_t phy_ifdata, 609 char *buffer, const size_t buflen, boolean_t isv6, ip_stack_t *ipst) 610 { 611 ill_t *ill; 612 613 ASSERT(buffer != NULL); 614 615 ill = ill_lookup_on_ifindex((uint_t)phy_ifdata, isv6, NULL, NULL, 616 NULL, NULL, ipst); 617 if (ill == NULL) 618 return (1); 619 620 (void) strlcpy(buffer, ill->ill_name, buflen); 621 ill_refrele(ill); 622 return (0); 623 } 624 625 /* 626 * Determine the MTU of an IPv4 network interface 627 */ 628 static int 629 ip_getmtu(net_handle_t neti, phy_if_t phy_ifdata, lif_if_t ifdata) 630 { 631 netstack_t *ns; 632 633 ns = neti->netd_stack->nts_netstack; 634 ASSERT(ns != NULL); 635 return (ip_getmtu_impl(phy_ifdata, ifdata, B_FALSE, ns->netstack_ip)); 636 } 637 638 /* 639 * Determine the MTU of an IPv6 network interface 640 */ 641 static int 642 ipv6_getmtu(net_handle_t neti, phy_if_t phy_ifdata, lif_if_t ifdata) 643 { 644 netstack_t *ns; 645 646 ns = neti->netd_stack->nts_netstack; 647 ASSERT(ns != NULL); 648 return (ip_getmtu_impl(phy_ifdata, ifdata, B_TRUE, ns->netstack_ip)); 649 } 650 651 /* 652 * Shared implementation to determine the MTU of a network interface 653 */ 654 /* ARGSUSED */ 655 static int 656 ip_getmtu_impl(phy_if_t phy_ifdata, lif_if_t ifdata, boolean_t isv6, 657 ip_stack_t *ipst) 658 { 659 lif_if_t ipifid; 660 ipif_t *ipif; 661 int mtu; 662 663 ipifid = UNMAP_IPIF_ID(ifdata); 664 665 ipif = ipif_getby_indexes((uint_t)phy_ifdata, (uint_t)ipifid, 666 isv6, ipst); 667 if (ipif == NULL) 668 return (0); 669 670 mtu = ipif->ipif_mtu; 671 ipif_refrele(ipif); 672 673 if (mtu == 0) { 674 ill_t *ill; 675 676 if ((ill = ill_lookup_on_ifindex((uint_t)phy_ifdata, isv6, 677 NULL, NULL, NULL, NULL, ipst)) == NULL) { 678 return (0); 679 } 680 mtu = ill->ill_max_frag; 681 ill_refrele(ill); 682 } 683 684 return (mtu); 685 } 686 687 /* 688 * Determine if path MTU discovery is enabled for IP 689 */ 690 static int 691 ip_getpmtuenabled(net_handle_t neti) 692 { 693 netstack_t *ns; 694 695 ns = neti->netd_stack->nts_netstack; 696 ASSERT(ns != NULL); 697 return (ns->netstack_ip->ips_ip_path_mtu_discovery); 698 } 699 700 /* 701 * Get next interface from the current list of IPv4 physical network interfaces 702 */ 703 static phy_if_t 704 ip_phygetnext(net_handle_t neti, phy_if_t phy_ifdata) 705 { 706 netstack_t *ns; 707 708 ns = neti->netd_stack->nts_netstack; 709 ASSERT(ns != NULL); 710 return (ill_get_next_ifindex(phy_ifdata, B_FALSE, ns->netstack_ip)); 711 } 712 713 /* 714 * Get next interface from the current list of IPv6 physical network interfaces 715 */ 716 static phy_if_t 717 ipv6_phygetnext(net_handle_t neti, phy_if_t phy_ifdata) 718 { 719 netstack_t *ns; 720 721 ns = neti->netd_stack->nts_netstack; 722 ASSERT(ns != NULL); 723 return (ill_get_next_ifindex(phy_ifdata, B_TRUE, ns->netstack_ip)); 724 } 725 726 /* 727 * Determine if a network interface name exists for IPv4 728 */ 729 static phy_if_t 730 ip_phylookup(net_handle_t neti, const char *name) 731 { 732 netstack_t *ns; 733 734 ns = neti->netd_stack->nts_netstack; 735 ASSERT(ns != NULL); 736 return (ip_phylookup_impl(name, B_FALSE, ns->netstack_ip)); 737 } 738 739 /* 740 * Determine if a network interface name exists for IPv6 741 */ 742 static phy_if_t 743 ipv6_phylookup(net_handle_t neti, const char *name) 744 { 745 netstack_t *ns; 746 747 ns = neti->netd_stack->nts_netstack; 748 ASSERT(ns != NULL); 749 return (ip_phylookup_impl(name, B_TRUE, ns->netstack_ip)); 750 } 751 752 /* 753 * Implement looking up an ill_t based on the name supplied and matching 754 * it up with either IPv4 or IPv6. ill_get_ifindex_by_name() is not used 755 * because it does not match on the address family in addition to the name. 756 */ 757 static phy_if_t 758 ip_phylookup_impl(const char *name, boolean_t isv6, ip_stack_t *ipst) 759 { 760 phy_if_t phy; 761 ill_t *ill; 762 763 ill = ill_lookup_on_name((char *)name, B_FALSE, isv6, NULL, NULL, 764 NULL, NULL, NULL, ipst); 765 if (ill == NULL) 766 return (0); 767 768 phy = ill->ill_phyint->phyint_ifindex; 769 770 ill_refrele(ill); 771 772 return (phy); 773 } 774 775 /* 776 * Get next interface from the current list of IPv4 logical network interfaces 777 */ 778 static lif_if_t 779 ip_lifgetnext(net_handle_t neti, phy_if_t phy_ifdata, lif_if_t ifdata) 780 { 781 netstack_t *ns; 782 783 ns = neti->netd_stack->nts_netstack; 784 ASSERT(ns != NULL); 785 return (ip_lifgetnext_impl(phy_ifdata, ifdata, B_FALSE, 786 ns->netstack_ip)); 787 } 788 789 /* 790 * Get next interface from the current list of IPv6 logical network interfaces 791 */ 792 static lif_if_t 793 ipv6_lifgetnext(net_handle_t neti, phy_if_t phy_ifdata, lif_if_t ifdata) 794 { 795 netstack_t *ns; 796 797 ns = neti->netd_stack->nts_netstack; 798 ASSERT(ns != NULL); 799 return (ip_lifgetnext_impl(phy_ifdata, ifdata, B_TRUE, 800 ns->netstack_ip)); 801 } 802 803 /* 804 * Shared implementation to get next interface from the current list of 805 * logical network interfaces 806 */ 807 static lif_if_t 808 ip_lifgetnext_impl(phy_if_t phy_ifdata, lif_if_t ifdata, boolean_t isv6, 809 ip_stack_t *ipst) 810 { 811 lif_if_t newidx, oldidx; 812 boolean_t nextok; 813 ipif_t *ipif; 814 ill_t *ill; 815 816 ill = ill_lookup_on_ifindex(phy_ifdata, isv6, NULL, NULL, 817 NULL, NULL, ipst); 818 if (ill == NULL) 819 return (0); 820 821 if (ifdata != 0) { 822 oldidx = UNMAP_IPIF_ID(ifdata); 823 nextok = B_FALSE; 824 } else { 825 oldidx = 0; 826 nextok = B_TRUE; 827 } 828 829 mutex_enter(&ill->ill_lock); 830 if (ill->ill_state_flags & ILL_CONDEMNED) { 831 mutex_exit(&ill->ill_lock); 832 ill_refrele(ill); 833 return (0); 834 } 835 836 /* 837 * It's safe to iterate the ill_ipif list when holding an ill_lock. 838 * And it's also safe to access ipif_id without ipif refhold. 839 * See the field access rules in ip.h. 840 */ 841 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) { 842 if (!IPIF_CAN_LOOKUP(ipif)) 843 continue; 844 if (nextok) { 845 ipif_refhold_locked(ipif); 846 break; 847 } else if (oldidx == ipif->ipif_id) { 848 nextok = B_TRUE; 849 } 850 } 851 852 mutex_exit(&ill->ill_lock); 853 ill_refrele(ill); 854 855 if (ipif == NULL) 856 return (0); 857 858 newidx = ipif->ipif_id; 859 ipif_refrele(ipif); 860 861 return (MAP_IPIF_ID(newidx)); 862 } 863 864 /* 865 * Inject an IPv4 packet to or from an interface 866 */ 867 static int 868 ip_inject(net_handle_t neti, inject_t style, net_inject_t *packet) 869 { 870 netstack_t *ns; 871 872 ns = neti->netd_stack->nts_netstack; 873 ASSERT(ns != NULL); 874 return (ip_inject_impl(style, packet, B_FALSE, ns->netstack_ip)); 875 } 876 877 878 /* 879 * Inject an IPv6 packet to or from an interface 880 */ 881 static int 882 ipv6_inject(net_handle_t neti, inject_t style, net_inject_t *packet) 883 { 884 netstack_t *ns; 885 886 ns = neti->netd_stack->nts_netstack; 887 return (ip_inject_impl(style, packet, B_TRUE, ns->netstack_ip)); 888 } 889 890 /* 891 * Shared implementation to inject a packet to or from an interface 892 * Return value: 893 * 0: successful 894 * -1: memory allocation failed 895 * 1: other errors 896 */ 897 static int 898 ip_inject_impl(inject_t style, net_inject_t *packet, boolean_t isv6, 899 ip_stack_t *ipst) 900 { 901 struct sockaddr_in6 *sin6; 902 ddi_taskq_t *tq = NULL; 903 void (* func)(void *); 904 injection_t *inject; 905 ip6_t *ip6h; 906 ire_t *ire; 907 mblk_t *mp; 908 zoneid_t zoneid; 909 910 ASSERT(packet != NULL); 911 ASSERT(packet->ni_packet != NULL); 912 ASSERT(packet->ni_packet->b_datap->db_type == M_DATA); 913 914 switch (style) { 915 case NI_QUEUE_IN: 916 inject = kmem_alloc(sizeof (*inject), KM_NOSLEEP); 917 if (inject == NULL) 918 return (-1); 919 inject->inj_data = *packet; 920 inject->inj_isv6 = isv6; 921 /* 922 * deliver up into the kernel, immitating its reception by a 923 * network interface, add to list and schedule timeout 924 */ 925 func = ip_ni_queue_in_func; 926 tq = eventq_queue_in; 927 break; 928 929 case NI_QUEUE_OUT: 930 inject = kmem_alloc(sizeof (*inject), KM_NOSLEEP); 931 if (inject == NULL) 932 return (-1); 933 inject->inj_data = *packet; 934 inject->inj_isv6 = isv6; 935 /* 936 * deliver out of the kernel, as if it were being sent via a 937 * raw socket so that IPFilter will see it again, add to list 938 * and schedule timeout 939 */ 940 func = ip_ni_queue_out_func; 941 tq = eventq_queue_out; 942 break; 943 944 case NI_DIRECT_OUT: 945 /* 946 * Note: 947 * For IPv4, the code path below will be greatly simplified 948 * with the delivery of surya - it will become a single 949 * function call to X. A follow on project is aimed to 950 * provide similar functionality for IPv6. 951 */ 952 mp = packet->ni_packet; 953 zoneid = 954 netstackid_to_zoneid(ipst->ips_netstack->netstack_stackid); 955 956 if (!isv6) { 957 struct sockaddr *sock; 958 959 sock = (struct sockaddr *)&packet->ni_addr; 960 /* 961 * ipfil_sendpkt was provided by surya to ease the 962 * problems associated with sending out a packet. 963 * Currently this function only supports IPv4. 964 */ 965 switch (ipfil_sendpkt(sock, mp, packet->ni_physical, 966 zoneid)) { 967 case 0 : 968 case EINPROGRESS: 969 return (0); 970 case ECOMM : 971 case ENONET : 972 return (1); 973 default : 974 return (1); 975 } 976 /* NOTREACHED */ 977 978 } 979 980 ip6h = (ip6_t *)mp->b_rptr; 981 sin6 = (struct sockaddr_in6 *)&packet->ni_addr; 982 ASSERT(sin6->sin6_family == AF_INET6); 983 984 ire = ire_route_lookup_v6(&sin6->sin6_addr, 0, 0, 0, 985 NULL, NULL, zoneid, NULL, 986 MATCH_IRE_DSTONLY|MATCH_IRE_DEFAULT|MATCH_IRE_RECURSIVE, 987 ipst); 988 989 if (ire == NULL) { 990 ip2dbg(("ip_inject: ire_cache_lookup failed\n")); 991 freemsg(mp); 992 return (1); 993 } 994 995 if (ire->ire_stq == NULL) { 996 /* Send to loopback destination. */ 997 if (ire->ire_rfq == NULL) { 998 ip2dbg(("ip_inject: bad nexthop\n")); 999 ire_refrele(ire); 1000 freemsg(mp); 1001 return (1); 1002 } 1003 DTRACE_IP7(send, mblk_t *, mp, conn_t *, NULL, 1004 void_ip_t *, ip6h, __dtrace_ipsr_ill_t *, 1005 ire->ire_ipif->ipif_ill, ipha_t *, NULL, ip6_t *, 1006 ip6h, int, 1); 1007 ip_wput_local_v6(ire->ire_rfq, 1008 ire->ire_ipif->ipif_ill, ip6h, mp, ire, 0, zoneid); 1009 ire_refrele(ire); 1010 return (0); 1011 } 1012 1013 mp->b_queue = ire->ire_stq; 1014 1015 if (ire->ire_nce == NULL || 1016 ire->ire_nce->nce_fp_mp == NULL && 1017 ire->ire_nce->nce_res_mp == NULL) { 1018 ip_newroute_v6(ire->ire_stq, mp, &sin6->sin6_addr, 1019 &ip6h->ip6_src, NULL, zoneid, ipst); 1020 1021 ire_refrele(ire); 1022 return (0); 1023 } else { 1024 /* prepend L2 header for IPv6 packets. */ 1025 mblk_t *llmp; 1026 1027 /* 1028 * Lock IREs, see 6420438 1029 */ 1030 mutex_enter(&ire->ire_lock); 1031 llmp = ire->ire_nce->nce_fp_mp ? 1032 ire->ire_nce->nce_fp_mp : 1033 ire->ire_nce->nce_res_mp; 1034 1035 if ((mp = dupb(llmp)) == NULL && 1036 (mp = copyb(llmp)) == NULL) { 1037 ip2dbg(("ip_inject: llhdr failed\n")); 1038 mutex_exit(&ire->ire_lock); 1039 ire_refrele(ire); 1040 freemsg(mp); 1041 return (1); 1042 } 1043 mutex_exit(&ire->ire_lock); 1044 linkb(mp, packet->ni_packet); 1045 } 1046 1047 mp->b_queue = ire->ire_stq; 1048 1049 break; 1050 default: 1051 freemsg(packet->ni_packet); 1052 return (1); 1053 } 1054 1055 if (tq) { 1056 inject->inj_ptr = ipst; 1057 if (ddi_taskq_dispatch(tq, func, (void *)inject, 1058 DDI_SLEEP) == DDI_FAILURE) { 1059 ip2dbg(("ip_inject: ddi_taskq_dispatch failed\n")); 1060 freemsg(packet->ni_packet); 1061 return (1); 1062 } 1063 } else { 1064 putnext(ire->ire_stq, mp); 1065 ire_refrele(ire); 1066 } 1067 1068 return (0); 1069 } 1070 1071 /* 1072 * Find the interface used for traffic to a given IPv4 address 1073 */ 1074 static phy_if_t 1075 ip_routeto(net_handle_t neti, struct sockaddr *address, struct sockaddr *next) 1076 { 1077 netstack_t *ns; 1078 1079 ASSERT(address != NULL); 1080 1081 if (address->sa_family != AF_INET) 1082 return (0); 1083 1084 ns = neti->netd_stack->nts_netstack; 1085 ASSERT(ns != NULL); 1086 1087 return (ip_routeto_impl(address, next, ns->netstack_ip)); 1088 } 1089 1090 /* 1091 * Find the interface used for traffic to a given IPv6 address 1092 */ 1093 static phy_if_t 1094 ipv6_routeto(net_handle_t neti, struct sockaddr *address, struct sockaddr *next) 1095 { 1096 netstack_t *ns; 1097 1098 ASSERT(address != NULL); 1099 1100 if (address->sa_family != AF_INET6) 1101 return (0); 1102 1103 ns = neti->netd_stack->nts_netstack; 1104 ASSERT(ns != NULL); 1105 1106 return (ip_routeto_impl(address, next, ns->netstack_ip)); 1107 } 1108 1109 1110 /* 1111 * Find the interface used for traffic to an address. 1112 * For lint reasons, next/next6/sin/sin6 are all declared and assigned 1113 * a value at the top. The alternative would end up with two bunches 1114 * of assignments, with each bunch setting half to NULL. 1115 */ 1116 static phy_if_t 1117 ip_routeto_impl(struct sockaddr *address, struct sockaddr *nexthop, 1118 ip_stack_t *ipst) 1119 { 1120 struct sockaddr_in6 *next6 = (struct sockaddr_in6 *)nexthop; 1121 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)address; 1122 struct sockaddr_in *next = (struct sockaddr_in *)nexthop; 1123 struct sockaddr_in *sin = (struct sockaddr_in *)address; 1124 ire_t *sire = NULL; 1125 ire_t *ire; 1126 ill_t *ill; 1127 phy_if_t phy_if; 1128 zoneid_t zoneid; 1129 1130 zoneid = netstackid_to_zoneid(ipst->ips_netstack->netstack_stackid); 1131 1132 if (address->sa_family == AF_INET6) { 1133 ire = ire_route_lookup_v6(&sin6->sin6_addr, NULL, 1134 0, 0, NULL, &sire, zoneid, NULL, 1135 MATCH_IRE_DSTONLY|MATCH_IRE_DEFAULT|MATCH_IRE_RECURSIVE, 1136 ipst); 1137 } else { 1138 ire = ire_route_lookup(sin->sin_addr.s_addr, 0, 1139 0, 0, NULL, &sire, zoneid, NULL, 1140 MATCH_IRE_DSTONLY|MATCH_IRE_DEFAULT|MATCH_IRE_RECURSIVE, 1141 ipst); 1142 } 1143 1144 if (ire == NULL) 1145 return (0); 1146 1147 /* 1148 * For some destinations, we have routes that are dead ends, so 1149 * return to indicate that no physical interface can be used to 1150 * reach the destination. 1151 */ 1152 if ((ire->ire_flags & (RTF_REJECT | RTF_BLACKHOLE)) != 0) { 1153 if (sire != NULL) 1154 ire_refrele(sire); 1155 ire_refrele(ire); 1156 return (0); 1157 } 1158 1159 ill = ire_to_ill(ire); 1160 if (ill == NULL) { 1161 if (sire != NULL) 1162 ire_refrele(sire); 1163 ire_refrele(ire); 1164 return (0); 1165 } 1166 1167 if (nexthop != NULL) { 1168 if (address->sa_family == AF_INET6) { 1169 next->sin_addr.s_addr = sire ? sire->ire_gateway_addr : 1170 sin->sin_addr.s_addr; 1171 } else { 1172 next6->sin6_addr = sire ? sire->ire_gateway_addr_v6 : 1173 sin6->sin6_addr; 1174 } 1175 } 1176 1177 ASSERT(ill != NULL); 1178 phy_if = (phy_if_t)ill->ill_phyint->phyint_ifindex; 1179 if (sire != NULL) 1180 ire_refrele(sire); 1181 ire_refrele(ire); 1182 1183 return (phy_if); 1184 } 1185 1186 /* 1187 * Determine if checksumming is being used for the given packet. 1188 * 1189 * Return value: 1190 * NET_HCK_NONE: full checksum recalculation is required 1191 * NET_HCK_L3_FULL: full layer 3 checksum 1192 * NET_HCK_L4_FULL: full layer 4 checksum 1193 * NET_HCK_L4_PART: partial layer 4 checksum 1194 */ 1195 /*ARGSUSED*/ 1196 static int 1197 ip_ispartialchecksum(net_handle_t neti, mblk_t *mp) 1198 { 1199 int ret = 0; 1200 1201 ASSERT(mp != NULL); 1202 1203 if ((DB_CKSUMFLAGS(mp) & HCK_FULLCKSUM) != 0) { 1204 ret |= (int)NET_HCK_L4_FULL; 1205 if ((DB_CKSUMFLAGS(mp) & HCK_IPV4_HDRCKSUM) != 0) 1206 ret |= (int)NET_HCK_L3_FULL; 1207 } 1208 if ((DB_CKSUMFLAGS(mp) & HCK_PARTIALCKSUM) != 0) { 1209 ret |= (int)NET_HCK_L4_PART; 1210 if ((DB_CKSUMFLAGS(mp) & HCK_IPV4_HDRCKSUM) != 0) 1211 ret |= (int)NET_HCK_L3_FULL; 1212 } 1213 1214 return (ret); 1215 } 1216 1217 /* 1218 * Return true or false, indicating whether the network and transport 1219 * headers are correct. Use the capabilities flags and flags set in the 1220 * dblk_t to determine whether or not the checksum is valid. 1221 * 1222 * Return: 1223 * 0: the checksum was incorrect 1224 * 1: the original checksum was correct 1225 */ 1226 /*ARGSUSED*/ 1227 static int 1228 ip_isvalidchecksum(net_handle_t neti, mblk_t *mp) 1229 { 1230 unsigned char *wptr; 1231 ipha_t *ipha = (ipha_t *)mp->b_rptr; 1232 int hlen; 1233 int ret; 1234 1235 ASSERT(mp != NULL); 1236 1237 if (dohwcksum && 1238 DB_CKSUM16(mp) != 0xFFFF && 1239 (DB_CKSUMFLAGS(mp) & HCK_FULLCKSUM) && 1240 (DB_CKSUMFLAGS(mp) & HCK_FULLCKSUM_OK) && 1241 (DB_CKSUMFLAGS(mp) & HCK_IPV4_HDRCKSUM)) 1242 return (1); 1243 1244 hlen = (ipha->ipha_version_and_hdr_length & 0x0F) << 2; 1245 1246 /* 1247 * Check that the mblk being passed in has enough data in it 1248 * before blindly checking ip_cksum. 1249 */ 1250 if (msgdsize(mp) < hlen) 1251 return (0); 1252 1253 if (mp->b_wptr < mp->b_rptr + hlen) { 1254 if (pullupmsg(mp, hlen) == 0) 1255 return (0); 1256 wptr = mp->b_wptr; 1257 } else { 1258 wptr = mp->b_wptr; 1259 mp->b_wptr = mp->b_rptr + hlen; 1260 } 1261 1262 if (ipha->ipha_hdr_checksum == ip_cksum(mp, 0, ipha->ipha_hdr_checksum)) 1263 ret = 1; 1264 else 1265 ret = 0; 1266 mp->b_wptr = wptr; 1267 1268 return (ret); 1269 } 1270 1271 /* 1272 * Unsupported with IPv6 1273 */ 1274 /*ARGSUSED*/ 1275 static int 1276 ipv6_isvalidchecksum(net_handle_t neti, mblk_t *mp) 1277 { 1278 return (-1); 1279 } 1280 1281 /* 1282 * Determine the network addresses for an IPv4 interface 1283 */ 1284 static int 1285 ip_getlifaddr(net_handle_t neti, phy_if_t phy_ifdata, lif_if_t ifdata, 1286 size_t nelem, net_ifaddr_t type[], void *storage) 1287 { 1288 netstack_t *ns; 1289 1290 ns = neti->netd_stack->nts_netstack; 1291 ASSERT(ns != NULL); 1292 return (ip_getlifaddr_impl(AF_INET, phy_ifdata, ifdata, 1293 nelem, type, storage, ns->netstack_ip)); 1294 } 1295 1296 /* 1297 * Determine the network addresses for an IPv6 interface 1298 */ 1299 static int 1300 ipv6_getlifaddr(net_handle_t neti, phy_if_t phy_ifdata, lif_if_t ifdata, 1301 size_t nelem, net_ifaddr_t type[], void *storage) 1302 { 1303 netstack_t *ns; 1304 1305 ns = neti->netd_stack->nts_netstack; 1306 ASSERT(ns != NULL); 1307 return (ip_getlifaddr_impl(AF_INET6, phy_ifdata, ifdata, 1308 nelem, type, storage, ns->netstack_ip)); 1309 } 1310 1311 /* 1312 * Shared implementation to determine the network addresses for an interface 1313 */ 1314 /* ARGSUSED */ 1315 static int 1316 ip_getlifaddr_impl(sa_family_t family, phy_if_t phy_ifdata, 1317 lif_if_t ifdata, size_t nelem, net_ifaddr_t type[], 1318 struct sockaddr *storage, ip_stack_t *ipst) 1319 { 1320 struct sockaddr_in6 *sin6; 1321 struct sockaddr_in *sin; 1322 lif_if_t ipifid; 1323 ipif_t *ipif; 1324 int i; 1325 1326 ASSERT(type != NULL); 1327 ASSERT(storage != NULL); 1328 1329 ipifid = UNMAP_IPIF_ID(ifdata); 1330 1331 if (family == AF_INET) { 1332 if ((ipif = ipif_getby_indexes((uint_t)phy_ifdata, 1333 (uint_t)ipifid, B_FALSE, ipst)) == NULL) 1334 return (1); 1335 1336 sin = (struct sockaddr_in *)storage; 1337 for (i = 0; i < nelem; i++, sin++) { 1338 if (ip_getifaddr_type(AF_INET, ipif, type[i], 1339 &sin->sin_addr) < 0) { 1340 ip2dbg(("ip_getlifaddr_impl failed type %d\n", 1341 type[i])); 1342 ipif_refrele(ipif); 1343 return (1); 1344 } 1345 sin->sin_family = AF_INET; 1346 } 1347 } else { 1348 if ((ipif = ipif_getby_indexes((uint_t)phy_ifdata, 1349 (uint_t)ipifid, B_TRUE, ipst)) == NULL) 1350 return (1); 1351 1352 sin6 = (struct sockaddr_in6 *)storage; 1353 for (i = 0; i < nelem; i++, sin6++) { 1354 if (ip_getifaddr_type(AF_INET6, ipif, type[i], 1355 &sin6->sin6_addr) < 0) { 1356 ip2dbg(("ip_getlifaddr_impl failed type %d\n", 1357 type[i])); 1358 ipif_refrele(ipif); 1359 return (1); 1360 } 1361 sin6->sin6_family = AF_INET6; 1362 } 1363 } 1364 ipif_refrele(ipif); 1365 return (0); 1366 } 1367 1368 /* 1369 * ip_getlifaddr private function 1370 */ 1371 static int 1372 ip_getifaddr_type(sa_family_t family, ipif_t *ill_ipif, 1373 lif_if_t type, void *storage) 1374 { 1375 void *src_addr; 1376 int mem_size; 1377 1378 ASSERT(ill_ipif != NULL); 1379 ASSERT(storage != NULL); 1380 1381 if (family == AF_INET) { 1382 mem_size = sizeof (struct in_addr); 1383 1384 switch (type) { 1385 case NA_ADDRESS: 1386 src_addr = &(ill_ipif->ipif_lcl_addr); 1387 break; 1388 case NA_PEER: 1389 src_addr = &(ill_ipif->ipif_pp_dst_addr); 1390 break; 1391 case NA_BROADCAST: 1392 src_addr = &(ill_ipif->ipif_brd_addr); 1393 break; 1394 case NA_NETMASK: 1395 src_addr = &(ill_ipif->ipif_net_mask); 1396 break; 1397 default: 1398 return (-1); 1399 /*NOTREACHED*/ 1400 } 1401 } else { 1402 mem_size = sizeof (struct in6_addr); 1403 1404 switch (type) { 1405 case NA_ADDRESS: 1406 src_addr = &(ill_ipif->ipif_v6lcl_addr); 1407 break; 1408 case NA_PEER: 1409 src_addr = &(ill_ipif->ipif_v6pp_dst_addr); 1410 break; 1411 case NA_BROADCAST: 1412 src_addr = &(ill_ipif->ipif_v6brd_addr); 1413 break; 1414 case NA_NETMASK: 1415 src_addr = &(ill_ipif->ipif_v6net_mask); 1416 break; 1417 default: 1418 return (-1); 1419 /*NOTREACHED*/ 1420 } 1421 } 1422 1423 (void) memcpy(storage, src_addr, mem_size); 1424 return (1); 1425 } 1426 1427 /* 1428 * Shared implementation to determine the zoneid associated with an IPv4/IPv6 1429 * address 1430 */ 1431 static int 1432 ip_getlifzone_impl(sa_family_t family, phy_if_t phy_ifdata, lif_if_t ifdata, 1433 ip_stack_t *ipst, zoneid_t *zoneid) 1434 { 1435 ipif_t *ipif; 1436 1437 ipif = ipif_getby_indexes((uint_t)phy_ifdata, 1438 UNMAP_IPIF_ID((uint_t)ifdata), (family == AF_INET6), ipst); 1439 if (ipif == NULL) 1440 return (-1); 1441 *zoneid = IP_REAL_ZONEID(ipif->ipif_zoneid, ipst); 1442 ipif_refrele(ipif); 1443 return (0); 1444 } 1445 1446 /* 1447 * Determine the zoneid associated with an IPv4 address 1448 */ 1449 static int 1450 ip_getlifzone(net_handle_t neti, phy_if_t phy_ifdata, lif_if_t ifdata, 1451 zoneid_t *zoneid) 1452 { 1453 return (ip_getlifzone_impl(AF_INET, phy_ifdata, ifdata, 1454 neti->netd_stack->nts_netstack->netstack_ip, zoneid)); 1455 } 1456 1457 /* 1458 * Determine the zoneid associated with an IPv6 address 1459 */ 1460 static int 1461 ipv6_getlifzone(net_handle_t neti, phy_if_t phy_ifdata, lif_if_t ifdata, 1462 zoneid_t *zoneid) 1463 { 1464 return (ip_getlifzone_impl(AF_INET6, phy_ifdata, ifdata, 1465 neti->netd_stack->nts_netstack->netstack_ip, zoneid)); 1466 } 1467 1468 /* 1469 * The behaviour here mirrors that for the SIOCFLIFFLAGS ioctl where the 1470 * union of all of the relevant flags is returned. 1471 */ 1472 static int 1473 ip_getlifflags_impl(sa_family_t family, phy_if_t phy_ifdata, lif_if_t ifdata, 1474 ip_stack_t *ipst, uint64_t *flags) 1475 { 1476 phyint_t *phyi; 1477 ipif_t *ipif; 1478 ill_t *ill; 1479 1480 ill = ill_lookup_on_ifindex(phy_ifdata, 1481 (family == AF_INET6), NULL, NULL, NULL, NULL, ipst); 1482 if (ill == NULL) 1483 return (-1); 1484 phyi = ill->ill_phyint; 1485 1486 ipif = ipif_getby_indexes((uint_t)phy_ifdata, 1487 UNMAP_IPIF_ID((uint_t)ifdata), (family == AF_INET6), ipst); 1488 if (ipif == NULL) { 1489 ill_refrele(ill); 1490 return (-1); 1491 } 1492 *flags = ipif->ipif_flags | ill->ill_flags | phyi->phyint_flags; 1493 ipif_refrele(ipif); 1494 ill_refrele(ill); 1495 return (0); 1496 } 1497 1498 static int 1499 ip_getlifflags(net_handle_t neti, phy_if_t phy_ifdata, lif_if_t ifdata, 1500 uint64_t *flags) 1501 { 1502 return (ip_getlifflags_impl(AF_INET, phy_ifdata, ifdata, 1503 neti->netd_stack->nts_netstack->netstack_ip, flags)); 1504 } 1505 1506 static int 1507 ipv6_getlifflags(net_handle_t neti, phy_if_t phy_ifdata, lif_if_t ifdata, 1508 uint64_t *flags) 1509 { 1510 return (ip_getlifflags_impl(AF_INET6, phy_ifdata, ifdata, 1511 neti->netd_stack->nts_netstack->netstack_ip, flags)); 1512 } 1513 1514 /* 1515 * Deliver packet up into the kernel, immitating its reception by a 1516 * network interface. 1517 */ 1518 static void 1519 ip_ni_queue_in_func(void *inject) 1520 { 1521 ip_ni_queue_func_impl(inject, B_FALSE); 1522 } 1523 1524 /* 1525 * Deliver out of the kernel, as if it were being sent via a 1526 * raw socket so that IPFilter will see it again. 1527 */ 1528 static void 1529 ip_ni_queue_out_func(void *inject) 1530 { 1531 ip_ni_queue_func_impl(inject, B_TRUE); 1532 } 1533 1534 /* 1535 * Shared implementation for inject via ip_output and ip_input 1536 */ 1537 static void 1538 ip_ni_queue_func_impl(injection_t *inject, boolean_t out) 1539 { 1540 net_inject_t *packet; 1541 conn_t *conn; 1542 ill_t *ill; 1543 ip_stack_t *ipst = (ip_stack_t *)inject->inj_ptr; 1544 1545 ASSERT(inject != NULL); 1546 packet = &inject->inj_data; 1547 ASSERT(packet->ni_packet != NULL); 1548 1549 ill = ill_lookup_on_ifindex((uint_t)packet->ni_physical, 1550 B_FALSE, NULL, NULL, NULL, NULL, ipst); 1551 if (ill == NULL) { 1552 kmem_free(inject, sizeof (*inject)); 1553 return; 1554 } 1555 1556 if (out == 0) { 1557 if (inject->inj_isv6) { 1558 ip_rput_v6(ill->ill_rq, packet->ni_packet); 1559 } else { 1560 ip_input(ill, NULL, packet->ni_packet, NULL); 1561 } 1562 kmem_free(inject, sizeof (*inject)); 1563 ill_refrele(ill); 1564 return; 1565 } 1566 1567 /* 1568 * Even though ipcl_conn_create requests that it be passed 1569 * a different value for "TCP", in this case there may not 1570 * be a TCP connection backing the packet and more than 1571 * likely, non-TCP packets will go here too. 1572 */ 1573 conn = ipcl_conn_create(IPCL_IPCCONN, KM_NOSLEEP, ipst->ips_netstack); 1574 if (conn != NULL) { 1575 if (inject->inj_isv6) { 1576 conn->conn_af_isv6 = B_TRUE; 1577 conn->conn_src_preferences = IPV6_PREFER_SRC_DEFAULT; 1578 conn->conn_multicast_loop = IP_DEFAULT_MULTICAST_LOOP; 1579 ip_output_v6(conn, packet->ni_packet, ill->ill_wq, 1580 IP_WPUT); 1581 } else { 1582 conn->conn_af_isv6 = B_FALSE; 1583 conn->conn_pkt_isv6 = B_FALSE; 1584 conn->conn_multicast_loop = IP_DEFAULT_MULTICAST_LOOP; 1585 ip_output(conn, packet->ni_packet, ill->ill_wq, 1586 IP_WPUT); 1587 } 1588 1589 CONN_DEC_REF(conn); 1590 } 1591 1592 kmem_free(inject, sizeof (*inject)); 1593 ill_refrele(ill); 1594 } 1595 1596 /* 1597 * taskq function for nic events. 1598 */ 1599 void 1600 ip_ne_queue_func(void *arg) 1601 { 1602 hook_event_token_t hr; 1603 hook_nic_event_int_t *info = (hook_nic_event_int_t *)arg; 1604 ip_stack_t *ipst; 1605 netstack_t *ns; 1606 1607 ns = netstack_find_by_stackid(info->hnei_stackid); 1608 if (ns == NULL) 1609 goto done; 1610 1611 ipst = ns->netstack_ip; 1612 if (ipst == NULL) 1613 goto done; 1614 1615 hr = (info->hnei_event.hne_protocol == ipst->ips_ipv6_net_data) ? 1616 ipst->ips_ipv6nicevents : ipst->ips_ipv4nicevents; 1617 (void) hook_run(info->hnei_event.hne_protocol->netd_hooks, hr, 1618 (hook_data_t)&info->hnei_event); 1619 1620 done: 1621 if (ns != NULL) 1622 netstack_rele(ns); 1623 kmem_free(info->hnei_event.hne_data, info->hnei_event.hne_datalen); 1624 kmem_free(arg, sizeof (hook_nic_event_int_t)); 1625 } 1626
Indexes created Sun Nov 08 03:03:56 UTC 2009
Terms of Use |
Privacy |
Trademarks |
Copyright Policy |
Site Guidelines |
Help
Your use of this web site or any of its content or software indicates your agreement to be bound by these Terms of Use.
Copyright © 1995-2008 Sun Microsystems, Inc.