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 (c) 1991, 2010, Oracle and/or its affiliates. All rights reserved. 23 * Copyright (c) 1990 Mentat Inc. 24 * Copyright (c) 2013 by Delphix. All rights reserved. 25 */ 26 27 #include <inet/tunables.h> 28 #include <sys/md5.h> 29 #include <inet/common.h> 30 #include <inet/ip.h> 31 #include <inet/ip6.h> 32 #include <netinet/icmp6.h> 33 #include <inet/ip_stack.h> 34 #include <inet/rawip_impl.h> 35 #include <inet/tcp_stack.h> 36 #include <inet/tcp_impl.h> 37 #include <inet/udp_impl.h> 38 #include <inet/sctp/sctp_stack.h> 39 #include <inet/sctp/sctp_impl.h> 40 #include <inet/tunables.h> 41 42 mod_prop_info_t * 43 mod_prop_lookup(mod_prop_info_t ptbl[], const char *prop_name, uint_t proto) 44 { 45 mod_prop_info_t *pinfo; 46 47 /* 48 * Walk the ptbl array looking for a property that has the requested 49 * name and protocol number. Note that we assume that all protocol 50 * tables are terminated by an entry with a NULL property name. 51 */ 52 for (pinfo = ptbl; pinfo->mpi_name != NULL; pinfo++) { 53 if (strcmp(pinfo->mpi_name, prop_name) == 0 && 54 pinfo->mpi_proto == proto) 55 return (pinfo); 56 } 57 return (NULL); 58 } 59 60 static int 61 prop_perm2const(mod_prop_info_t *pinfo) 62 { 63 if (pinfo->mpi_setf == NULL) 64 return (MOD_PROP_PERM_READ); 65 if (pinfo->mpi_getf == NULL) 66 return (MOD_PROP_PERM_WRITE); 67 return (MOD_PROP_PERM_RW); 68 } 69 70 /* 71 * Modifies the value of the property to default value or to the `pval' 72 * specified by the user. 73 */ 74 /* ARGSUSED */ 75 int 76 mod_set_boolean(netstack_t *stack, cred_t *cr, mod_prop_info_t *pinfo, 77 const char *ifname, const void* pval, uint_t flags) 78 { 79 char *end; 80 unsigned long new_value; 81 82 if (flags & MOD_PROP_DEFAULT) { 83 pinfo->prop_cur_bval = pinfo->prop_def_bval; 84 return (0); 85 } 86 87 if (ddi_strtoul(pval, &end, 10, &new_value) != 0 || *end != '\0') 88 return (EINVAL); 89 if (new_value != B_TRUE && new_value != B_FALSE) 90 return (EINVAL); 91 pinfo->prop_cur_bval = new_value; 92 return (0); 93 } 94 95 /* 96 * Retrieves property permission, default value, current value or possible 97 * values for those properties whose value type is boolean_t. 98 */ 99 /* ARGSUSED */ 100 int 101 mod_get_boolean(netstack_t *stack, mod_prop_info_t *pinfo, const char *ifname, 102 void *pval, uint_t psize, uint_t flags) 103 { 104 boolean_t get_def = (flags & MOD_PROP_DEFAULT); 105 boolean_t get_perm = (flags & MOD_PROP_PERM); 106 boolean_t get_range = (flags & MOD_PROP_POSSIBLE); 107 size_t nbytes; 108 109 bzero(pval, psize); 110 if (get_perm) 111 nbytes = snprintf(pval, psize, "%u", prop_perm2const(pinfo)); 112 else if (get_range) 113 nbytes = snprintf(pval, psize, "%u,%u", B_FALSE, B_TRUE); 114 else if (get_def) 115 nbytes = snprintf(pval, psize, "%u", pinfo->prop_def_bval); 116 else 117 nbytes = snprintf(pval, psize, "%u", pinfo->prop_cur_bval); 118 if (nbytes >= psize) 119 return (ENOBUFS); 120 return (0); 121 } 122 123 int 124 mod_uint32_value(const void *pval, mod_prop_info_t *pinfo, uint_t flags, 125 ulong_t *new_value) 126 { 127 char *end; 128 129 if (flags & MOD_PROP_DEFAULT) { 130 *new_value = pinfo->prop_def_uval; 131 return (0); 132 } 133 134 if (ddi_strtoul(pval, &end, 10, (ulong_t *)new_value) != 0 || 135 *end != '\0') 136 return (EINVAL); 137 if (*new_value < pinfo->prop_min_uval || 138 *new_value > pinfo->prop_max_uval) { 139 return (ERANGE); 140 } 141 return (0); 142 } 143 144 /* 145 * Modifies the value of the property to default value or to the `pval' 146 * specified by the user. 147 */ 148 /* ARGSUSED */ 149 int 150 mod_set_uint32(netstack_t *stack, cred_t *cr, mod_prop_info_t *pinfo, 151 const char *ifname, const void *pval, uint_t flags) 152 { 153 unsigned long new_value; 154 int err; 155 156 if ((err = mod_uint32_value(pval, pinfo, flags, &new_value)) != 0) 157 return (err); 158 pinfo->prop_cur_uval = (uint32_t)new_value; 159 return (0); 160 } 161 162 /* 163 * Rounds up the value to make it multiple of 8. 164 */ 165 /* ARGSUSED */ 166 int 167 mod_set_aligned(netstack_t *stack, cred_t *cr, mod_prop_info_t *pinfo, 168 const char *ifname, const void* pval, uint_t flags) 169 { 170 int err; 171 172 if ((err = mod_set_uint32(stack, cr, pinfo, ifname, pval, flags)) != 0) 173 return (err); 174 175 /* if required, align the value to multiple of 8 */ 176 if (pinfo->prop_cur_uval & 0x7) { 177 pinfo->prop_cur_uval &= ~0x7; 178 pinfo->prop_cur_uval += 0x8; 179 } 180 181 return (0); 182 } 183 184 /* 185 * Retrieves property permission, default value, current value or possible 186 * values for those properties whose value type is uint32_t. 187 */ 188 /* ARGSUSED */ 189 int 190 mod_get_uint32(netstack_t *stack, mod_prop_info_t *pinfo, const char *ifname, 191 void *pval, uint_t psize, uint_t flags) 192 { 193 boolean_t get_def = (flags & MOD_PROP_DEFAULT); 194 boolean_t get_perm = (flags & MOD_PROP_PERM); 195 boolean_t get_range = (flags & MOD_PROP_POSSIBLE); 196 size_t nbytes; 197 198 bzero(pval, psize); 199 if (get_perm) 200 nbytes = snprintf(pval, psize, "%u", prop_perm2const(pinfo)); 201 else if (get_range) 202 nbytes = snprintf(pval, psize, "%u-%u", 203 pinfo->prop_min_uval, pinfo->prop_max_uval); 204 else if (get_def) 205 nbytes = snprintf(pval, psize, "%u", pinfo->prop_def_uval); 206 else 207 nbytes = snprintf(pval, psize, "%u", pinfo->prop_cur_uval); 208 if (nbytes >= psize) 209 return (ENOBUFS); 210 return (0); 211 } 212 213 /* 214 * The range of the buffer size properties has a static lower bound configured 215 * in the property info structure of the property itself, and a dynamic upper 216 * bound. The upper bound is the current value of the "max_buf" property 217 * in the appropriate protocol property table. 218 */ 219 static void 220 mod_get_buf_prop_range(mod_prop_info_t ptbl[], mod_prop_info_t *pinfo, 221 uint32_t *min, uint32_t *max) 222 { 223 mod_prop_info_t *maxbuf_pinfo = mod_prop_lookup(ptbl, "max_buf", 224 pinfo->mpi_proto); 225 226 *min = pinfo->prop_min_uval; 227 *max = maxbuf_pinfo->prop_cur_uval; 228 } 229 230 /* 231 * Modifies the value of the buffer size property to its default value or to 232 * the value specified by the user. This is similar to mod_set_uint32() except 233 * that the value has a dynamically bounded range (see mod_get_buf_prop_range() 234 * for details). 235 */ 236 /* ARGSUSED */ 237 int 238 mod_set_buf_prop(mod_prop_info_t ptbl[], netstack_t *stack, cred_t *cr, 239 mod_prop_info_t *pinfo, const char *ifname, const void *pval, uint_t flags) 240 { 241 unsigned long new_value; 242 char *end; 243 uint32_t min, max; 244 245 if (flags & MOD_PROP_DEFAULT) { 246 pinfo->prop_cur_uval = pinfo->prop_def_uval; 247 return (0); 248 } 249 250 if (ddi_strtoul(pval, &end, 10, &new_value) != 0 || *end != '\0') 251 return (EINVAL); 252 253 mod_get_buf_prop_range(ptbl, pinfo, &min, &max); 254 if (new_value < min || new_value > max) 255 return (ERANGE); 256 257 pinfo->prop_cur_uval = new_value; 258 return (0); 259 } 260 261 /* 262 * Retrieves property permissions, default value, current value, or possible 263 * values for buffer size properties. While these properties have integer 264 * values, they have a dynamic range (see mod_get_buf_prop_range() for 265 * details). As such, they need to be handled differently. 266 */ 267 int 268 mod_get_buf_prop(mod_prop_info_t ptbl[], netstack_t *stack, 269 mod_prop_info_t *pinfo, const char *ifname, void *pval, uint_t psize, 270 uint_t flags) 271 { 272 size_t nbytes; 273 uint32_t min, max; 274 275 if (flags & MOD_PROP_POSSIBLE) { 276 mod_get_buf_prop_range(ptbl, pinfo, &min, &max); 277 nbytes = snprintf(pval, psize, "%u-%u", min, max); 278 return (nbytes < psize ? 0 : ENOBUFS); 279 } 280 return (mod_get_uint32(stack, pinfo, ifname, pval, psize, flags)); 281 } 282 283 /* 284 * Implements /sbin/ndd -get /dev/ip ?, for all the modules. Needed for 285 * backward compatibility with /sbin/ndd. 286 */ 287 /* ARGSUSED */ 288 int 289 mod_get_allprop(netstack_t *stack, mod_prop_info_t *pinfo, const char *ifname, 290 void *val, uint_t psize, uint_t flags) 291 { 292 char *pval = val; 293 mod_prop_info_t *ptbl, *prop; 294 uint_t size; 295 size_t nbytes = 0, tbytes = 0; 296 297 bzero(pval, psize); 298 size = psize; 299 300 switch (pinfo->mpi_proto) { 301 case MOD_PROTO_IP: 302 case MOD_PROTO_IPV4: 303 case MOD_PROTO_IPV6: 304 ptbl = stack->netstack_ip->ips_propinfo_tbl; 305 break; 306 case MOD_PROTO_RAWIP: 307 ptbl = stack->netstack_icmp->is_propinfo_tbl; 308 break; 309 case MOD_PROTO_TCP: 310 ptbl = stack->netstack_tcp->tcps_propinfo_tbl; 311 break; 312 case MOD_PROTO_UDP: 313 ptbl = stack->netstack_udp->us_propinfo_tbl; 314 break; 315 case MOD_PROTO_SCTP: 316 ptbl = stack->netstack_sctp->sctps_propinfo_tbl; 317 break; 318 default: 319 return (EINVAL); 320 } 321 322 for (prop = ptbl; prop->mpi_name != NULL; prop++) { 323 if (prop->mpi_name[0] == '\0' || 324 strcmp(prop->mpi_name, "?") == 0) { 325 continue; 326 } 327 nbytes = snprintf(pval, size, "%s %d %d", prop->mpi_name, 328 prop->mpi_proto, prop_perm2const(prop)); 329 size -= nbytes + 1; 330 pval += nbytes + 1; 331 tbytes += nbytes + 1; 332 if (tbytes >= psize) { 333 /* Buffer overflow, stop copying information */ 334 return (ENOBUFS); 335 } 336 } 337 return (0); 338 } 339 340 /* 341 * Hold a lock while changing *_epriv_ports to prevent multiple 342 * threads from changing it at the same time. 343 */ 344 /* ARGSUSED */ 345 int 346 mod_set_extra_privports(netstack_t *stack, cred_t *cr, mod_prop_info_t *pinfo, 347 const char *ifname, const void* val, uint_t flags) 348 { 349 uint_t proto = pinfo->mpi_proto; 350 tcp_stack_t *tcps; 351 sctp_stack_t *sctps; 352 udp_stack_t *us; 353 unsigned long new_value; 354 char *end; 355 kmutex_t *lock; 356 uint_t i, nports; 357 in_port_t *ports; 358 boolean_t def = (flags & MOD_PROP_DEFAULT); 359 const char *pval = val; 360 361 if (!def) { 362 if (ddi_strtoul(pval, &end, 10, &new_value) != 0 || 363 *end != '\0') { 364 return (EINVAL); 365 } 366 367 if (new_value < pinfo->prop_min_uval || 368 new_value > pinfo->prop_max_uval) { 369 return (ERANGE); 370 } 371 } 372 373 switch (proto) { 374 case MOD_PROTO_TCP: 375 tcps = stack->netstack_tcp; 376 lock = &tcps->tcps_epriv_port_lock; 377 ports = tcps->tcps_g_epriv_ports; 378 nports = tcps->tcps_g_num_epriv_ports; 379 break; 380 case MOD_PROTO_UDP: 381 us = stack->netstack_udp; 382 lock = &us->us_epriv_port_lock; 383 ports = us->us_epriv_ports; 384 nports = us->us_num_epriv_ports; 385 break; 386 case MOD_PROTO_SCTP: 387 sctps = stack->netstack_sctp; 388 lock = &sctps->sctps_epriv_port_lock; 389 ports = sctps->sctps_g_epriv_ports; 390 nports = sctps->sctps_g_num_epriv_ports; 391 break; 392 default: 393 return (ENOTSUP); 394 } 395 396 mutex_enter(lock); 397 398 /* if MOD_PROP_DEFAULT is set then reset the ports list to default */ 399 if (def) { 400 for (i = 0; i < nports; i++) 401 ports[i] = 0; 402 ports[0] = ULP_DEF_EPRIV_PORT1; 403 ports[1] = ULP_DEF_EPRIV_PORT2; 404 mutex_exit(lock); 405 return (0); 406 } 407 408 /* Check if the value is already in the list */ 409 for (i = 0; i < nports; i++) { 410 if (new_value == ports[i]) 411 break; 412 } 413 414 if (flags & MOD_PROP_REMOVE) { 415 if (i == nports) { 416 mutex_exit(lock); 417 return (ESRCH); 418 } 419 /* Clear the value */ 420 ports[i] = 0; 421 } else if (flags & MOD_PROP_APPEND) { 422 if (i != nports) { 423 mutex_exit(lock); 424 return (EEXIST); 425 } 426 427 /* Find an empty slot */ 428 for (i = 0; i < nports; i++) { 429 if (ports[i] == 0) 430 break; 431 } 432 if (i == nports) { 433 mutex_exit(lock); 434 return (EOVERFLOW); 435 } 436 /* Set the new value */ 437 ports[i] = (in_port_t)new_value; 438 } else { 439 /* 440 * If the user used 'assignment' modifier. 441 * For eg: 442 * # ipadm set-prop -p extra_priv_ports=3001 tcp 443 * 444 * We clear all the ports and then just add 3001. 445 */ 446 ASSERT(flags == MOD_PROP_ACTIVE); 447 for (i = 0; i < nports; i++) 448 ports[i] = 0; 449 ports[0] = (in_port_t)new_value; 450 } 451 452 mutex_exit(lock); 453 return (0); 454 } 455 456 /* 457 * Note: No locks are held when inspecting *_epriv_ports 458 * but instead the code relies on: 459 * - the fact that the address of the array and its size never changes 460 * - the atomic assignment of the elements of the array 461 */ 462 /* ARGSUSED */ 463 int 464 mod_get_extra_privports(netstack_t *stack, mod_prop_info_t *pinfo, 465 const char *ifname, void *val, uint_t psize, uint_t flags) 466 { 467 uint_t proto = pinfo->mpi_proto; 468 tcp_stack_t *tcps; 469 sctp_stack_t *sctps; 470 udp_stack_t *us; 471 uint_t i, nports, size; 472 in_port_t *ports; 473 char *pval = val; 474 size_t nbytes = 0, tbytes = 0; 475 boolean_t get_def = (flags & MOD_PROP_DEFAULT); 476 boolean_t get_perm = (flags & MOD_PROP_PERM); 477 boolean_t get_range = (flags & MOD_PROP_POSSIBLE); 478 479 bzero(pval, psize); 480 size = psize; 481 482 if (get_def) { 483 tbytes = snprintf(pval, psize, "%u,%u", ULP_DEF_EPRIV_PORT1, 484 ULP_DEF_EPRIV_PORT2); 485 goto ret; 486 } else if (get_perm) { 487 tbytes = snprintf(pval, psize, "%u", MOD_PROP_PERM_RW); 488 goto ret; 489 } 490 491 switch (proto) { 492 case MOD_PROTO_TCP: 493 tcps = stack->netstack_tcp; 494 ports = tcps->tcps_g_epriv_ports; 495 nports = tcps->tcps_g_num_epriv_ports; 496 break; 497 case MOD_PROTO_UDP: 498 us = stack->netstack_udp; 499 ports = us->us_epriv_ports; 500 nports = us->us_num_epriv_ports; 501 break; 502 case MOD_PROTO_SCTP: 503 sctps = stack->netstack_sctp; 504 ports = sctps->sctps_g_epriv_ports; 505 nports = sctps->sctps_g_num_epriv_ports; 506 break; 507 default: 508 return (ENOTSUP); 509 } 510 511 if (get_range) { 512 tbytes = snprintf(pval, psize, "%u-%u", pinfo->prop_min_uval, 513 pinfo->prop_max_uval); 514 goto ret; 515 } 516 517 for (i = 0; i < nports; i++) { 518 if (ports[i] != 0) { 519 if (psize == size) 520 nbytes = snprintf(pval, size, "%u", ports[i]); 521 else 522 nbytes = snprintf(pval, size, ",%u", ports[i]); 523 size -= nbytes; 524 pval += nbytes; 525 tbytes += nbytes; 526 if (tbytes >= psize) 527 return (ENOBUFS); 528 } 529 } 530 return (0); 531 ret: 532 if (tbytes >= psize) 533 return (ENOBUFS); 534 return (0); 535 } 536