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/stream.h> 29 #include <sys/strsubr.h> 30 #include <sys/strsun.h> 31 #include <sys/stropts.h> 32 #include <sys/vnode.h> 33 #include <sys/zone.h> 34 #include <sys/strlog.h> 35 #include <sys/sysmacros.h> 36 #define _SUN_TPI_VERSION 2 37 #include <sys/tihdr.h> 38 #include <sys/timod.h> 39 #include <sys/tiuser.h> 40 #include <sys/ddi.h> 41 #include <sys/sunddi.h> 42 #include <sys/sunldi.h> 43 #include <sys/file.h> 44 #include <sys/modctl.h> 45 #include <sys/debug.h> 46 #include <sys/kmem.h> 47 #include <sys/cmn_err.h> 48 #include <sys/proc.h> 49 #include <sys/suntpi.h> 50 #include <sys/atomic.h> 51 #include <sys/mkdev.h> 52 #include <sys/policy.h> 53 #include <sys/disp.h> 54 55 #include <sys/socket.h> 56 #include <netinet/in.h> 57 #include <net/pfkeyv2.h> 58 59 #include <inet/common.h> 60 #include <netinet/ip6.h> 61 #include <inet/ip.h> 62 #include <inet/proto_set.h> 63 #include <inet/nd.h> 64 #include <inet/optcom.h> 65 #include <inet/ipsec_info.h> 66 #include <inet/ipsec_impl.h> 67 #include <inet/keysock.h> 68 69 #include <sys/isa_defs.h> 70 71 /* 72 * This is a transport provider for the PF_KEY key mangement socket. 73 * (See RFC 2367 for details.) 74 * Downstream messages are wrapped in a keysock consumer interface KEYSOCK_IN 75 * messages (see ipsec_info.h), and passed to the appropriate consumer. 76 * Upstream messages are generated for all open PF_KEY sockets, when 77 * appropriate, as well as the sender (as long as SO_USELOOPBACK is enabled) 78 * in reply to downstream messages. 79 * 80 * Upstream messages must be created asynchronously for the following 81 * situations: 82 * 83 * 1.) A keysock consumer requires an SA, and there is currently none. 84 * 2.) An SA expires, either hard or soft lifetime. 85 * 3.) Other events a consumer deems fit. 86 * 87 * The MT model of this is PERMOD, with shared put procedures. Two types of 88 * messages, SADB_FLUSH and SADB_DUMP, need to lock down the perimeter to send 89 * down the *multiple* messages they create. 90 */ 91 92 static vmem_t *keysock_vmem; /* for minor numbers. */ 93 94 #define KEYSOCK_MAX_CONSUMERS 256 95 96 /* Default structure copied into T_INFO_ACK messages (from rts.c...) */ 97 static struct T_info_ack keysock_g_t_info_ack = { 98 T_INFO_ACK, 99 T_INFINITE, /* TSDU_size. Maximum size messages. */ 100 T_INVALID, /* ETSDU_size. No expedited data. */ 101 T_INVALID, /* CDATA_size. No connect data. */ 102 T_INVALID, /* DDATA_size. No disconnect data. */ 103 0, /* ADDR_size. */ 104 0, /* OPT_size. No user-settable options */ 105 64 * 1024, /* TIDU_size. keysock allows maximum size messages. */ 106 T_COTS, /* SERV_type. keysock supports connection oriented. */ 107 TS_UNBND, /* CURRENT_state. This is set from keysock_state. */ 108 (XPG4_1) /* Provider flags */ 109 }; 110 111 /* Named Dispatch Parameter Management Structure */ 112 typedef struct keysockparam_s { 113 uint_t keysock_param_min; 114 uint_t keysock_param_max; 115 uint_t keysock_param_value; 116 char *keysock_param_name; 117 } keysockparam_t; 118 119 /* 120 * Table of NDD variables supported by keysock. These are loaded into 121 * keysock_g_nd in keysock_init_nd. 122 * All of these are alterable, within the min/max values given, at run time. 123 */ 124 static keysockparam_t lcl_param_arr[] = { 125 /* min max value name */ 126 { 4096, 65536, 8192, "keysock_xmit_hiwat"}, 127 { 0, 65536, 1024, "keysock_xmit_lowat"}, 128 { 4096, 65536, 8192, "keysock_recv_hiwat"}, 129 { 65536, 1024*1024*1024, 256*1024, "keysock_max_buf"}, 130 { 0, 3, 0, "keysock_debug"}, 131 }; 132 #define keystack_xmit_hiwat keystack_params[0].keysock_param_value 133 #define keystack_xmit_lowat keystack_params[1].keysock_param_value 134 #define keystack_recv_hiwat keystack_params[2].keysock_param_value 135 #define keystack_max_buf keystack_params[3].keysock_param_value 136 #define keystack_debug keystack_params[4].keysock_param_value 137 138 #define ks0dbg(a) printf a 139 /* NOTE: != 0 instead of > 0 so lint doesn't complain. */ 140 #define ks1dbg(keystack, a) if (keystack->keystack_debug != 0) printf a 141 #define ks2dbg(keystack, a) if (keystack->keystack_debug > 1) printf a 142 #define ks3dbg(keystack, a) if (keystack->keystack_debug > 2) printf a 143 144 static int keysock_close(queue_t *); 145 static int keysock_open(queue_t *, dev_t *, int, int, cred_t *); 146 static void keysock_wput(queue_t *, mblk_t *); 147 static void keysock_rput(queue_t *, mblk_t *); 148 static void keysock_rsrv(queue_t *); 149 static void keysock_passup(mblk_t *, sadb_msg_t *, minor_t, 150 keysock_consumer_t *, boolean_t, keysock_stack_t *); 151 static void *keysock_stack_init(netstackid_t stackid, netstack_t *ns); 152 static void keysock_stack_fini(netstackid_t stackid, void *arg); 153 154 static struct module_info info = { 155 5138, "keysock", 1, INFPSZ, 512, 128 156 }; 157 158 static struct qinit rinit = { 159 (pfi_t)keysock_rput, (pfi_t)keysock_rsrv, keysock_open, keysock_close, 160 NULL, &info 161 }; 162 163 static struct qinit winit = { 164 (pfi_t)keysock_wput, NULL, NULL, NULL, NULL, &info 165 }; 166 167 struct streamtab keysockinfo = { 168 &rinit, &winit 169 }; 170 171 extern struct modlinkage *keysock_modlp; 172 173 /* 174 * Plumb IPsec. 175 * 176 * NOTE: New "default" modules will need to be loaded here if needed before 177 * boot time. 178 */ 179 180 /* Keep these in global space to keep the lint from complaining. */ 181 static char *IPSECESP = "ipsecesp"; 182 static char *IPSECESPDEV = "/devices/pseudo/ipsecesp@0:ipsecesp"; 183 static char *IPSECAH = "ipsecah"; 184 static char *IPSECAHDEV = "/devices/pseudo/ipsecah@0:ipsecah"; 185 static char *IP6DEV = "/devices/pseudo/ip6@0:ip6"; 186 static char *KEYSOCK = "keysock"; 187 static char *STRMOD = "strmod"; 188 189 /* 190 * Load the other ipsec modules and plumb them together. 191 */ 192 int 193 keysock_plumb_ipsec(netstack_t *ns) 194 { 195 ldi_handle_t lh, ip6_lh = NULL; 196 ldi_ident_t li = NULL; 197 int err = 0; 198 int muxid, rval; 199 boolean_t esp_present = B_TRUE; 200 cred_t *cr; 201 keysock_stack_t *keystack = ns->netstack_keysock; 202 203 #ifdef NS_DEBUG 204 (void) printf("keysock_plumb_ipsec(%d)\n", 205 ns->netstack_stackid); 206 #endif 207 208 keystack->keystack_plumbed = 0; /* we're trying again.. */ 209 210 cr = zone_get_kcred(netstackid_to_zoneid( 211 keystack->keystack_netstack->netstack_stackid)); 212 ASSERT(cr != NULL); 213 /* 214 * Load up the drivers (AH/ESP). 215 * 216 * I do this separately from the actual plumbing in case this function 217 * ever gets called from a diskless boot before the root filesystem is 218 * up. I don't have to worry about "keysock" because, well, if I'm 219 * here, keysock must've loaded successfully. 220 */ 221 if (i_ddi_attach_pseudo_node(IPSECAH) == NULL) { 222 ks0dbg(("IPsec: AH failed to attach.\n")); 223 goto bail; 224 } 225 if (i_ddi_attach_pseudo_node(IPSECESP) == NULL) { 226 ks0dbg(("IPsec: ESP failed to attach.\n")); 227 esp_present = B_FALSE; 228 } 229 230 /* 231 * Set up the IP streams for AH and ESP, as well as tacking keysock 232 * on top of them. Assume keysock has set the autopushes up already. 233 */ 234 235 /* Open IP. */ 236 err = ldi_ident_from_mod(keysock_modlp, &li); 237 if (err) { 238 ks0dbg(("IPsec: lid_ident_from_mod failed (err %d).\n", 239 err)); 240 goto bail; 241 } 242 243 err = ldi_open_by_name(IP6DEV, FREAD|FWRITE, cr, &ip6_lh, li); 244 if (err) { 245 ks0dbg(("IPsec: Open of IP6 failed (err %d).\n", err)); 246 goto bail; 247 } 248 249 /* PLINK KEYSOCK/AH */ 250 err = ldi_open_by_name(IPSECAHDEV, FREAD|FWRITE, cr, &lh, li); 251 if (err) { 252 ks0dbg(("IPsec: Open of AH failed (err %d).\n", err)); 253 goto bail; 254 } 255 err = ldi_ioctl(lh, 256 I_PUSH, (intptr_t)KEYSOCK, FKIOCTL, cr, &rval); 257 if (err) { 258 ks0dbg(("IPsec: Push of KEYSOCK onto AH failed (err %d).\n", 259 err)); 260 (void) ldi_close(lh, FREAD|FWRITE, cr); 261 goto bail; 262 } 263 err = ldi_ioctl(ip6_lh, I_PLINK, (intptr_t)lh, 264 FREAD+FWRITE+FNOCTTY+FKIOCTL, cr, &muxid); 265 if (err) { 266 ks0dbg(("IPsec: PLINK of KEYSOCK/AH failed (err %d).\n", err)); 267 (void) ldi_close(lh, FREAD|FWRITE, cr); 268 goto bail; 269 } 270 (void) ldi_close(lh, FREAD|FWRITE, cr); 271 272 /* PLINK KEYSOCK/ESP */ 273 if (esp_present) { 274 err = ldi_open_by_name(IPSECESPDEV, 275 FREAD|FWRITE, cr, &lh, li); 276 if (err) { 277 ks0dbg(("IPsec: Open of ESP failed (err %d).\n", err)); 278 goto bail; 279 } 280 err = ldi_ioctl(lh, 281 I_PUSH, (intptr_t)KEYSOCK, FKIOCTL, cr, &rval); 282 if (err) { 283 ks0dbg(("IPsec: " 284 "Push of KEYSOCK onto ESP failed (err %d).\n", 285 err)); 286 (void) ldi_close(lh, FREAD|FWRITE, cr); 287 goto bail; 288 } 289 err = ldi_ioctl(ip6_lh, I_PLINK, (intptr_t)lh, 290 FREAD+FWRITE+FNOCTTY+FKIOCTL, cr, &muxid); 291 if (err) { 292 ks0dbg(("IPsec: " 293 "PLINK of KEYSOCK/ESP failed (err %d).\n", err)); 294 (void) ldi_close(lh, FREAD|FWRITE, cr); 295 goto bail; 296 } 297 (void) ldi_close(lh, FREAD|FWRITE, cr); 298 } 299 300 bail: 301 keystack->keystack_plumbed = (err == 0) ? 1 : -1; 302 if (ip6_lh != NULL) { 303 (void) ldi_close(ip6_lh, FREAD|FWRITE, cr); 304 } 305 if (li != NULL) 306 ldi_ident_release(li); 307 #ifdef NS_DEBUG 308 (void) printf("keysock_plumb_ipsec -> %d\n", 309 keystack->keystack_plumbed); 310 #endif 311 crfree(cr); 312 return (err); 313 } 314 315 /* ARGSUSED */ 316 static int 317 keysock_param_get(q, mp, cp, cr) 318 queue_t *q; 319 mblk_t *mp; 320 caddr_t cp; 321 cred_t *cr; 322 { 323 keysockparam_t *keysockpa = (keysockparam_t *)cp; 324 uint_t value; 325 keysock_t *ks = (keysock_t *)q->q_ptr; 326 keysock_stack_t *keystack = ks->keysock_keystack; 327 328 mutex_enter(&keystack->keystack_param_lock); 329 value = keysockpa->keysock_param_value; 330 mutex_exit(&keystack->keystack_param_lock); 331 332 (void) mi_mpprintf(mp, "%u", value); 333 return (0); 334 } 335 336 /* This routine sets an NDD variable in a keysockparam_t structure. */ 337 /* ARGSUSED */ 338 static int 339 keysock_param_set(q, mp, value, cp, cr) 340 queue_t *q; 341 mblk_t *mp; 342 char *value; 343 caddr_t cp; 344 cred_t *cr; 345 { 346 ulong_t new_value; 347 keysockparam_t *keysockpa = (keysockparam_t *)cp; 348 keysock_t *ks = (keysock_t *)q->q_ptr; 349 keysock_stack_t *keystack = ks->keysock_keystack; 350 351 /* Convert the value from a string into a long integer. */ 352 if (ddi_strtoul(value, NULL, 10, &new_value) != 0) 353 return (EINVAL); 354 355 mutex_enter(&keystack->keystack_param_lock); 356 /* 357 * Fail the request if the new value does not lie within the 358 * required bounds. 359 */ 360 if (new_value < keysockpa->keysock_param_min || 361 new_value > keysockpa->keysock_param_max) { 362 mutex_exit(&keystack->keystack_param_lock); 363 return (EINVAL); 364 } 365 366 /* Set the new value */ 367 keysockpa->keysock_param_value = new_value; 368 mutex_exit(&keystack->keystack_param_lock); 369 370 return (0); 371 } 372 373 /* 374 * Initialize keysock at module load time 375 */ 376 boolean_t 377 keysock_ddi_init(void) 378 { 379 keysock_max_optsize = optcom_max_optsize( 380 keysock_opt_obj.odb_opt_des_arr, keysock_opt_obj.odb_opt_arr_cnt); 381 382 keysock_vmem = vmem_create("keysock", (void *)1, MAXMIN, 1, 383 NULL, NULL, NULL, 1, VM_SLEEP | VMC_IDENTIFIER); 384 385 /* 386 * We want to be informed each time a stack is created or 387 * destroyed in the kernel, so we can maintain the 388 * set of keysock_stack_t's. 389 */ 390 netstack_register(NS_KEYSOCK, keysock_stack_init, NULL, 391 keysock_stack_fini); 392 393 return (B_TRUE); 394 } 395 396 /* 397 * Walk through the param array specified registering each element with the 398 * named dispatch handler. 399 */ 400 static boolean_t 401 keysock_param_register(IDP *ndp, keysockparam_t *ksp, int cnt) 402 { 403 for (; cnt-- > 0; ksp++) { 404 if (ksp->keysock_param_name != NULL && 405 ksp->keysock_param_name[0]) { 406 if (!nd_load(ndp, 407 ksp->keysock_param_name, 408 keysock_param_get, keysock_param_set, 409 (caddr_t)ksp)) { 410 nd_free(ndp); 411 return (B_FALSE); 412 } 413 } 414 } 415 return (B_TRUE); 416 } 417 418 /* 419 * Initialize keysock for one stack instance 420 */ 421 /* ARGSUSED */ 422 static void * 423 keysock_stack_init(netstackid_t stackid, netstack_t *ns) 424 { 425 keysock_stack_t *keystack; 426 keysockparam_t *ksp; 427 428 keystack = (keysock_stack_t *)kmem_zalloc(sizeof (*keystack), KM_SLEEP); 429 keystack->keystack_netstack = ns; 430 431 keystack->keystack_acquire_seq = 0xffffffff; 432 433 ksp = (keysockparam_t *)kmem_alloc(sizeof (lcl_param_arr), KM_SLEEP); 434 keystack->keystack_params = ksp; 435 bcopy(lcl_param_arr, ksp, sizeof (lcl_param_arr)); 436 437 (void) keysock_param_register(&keystack->keystack_g_nd, ksp, 438 A_CNT(lcl_param_arr)); 439 440 mutex_init(&keystack->keystack_list_lock, NULL, MUTEX_DEFAULT, NULL); 441 mutex_init(&keystack->keystack_consumers_lock, 442 NULL, MUTEX_DEFAULT, NULL); 443 mutex_init(&keystack->keystack_param_lock, NULL, MUTEX_DEFAULT, NULL); 444 return (keystack); 445 } 446 447 /* 448 * Free NDD variable space, and other destructors, for keysock. 449 */ 450 void 451 keysock_ddi_destroy(void) 452 { 453 netstack_unregister(NS_KEYSOCK); 454 vmem_destroy(keysock_vmem); 455 } 456 457 /* 458 * Remove one stack instance from keysock 459 */ 460 /* ARGSUSED */ 461 static void 462 keysock_stack_fini(netstackid_t stackid, void *arg) 463 { 464 keysock_stack_t *keystack = (keysock_stack_t *)arg; 465 466 nd_free(&keystack->keystack_g_nd); 467 kmem_free(keystack->keystack_params, sizeof (lcl_param_arr)); 468 keystack->keystack_params = NULL; 469 470 mutex_destroy(&keystack->keystack_list_lock); 471 mutex_destroy(&keystack->keystack_consumers_lock); 472 mutex_destroy(&keystack->keystack_param_lock); 473 474 kmem_free(keystack, sizeof (*keystack)); 475 } 476 477 /* 478 * Close routine for keysock. 479 */ 480 static int 481 keysock_close(queue_t *q) 482 { 483 keysock_t *ks; 484 keysock_consumer_t *kc; 485 void *ptr = q->q_ptr; 486 int size; 487 keysock_stack_t *keystack; 488 489 490 qprocsoff(q); 491 492 /* Safe assumption. */ 493 ASSERT(ptr != NULL); 494 495 if (WR(q)->q_next) { 496 kc = (keysock_consumer_t *)ptr; 497 keystack = kc->kc_keystack; 498 499 ks1dbg(keystack, ("Module close, removing a consumer (%d).\n", 500 kc->kc_sa_type)); 501 /* 502 * Because of PERMOD open/close exclusive perimeter, I 503 * can inspect KC_FLUSHING w/o locking down kc->kc_lock. 504 */ 505 if (kc->kc_flags & KC_FLUSHING) { 506 /* 507 * If this decrement was the last one, send 508 * down the next pending one, if any. 509 * 510 * With a PERMOD perimeter, the mutexes ops aren't 511 * really necessary, but if we ever loosen up, we will 512 * have this bit covered already. 513 */ 514 keystack->keystack_flushdump--; 515 if (keystack->keystack_flushdump == 0) { 516 /* 517 * The flush/dump terminated by having a 518 * consumer go away. I need to send up to the 519 * appropriate keysock all of the relevant 520 * information. Unfortunately, I don't 521 * have that handy. 522 */ 523 ks0dbg(("Consumer went away while flushing or" 524 " dumping.\n")); 525 } 526 } 527 size = sizeof (keysock_consumer_t); 528 mutex_enter(&keystack->keystack_consumers_lock); 529 keystack->keystack_consumers[kc->kc_sa_type] = NULL; 530 mutex_exit(&keystack->keystack_consumers_lock); 531 mutex_destroy(&kc->kc_lock); 532 netstack_rele(kc->kc_keystack->keystack_netstack); 533 } else { 534 ks = (keysock_t *)ptr; 535 keystack = ks->keysock_keystack; 536 537 ks3dbg(keystack, 538 ("Driver close, PF_KEY socket is going away.\n")); 539 if ((ks->keysock_flags & KEYSOCK_EXTENDED) != 0) 540 atomic_add_32(&keystack->keystack_num_extended, -1); 541 size = sizeof (keysock_t); 542 mutex_enter(&keystack->keystack_list_lock); 543 *(ks->keysock_ptpn) = ks->keysock_next; 544 if (ks->keysock_next != NULL) 545 ks->keysock_next->keysock_ptpn = ks->keysock_ptpn; 546 mutex_exit(&keystack->keystack_list_lock); 547 mutex_destroy(&ks->keysock_lock); 548 vmem_free(keysock_vmem, (void *)(uintptr_t)ks->keysock_serial, 549 1); 550 netstack_rele(ks->keysock_keystack->keystack_netstack); 551 } 552 553 /* Now I'm free. */ 554 kmem_free(ptr, size); 555 return (0); 556 } 557 /* 558 * Open routine for keysock. 559 */ 560 /* ARGSUSED */ 561 static int 562 keysock_open(queue_t *q, dev_t *devp, int flag, int sflag, cred_t *credp) 563 { 564 keysock_t *ks; 565 keysock_consumer_t *kc; 566 mblk_t *mp; 567 ipsec_info_t *ii; 568 netstack_t *ns; 569 keysock_stack_t *keystack; 570 571 if (secpolicy_ip_config(credp, B_FALSE) != 0) { 572 /* Privilege debugging will log the error */ 573 return (EPERM); 574 } 575 576 if (q->q_ptr != NULL) 577 return (0); /* Re-open of an already open instance. */ 578 579 ns = netstack_find_by_cred(credp); 580 ASSERT(ns != NULL); 581 keystack = ns->netstack_keysock; 582 ASSERT(keystack != NULL); 583 584 ks3dbg(keystack, ("Entering keysock open.\n")); 585 586 if (keystack->keystack_plumbed < 1) { 587 netstack_t *ns = keystack->keystack_netstack; 588 589 keystack->keystack_plumbed = 0; 590 #ifdef NS_DEBUG 591 printf("keysock_open(%d) - plumb\n", 592 keystack->keystack_netstack->netstack_stackid); 593 #endif 594 /* 595 * Don't worry about ipsec_failure being true here. 596 * (See ip.c). An open of keysock should try and force 597 * the issue. Maybe it was a transient failure. 598 */ 599 ipsec_loader_loadnow(ns->netstack_ipsec); 600 } 601 602 if (sflag & MODOPEN) { 603 /* Initialize keysock_consumer state here. */ 604 kc = kmem_zalloc(sizeof (keysock_consumer_t), KM_NOSLEEP); 605 if (kc == NULL) { 606 netstack_rele(keystack->keystack_netstack); 607 return (ENOMEM); 608 } 609 mutex_init(&kc->kc_lock, NULL, MUTEX_DEFAULT, 0); 610 kc->kc_rq = q; 611 kc->kc_wq = WR(q); 612 613 q->q_ptr = kc; 614 WR(q)->q_ptr = kc; 615 616 kc->kc_keystack = keystack; 617 qprocson(q); 618 619 /* 620 * Send down initial message to whatever I was pushed on top 621 * of asking for its consumer type. The reply will set it. 622 */ 623 624 /* Allocate it. */ 625 mp = allocb(sizeof (ipsec_info_t), BPRI_HI); 626 if (mp == NULL) { 627 ks1dbg(keystack, ( 628 "keysock_open: Cannot allocate KEYSOCK_HELLO.\n")); 629 /* Do I need to set these to null? */ 630 q->q_ptr = NULL; 631 WR(q)->q_ptr = NULL; 632 mutex_destroy(&kc->kc_lock); 633 kmem_free(kc, sizeof (*kc)); 634 netstack_rele(keystack->keystack_netstack); 635 return (ENOMEM); 636 } 637 638 /* If I allocated okay, putnext to what I was pushed atop. */ 639 mp->b_wptr += sizeof (ipsec_info_t); 640 mp->b_datap->db_type = M_CTL; 641 ii = (ipsec_info_t *)mp->b_rptr; 642 ii->ipsec_info_type = KEYSOCK_HELLO; 643 /* Length only of type/len. */ 644 ii->ipsec_info_len = sizeof (ii->ipsec_allu); 645 ks2dbg(keystack, ("Ready to putnext KEYSOCK_HELLO.\n")); 646 putnext(kc->kc_wq, mp); 647 } else { 648 minor_t ksminor; 649 650 /* Initialize keysock state. */ 651 652 ks2dbg(keystack, ("Made it into PF_KEY socket open.\n")); 653 654 ksminor = (minor_t)(uintptr_t) 655 vmem_alloc(keysock_vmem, 1, VM_NOSLEEP); 656 if (ksminor == 0) { 657 netstack_rele(keystack->keystack_netstack); 658 return (ENOMEM); 659 } 660 ks = kmem_zalloc(sizeof (keysock_t), KM_NOSLEEP); 661 if (ks == NULL) { 662 vmem_free(keysock_vmem, (void *)(uintptr_t)ksminor, 1); 663 netstack_rele(keystack->keystack_netstack); 664 return (ENOMEM); 665 } 666 667 mutex_init(&ks->keysock_lock, NULL, MUTEX_DEFAULT, 0); 668 ks->keysock_rq = q; 669 ks->keysock_wq = WR(q); 670 ks->keysock_state = TS_UNBND; 671 ks->keysock_serial = ksminor; 672 673 q->q_ptr = ks; 674 WR(q)->q_ptr = ks; 675 ks->keysock_keystack = keystack; 676 677 /* 678 * The receive hiwat is only looked at on the stream head 679 * queue. Store in q_hiwat in order to return on SO_RCVBUF 680 * getsockopts. 681 */ 682 683 q->q_hiwat = keystack->keystack_recv_hiwat; 684 685 /* 686 * The transmit hiwat/lowat is only looked at on IP's queue. 687 * Store in q_hiwat/q_lowat in order to return on 688 * SO_SNDBUF/SO_SNDLOWAT getsockopts. 689 */ 690 691 WR(q)->q_hiwat = keystack->keystack_xmit_hiwat; 692 WR(q)->q_lowat = keystack->keystack_xmit_lowat; 693 694 *devp = makedevice(getmajor(*devp), ksminor); 695 696 /* 697 * Thread keysock into the global keysock list. 698 */ 699 mutex_enter(&keystack->keystack_list_lock); 700 ks->keysock_next = keystack->keystack_list; 701 ks->keysock_ptpn = &keystack->keystack_list; 702 if (keystack->keystack_list != NULL) { 703 keystack->keystack_list->keysock_ptpn = 704 &ks->keysock_next; 705 } 706 keystack->keystack_list = ks; 707 mutex_exit(&keystack->keystack_list_lock); 708 709 qprocson(q); 710 (void) proto_set_rx_hiwat(q, NULL, 711 keystack->keystack_recv_hiwat); 712 /* 713 * Wait outside the keysock module perimeter for IPsec 714 * plumbing to be completed. If it fails, keysock_close() 715 * undoes everything we just did. 716 */ 717 if (!ipsec_loader_wait(q, 718 keystack->keystack_netstack->netstack_ipsec)) { 719 (void) keysock_close(q); 720 return (EPFNOSUPPORT); 721 } 722 } 723 724 return (0); 725 } 726 727 /* BELOW THIS LINE ARE ROUTINES INCLUDING AND RELATED TO keysock_wput(). */ 728 729 /* 730 * Copy relevant state bits. 731 */ 732 static void 733 keysock_copy_info(struct T_info_ack *tap, keysock_t *ks) 734 { 735 *tap = keysock_g_t_info_ack; 736 tap->CURRENT_state = ks->keysock_state; 737 tap->OPT_size = keysock_max_optsize; 738 } 739 740 /* 741 * This routine responds to T_CAPABILITY_REQ messages. It is called by 742 * keysock_wput. Much of the T_CAPABILITY_ACK information is copied from 743 * keysock_g_t_info_ack. The current state of the stream is copied from 744 * keysock_state. 745 */ 746 static void 747 keysock_capability_req(queue_t *q, mblk_t *mp) 748 { 749 keysock_t *ks = (keysock_t *)q->q_ptr; 750 t_uscalar_t cap_bits1; 751 struct T_capability_ack *tcap; 752 753 cap_bits1 = ((struct T_capability_req *)mp->b_rptr)->CAP_bits1; 754 755 mp = tpi_ack_alloc(mp, sizeof (struct T_capability_ack), 756 mp->b_datap->db_type, T_CAPABILITY_ACK); 757 if (mp == NULL) 758 return; 759 760 tcap = (struct T_capability_ack *)mp->b_rptr; 761 tcap->CAP_bits1 = 0; 762 763 if (cap_bits1 & TC1_INFO) { 764 keysock_copy_info(&tcap->INFO_ack, ks); 765 tcap->CAP_bits1 |= TC1_INFO; 766 } 767 768 qreply(q, mp); 769 } 770 771 /* 772 * This routine responds to T_INFO_REQ messages. It is called by 773 * keysock_wput_other. 774 * Most of the T_INFO_ACK information is copied from keysock_g_t_info_ack. 775 * The current state of the stream is copied from keysock_state. 776 */ 777 static void 778 keysock_info_req(q, mp) 779 queue_t *q; 780 mblk_t *mp; 781 { 782 mp = tpi_ack_alloc(mp, sizeof (struct T_info_ack), M_PCPROTO, 783 T_INFO_ACK); 784 if (mp == NULL) 785 return; 786 keysock_copy_info((struct T_info_ack *)mp->b_rptr, 787 (keysock_t *)q->q_ptr); 788 qreply(q, mp); 789 } 790 791 /* 792 * keysock_err_ack. This routine creates a 793 * T_ERROR_ACK message and passes it 794 * upstream. 795 */ 796 static void 797 keysock_err_ack(q, mp, t_error, sys_error) 798 queue_t *q; 799 mblk_t *mp; 800 int t_error; 801 int sys_error; 802 { 803 if ((mp = mi_tpi_err_ack_alloc(mp, t_error, sys_error)) != NULL) 804 qreply(q, mp); 805 } 806 807 /* 808 * This routine retrieves the current status of socket options. 809 * It returns the size of the option retrieved. 810 */ 811 /* ARGSUSED */ 812 int 813 keysock_opt_get(queue_t *q, int level, int name, uchar_t *ptr) 814 { 815 int *i1 = (int *)ptr; 816 keysock_t *ks = (keysock_t *)q->q_ptr; 817 818 switch (level) { 819 case SOL_SOCKET: 820 mutex_enter(&ks->keysock_lock); 821 switch (name) { 822 case SO_TYPE: 823 *i1 = SOCK_RAW; 824 break; 825 case SO_USELOOPBACK: 826 *i1 = (int)(!((ks->keysock_flags & KEYSOCK_NOLOOP) == 827 KEYSOCK_NOLOOP)); 828 break; 829 /* 830 * The following two items can be manipulated, 831 * but changing them should do nothing. 832 */ 833 case SO_SNDBUF: 834 *i1 = (int)q->q_hiwat; 835 break; 836 case SO_RCVBUF: 837 *i1 = (int)(RD(q)->q_hiwat); 838 break; 839 } 840 mutex_exit(&ks->keysock_lock); 841 break; 842 default: 843 return (0); 844 } 845 return (sizeof (int)); 846 } 847 848 /* 849 * This routine sets socket options. 850 */ 851 /* ARGSUSED */ 852 int 853 keysock_opt_set(queue_t *q, uint_t mgmt_flags, int level, 854 int name, uint_t inlen, uchar_t *invalp, uint_t *outlenp, 855 uchar_t *outvalp, void *thisdg_attrs, cred_t *cr) 856 { 857 int *i1 = (int *)invalp, errno = 0; 858 keysock_t *ks = (keysock_t *)q->q_ptr; 859 keysock_stack_t *keystack = ks->keysock_keystack; 860 861 switch (level) { 862 case SOL_SOCKET: 863 mutex_enter(&ks->keysock_lock); 864 switch (name) { 865 case SO_USELOOPBACK: 866 if (!(*i1)) 867 ks->keysock_flags |= KEYSOCK_NOLOOP; 868 else ks->keysock_flags &= ~KEYSOCK_NOLOOP; 869 break; 870 case SO_SNDBUF: 871 if (*i1 > keystack->keystack_max_buf) 872 errno = ENOBUFS; 873 else q->q_hiwat = *i1; 874 break; 875 case SO_RCVBUF: 876 if (*i1 > keystack->keystack_max_buf) { 877 errno = ENOBUFS; 878 } else { 879 RD(q)->q_hiwat = *i1; 880 (void) proto_set_rx_hiwat(RD(q), NULL, *i1); 881 } 882 break; 883 default: 884 errno = EINVAL; 885 } 886 mutex_exit(&ks->keysock_lock); 887 break; 888 default: 889 errno = EINVAL; 890 } 891 return (errno); 892 } 893 894 /* 895 * Handle STREAMS messages. 896 */ 897 static void 898 keysock_wput_other(queue_t *q, mblk_t *mp) 899 { 900 struct iocblk *iocp; 901 int error; 902 keysock_t *ks = (keysock_t *)q->q_ptr; 903 keysock_stack_t *keystack = ks->keysock_keystack; 904 cred_t *cr; 905 906 switch (mp->b_datap->db_type) { 907 case M_PROTO: 908 case M_PCPROTO: 909 if ((mp->b_wptr - mp->b_rptr) < sizeof (long)) { 910 ks3dbg(keystack, ( 911 "keysock_wput_other: Not big enough M_PROTO\n")); 912 freemsg(mp); 913 return; 914 } 915 switch (((union T_primitives *)mp->b_rptr)->type) { 916 case T_CAPABILITY_REQ: 917 keysock_capability_req(q, mp); 918 break; 919 case T_INFO_REQ: 920 keysock_info_req(q, mp); 921 break; 922 case T_SVR4_OPTMGMT_REQ: 923 case T_OPTMGMT_REQ: 924 /* 925 * All Solaris components should pass a db_credp 926 * for this TPI message, hence we ASSERT. 927 * But in case there is some other M_PROTO that looks 928 * like a TPI message sent by some other kernel 929 * component, we check and return an error. 930 */ 931 cr = msg_getcred(mp, NULL); 932 ASSERT(cr != NULL); 933 if (cr == NULL) { 934 keysock_err_ack(q, mp, TSYSERR, EINVAL); 935 return; 936 } 937 if (((union T_primitives *)mp->b_rptr)->type == 938 T_SVR4_OPTMGMT_REQ) { 939 svr4_optcom_req(q, mp, cr, &keysock_opt_obj); 940 } else { 941 tpi_optcom_req(q, mp, cr, &keysock_opt_obj); 942 } 943 break; 944 case T_DATA_REQ: 945 case T_EXDATA_REQ: 946 case T_ORDREL_REQ: 947 /* Illegal for keysock. */ 948 freemsg(mp); 949 (void) putnextctl1(RD(q), M_ERROR, EPROTO); 950 break; 951 default: 952 /* Not supported by keysock. */ 953 keysock_err_ack(q, mp, TNOTSUPPORT, 0); 954 break; 955 } 956 return; 957 case M_IOCTL: 958 iocp = (struct iocblk *)mp->b_rptr; 959 error = EINVAL; 960 961 switch (iocp->ioc_cmd) { 962 case ND_SET: 963 case ND_GET: 964 if (nd_getset(q, keystack->keystack_g_nd, mp)) { 965 qreply(q, mp); 966 return; 967 } else 968 error = ENOENT; 969 /* FALLTHRU */ 970 default: 971 miocnak(q, mp, 0, error); 972 return; 973 } 974 case M_FLUSH: 975 if (*mp->b_rptr & FLUSHW) { 976 flushq(q, FLUSHALL); 977 *mp->b_rptr &= ~FLUSHW; 978 } 979 if (*mp->b_rptr & FLUSHR) { 980 qreply(q, mp); 981 return; 982 } 983 /* Else FALLTHRU */ 984 } 985 986 /* If fell through, just black-hole the message. */ 987 freemsg(mp); 988 } 989 990 /* 991 * Transmit a PF_KEY error message to the instance either pointed to 992 * by ks, the instance with serial number serial, or more, depending. 993 * 994 * The faulty message (or a reasonable facsimile thereof) is in mp. 995 * This function will free mp or recycle it for delivery, thereby causing 996 * the stream head to free it. 997 */ 998 static void 999 keysock_error(keysock_t *ks, mblk_t *mp, int error, int diagnostic) 1000 { 1001 sadb_msg_t *samsg = (sadb_msg_t *)mp->b_rptr; 1002 keysock_stack_t *keystack = ks->keysock_keystack; 1003 1004 ASSERT(mp->b_datap->db_type == M_DATA); 1005 1006 if (samsg->sadb_msg_type < SADB_GETSPI || 1007 samsg->sadb_msg_type > SADB_MAX) 1008 samsg->sadb_msg_type = SADB_RESERVED; 1009 1010 /* 1011 * Strip out extension headers. 1012 */ 1013 ASSERT(mp->b_rptr + sizeof (*samsg) <= mp->b_datap->db_lim); 1014 mp->b_wptr = mp->b_rptr + sizeof (*samsg); 1015 samsg->sadb_msg_len = SADB_8TO64(sizeof (sadb_msg_t)); 1016 samsg->sadb_msg_errno = (uint8_t)error; 1017 samsg->sadb_x_msg_diagnostic = (uint16_t)diagnostic; 1018 1019 keysock_passup(mp, samsg, ks->keysock_serial, NULL, B_FALSE, keystack); 1020 } 1021 1022 /* 1023 * Pass down a message to a consumer. Wrap it in KEYSOCK_IN, and copy 1024 * in the extv if passed in. 1025 */ 1026 static void 1027 keysock_passdown(keysock_t *ks, mblk_t *mp, uint8_t satype, sadb_ext_t *extv[], 1028 boolean_t flushmsg) 1029 { 1030 keysock_consumer_t *kc; 1031 mblk_t *wrapper; 1032 keysock_in_t *ksi; 1033 int i; 1034 keysock_stack_t *keystack = ks->keysock_keystack; 1035 1036 wrapper = allocb(sizeof (ipsec_info_t), BPRI_HI); 1037 if (wrapper == NULL) { 1038 ks3dbg(keystack, ("keysock_passdown: allocb failed.\n")); 1039 if (extv[SADB_EXT_KEY_ENCRYPT] != NULL) 1040 bzero(extv[SADB_EXT_KEY_ENCRYPT], 1041 SADB_64TO8( 1042 extv[SADB_EXT_KEY_ENCRYPT]->sadb_ext_len)); 1043 if (extv[SADB_EXT_KEY_AUTH] != NULL) 1044 bzero(extv[SADB_EXT_KEY_AUTH], 1045 SADB_64TO8( 1046 extv[SADB_EXT_KEY_AUTH]->sadb_ext_len)); 1047 if (flushmsg) { 1048 ks0dbg(( 1049 "keysock: Downwards flush/dump message failed!\n")); 1050 /* If this is true, I hold the perimeter. */ 1051 keystack->keystack_flushdump--; 1052 } 1053 freemsg(mp); 1054 return; 1055 } 1056 1057 wrapper->b_datap->db_type = M_CTL; 1058 ksi = (keysock_in_t *)wrapper->b_rptr; 1059 ksi->ks_in_type = KEYSOCK_IN; 1060 ksi->ks_in_len = sizeof (keysock_in_t); 1061 if (extv[SADB_EXT_ADDRESS_SRC] != NULL) 1062 ksi->ks_in_srctype = KS_IN_ADDR_UNKNOWN; 1063 else ksi->ks_in_srctype = KS_IN_ADDR_NOTTHERE; 1064 if (extv[SADB_EXT_ADDRESS_DST] != NULL) 1065 ksi->ks_in_dsttype = KS_IN_ADDR_UNKNOWN; 1066 else ksi->ks_in_dsttype = KS_IN_ADDR_NOTTHERE; 1067 for (i = 0; i <= SADB_EXT_MAX; i++) 1068 ksi->ks_in_extv[i] = extv[i]; 1069 ksi->ks_in_serial = ks->keysock_serial; 1070 wrapper->b_wptr += sizeof (ipsec_info_t); 1071 wrapper->b_cont = mp; 1072 1073 /* 1074 * Find the appropriate consumer where the message is passed down. 1075 */ 1076 kc = keystack->keystack_consumers[satype]; 1077 if (kc == NULL) { 1078 freeb(wrapper); 1079 keysock_error(ks, mp, EINVAL, SADB_X_DIAGNOSTIC_UNKNOWN_SATYPE); 1080 if (flushmsg) { 1081 ks0dbg(( 1082 "keysock: Downwards flush/dump message failed!\n")); 1083 /* If this is true, I hold the perimeter. */ 1084 keystack->keystack_flushdump--; 1085 } 1086 return; 1087 } 1088 1089 /* 1090 * NOTE: There used to be code in here to spin while a flush or 1091 * dump finished. Keysock now assumes that consumers have enough 1092 * MT-savviness to deal with that. 1093 */ 1094 1095 /* 1096 * Current consumers (AH and ESP) are guaranteed to return a 1097 * FLUSH or DUMP message back, so when we reach here, we don't 1098 * have to worry about keysock_flushdumps. 1099 */ 1100 1101 putnext(kc->kc_wq, wrapper); 1102 } 1103 1104 /* 1105 * High-level reality checking of extensions. 1106 */ 1107 static boolean_t 1108 ext_check(sadb_ext_t *ext, keysock_stack_t *keystack) 1109 { 1110 int i; 1111 uint64_t *lp; 1112 sadb_ident_t *id; 1113 char *idstr; 1114 1115 switch (ext->sadb_ext_type) { 1116 case SADB_EXT_ADDRESS_SRC: 1117 case SADB_EXT_ADDRESS_DST: 1118 case SADB_X_EXT_ADDRESS_INNER_SRC: 1119 case SADB_X_EXT_ADDRESS_INNER_DST: 1120 /* Check for at least enough addtl length for a sockaddr. */ 1121 if (ext->sadb_ext_len <= SADB_8TO64(sizeof (sadb_address_t))) 1122 return (B_FALSE); 1123 break; 1124 case SADB_EXT_LIFETIME_HARD: 1125 case SADB_EXT_LIFETIME_SOFT: 1126 case SADB_EXT_LIFETIME_CURRENT: 1127 if (ext->sadb_ext_len != SADB_8TO64(sizeof (sadb_lifetime_t))) 1128 return (B_FALSE); 1129 break; 1130 case SADB_EXT_SPIRANGE: 1131 /* See if the SPI range is legit. */ 1132 if (htonl(((sadb_spirange_t *)ext)->sadb_spirange_min) > 1133 htonl(((sadb_spirange_t *)ext)->sadb_spirange_max)) 1134 return (B_FALSE); 1135 break; 1136 case SADB_EXT_KEY_AUTH: 1137 case SADB_EXT_KEY_ENCRYPT: 1138 /* Key length check. */ 1139 if (((sadb_key_t *)ext)->sadb_key_bits == 0) 1140 return (B_FALSE); 1141 /* 1142 * Check to see if the key length (in bits) is less than the 1143 * extension length (in 8-bits words). 1144 */ 1145 if ((roundup(SADB_1TO8(((sadb_key_t *)ext)->sadb_key_bits), 8) + 1146 sizeof (sadb_key_t)) != SADB_64TO8(ext->sadb_ext_len)) { 1147 ks1dbg(keystack, ( 1148 "ext_check: Key bits/length inconsistent.\n")); 1149 ks1dbg(keystack, ("%d bits, len is %d bytes.\n", 1150 ((sadb_key_t *)ext)->sadb_key_bits, 1151 SADB_64TO8(ext->sadb_ext_len))); 1152 return (B_FALSE); 1153 } 1154 1155 /* All-zeroes key check. */ 1156 lp = (uint64_t *)(((char *)ext) + sizeof (sadb_key_t)); 1157 for (i = 0; 1158 i < (ext->sadb_ext_len - SADB_8TO64(sizeof (sadb_key_t))); 1159 i++) 1160 if (lp[i] != 0) 1161 break; /* Out of for loop. */ 1162 /* If finished the loop naturally, it's an all zero key. */ 1163 if (lp[i] == 0) 1164 return (B_FALSE); 1165 break; 1166 case SADB_EXT_IDENTITY_SRC: 1167 case SADB_EXT_IDENTITY_DST: 1168 /* 1169 * Make sure the strings in these identities are 1170 * null-terminated. RFC 2367 underspecified how to handle 1171 * such a case. I "proactively" null-terminate the string 1172 * at the last byte if it's not terminated sooner. 1173 */ 1174 id = (sadb_ident_t *)ext; 1175 i = SADB_64TO8(id->sadb_ident_len); 1176 i -= sizeof (sadb_ident_t); 1177 idstr = (char *)(id + 1); 1178 while (*idstr != '\0' && i > 0) { 1179 i--; 1180 idstr++; 1181 } 1182 if (i == 0) { 1183 /* 1184 * I.e., if the bozo user didn't NULL-terminate the 1185 * string... 1186 */ 1187 idstr--; 1188 *idstr = '\0'; 1189 } 1190 break; 1191 } 1192 return (B_TRUE); /* For now... */ 1193 } 1194 1195 /* Return values for keysock_get_ext(). */ 1196 #define KGE_OK 0 1197 #define KGE_DUP 1 1198 #define KGE_UNK 2 1199 #define KGE_LEN 3 1200 #define KGE_CHK 4 1201 1202 /* 1203 * Parse basic extension headers and return in the passed-in pointer vector. 1204 * Return values include: 1205 * 1206 * KGE_OK Everything's nice and parsed out. 1207 * If there are no extensions, place NULL in extv[0]. 1208 * KGE_DUP There is a duplicate extension. 1209 * First instance in appropriate bin. First duplicate in 1210 * extv[0]. 1211 * KGE_UNK Unknown extension type encountered. extv[0] contains 1212 * unknown header. 1213 * KGE_LEN Extension length error. 1214 * KGE_CHK High-level reality check failed on specific extension. 1215 * 1216 * My apologies for some of the pointer arithmetic in here. I'm thinking 1217 * like an assembly programmer, yet trying to make the compiler happy. 1218 */ 1219 static int 1220 keysock_get_ext(sadb_ext_t *extv[], sadb_msg_t *basehdr, uint_t msgsize, 1221 keysock_stack_t *keystack) 1222 { 1223 bzero(extv, sizeof (sadb_ext_t *) * (SADB_EXT_MAX + 1)); 1224 1225 /* Use extv[0] as the "current working pointer". */ 1226 1227 extv[0] = (sadb_ext_t *)(basehdr + 1); 1228 1229 while (extv[0] < (sadb_ext_t *)(((uint8_t *)basehdr) + msgsize)) { 1230 /* Check for unknown headers. */ 1231 if (extv[0]->sadb_ext_type == 0 || 1232 extv[0]->sadb_ext_type > SADB_EXT_MAX) 1233 return (KGE_UNK); 1234 1235 /* 1236 * Check length. Use uint64_t because extlen is in units 1237 * of 64-bit words. If length goes beyond the msgsize, 1238 * return an error. (Zero length also qualifies here.) 1239 */ 1240 if (extv[0]->sadb_ext_len == 0 || 1241 (void *)((uint64_t *)extv[0] + extv[0]->sadb_ext_len) > 1242 (void *)((uint8_t *)basehdr + msgsize)) 1243 return (KGE_LEN); 1244 1245 /* Check for redundant headers. */ 1246 if (extv[extv[0]->sadb_ext_type] != NULL) 1247 return (KGE_DUP); 1248 1249 /* 1250 * Reality check the extension if possible at the keysock 1251 * level. 1252 */ 1253 if (!ext_check(extv[0], keystack)) 1254 return (KGE_CHK); 1255 1256 /* If I make it here, assign the appropriate bin. */ 1257 extv[extv[0]->sadb_ext_type] = extv[0]; 1258 1259 /* Advance pointer (See above for uint64_t ptr reasoning.) */ 1260 extv[0] = (sadb_ext_t *) 1261 ((uint64_t *)extv[0] + extv[0]->sadb_ext_len); 1262 } 1263 1264 /* Everything's cool. */ 1265 1266 /* 1267 * If extv[0] == NULL, then there are no extension headers in this 1268 * message. Ensure that this is the case. 1269 */ 1270 if (extv[0] == (sadb_ext_t *)(basehdr + 1)) 1271 extv[0] = NULL; 1272 1273 return (KGE_OK); 1274 } 1275 1276 /* 1277 * qwriter() callback to handle flushes and dumps. This routine will hold 1278 * the inner perimeter. 1279 */ 1280 void 1281 keysock_do_flushdump(queue_t *q, mblk_t *mp) 1282 { 1283 int i, start, finish; 1284 mblk_t *mp1 = NULL; 1285 keysock_t *ks = (keysock_t *)q->q_ptr; 1286 sadb_ext_t *extv[SADB_EXT_MAX + 1]; 1287 sadb_msg_t *samsg = (sadb_msg_t *)mp->b_rptr; 1288 keysock_stack_t *keystack = ks->keysock_keystack; 1289 1290 /* 1291 * I am guaranteed this will work. I did the work in keysock_parse() 1292 * already. 1293 */ 1294 (void) keysock_get_ext(extv, samsg, SADB_64TO8(samsg->sadb_msg_len), 1295 keystack); 1296 1297 /* 1298 * I hold the perimeter, therefore I don't need to use atomic ops. 1299 */ 1300 if (keystack->keystack_flushdump != 0) { 1301 /* XXX Should I instead use EBUSY? */ 1302 /* XXX Or is there a way to queue these up? */ 1303 keysock_error(ks, mp, ENOMEM, SADB_X_DIAGNOSTIC_NONE); 1304 return; 1305 } 1306 1307 if (samsg->sadb_msg_satype == SADB_SATYPE_UNSPEC) { 1308 start = 0; 1309 finish = KEYSOCK_MAX_CONSUMERS - 1; 1310 } else { 1311 start = samsg->sadb_msg_satype; 1312 finish = samsg->sadb_msg_satype; 1313 } 1314 1315 /* 1316 * Fill up keysock_flushdump with the number of outstanding dumps 1317 * and/or flushes. 1318 */ 1319 1320 keystack->keystack_flushdump_errno = 0; 1321 1322 /* 1323 * Okay, I hold the perimeter. Eventually keysock_flushdump will 1324 * contain the number of consumers with outstanding flush operations. 1325 * 1326 * SO, here's the plan: 1327 * * For each relevant consumer (Might be one, might be all) 1328 * * Twiddle on the FLUSHING flag. 1329 * * Pass down the FLUSH/DUMP message. 1330 * 1331 * When I see upbound FLUSH/DUMP messages, I will decrement the 1332 * keysock_flushdump. When I decrement it to 0, I will pass the 1333 * FLUSH/DUMP message back up to the PF_KEY sockets. Because I will 1334 * pass down the right SA type to the consumer (either its own, or 1335 * that of UNSPEC), the right one will be reflected from each consumer, 1336 * and accordingly back to the socket. 1337 */ 1338 1339 mutex_enter(&keystack->keystack_consumers_lock); 1340 for (i = start; i <= finish; i++) { 1341 if (keystack->keystack_consumers[i] != NULL) { 1342 mp1 = copymsg(mp); 1343 if (mp1 == NULL) { 1344 ks0dbg(("SADB_FLUSH copymsg() failed.\n")); 1345 /* 1346 * Error? And what about outstanding 1347 * flushes? Oh, yeah, they get sucked up and 1348 * the counter is decremented. Consumers 1349 * (see keysock_passdown()) are guaranteed 1350 * to deliver back a flush request, even if 1351 * it's an error. 1352 */ 1353 keysock_error(ks, mp, ENOMEM, 1354 SADB_X_DIAGNOSTIC_NONE); 1355 return; 1356 } 1357 /* 1358 * Because my entry conditions are met above, the 1359 * following assertion should hold true. 1360 */ 1361 mutex_enter(&keystack->keystack_consumers[i]->kc_lock); 1362 ASSERT((keystack->keystack_consumers[i]->kc_flags & 1363 KC_FLUSHING) == 0); 1364 keystack->keystack_consumers[i]->kc_flags |= 1365 KC_FLUSHING; 1366 mutex_exit(&(keystack->keystack_consumers[i]->kc_lock)); 1367 /* Always increment the number of flushes... */ 1368 keystack->keystack_flushdump++; 1369 /* Guaranteed to return a message. */ 1370 keysock_passdown(ks, mp1, i, extv, B_TRUE); 1371 } else if (start == finish) { 1372 /* 1373 * In case where start == finish, and there's no 1374 * consumer, should we force an error? Yes. 1375 */ 1376 mutex_exit(&keystack->keystack_consumers_lock); 1377 keysock_error(ks, mp, EINVAL, 1378 SADB_X_DIAGNOSTIC_UNKNOWN_SATYPE); 1379 return; 1380 } 1381 } 1382 mutex_exit(&keystack->keystack_consumers_lock); 1383 1384 if (keystack->keystack_flushdump == 0) { 1385 /* 1386 * There were no consumers at all for this message. 1387 * XXX For now return ESRCH. 1388 */ 1389 keysock_error(ks, mp, ESRCH, SADB_X_DIAGNOSTIC_NO_SADBS); 1390 } else { 1391 /* Otherwise, free the original message. */ 1392 freemsg(mp); 1393 } 1394 } 1395 1396 /* 1397 * Get the right diagnostic for a duplicate. Should probably use a static 1398 * table lookup. 1399 */ 1400 int 1401 keysock_duplicate(int ext_type) 1402 { 1403 int rc = 0; 1404 1405 switch (ext_type) { 1406 case SADB_EXT_ADDRESS_SRC: 1407 rc = SADB_X_DIAGNOSTIC_DUPLICATE_SRC; 1408 break; 1409 case SADB_EXT_ADDRESS_DST: 1410 rc = SADB_X_DIAGNOSTIC_DUPLICATE_DST; 1411 break; 1412 case SADB_X_EXT_ADDRESS_INNER_SRC: 1413 rc = SADB_X_DIAGNOSTIC_DUPLICATE_INNER_SRC; 1414 break; 1415 case SADB_X_EXT_ADDRESS_INNER_DST: 1416 rc = SADB_X_DIAGNOSTIC_DUPLICATE_INNER_DST; 1417 break; 1418 case SADB_EXT_SA: 1419 rc = SADB_X_DIAGNOSTIC_DUPLICATE_SA; 1420 break; 1421 case SADB_EXT_SPIRANGE: 1422 rc = SADB_X_DIAGNOSTIC_DUPLICATE_RANGE; 1423 break; 1424 case SADB_EXT_KEY_AUTH: 1425 rc = SADB_X_DIAGNOSTIC_DUPLICATE_AKEY; 1426 break; 1427 case SADB_EXT_KEY_ENCRYPT: 1428 rc = SADB_X_DIAGNOSTIC_DUPLICATE_EKEY; 1429 break; 1430 } 1431 return (rc); 1432 } 1433 1434 /* 1435 * Get the right diagnostic for a reality check failure. Should probably use 1436 * a static table lookup. 1437 */ 1438 int 1439 keysock_malformed(int ext_type) 1440 { 1441 int rc = 0; 1442 1443 switch (ext_type) { 1444 case SADB_EXT_ADDRESS_SRC: 1445 rc = SADB_X_DIAGNOSTIC_MALFORMED_SRC; 1446 break; 1447 case SADB_EXT_ADDRESS_DST: 1448 rc = SADB_X_DIAGNOSTIC_MALFORMED_DST; 1449 break; 1450 case SADB_X_EXT_ADDRESS_INNER_SRC: 1451 rc = SADB_X_DIAGNOSTIC_MALFORMED_INNER_SRC; 1452 break; 1453 case SADB_X_EXT_ADDRESS_INNER_DST: 1454 rc = SADB_X_DIAGNOSTIC_MALFORMED_INNER_DST; 1455 break; 1456 case SADB_EXT_SA: 1457 rc = SADB_X_DIAGNOSTIC_MALFORMED_SA; 1458 break; 1459 case SADB_EXT_SPIRANGE: 1460 rc = SADB_X_DIAGNOSTIC_MALFORMED_RANGE; 1461 break; 1462 case SADB_EXT_KEY_AUTH: 1463 rc = SADB_X_DIAGNOSTIC_MALFORMED_AKEY; 1464 break; 1465 case SADB_EXT_KEY_ENCRYPT: 1466 rc = SADB_X_DIAGNOSTIC_MALFORMED_EKEY; 1467 break; 1468 } 1469 return (rc); 1470 } 1471 1472 /* 1473 * Keysock massaging of an inverse ACQUIRE. Consult policy, 1474 * and construct an appropriate response. 1475 */ 1476 static void 1477 keysock_inverse_acquire(mblk_t *mp, sadb_msg_t *samsg, sadb_ext_t *extv[], 1478 keysock_t *ks) 1479 { 1480 mblk_t *reply_mp; 1481 keysock_stack_t *keystack = ks->keysock_keystack; 1482 1483 /* 1484 * Reality check things... 1485 */ 1486 if (extv[SADB_EXT_ADDRESS_SRC] == NULL) { 1487 keysock_error(ks, mp, EINVAL, SADB_X_DIAGNOSTIC_MISSING_SRC); 1488 return; 1489 } 1490 if (extv[SADB_EXT_ADDRESS_DST] == NULL) { 1491 keysock_error(ks, mp, EINVAL, SADB_X_DIAGNOSTIC_MISSING_DST); 1492 return; 1493 } 1494 1495 if (extv[SADB_X_EXT_ADDRESS_INNER_SRC] != NULL && 1496 extv[SADB_X_EXT_ADDRESS_INNER_DST] == NULL) { 1497 keysock_error(ks, mp, EINVAL, 1498 SADB_X_DIAGNOSTIC_MISSING_INNER_DST); 1499 return; 1500 } 1501 1502 if (extv[SADB_X_EXT_ADDRESS_INNER_SRC] == NULL && 1503 extv[SADB_X_EXT_ADDRESS_INNER_DST] != NULL) { 1504 keysock_error(ks, mp, EINVAL, 1505 SADB_X_DIAGNOSTIC_MISSING_INNER_SRC); 1506 return; 1507 } 1508 1509 reply_mp = ipsec_construct_inverse_acquire(samsg, extv, 1510 keystack->keystack_netstack); 1511 1512 if (reply_mp != NULL) { 1513 freemsg(mp); 1514 keysock_passup(reply_mp, (sadb_msg_t *)reply_mp->b_rptr, 1515 ks->keysock_serial, NULL, B_FALSE, keystack); 1516 } else { 1517 keysock_error(ks, mp, samsg->sadb_msg_errno, 1518 samsg->sadb_x_msg_diagnostic); 1519 } 1520 } 1521 1522 /* 1523 * Spew an extended REGISTER down to the relevant consumers. 1524 */ 1525 static void 1526 keysock_extended_register(keysock_t *ks, mblk_t *mp, sadb_ext_t *extv[]) 1527 { 1528 sadb_x_ereg_t *ereg = (sadb_x_ereg_t *)extv[SADB_X_EXT_EREG]; 1529 uint8_t *satypes, *fencepost; 1530 mblk_t *downmp; 1531 sadb_ext_t *downextv[SADB_EXT_MAX + 1]; 1532 keysock_stack_t *keystack = ks->keysock_keystack; 1533 1534 if (ks->keysock_registered[0] != 0 || ks->keysock_registered[1] != 0 || 1535 ks->keysock_registered[2] != 0 || ks->keysock_registered[3] != 0) { 1536 keysock_error(ks, mp, EBUSY, 0); 1537 } 1538 1539 ks->keysock_flags |= KEYSOCK_EXTENDED; 1540 if (ereg == NULL) { 1541 keysock_error(ks, mp, EINVAL, SADB_X_DIAGNOSTIC_SATYPE_NEEDED); 1542 } else { 1543 ASSERT(mp->b_rptr + msgdsize(mp) == mp->b_wptr); 1544 fencepost = (uint8_t *)mp->b_wptr; 1545 satypes = ereg->sadb_x_ereg_satypes; 1546 while (*satypes != SADB_SATYPE_UNSPEC && satypes != fencepost) { 1547 downmp = copymsg(mp); 1548 if (downmp == NULL) { 1549 keysock_error(ks, mp, ENOMEM, 0); 1550 return; 1551 } 1552 /* 1553 * Since we've made it here, keysock_get_ext will work! 1554 */ 1555 (void) keysock_get_ext(downextv, 1556 (sadb_msg_t *)downmp->b_rptr, msgdsize(downmp), 1557 keystack); 1558 keysock_passdown(ks, downmp, *satypes, downextv, 1559 B_FALSE); 1560 ++satypes; 1561 } 1562 freemsg(mp); 1563 } 1564 1565 /* 1566 * Set global to indicate we prefer an extended ACQUIRE. 1567 */ 1568 atomic_add_32(&keystack->keystack_num_extended, 1); 1569 } 1570 1571 static void 1572 keysock_delpair_all(keysock_t *ks, mblk_t *mp, sadb_ext_t *extv[]) 1573 { 1574 int i, start, finish; 1575 mblk_t *mp1 = NULL; 1576 keysock_stack_t *keystack = ks->keysock_keystack; 1577 1578 start = 0; 1579 finish = KEYSOCK_MAX_CONSUMERS - 1; 1580 1581 for (i = start; i <= finish; i++) { 1582 if (keystack->keystack_consumers[i] != NULL) { 1583 mp1 = copymsg(mp); 1584 if (mp1 == NULL) { 1585 keysock_error(ks, mp, ENOMEM, 1586 SADB_X_DIAGNOSTIC_NONE); 1587 return; 1588 } 1589 keysock_passdown(ks, mp1, i, extv, B_FALSE); 1590 } 1591 } 1592 } 1593 1594 /* 1595 * Handle PF_KEY messages. 1596 */ 1597 static void 1598 keysock_parse(queue_t *q, mblk_t *mp) 1599 { 1600 sadb_msg_t *samsg; 1601 sadb_ext_t *extv[SADB_EXT_MAX + 1]; 1602 keysock_t *ks = (keysock_t *)q->q_ptr; 1603 uint_t msgsize; 1604 uint8_t satype; 1605 keysock_stack_t *keystack = ks->keysock_keystack; 1606 1607 /* Make sure I'm a PF_KEY socket. (i.e. nothing's below me) */ 1608 ASSERT(WR(q)->q_next == NULL); 1609 1610 samsg = (sadb_msg_t *)mp->b_rptr; 1611 ks2dbg(keystack, ("Received possible PF_KEY message, type %d.\n", 1612 samsg->sadb_msg_type)); 1613 1614 msgsize = SADB_64TO8(samsg->sadb_msg_len); 1615 1616 if (msgdsize(mp) != msgsize) { 1617 /* 1618 * Message len incorrect w.r.t. actual size. Send an error 1619 * (EMSGSIZE). It may be necessary to massage things a 1620 * bit. For example, if the sadb_msg_type is hosed, 1621 * I need to set it to SADB_RESERVED to get delivery to 1622 * do the right thing. Then again, maybe just letting 1623 * the error delivery do the right thing. 1624 */ 1625 ks2dbg(keystack, 1626 ("mblk (%lu) and base (%d) message sizes don't jibe.\n", 1627 msgdsize(mp), msgsize)); 1628 keysock_error(ks, mp, EMSGSIZE, SADB_X_DIAGNOSTIC_NONE); 1629 return; 1630 } 1631 1632 if (msgsize > (uint_t)(mp->b_wptr - mp->b_rptr)) { 1633 /* Get all message into one mblk. */ 1634 if (pullupmsg(mp, -1) == 0) { 1635 /* 1636 * Something screwy happened. 1637 */ 1638 ks3dbg(keystack, 1639 ("keysock_parse: pullupmsg() failed.\n")); 1640 return; 1641 } else { 1642 samsg = (sadb_msg_t *)mp->b_rptr; 1643 } 1644 } 1645 1646 switch (keysock_get_ext(extv, samsg, msgsize, keystack)) { 1647 case KGE_DUP: 1648 /* Handle duplicate extension. */ 1649 ks1dbg(keystack, ("Got duplicate extension of type %d.\n", 1650 extv[0]->sadb_ext_type)); 1651 keysock_error(ks, mp, EINVAL, 1652 keysock_duplicate(extv[0]->sadb_ext_type)); 1653 return; 1654 case KGE_UNK: 1655 /* Handle unknown extension. */ 1656 ks1dbg(keystack, ("Got unknown extension of type %d.\n", 1657 extv[0]->sadb_ext_type)); 1658 keysock_error(ks, mp, EINVAL, SADB_X_DIAGNOSTIC_UNKNOWN_EXT); 1659 return; 1660 case KGE_LEN: 1661 /* Length error. */ 1662 ks1dbg(keystack, 1663 ("Length %d on extension type %d overrun or 0.\n", 1664 extv[0]->sadb_ext_len, extv[0]->sadb_ext_type)); 1665 keysock_error(ks, mp, EINVAL, SADB_X_DIAGNOSTIC_BAD_EXTLEN); 1666 return; 1667 case KGE_CHK: 1668 /* Reality check failed. */ 1669 ks1dbg(keystack, 1670 ("Reality check failed on extension type %d.\n", 1671 extv[0]->sadb_ext_type)); 1672 keysock_error(ks, mp, EINVAL, 1673 keysock_malformed(extv[0]->sadb_ext_type)); 1674 return; 1675 default: 1676 /* Default case is no errors. */ 1677 break; 1678 } 1679 1680 switch (samsg->sadb_msg_type) { 1681 case SADB_REGISTER: 1682 /* 1683 * There's a semantic weirdness in that a message OTHER than 1684 * the return REGISTER message may be passed up if I set the 1685 * registered bit BEFORE I pass it down. 1686 * 1687 * SOOOO, I'll not twiddle any registered bits until I see 1688 * the upbound REGISTER (with a serial number in it). 1689 */ 1690 if (samsg->sadb_msg_satype == SADB_SATYPE_UNSPEC) { 1691 /* Handle extended register here. */ 1692 keysock_extended_register(ks, mp, extv); 1693 return; 1694 } else if (ks->keysock_flags & KEYSOCK_EXTENDED) { 1695 keysock_error(ks, mp, EBUSY, 0); 1696 return; 1697 } 1698 /* FALLTHRU */ 1699 case SADB_GETSPI: 1700 case SADB_ADD: 1701 case SADB_UPDATE: 1702 case SADB_X_UPDATEPAIR: 1703 case SADB_DELETE: 1704 case SADB_X_DELPAIR: 1705 case SADB_GET: 1706 /* 1707 * Pass down to appropriate consumer. 1708 */ 1709 if (samsg->sadb_msg_satype != SADB_SATYPE_UNSPEC) 1710 keysock_passdown(ks, mp, samsg->sadb_msg_satype, extv, 1711 B_FALSE); 1712 else keysock_error(ks, mp, EINVAL, 1713 SADB_X_DIAGNOSTIC_SATYPE_NEEDED); 1714 return; 1715 case SADB_X_DELPAIR_STATE: 1716 if (samsg->sadb_msg_satype == SADB_SATYPE_UNSPEC) { 1717 keysock_delpair_all(ks, mp, extv); 1718 } else { 1719 keysock_passdown(ks, mp, samsg->sadb_msg_satype, extv, 1720 B_FALSE); 1721 } 1722 return; 1723 case SADB_ACQUIRE: 1724 /* 1725 * If I _receive_ an acquire, this means I should spread it 1726 * out to registered sockets. Unless there's an errno... 1727 * 1728 * Need ADDRESS, may have ID, SENS, and PROP, unless errno, 1729 * in which case there should be NO extensions. 1730 * 1731 * Return to registered. 1732 */ 1733 if (samsg->sadb_msg_errno != 0) { 1734 satype = samsg->sadb_msg_satype; 1735 if (satype == SADB_SATYPE_UNSPEC) { 1736 if (!(ks->keysock_flags & KEYSOCK_EXTENDED)) { 1737 keysock_error(ks, mp, EINVAL, 1738 SADB_X_DIAGNOSTIC_SATYPE_NEEDED); 1739 return; 1740 } 1741 /* 1742 * Reassign satype based on the first 1743 * flags that KEYSOCK_SETREG says. 1744 */ 1745 while (satype <= SADB_SATYPE_MAX) { 1746 if (KEYSOCK_ISREG(ks, satype)) 1747 break; 1748 satype++; 1749 } 1750 if (satype > SADB_SATYPE_MAX) { 1751 keysock_error(ks, mp, EBUSY, 0); 1752 return; 1753 } 1754 } 1755 keysock_passdown(ks, mp, satype, extv, B_FALSE); 1756 } else { 1757 if (samsg->sadb_msg_satype == SADB_SATYPE_UNSPEC) { 1758 keysock_error(ks, mp, EINVAL, 1759 SADB_X_DIAGNOSTIC_SATYPE_NEEDED); 1760 } else { 1761 keysock_passup(mp, samsg, 0, NULL, B_FALSE, 1762 keystack); 1763 } 1764 } 1765 return; 1766 case SADB_EXPIRE: 1767 /* 1768 * If someone sends this in, then send out to all senders. 1769 * (Save maybe ESP or AH, I have to be careful here.) 1770 * 1771 * Need ADDRESS, may have ID and SENS. 1772 * 1773 * XXX for now this is unsupported. 1774 */ 1775 break; 1776 case SADB_FLUSH: 1777 /* 1778 * Nuke all SAs. 1779 * 1780 * No extensions at all. Return to all listeners. 1781 * 1782 * Question: Should I hold a lock here to prevent 1783 * additions/deletions while flushing? 1784 * Answer: No. (See keysock_passdown() for details.) 1785 */ 1786 if (extv[0] != NULL) { 1787 /* 1788 * FLUSH messages shouldn't have extensions. 1789 * Return EINVAL. 1790 */ 1791 ks2dbg(keystack, ("FLUSH message with extension.\n")); 1792 keysock_error(ks, mp, EINVAL, SADB_X_DIAGNOSTIC_NO_EXT); 1793 return; 1794 } 1795 1796 /* Passing down of DUMP/FLUSH messages are special. */ 1797 qwriter(q, mp, keysock_do_flushdump, PERIM_INNER); 1798 return; 1799 case SADB_DUMP: /* not used by normal applications */ 1800 if ((extv[0] != NULL) && 1801 ((msgsize > 1802 (sizeof (sadb_msg_t) + sizeof (sadb_x_edump_t))) || 1803 (extv[SADB_X_EXT_EDUMP] == NULL))) { 1804 keysock_error(ks, mp, EINVAL, 1805 SADB_X_DIAGNOSTIC_NO_EXT); 1806 return; 1807 } 1808 qwriter(q, mp, keysock_do_flushdump, PERIM_INNER); 1809 return; 1810 case SADB_X_PROMISC: 1811 /* 1812 * Promiscuous processing message. 1813 */ 1814 if (samsg->sadb_msg_satype == 0) 1815 ks->keysock_flags &= ~KEYSOCK_PROMISC; 1816 else 1817 ks->keysock_flags |= KEYSOCK_PROMISC; 1818 keysock_passup(mp, samsg, ks->keysock_serial, NULL, B_FALSE, 1819 keystack); 1820 return; 1821 case SADB_X_INVERSE_ACQUIRE: 1822 keysock_inverse_acquire(mp, samsg, extv, ks); 1823 return; 1824 default: 1825 ks2dbg(keystack, ("Got unknown message type %d.\n", 1826 samsg->sadb_msg_type)); 1827 keysock_error(ks, mp, EINVAL, SADB_X_DIAGNOSTIC_UNKNOWN_MSG); 1828 return; 1829 } 1830 1831 /* As a placeholder... */ 1832 ks0dbg(("keysock_parse(): Hit EOPNOTSUPP\n")); 1833 keysock_error(ks, mp, EOPNOTSUPP, SADB_X_DIAGNOSTIC_NONE); 1834 } 1835 1836 /* 1837 * wput routing for PF_KEY/keysock/whatever. Unlike the routing socket, 1838 * I don't convert to ioctl()'s for IP. I am the end-all driver as far 1839 * as PF_KEY sockets are concerned. I do some conversion, but not as much 1840 * as IP/rts does. 1841 */ 1842 static void 1843 keysock_wput(queue_t *q, mblk_t *mp) 1844 { 1845 uchar_t *rptr = mp->b_rptr; 1846 mblk_t *mp1; 1847 keysock_t *ks; 1848 keysock_stack_t *keystack; 1849 1850 if (WR(q)->q_next) { 1851 keysock_consumer_t *kc = (keysock_consumer_t *)q->q_ptr; 1852 keystack = kc->kc_keystack; 1853 1854 ks3dbg(keystack, ("In keysock_wput\n")); 1855 1856 /* 1857 * We shouldn't get writes on a consumer instance. 1858 * But for now, just passthru. 1859 */ 1860 ks1dbg(keystack, ("Huh? wput for an consumer instance (%d)?\n", 1861 kc->kc_sa_type)); 1862 putnext(q, mp); 1863 return; 1864 } 1865 ks = (keysock_t *)q->q_ptr; 1866 keystack = ks->keysock_keystack; 1867 1868 ks3dbg(keystack, ("In keysock_wput\n")); 1869 1870 switch (mp->b_datap->db_type) { 1871 case M_DATA: 1872 /* 1873 * Silently discard. 1874 */ 1875 ks2dbg(keystack, ("raw M_DATA in keysock.\n")); 1876 freemsg(mp); 1877 return; 1878 case M_PROTO: 1879 case M_PCPROTO: 1880 if ((mp->b_wptr - rptr) >= sizeof (struct T_data_req)) { 1881 if (((union T_primitives *)rptr)->type == T_DATA_REQ) { 1882 if ((mp1 = mp->b_cont) == NULL) { 1883 /* No data after T_DATA_REQ. */ 1884 ks2dbg(keystack, 1885 ("No data after DATA_REQ.\n")); 1886 freemsg(mp); 1887 return; 1888 } 1889 freeb(mp); 1890 mp = mp1; 1891 ks2dbg(keystack, ("T_DATA_REQ\n")); 1892 break; /* Out of switch. */ 1893 } 1894 } 1895 /* FALLTHRU */ 1896 default: 1897 ks3dbg(keystack, ("In default wput case (%d %d).\n", 1898 mp->b_datap->db_type, ((union T_primitives *)rptr)->type)); 1899 keysock_wput_other(q, mp); 1900 return; 1901 } 1902 1903 /* I now have a PF_KEY message in an M_DATA block, pointed to by mp. */ 1904 keysock_parse(q, mp); 1905 } 1906 1907 /* BELOW THIS LINE ARE ROUTINES INCLUDING AND RELATED TO keysock_rput(). */ 1908 1909 /* 1910 * Called upon receipt of a KEYSOCK_HELLO_ACK to set up the appropriate 1911 * state vectors. 1912 */ 1913 static void 1914 keysock_link_consumer(uint8_t satype, keysock_consumer_t *kc) 1915 { 1916 keysock_t *ks; 1917 keysock_stack_t *keystack = kc->kc_keystack; 1918 1919 mutex_enter(&keystack->keystack_consumers_lock); 1920 mutex_enter(&kc->kc_lock); 1921 if (keystack->keystack_consumers[satype] != NULL) { 1922 ks0dbg(( 1923 "Hmmmm, someone closed %d before the HELLO_ACK happened.\n", 1924 satype)); 1925 /* 1926 * Perhaps updating the new below-me consumer with what I have 1927 * so far would work too? 1928 */ 1929 mutex_exit(&kc->kc_lock); 1930 mutex_exit(&keystack->keystack_consumers_lock); 1931 } else { 1932 /* Add new below-me consumer. */ 1933 keystack->keystack_consumers[satype] = kc; 1934 1935 kc->kc_flags = 0; 1936 kc->kc_sa_type = satype; 1937 mutex_exit(&kc->kc_lock); 1938 mutex_exit(&keystack->keystack_consumers_lock); 1939 1940 /* Scan the keysock list. */ 1941 mutex_enter(&keystack->keystack_list_lock); 1942 for (ks = keystack->keystack_list; ks != NULL; 1943 ks = ks->keysock_next) { 1944 if (KEYSOCK_ISREG(ks, satype)) { 1945 /* 1946 * XXX Perhaps send an SADB_REGISTER down on 1947 * the socket's behalf. 1948 */ 1949 ks1dbg(keystack, 1950 ("Socket %u registered already for " 1951 "new consumer.\n", ks->keysock_serial)); 1952 } 1953 } 1954 mutex_exit(&keystack->keystack_list_lock); 1955 } 1956 } 1957 1958 /* 1959 * Generate a KEYSOCK_OUT_ERR message for my consumer. 1960 */ 1961 static void 1962 keysock_out_err(keysock_consumer_t *kc, int ks_errno, mblk_t *mp) 1963 { 1964 keysock_out_err_t *kse; 1965 mblk_t *imp; 1966 keysock_stack_t *keystack = kc->kc_keystack; 1967 1968 imp = allocb(sizeof (ipsec_info_t), BPRI_HI); 1969 if (imp == NULL) { 1970 ks1dbg(keystack, ("keysock_out_err: Can't alloc message.\n")); 1971 return; 1972 } 1973 1974 imp->b_datap->db_type = M_CTL; 1975 imp->b_wptr += sizeof (ipsec_info_t); 1976 1977 kse = (keysock_out_err_t *)imp->b_rptr; 1978 imp->b_cont = mp; 1979 kse->ks_err_type = KEYSOCK_OUT_ERR; 1980 kse->ks_err_len = sizeof (*kse); 1981 /* Is serial necessary? */ 1982 kse->ks_err_serial = 0; 1983 kse->ks_err_errno = ks_errno; 1984 1985 /* 1986 * XXX What else do I need to do here w.r.t. information 1987 * to tell the consumer what caused this error? 1988 * 1989 * I believe the answer is the PF_KEY ACQUIRE (or other) message 1990 * attached in mp, which is appended at the end. I believe the 1991 * db_ref won't matter here, because the PF_KEY message is only read 1992 * for KEYSOCK_OUT_ERR. 1993 */ 1994 1995 putnext(kc->kc_wq, imp); 1996 } 1997 1998 /* XXX this is a hack errno. */ 1999 #define EIPSECNOSA 255 2000 2001 /* 2002 * Route message (pointed by mp, header in samsg) toward appropriate 2003 * sockets. Assume the message's creator did its job correctly. 2004 * 2005 * This should be a function that is followed by a return in its caller. 2006 * The compiler _should_ be able to use tail-call optimizations to make the 2007 * large ## of parameters not a huge deal. 2008 */ 2009 static void 2010 keysock_passup(mblk_t *mp, sadb_msg_t *samsg, minor_t serial, 2011 keysock_consumer_t *kc, boolean_t persistent, keysock_stack_t *keystack) 2012 { 2013 keysock_t *ks; 2014 uint8_t satype = samsg->sadb_msg_satype; 2015 boolean_t toall = B_FALSE, allreg = B_FALSE, allereg = B_FALSE, 2016 setalg = B_FALSE; 2017 mblk_t *mp1; 2018 int err = EIPSECNOSA; 2019 2020 /* Convert mp, which is M_DATA, into an M_PROTO of type T_DATA_IND */ 2021 mp1 = allocb(sizeof (struct T_data_req), BPRI_HI); 2022 if (mp1 == NULL) { 2023 err = ENOMEM; 2024 goto error; 2025 } 2026 mp1->b_wptr += sizeof (struct T_data_req); 2027 ((struct T_data_ind *)mp1->b_rptr)->PRIM_type = T_DATA_IND; 2028 ((struct T_data_ind *)mp1->b_rptr)->MORE_flag = 0; 2029 mp1->b_datap->db_type = M_PROTO; 2030 mp1->b_cont = mp; 2031 mp = mp1; 2032 2033 switch (samsg->sadb_msg_type) { 2034 case SADB_FLUSH: 2035 case SADB_GETSPI: 2036 case SADB_UPDATE: 2037 case SADB_X_UPDATEPAIR: 2038 case SADB_ADD: 2039 case SADB_DELETE: 2040 case SADB_X_DELPAIR: 2041 case SADB_EXPIRE: 2042 /* 2043 * These are most likely replies. Don't worry about 2044 * KEYSOCK_OUT_ERR handling. Deliver to all sockets. 2045 */ 2046 ks3dbg(keystack, 2047 ("Delivering normal message (%d) to all sockets.\n", 2048 samsg->sadb_msg_type)); 2049 toall = B_TRUE; 2050 break; 2051 case SADB_REGISTER: 2052 /* 2053 * REGISTERs come up for one of three reasons: 2054 * 2055 * 1.) In response to a normal SADB_REGISTER 2056 * (samsg->sadb_msg_satype != SADB_SATYPE_UNSPEC && 2057 * serial != 0) 2058 * Deliver to normal SADB_REGISTERed sockets. 2059 * 2.) In response to an extended REGISTER 2060 * (samsg->sadb_msg_satype == SADB_SATYPE_UNSPEC) 2061 * Deliver to extended REGISTERed socket. 2062 * 3.) Spontaneous algorithm changes 2063 * (samsg->sadb_msg_satype != SADB_SATYPE_UNSPEC && 2064 * serial == 0) 2065 * Deliver to REGISTERed sockets of all sorts. 2066 */ 2067 if (kc == NULL) { 2068 /* Here because of keysock_error() call. */ 2069 ASSERT(samsg->sadb_msg_errno != 0); 2070 break; /* Out of switch. */ 2071 } 2072 ks3dbg(keystack, ("Delivering REGISTER.\n")); 2073 if (satype == SADB_SATYPE_UNSPEC) { 2074 /* REGISTER Reason #2 */ 2075 allereg = B_TRUE; 2076 /* 2077 * Rewhack SA type so PF_KEY socket holder knows what 2078 * consumer generated this algorithm list. 2079 */ 2080 satype = kc->kc_sa_type; 2081 samsg->sadb_msg_satype = satype; 2082 setalg = B_TRUE; 2083 } else if (serial == 0) { 2084 /* REGISTER Reason #3 */ 2085 allreg = B_TRUE; 2086 allereg = B_TRUE; 2087 } else { 2088 /* REGISTER Reason #1 */ 2089 allreg = B_TRUE; 2090 setalg = B_TRUE; 2091 } 2092 break; 2093 case SADB_ACQUIRE: 2094 /* 2095 * ACQUIREs are either extended (sadb_msg_satype == 0) or 2096 * regular (sadb_msg_satype != 0). And we're guaranteed 2097 * that serial == 0 for an ACQUIRE. 2098 */ 2099 ks3dbg(keystack, ("Delivering ACQUIRE.\n")); 2100 allereg = (satype == SADB_SATYPE_UNSPEC); 2101 allreg = !allereg; 2102 /* 2103 * Corner case - if we send a regular ACQUIRE and there's 2104 * extended ones registered, don't send an error down to 2105 * consumers if nobody's listening and prematurely destroy 2106 * their ACQUIRE record. This might be too hackish of a 2107 * solution. 2108 */ 2109 if (allreg && keystack->keystack_num_extended > 0) 2110 err = 0; 2111 break; 2112 case SADB_X_PROMISC: 2113 case SADB_X_INVERSE_ACQUIRE: 2114 case SADB_DUMP: 2115 case SADB_GET: 2116 default: 2117 /* 2118 * Deliver to the sender and promiscuous only. 2119 */ 2120 ks3dbg(keystack, ("Delivering sender/promisc only (%d).\n", 2121 samsg->sadb_msg_type)); 2122 break; 2123 } 2124 2125 mutex_enter(&keystack->keystack_list_lock); 2126 for (ks = keystack->keystack_list; ks != NULL; ks = ks->keysock_next) { 2127 /* Delivery loop. */ 2128 2129 /* 2130 * Check special keysock-setting cases (REGISTER replies) 2131 * here. 2132 */ 2133 if (setalg && serial == ks->keysock_serial) { 2134 ASSERT(kc != NULL); 2135 ASSERT(kc->kc_sa_type == satype); 2136 KEYSOCK_SETREG(ks, satype); 2137 } 2138 2139 /* 2140 * NOLOOP takes precedence over PROMISC. So if you've set 2141 * !SO_USELOOPBACK, don't expect to see any data... 2142 */ 2143 if (ks->keysock_flags & KEYSOCK_NOLOOP) 2144 continue; 2145 2146 /* 2147 * Messages to all, or promiscuous sockets just GET the 2148 * message. Perform rules-type checking iff it's not for all 2149 * listeners or the socket is in promiscuous mode. 2150 * 2151 * NOTE:Because of the (kc != NULL && ISREG()), make sure 2152 * extended ACQUIREs arrive off a consumer that is 2153 * part of the extended REGISTER set of consumers. 2154 */ 2155 if (serial != ks->keysock_serial && 2156 !toall && 2157 !(ks->keysock_flags & KEYSOCK_PROMISC) && 2158 !((ks->keysock_flags & KEYSOCK_EXTENDED) ? 2159 allereg : allreg && kc != NULL && 2160 KEYSOCK_ISREG(ks, kc->kc_sa_type))) 2161 continue; 2162 2163 mp1 = dupmsg(mp); 2164 if (mp1 == NULL) { 2165 ks2dbg(keystack, ( 2166 "keysock_passup(): dupmsg() failed.\n")); 2167 mp1 = mp; 2168 mp = NULL; 2169 err = ENOMEM; 2170 } 2171 2172 /* 2173 * At this point, we can deliver or attempt to deliver 2174 * this message. We're free of obligation to report 2175 * no listening PF_KEY sockets. So set err to 0. 2176 */ 2177 err = 0; 2178 2179 /* 2180 * See if we canputnext(), as well as see if the message 2181 * needs to be queued if we can't. 2182 */ 2183 if (!canputnext(ks->keysock_rq)) { 2184 if (persistent) { 2185 if (putq(ks->keysock_rq, mp1) == 0) { 2186 ks1dbg(keystack, ( 2187 "keysock_passup: putq failed.\n")); 2188 } else { 2189 continue; 2190 } 2191 } 2192 freemsg(mp1); 2193 continue; 2194 } 2195 2196 ks3dbg(keystack, 2197 ("Putting to serial %d.\n", ks->keysock_serial)); 2198 /* 2199 * Unlike the specific keysock instance case, this 2200 * will only hit for listeners, so we will only 2201 * putnext() if we can. 2202 */ 2203 putnext(ks->keysock_rq, mp1); 2204 if (mp == NULL) 2205 break; /* out of for loop. */ 2206 } 2207 mutex_exit(&keystack->keystack_list_lock); 2208 2209 error: 2210 if ((err != 0) && (kc != NULL)) { 2211 /* 2212 * Generate KEYSOCK_OUT_ERR for consumer. 2213 * Basically, I send this back if I have not been able to 2214 * transmit (for whatever reason) 2215 */ 2216 ks1dbg(keystack, 2217 ("keysock_passup(): No registered of type %d.\n", 2218 satype)); 2219 if (mp != NULL) { 2220 if (mp->b_datap->db_type == M_PROTO) { 2221 mp1 = mp; 2222 mp = mp->b_cont; 2223 freeb(mp1); 2224 } 2225 /* 2226 * Do a copymsg() because people who get 2227 * KEYSOCK_OUT_ERR may alter the message contents. 2228 */ 2229 mp1 = copymsg(mp); 2230 if (mp1 == NULL) { 2231 ks2dbg(keystack, 2232 ("keysock_passup: copymsg() failed.\n")); 2233 mp1 = mp; 2234 mp = NULL; 2235 } 2236 keysock_out_err(kc, err, mp1); 2237 } 2238 } 2239 2240 /* 2241 * XXX Blank the message somehow. This is difficult because we don't 2242 * know at this point if the message has db_ref > 1, etc. 2243 * 2244 * Optimally, keysock messages containing actual keying material would 2245 * be allocated with esballoc(), with a zeroing free function. 2246 */ 2247 if (mp != NULL) 2248 freemsg(mp); 2249 } 2250 2251 /* 2252 * Keysock's read service procedure is there only for PF_KEY reply 2253 * messages that really need to reach the top. 2254 */ 2255 static void 2256 keysock_rsrv(queue_t *q) 2257 { 2258 mblk_t *mp; 2259 2260 while ((mp = getq(q)) != NULL) { 2261 if (canputnext(q)) { 2262 putnext(q, mp); 2263 } else { 2264 (void) putbq(q, mp); 2265 return; 2266 } 2267 } 2268 } 2269 2270 /* 2271 * The read procedure should only be invoked by a keysock consumer, like 2272 * ESP, AH, etc. I should only see KEYSOCK_OUT and KEYSOCK_HELLO_ACK 2273 * messages on my read queues. 2274 */ 2275 static void 2276 keysock_rput(queue_t *q, mblk_t *mp) 2277 { 2278 keysock_consumer_t *kc = (keysock_consumer_t *)q->q_ptr; 2279 ipsec_info_t *ii; 2280 keysock_hello_ack_t *ksa; 2281 minor_t serial; 2282 mblk_t *mp1; 2283 sadb_msg_t *samsg; 2284 keysock_stack_t *keystack = kc->kc_keystack; 2285 2286 /* Make sure I'm a consumer instance. (i.e. something's below me) */ 2287 ASSERT(WR(q)->q_next != NULL); 2288 2289 if (mp->b_datap->db_type != M_CTL) { 2290 /* 2291 * Keysock should only see keysock consumer interface 2292 * messages (see ipsec_info.h) on its read procedure. 2293 * To be robust, however, putnext() up so the STREAM head can 2294 * deal with it appropriately. 2295 */ 2296 ks1dbg(keystack, 2297 ("Hmmm, a non M_CTL (%d, 0x%x) on keysock_rput.\n", 2298 mp->b_datap->db_type, mp->b_datap->db_type)); 2299 putnext(q, mp); 2300 return; 2301 } 2302 2303 ii = (ipsec_info_t *)mp->b_rptr; 2304 2305 switch (ii->ipsec_info_type) { 2306 case KEYSOCK_OUT: 2307 /* 2308 * A consumer needs to pass a response message or an ACQUIRE 2309 * UP. I assume that the consumer has done the right 2310 * thing w.r.t. message creation, etc. 2311 */ 2312 serial = ((keysock_out_t *)mp->b_rptr)->ks_out_serial; 2313 mp1 = mp->b_cont; /* Get M_DATA portion. */ 2314 freeb(mp); 2315 samsg = (sadb_msg_t *)mp1->b_rptr; 2316 if (samsg->sadb_msg_type == SADB_FLUSH || 2317 (samsg->sadb_msg_type == SADB_DUMP && 2318 samsg->sadb_msg_len == SADB_8TO64(sizeof (*samsg)))) { 2319 /* 2320 * If I'm an end-of-FLUSH or an end-of-DUMP marker... 2321 */ 2322 ASSERT(keystack->keystack_flushdump != 0); 2323 /* Am I flushing? */ 2324 2325 mutex_enter(&kc->kc_lock); 2326 kc->kc_flags &= ~KC_FLUSHING; 2327 mutex_exit(&kc->kc_lock); 2328 2329 if (samsg->sadb_msg_errno != 0) 2330 keystack->keystack_flushdump_errno = 2331 samsg->sadb_msg_errno; 2332 2333 /* 2334 * Lower the atomic "flushing" count. If it's 2335 * the last one, send up the end-of-{FLUSH,DUMP} to 2336 * the appropriate PF_KEY socket. 2337 */ 2338 if (atomic_add_32_nv(&keystack->keystack_flushdump, 2339 -1) != 0) { 2340 ks1dbg(keystack, 2341 ("One flush/dump message back from %d," 2342 " more to go.\n", samsg->sadb_msg_satype)); 2343 freemsg(mp1); 2344 return; 2345 } 2346 2347 samsg->sadb_msg_errno = 2348 (uint8_t)keystack->keystack_flushdump_errno; 2349 if (samsg->sadb_msg_type == SADB_DUMP) { 2350 samsg->sadb_msg_seq = 0; 2351 } 2352 } 2353 keysock_passup(mp1, samsg, serial, kc, 2354 (samsg->sadb_msg_type == SADB_DUMP), keystack); 2355 return; 2356 case KEYSOCK_HELLO_ACK: 2357 /* Aha, now we can link in the consumer! */ 2358 ksa = (keysock_hello_ack_t *)ii; 2359 keysock_link_consumer(ksa->ks_hello_satype, kc); 2360 freemsg(mp); 2361 return; 2362 default: 2363 ks1dbg(keystack, ("Hmmm, an IPsec info I'm not used to, 0x%x\n", 2364 ii->ipsec_info_type)); 2365 putnext(q, mp); 2366 } 2367 } 2368 2369 /* 2370 * So we can avoid external linking problems.... 2371 */ 2372 boolean_t 2373 keysock_extended_reg(netstack_t *ns) 2374 { 2375 keysock_stack_t *keystack = ns->netstack_keysock; 2376 2377 return (keystack->keystack_num_extended != 0); 2378 } 2379 2380 uint32_t 2381 keysock_next_seq(netstack_t *ns) 2382 { 2383 keysock_stack_t *keystack = ns->netstack_keysock; 2384 2385 return (atomic_add_32_nv(&keystack->keystack_acquire_seq, -1)); 2386 } 2387
Indexes created Fri Nov 27 03:38:04 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.