1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved. 24 * Copyright (c) 2016 by Delphix. All rights reserved. 25 * Copyright 2022 Tintri by DDN, Inc. All rights reserved. 26 * Copyright 2022 RackTop Systems, Inc. 27 */ 28 29 /* 30 * General Structures Layout 31 * ------------------------- 32 * 33 * This is a simplified diagram showing the relationship between most of the 34 * main structures. 35 * 36 * +-------------------+ 37 * | SMB_INFO | 38 * +-------------------+ 39 * | 40 * | 41 * v 42 * +-------------------+ +-------------------+ +-------------------+ 43 * | SESSION |<----->| SESSION |......| SESSION | 44 * +-------------------+ +-------------------+ +-------------------+ 45 * | | 46 * | | 47 * | v 48 * | +-------------------+ +-------------------+ +-------------------+ 49 * | | USER |<--->| USER |...| USER | 50 * | +-------------------+ +-------------------+ +-------------------+ 51 * | 52 * | 53 * v 54 * +-------------------+ +-------------------+ +-------------------+ 55 * | TREE |<----->| TREE |......| TREE | 56 * +-------------------+ +-------------------+ +-------------------+ 57 * | | 58 * | | 59 * | v 60 * | +-------+ +-------+ +-------+ 61 * | | OFILE |<----->| OFILE |......| OFILE | 62 * | +-------+ +-------+ +-------+ 63 * | 64 * | 65 * v 66 * +-------+ +------+ +------+ 67 * | ODIR |<----->| ODIR |......| ODIR | 68 * +-------+ +------+ +------+ 69 * 70 * 71 * Tree State Machine 72 * ------------------ 73 * 74 * +-----------------------------+ T0 75 * | SMB_TREE_STATE_CONNECTED |<----------- Creation/Allocation 76 * +-----------------------------+ 77 * | 78 * | T1 79 * | 80 * v 81 * +------------------------------+ 82 * | SMB_TREE_STATE_DISCONNECTING | 83 * +------------------------------+ 84 * | 85 * | T2 86 * | 87 * v 88 * +-----------------------------+ T3 89 * | SMB_TREE_STATE_DISCONNECTED |----------> Deletion/Free 90 * +-----------------------------+ 91 * 92 * SMB_TREE_STATE_CONNECTED 93 * 94 * While in this state: 95 * - The tree is queued in the list of trees of its user. 96 * - References will be given out if the tree is looked up. 97 * - Files under that tree can be accessed. 98 * 99 * SMB_TREE_STATE_DISCONNECTING 100 * 101 * While in this state: 102 * - The tree is queued in the list of trees of its user. 103 * - References will not be given out if the tree is looked up. 104 * - The files and directories open under the tree are being closed. 105 * - The resources associated with the tree remain. 106 * 107 * SMB_TREE_STATE_DISCONNECTED 108 * 109 * While in this state: 110 * - The tree is queued in the list of trees of its user. 111 * - References will not be given out if the tree is looked up. 112 * - The tree has no more files and directories opened. 113 * - The resources associated with the tree remain. 114 * 115 * Transition T0 116 * 117 * This transition occurs in smb_tree_connect(). A new tree is created and 118 * added to the list of trees of a user. 119 * 120 * Transition T1 121 * 122 * This transition occurs in smb_tree_disconnect(). 123 * 124 * Transition T2 125 * 126 * This transition occurs in smb_tree_disconnect() 127 * 128 * Transition T3 129 * 130 * This transition occurs in smb_tree_release(). The resources associated 131 * with the tree are freed as well as the tree structure. For the transition 132 * to occur, the tree must be in the SMB_TREE_STATE_DISCONNECTED and the 133 * reference count must be zero. 134 * 135 * Comments 136 * -------- 137 * 138 * The state machine of the tree structures is controlled by 3 elements: 139 * - The list of trees of the user it belongs to. 140 * - The mutex embedded in the structure itself. 141 * - The reference count. 142 * 143 * There's a mutex embedded in the tree structure used to protect its fields 144 * and there's a lock embedded in the list of trees of a user. To 145 * increment or to decrement the reference count the mutex must be entered. 146 * To insert the tree into the list of trees of the user and to remove 147 * the tree from it, the lock must be entered in RW_WRITER mode. 148 * 149 * Rules of access to a tree structure: 150 * 151 * 1) In order to avoid deadlocks, when both (mutex and lock of the user 152 * list) have to be entered, the lock must be entered first. Additionally, 153 * when both the (mutex and lock of the ofile list) have to be entered, 154 * the mutex must be entered first. However, the ofile list lock must NOT 155 * be dropped while the mutex is held in such a way that the ofile deleteq 156 * is flushed. 157 * 158 * 2) All actions applied to a tree require a reference count. 159 * 160 * 3) There are 2 ways of getting a reference count: when a tree is 161 * connected and when a tree is looked up. 162 * 163 * It should be noted that the reference count of a tree registers the 164 * number of references to the tree in other structures (such as an smb 165 * request). The reference count is not incremented in these 2 instances: 166 * 167 * 1) The tree is connected. An tree is anchored by its state. If there's 168 * no activity involving a tree currently connected, the reference 169 * count of that tree is zero. 170 * 171 * 2) The tree is queued in the list of trees of the user. The fact of 172 * being queued in that list is NOT registered by incrementing the 173 * reference count. 174 */ 175 176 #include <sys/refstr_impl.h> 177 #include <smbsrv/smb_kproto.h> 178 #include <smbsrv/smb_ktypes.h> 179 #include <smbsrv/smb_fsops.h> 180 #include <smbsrv/smb_share.h> 181 182 int smb_tcon_mute = 1; 183 184 uint32_t smb_tree_connect_core(smb_request_t *); 185 uint32_t smb_tree_connect_disk(smb_request_t *, smb_arg_tcon_t *); 186 uint32_t smb_tree_connect_printq(smb_request_t *, smb_arg_tcon_t *); 187 uint32_t smb_tree_connect_ipc(smb_request_t *, smb_arg_tcon_t *); 188 static void smb_tree_dealloc(void *); 189 static boolean_t smb_tree_is_connected_locked(smb_tree_t *); 190 static char *smb_tree_get_sharename(char *); 191 static int smb_tree_getattr(const smb_kshare_t *, smb_node_t *, smb_tree_t *); 192 static void smb_tree_get_creation(smb_node_t *, smb_tree_t *); 193 static void smb_tree_get_volname(vfs_t *, smb_tree_t *); 194 static void smb_tree_get_flags(const smb_kshare_t *, vfs_t *, smb_tree_t *); 195 static void smb_tree_log(smb_request_t *, const char *, const char *, ...); 196 static void smb_tree_close_odirs(smb_tree_t *, uint32_t); 197 static void smb_tree_set_execinfo(smb_tree_t *, smb_shr_execinfo_t *, int); 198 static int smb_tree_enum_private(smb_tree_t *, smb_svcenum_t *); 199 static int smb_tree_netinfo_encode(smb_tree_t *, uint8_t *, size_t, uint32_t *); 200 static void smb_tree_netinfo_init(smb_tree_t *tree, smb_netconnectinfo_t *); 201 static void smb_tree_netinfo_fini(smb_netconnectinfo_t *); 202 203 uint32_t 204 smb_tree_connect(smb_request_t *sr) 205 { 206 smb_server_t *sv = sr->sr_server; 207 uint32_t status; 208 209 if (smb_threshold_enter(&sv->sv_tcon_ct) != 0) { 210 return (NT_STATUS_INSUFF_SERVER_RESOURCES); 211 } 212 213 status = smb_tree_connect_core(sr); 214 smb_threshold_exit(&sv->sv_tcon_ct); 215 return (status); 216 } 217 218 /* 219 * Lookup the share name dispatch the appropriate stype handler. 220 * Share names are case insensitive so we map the share name to 221 * lower-case as a convenience for internal processing. 222 * 223 * Valid service values are: 224 * A: Disk share 225 * LPT1: Printer 226 * IPC Named pipe (IPC$ is reserved as the named pipe share). 227 * COMM Communications device 228 * ????? Any type of device (wildcard) 229 */ 230 uint32_t 231 smb_tree_connect_core(smb_request_t *sr) 232 { 233 smb_arg_tcon_t *tcon = &sr->sr_tcon; 234 smb_kshare_t *si; 235 char *name; 236 uint32_t status; 237 238 (void) smb_strlwr(tcon->path); 239 240 if ((name = smb_tree_get_sharename(tcon->path)) == NULL) { 241 smb_tree_log(sr, tcon->path, "invalid UNC path"); 242 return (NT_STATUS_BAD_NETWORK_NAME); 243 } 244 245 si = smb_kshare_lookup(sr->sr_server, name); 246 if (si == NULL) { 247 smb_tree_log(sr, name, "share not found"); 248 return (NT_STATUS_BAD_NETWORK_NAME); 249 } 250 251 if (!strcasecmp(SMB_SHARE_PRINT, name)) { 252 smb_kshare_release(sr->sr_server, si); 253 smb_tree_log(sr, name, "access not permitted"); 254 return (NT_STATUS_ACCESS_DENIED); 255 } 256 257 /* NB: name points into tcon->path - don't free it. */ 258 tcon->name = name; 259 sr->sr_tcon.si = si; 260 261 /* 262 * [MS-SMB2] 3.3.5.7 Receiving an SMB2 TREE_CONNECT Request 263 * 264 * If we support 3.x, RejectUnencryptedAccess is TRUE, 265 * if Tcon.EncryptData is TRUE or global EncryptData is TRUE, 266 * and the connection doesn't support encryption, 267 * return ACCESS_DENIED. 268 * 269 * If RejectUnencryptedAccess is TRUE, we force max_protocol 270 * to at least 3.0. Additionally, if the tree requires encryption, 271 * we don't care what we support, we still enforce encryption. 272 */ 273 if ((sr->sr_server->sv_cfg.skc_encrypt == SMB_CONFIG_REQUIRED || 274 si->shr_encrypt == SMB_CONFIG_REQUIRED) && 275 (sr->session->srv_cap & SMB2_CAP_ENCRYPTION) == 0) { 276 status = NT_STATUS_ACCESS_DENIED; 277 goto out; 278 } 279 280 switch (si->shr_type & STYPE_MASK) { 281 case STYPE_DISKTREE: 282 status = smb_tree_connect_disk(sr, &sr->sr_tcon); 283 break; 284 case STYPE_IPC: 285 status = smb_tree_connect_ipc(sr, &sr->sr_tcon); 286 break; 287 case STYPE_PRINTQ: 288 status = smb_tree_connect_printq(sr, &sr->sr_tcon); 289 break; 290 default: 291 status = NT_STATUS_BAD_DEVICE_TYPE; 292 break; 293 } 294 295 out: 296 smb_kshare_release(sr->sr_server, si); 297 sr->sr_tcon.si = NULL; 298 299 return (status); 300 } 301 302 /* 303 * Disconnect a tree. 304 * 305 * The "do_exec" arg is obsolete and ignored. 306 */ 307 void 308 smb_tree_disconnect(smb_tree_t *tree, boolean_t do_exec) 309 { 310 _NOTE(ARGUNUSED(do_exec)) 311 smb_shr_execinfo_t execinfo; 312 313 ASSERT(tree->t_magic == SMB_TREE_MAGIC); 314 315 mutex_enter(&tree->t_mutex); 316 ASSERT(tree->t_refcnt); 317 318 if (!smb_tree_is_connected_locked(tree)) { 319 mutex_exit(&tree->t_mutex); 320 return; 321 } 322 323 /* 324 * Indicate that the disconnect process has started. 325 */ 326 tree->t_state = SMB_TREE_STATE_DISCONNECTING; 327 mutex_exit(&tree->t_mutex); 328 329 /* 330 * The files opened under this tree are closed. 331 */ 332 smb_ofile_close_all(tree, 0); 333 /* 334 * The directories opened under this tree are closed. 335 */ 336 smb_tree_close_odirs(tree, 0); 337 338 if ((tree->t_execflags & SMB_EXEC_UNMAP) != 0) { 339 smb_tree_set_execinfo(tree, &execinfo, SMB_EXEC_UNMAP); 340 (void) smb_kshare_exec(tree->t_server, &execinfo); 341 } 342 } 343 344 /* 345 * Take a reference on a tree. 346 */ 347 boolean_t 348 smb_tree_hold( 349 smb_tree_t *tree) 350 { 351 SMB_TREE_VALID(tree); 352 353 mutex_enter(&tree->t_mutex); 354 355 if (smb_tree_is_connected_locked(tree)) { 356 tree->t_refcnt++; 357 mutex_exit(&tree->t_mutex); 358 return (B_TRUE); 359 } 360 361 mutex_exit(&tree->t_mutex); 362 return (B_FALSE); 363 } 364 365 /* 366 * Bump the hold count regardless of the tree state. This is used in 367 * some internal code paths where we've already checked that we had a 368 * valid tree connection, and don't want to deal with the possiblity 369 * that the tree state might have changed to disconnecting after our 370 * original hold was taken. It's correct to continue processing a 371 * request even when new requests cannot lookup that tree anymore. 372 */ 373 void 374 smb_tree_hold_internal( 375 smb_tree_t *tree) 376 { 377 SMB_TREE_VALID(tree); 378 379 mutex_enter(&tree->t_mutex); 380 tree->t_refcnt++; 381 mutex_exit(&tree->t_mutex); 382 } 383 384 /* 385 * Release a reference on a tree. If the tree is disconnected and the 386 * reference count falls to zero, post the object for deletion. 387 * Object deletion is deferred to avoid modifying a list while an 388 * iteration may be in progress. 389 */ 390 void 391 smb_tree_release( 392 smb_tree_t *tree) 393 { 394 SMB_TREE_VALID(tree); 395 396 /* flush the ofile and odir lists' delete queues */ 397 smb_lavl_flush(&tree->t_ofile_list); 398 smb_llist_flush(&tree->t_odir_list); 399 400 mutex_enter(&tree->t_mutex); 401 ASSERT(tree->t_refcnt); 402 tree->t_refcnt--; 403 404 switch (tree->t_state) { 405 case SMB_TREE_STATE_DISCONNECTING: 406 if (tree->t_refcnt == 0) { 407 smb_session_t *ssn = tree->t_session; 408 tree->t_state = SMB_TREE_STATE_DISCONNECTED; 409 smb_llist_post(&ssn->s_tree_list, tree, 410 smb_tree_dealloc); 411 } 412 break; 413 case SMB_TREE_STATE_CONNECTED: 414 break; 415 default: 416 ASSERT(0); 417 break; 418 } 419 420 mutex_exit(&tree->t_mutex); 421 } 422 423 /* 424 * Close ofiles and odirs that match pid. 425 */ 426 void 427 smb_tree_close_pid( 428 smb_tree_t *tree, 429 uint32_t pid) 430 { 431 ASSERT(tree); 432 ASSERT(tree->t_magic == SMB_TREE_MAGIC); 433 434 smb_ofile_close_all(tree, pid); 435 smb_tree_close_odirs(tree, pid); 436 } 437 438 /* 439 * Check whether or not a tree supports the features identified by flags. 440 */ 441 boolean_t 442 smb_tree_has_feature(smb_tree_t *tree, uint32_t flags) 443 { 444 ASSERT(tree); 445 ASSERT(tree->t_magic == SMB_TREE_MAGIC); 446 447 return ((tree->t_flags & flags) == flags); 448 } 449 450 /* 451 * If the enumeration request is for tree data, handle the request 452 * here. Otherwise, pass it on to the ofiles. 453 * 454 * This function should be called with a hold on the tree. 455 */ 456 int 457 smb_tree_enum(smb_tree_t *tree, smb_svcenum_t *svcenum) 458 { 459 smb_lavl_t *lavl; 460 smb_ofile_t *of; 461 int rc = 0; 462 463 if (svcenum->se_type == SMB_SVCENUM_TYPE_TREE) 464 return (smb_tree_enum_private(tree, svcenum)); 465 466 lavl = &tree->t_ofile_list; 467 smb_lavl_enter(lavl, RW_READER); 468 469 of = smb_lavl_first(lavl); 470 while (of) { 471 if (smb_ofile_hold(of)) { 472 rc = smb_ofile_enum(of, svcenum); 473 smb_ofile_release(of); 474 } 475 if (rc != 0) 476 break; 477 of = smb_lavl_next(lavl, of); 478 } 479 480 smb_lavl_exit(lavl); 481 482 return (rc); 483 } 484 485 /* 486 * Close a file by its unique id. 487 */ 488 int 489 smb_tree_fclose(smb_tree_t *tree, uint32_t uniqid) 490 { 491 smb_ofile_t *of; 492 493 ASSERT(tree); 494 ASSERT(tree->t_magic == SMB_TREE_MAGIC); 495 496 /* 497 * Note that ORPHANED ofiles aren't fclosable, as they have 498 * no session, user, or tree by which they might be found. 499 * They will eventually expire. 500 */ 501 if ((of = smb_ofile_lookup_by_uniqid(tree, uniqid)) == NULL) 502 return (ENOENT); 503 504 if (smb_ofile_disallow_fclose(of)) { 505 smb_ofile_release(of); 506 return (EACCES); 507 } 508 509 smb_ofile_close(of, 0); 510 smb_ofile_release(of); 511 return (0); 512 } 513 514 /* *************************** Static Functions ***************************** */ 515 516 #define SHARES_DIR ".zfs/shares/" 517 518 /* 519 * Calculates permissions given by the share's ACL to the 520 * user in the passed request. The default is full access. 521 * If any error occurs, full access is granted. 522 * 523 * Using the vnode of the share path find the root directory 524 * of the mounted file system. Then look to see if there is a 525 * .zfs/shares directory and if there is, lookup the file with 526 * the same name as the share name in it. The ACL set for this 527 * file is the share's ACL which is used for access check here. 528 */ 529 static uint32_t 530 smb_tree_acl_access(smb_request_t *sr, const smb_kshare_t *si, vnode_t *pathvp) 531 { 532 smb_user_t *user; 533 cred_t *cred; 534 int rc; 535 vfs_t *vfsp; 536 vnode_t *root = NULL; 537 vnode_t *sharevp = NULL; 538 char *sharepath; 539 struct pathname pnp; 540 size_t size; 541 uint32_t access; 542 543 user = sr->uid_user; 544 cred = user->u_cred; 545 access = ACE_ALL_PERMS; 546 547 if (si->shr_flags & SMB_SHRF_AUTOHOME) { 548 /* 549 * An autohome share owner gets full access to the share. 550 * Everyone else is denied access. 551 */ 552 if (si->shr_uid != crgetuid(cred)) 553 access = 0; 554 555 return (access); 556 } 557 558 /* 559 * The hold on 'root' is released by the lookuppnvp() that follows 560 */ 561 vfsp = pathvp->v_vfsp; 562 if (vfsp != NULL) 563 rc = VFS_ROOT(vfsp, &root); 564 else 565 rc = ENOENT; 566 567 if (rc != 0) 568 return (access); 569 570 571 size = sizeof (SHARES_DIR) + strlen(si->shr_name) + 1; 572 sharepath = smb_srm_alloc(sr, size); 573 (void) snprintf(sharepath, size, "%s%s", SHARES_DIR, si->shr_name); 574 575 pn_alloc(&pnp); 576 (void) pn_set(&pnp, sharepath); 577 rc = lookuppnvp(&pnp, NULL, NO_FOLLOW, NULL, &sharevp, rootdir, root, 578 zone_kcred()); 579 pn_free(&pnp); 580 581 /* 582 * Now get the effective access value based on cred and ACL values. 583 */ 584 if (rc == 0) { 585 smb_vop_eaccess(sharevp, (int *)&access, V_ACE_MASK, NULL, 586 cred); 587 VN_RELE(sharevp); 588 } 589 590 return (access); 591 } 592 593 /* 594 * Performs the following access checks for a disk share: 595 * 596 * - No IPC/anonymous user is allowed 597 * 598 * - If user is Guest, guestok property of the share should be 599 * enabled 600 * 601 * - If this is an Admin share, the user should have administrative 602 * privileges 603 * 604 * - Host based access control lists 605 * 606 * - Share ACL 607 * 608 * Returns the access allowed or 0 if access is denied. 609 */ 610 static uint32_t 611 smb_tree_chkaccess(smb_request_t *sr, smb_kshare_t *shr, vnode_t *vp) 612 { 613 smb_user_t *user = sr->uid_user; 614 char *sharename = shr->shr_name; 615 uint32_t host_access; 616 uint32_t acl_access; 617 uint32_t access; 618 619 if (user->u_flags & SMB_USER_FLAG_ANON) { 620 smb_tree_log(sr, sharename, "access denied: IPC only"); 621 return (0); 622 } 623 624 if ((user->u_flags & SMB_USER_FLAG_GUEST) && 625 ((shr->shr_flags & SMB_SHRF_GUEST_OK) == 0)) { 626 smb_tree_log(sr, sharename, "access denied: guest disabled"); 627 return (0); 628 } 629 630 if ((shr->shr_flags & SMB_SHRF_ADMIN) && !smb_user_is_admin(user)) { 631 smb_tree_log(sr, sharename, "access denied: not admin"); 632 return (0); 633 } 634 635 host_access = smb_kshare_hostaccess(shr, sr->session); 636 if ((host_access & ACE_ALL_PERMS) == 0) { 637 smb_tree_log(sr, sharename, "access denied: host access"); 638 return (0); 639 } 640 641 acl_access = smb_tree_acl_access(sr, shr, vp); 642 if ((acl_access & ACE_ALL_PERMS) == 0) { 643 smb_tree_log(sr, sharename, "access denied: share ACL"); 644 return (0); 645 } 646 647 access = host_access & acl_access; 648 if ((access & ACE_ALL_PERMS) == 0) { 649 smb_tree_log(sr, sharename, "access denied"); 650 return (0); 651 } 652 653 return (access); 654 } 655 656 /* How long should tree connect wait for DH import to complete? */ 657 int smb_tcon_import_wait = 20; /* sec. */ 658 659 /* 660 * Connect a share for use with files and directories. 661 */ 662 uint32_t 663 smb_tree_connect_disk(smb_request_t *sr, smb_arg_tcon_t *tcon) 664 { 665 char *sharename = tcon->path; 666 const char *any = "?????"; 667 smb_user_t *user = sr->uid_user; 668 smb_node_t *snode = NULL; 669 smb_kshare_t *si = tcon->si; 670 char *service = tcon->service; 671 smb_tree_t *tree; 672 int rc; 673 uint32_t access; 674 smb_shr_execinfo_t execinfo; 675 clock_t time; 676 677 ASSERT(user); 678 ASSERT(user->u_cred); 679 680 if (service != NULL && 681 strcmp(service, any) != 0 && 682 strcasecmp(service, "A:") != 0) { 683 smb_tree_log(sr, sharename, "invalid service (%s)", service); 684 return (NT_STATUS_BAD_DEVICE_TYPE); 685 } 686 687 /* 688 * Check that the shared directory exists. 689 */ 690 snode = si->shr_root_node; 691 if (snode == NULL) { 692 smb_tree_log(sr, sharename, "bad path: %s", si->shr_path); 693 return (NT_STATUS_BAD_NETWORK_NAME); 694 } 695 696 if ((access = smb_tree_chkaccess(sr, si, snode->vp)) == 0) { 697 return (NT_STATUS_ACCESS_DENIED); 698 } 699 700 /* 701 * Wait for DH import of persistent handles to finish. 702 * If we timeout, it's not clear what status to return, 703 * but as the share is not really available yet, let's 704 * return the status for "no such share". 705 */ 706 time = SEC_TO_TICK(smb_tcon_import_wait) + ddi_get_lbolt(); 707 mutex_enter(&si->shr_mutex); 708 while (si->shr_import_busy != NULL) { 709 if (cv_timedwait(&si->shr_cv, &si->shr_mutex, time) < 0) { 710 mutex_exit(&si->shr_mutex); 711 return (NT_STATUS_BAD_NETWORK_NAME); 712 } 713 } 714 mutex_exit(&si->shr_mutex); 715 716 /* 717 * Set up the OptionalSupport for this share. 718 */ 719 tcon->optional_support = SMB_SUPPORT_SEARCH_BITS; 720 721 switch (si->shr_flags & SMB_SHRF_CSC_MASK) { 722 case SMB_SHRF_CSC_DISABLED: 723 tcon->optional_support |= SMB_CSC_CACHE_NONE; 724 break; 725 case SMB_SHRF_CSC_AUTO: 726 tcon->optional_support |= SMB_CSC_CACHE_AUTO_REINT; 727 break; 728 case SMB_SHRF_CSC_VDO: 729 tcon->optional_support |= SMB_CSC_CACHE_VDO; 730 break; 731 case SMB_SHRF_CSC_MANUAL: 732 default: 733 /* 734 * Default to SMB_CSC_CACHE_MANUAL_REINT. 735 */ 736 break; 737 } 738 739 /* ABE support */ 740 if (si->shr_flags & SMB_SHRF_ABE) 741 tcon->optional_support |= 742 SHI1005_FLAGS_ACCESS_BASED_DIRECTORY_ENUM; 743 744 if (si->shr_flags & SMB_SHRF_DFSROOT) 745 tcon->optional_support |= SMB_SHARE_IS_IN_DFS; 746 747 tree = smb_tree_alloc(sr, si, snode, access, sr->sr_cfg->skc_execflags); 748 749 if (tree == NULL) 750 return (NT_STATUS_INSUFF_SERVER_RESOURCES); 751 752 if (tree->t_flags & SMB_TREE_SHORTNAMES) 753 tcon->optional_support |= SMB_UNIQUE_FILE_NAME; 754 755 if (tree->t_execflags & SMB_EXEC_MAP) { 756 smb_tree_set_execinfo(tree, &execinfo, SMB_EXEC_MAP); 757 758 rc = smb_kshare_exec(tree->t_server, &execinfo); 759 760 if ((rc != 0) && (tree->t_execflags & SMB_EXEC_TERM)) { 761 /* 762 * Inline parts of: smb_tree_disconnect() 763 * Not using smb_tree_disconnect() for cleanup 764 * here because: we don't want an exec up-call, 765 * and there can't be any opens as we never 766 * returned this TID to the client. 767 */ 768 mutex_enter(&tree->t_mutex); 769 tree->t_state = SMB_TREE_STATE_DISCONNECTING; 770 mutex_exit(&tree->t_mutex); 771 772 smb_tree_release(tree); 773 return (NT_STATUS_ACCESS_DENIED); 774 } 775 } 776 777 sr->tid_tree = tree; 778 sr->smb_tid = tree->t_tid; 779 780 return (0); 781 } 782 783 /* 784 * Shares have both a share and host based access control. The access 785 * granted will be minimum permissions based on both hostaccess 786 * (permissions allowed by host based access) and aclaccess (from the 787 * share ACL). 788 */ 789 uint32_t 790 smb_tree_connect_printq(smb_request_t *sr, smb_arg_tcon_t *tcon) 791 { 792 char *sharename = tcon->path; 793 const char *any = "?????"; 794 smb_user_t *user = sr->uid_user; 795 smb_node_t *dnode = NULL; 796 smb_node_t *snode = NULL; 797 smb_kshare_t *si = tcon->si; 798 char *service = tcon->service; 799 char last_component[MAXNAMELEN]; 800 smb_tree_t *tree; 801 int rc; 802 uint32_t access; 803 804 ASSERT(user); 805 ASSERT(user->u_cred); 806 807 if (sr->sr_server->sv_cfg.skc_print_enable == 0) { 808 smb_tree_log(sr, sharename, "printing disabled"); 809 return (NT_STATUS_BAD_NETWORK_NAME); 810 } 811 812 if (service != NULL && 813 strcmp(service, any) != 0 && 814 strcasecmp(service, "LPT1:") != 0) { 815 smb_tree_log(sr, sharename, "invalid service (%s)", service); 816 return (NT_STATUS_BAD_DEVICE_TYPE); 817 } 818 819 /* 820 * Check that the shared directory exists. 821 */ 822 rc = smb_pathname_reduce(sr, user->u_cred, si->shr_path, 0, 0, &dnode, 823 last_component); 824 if (rc == 0) { 825 rc = smb_fsop_lookup(sr, user->u_cred, SMB_FOLLOW_LINKS, 826 sr->sr_server->si_root_smb_node, dnode, last_component, 827 &snode); 828 829 smb_node_release(dnode); 830 } 831 832 if (rc) { 833 if (snode) 834 smb_node_release(snode); 835 836 smb_tree_log(sr, sharename, "bad path: %s", si->shr_path); 837 return (NT_STATUS_BAD_NETWORK_NAME); 838 } 839 840 if ((access = smb_tree_chkaccess(sr, si, snode->vp)) == 0) { 841 smb_node_release(snode); 842 return (NT_STATUS_ACCESS_DENIED); 843 } 844 845 tcon->optional_support = SMB_SUPPORT_SEARCH_BITS; 846 847 tree = smb_tree_alloc(sr, si, snode, access, sr->sr_cfg->skc_execflags); 848 849 smb_node_release(snode); 850 851 if (tree == NULL) 852 return (NT_STATUS_INSUFF_SERVER_RESOURCES); 853 854 sr->tid_tree = tree; 855 sr->smb_tid = tree->t_tid; 856 857 return (0); 858 } 859 860 /* 861 * Connect an IPC share for use with named pipes. 862 */ 863 uint32_t 864 smb_tree_connect_ipc(smb_request_t *sr, smb_arg_tcon_t *tcon) 865 { 866 char *name = tcon->path; 867 const char *any = "?????"; 868 smb_user_t *user = sr->uid_user; 869 smb_tree_t *tree; 870 smb_kshare_t *si = tcon->si; 871 char *service = tcon->service; 872 873 ASSERT(user); 874 875 if (service != NULL && 876 strcmp(service, any) != 0 && 877 strcasecmp(service, "IPC") != 0) { 878 smb_tree_log(sr, name, "invalid service (%s)", service); 879 return (NT_STATUS_BAD_DEVICE_TYPE); 880 } 881 882 if ((user->u_flags & SMB_USER_FLAG_ANON) && 883 sr->sr_cfg->skc_restrict_anon) { 884 smb_tree_log(sr, name, "access denied: restrict anonymous"); 885 return (NT_STATUS_ACCESS_DENIED); 886 } 887 888 tcon->optional_support = SMB_SUPPORT_SEARCH_BITS; 889 890 tree = smb_tree_alloc(sr, si, NULL, ACE_ALL_PERMS, 0); 891 if (tree == NULL) 892 return (NT_STATUS_INSUFF_SERVER_RESOURCES); 893 894 sr->tid_tree = tree; 895 sr->smb_tid = tree->t_tid; 896 897 return (0); 898 } 899 900 /* 901 * Allocate a tree. 902 */ 903 smb_tree_t * 904 smb_tree_alloc(smb_request_t *sr, const smb_kshare_t *si, 905 smb_node_t *snode, uint32_t access, uint32_t execflags) 906 { 907 smb_session_t *session = sr->session; 908 smb_tree_t *tree; 909 uint32_t stype = si->shr_type; 910 uint16_t tid; 911 912 if (smb_idpool_alloc(&session->s_tid_pool, &tid)) 913 return (NULL); 914 915 tree = kmem_cache_alloc(smb_cache_tree, KM_SLEEP); 916 bzero(tree, sizeof (smb_tree_t)); 917 918 tree->t_session = session; 919 tree->t_server = session->s_server; 920 921 if (STYPE_ISDSK(stype) || STYPE_ISPRN(stype)) { 922 if (smb_tree_getattr(si, snode, tree) != 0) { 923 smb_idpool_free(&session->s_tid_pool, tid); 924 kmem_cache_free(smb_cache_tree, tree); 925 return (NULL); 926 } 927 } 928 929 if (smb_idpool_constructor(&tree->t_fid_pool)) { 930 smb_idpool_free(&session->s_tid_pool, tid); 931 kmem_cache_free(smb_cache_tree, tree); 932 return (NULL); 933 } 934 935 if (smb_idpool_constructor(&tree->t_odid_pool)) { 936 smb_idpool_destructor(&tree->t_fid_pool); 937 smb_idpool_free(&session->s_tid_pool, tid); 938 kmem_cache_free(smb_cache_tree, tree); 939 return (NULL); 940 } 941 942 smb_lavl_constructor(&tree->t_ofile_list, 943 smb_ofile_avl_compare, sizeof (smb_ofile_t), 944 offsetof(smb_ofile_t, f_tree_lnd)); 945 946 smb_llist_constructor(&tree->t_odir_list, sizeof (smb_odir_t), 947 offsetof(smb_odir_t, d_lnd)); 948 949 (void) strlcpy(tree->t_sharename, si->shr_name, 950 sizeof (tree->t_sharename)); 951 (void) strlcpy(tree->t_resource, si->shr_path, 952 sizeof (tree->t_resource)); 953 954 mutex_init(&tree->t_mutex, NULL, MUTEX_DEFAULT, NULL); 955 956 tree->t_refcnt = 1; 957 tree->t_tid = tid; 958 tree->t_res_type = stype; 959 tree->t_state = SMB_TREE_STATE_CONNECTED; 960 tree->t_magic = SMB_TREE_MAGIC; 961 tree->t_access = access; 962 tree->t_connect_time = gethrestime_sec(); 963 tree->t_execflags = execflags; 964 965 /* grab a ref for tree->t_owner */ 966 smb_user_hold_internal(sr->uid_user); 967 smb_user_inc_trees(sr->uid_user); 968 tree->t_owner = sr->uid_user; 969 970 /* if FS is readonly, enforce that here */ 971 if (tree->t_flags & SMB_TREE_READONLY) 972 tree->t_access &= ~ACE_ALL_WRITE_PERMS; 973 974 if (STYPE_ISDSK(stype) || STYPE_ISPRN(stype)) { 975 smb_node_ref(snode); 976 tree->t_snode = snode; 977 tree->t_acltype = smb_fsop_acltype(snode); 978 } 979 980 smb_llist_enter(&session->s_tree_list, RW_WRITER); 981 smb_llist_insert_head(&session->s_tree_list, tree); 982 smb_llist_exit(&session->s_tree_list); 983 atomic_inc_32(&session->s_tree_cnt); 984 smb_server_inc_trees(session->s_server); 985 return (tree); 986 } 987 988 /* 989 * Deallocate a tree. The open file and open directory lists should be 990 * empty. 991 * 992 * Remove the tree from the user's tree list before freeing resources 993 * associated with the tree. 994 */ 995 static void 996 smb_tree_dealloc(void *arg) 997 { 998 smb_session_t *session; 999 smb_tree_t *tree = (smb_tree_t *)arg; 1000 1001 SMB_TREE_VALID(tree); 1002 ASSERT(tree->t_state == SMB_TREE_STATE_DISCONNECTED); 1003 ASSERT(tree->t_refcnt == 0); 1004 1005 smb_server_dec_trees(tree->t_server); 1006 1007 session = tree->t_session; 1008 smb_llist_enter(&session->s_tree_list, RW_WRITER); 1009 smb_llist_remove(&session->s_tree_list, tree); 1010 smb_idpool_free(&session->s_tid_pool, tree->t_tid); 1011 atomic_dec_32(&session->s_tree_cnt); 1012 smb_llist_exit(&session->s_tree_list); 1013 1014 /* 1015 * This tree is no longer on s_tree_list, however... 1016 * 1017 * This is called via smb_llist_post, which means it may run 1018 * BEFORE smb_tree_release drops t_mutex (if another thread 1019 * flushes the delete queue before we do). Synchronize. 1020 */ 1021 mutex_enter(&tree->t_mutex); 1022 mutex_exit(&tree->t_mutex); 1023 1024 tree->t_magic = (uint32_t)~SMB_TREE_MAGIC; 1025 1026 if (tree->t_snode) 1027 smb_node_release(tree->t_snode); 1028 1029 mutex_destroy(&tree->t_mutex); 1030 smb_lavl_destructor(&tree->t_ofile_list); 1031 smb_llist_destructor(&tree->t_odir_list); 1032 smb_idpool_destructor(&tree->t_fid_pool); 1033 smb_idpool_destructor(&tree->t_odid_pool); 1034 1035 SMB_USER_VALID(tree->t_owner); 1036 smb_user_dec_trees(tree->t_owner); 1037 smb_user_release(tree->t_owner); 1038 1039 kmem_cache_free(smb_cache_tree, tree); 1040 } 1041 1042 /* 1043 * Determine whether or not a tree is connected. 1044 * This function must be called with the tree mutex held. 1045 */ 1046 static boolean_t 1047 smb_tree_is_connected_locked(smb_tree_t *tree) 1048 { 1049 switch (tree->t_state) { 1050 case SMB_TREE_STATE_CONNECTED: 1051 return (B_TRUE); 1052 1053 case SMB_TREE_STATE_DISCONNECTING: 1054 case SMB_TREE_STATE_DISCONNECTED: 1055 /* 1056 * The tree exists but is being disconnected or destroyed. 1057 */ 1058 return (B_FALSE); 1059 1060 default: 1061 ASSERT(0); 1062 return (B_FALSE); 1063 } 1064 } 1065 1066 /* 1067 * Return a pointer to the share name within a share resource path. 1068 * 1069 * The share path may be a Uniform Naming Convention (UNC) string 1070 * (\\server\share) or simply the share name. We validate the UNC 1071 * format but we don't look at the server name. 1072 */ 1073 static char * 1074 smb_tree_get_sharename(char *unc_path) 1075 { 1076 char *sharename = unc_path; 1077 1078 if (sharename[0] == '\\') { 1079 /* 1080 * Looks like a UNC path, validate the format. 1081 */ 1082 if (sharename[1] != '\\') 1083 return (NULL); 1084 1085 if ((sharename = strchr(sharename+2, '\\')) == NULL) 1086 return (NULL); 1087 1088 ++sharename; 1089 } else if (strchr(sharename, '\\') != NULL) { 1090 /* 1091 * This should be a share name (no embedded \'s). 1092 */ 1093 return (NULL); 1094 } 1095 1096 return (sharename); 1097 } 1098 1099 /* 1100 * Obtain the tree attributes: volume name, typename and flags. 1101 * Called only with DISK and PRINTQ shares. 1102 */ 1103 static int 1104 smb_tree_getattr(const smb_kshare_t *si, smb_node_t *node, smb_tree_t *tree) 1105 { 1106 vfs_t *vfsp = SMB_NODE_VFS(node); 1107 vfs_t *realvfsp; 1108 1109 ASSERT(vfsp); 1110 1111 smb_tree_get_creation(node, tree); 1112 smb_tree_get_volname(vfsp, tree); 1113 1114 /* 1115 * In the case of an lofs mount, we need to ask the (real) 1116 * underlying filesystem about capabilities, where the 1117 * passed in vfs_t will be from lofs. 1118 */ 1119 realvfsp = getvfs(&vfsp->vfs_fsid); 1120 if (realvfsp != NULL) { 1121 smb_tree_get_flags(si, realvfsp, tree); 1122 VFS_RELE(realvfsp); 1123 } else { 1124 cmn_err(CE_NOTE, "Failed getting info for share: %s", 1125 si->shr_name); 1126 /* do the best we can without realvfsp */ 1127 smb_tree_get_flags(si, vfsp, tree); 1128 } 1129 1130 if (tree->t_session->dialect >= SMB_VERS_3_0) 1131 tree->t_encrypt = si->shr_encrypt; 1132 else 1133 tree->t_encrypt = SMB_CONFIG_DISABLED; 1134 1135 return (0); 1136 } 1137 1138 /* 1139 * File volume creation time 1140 */ 1141 static void 1142 smb_tree_get_creation(smb_node_t *node, smb_tree_t *tree) 1143 { 1144 smb_attr_t attr; 1145 cred_t *kcr = zone_kcred(); 1146 1147 bzero(&attr, sizeof (attr)); 1148 attr.sa_mask = SMB_AT_CRTIME; 1149 (void) smb_node_getattr(NULL, node, kcr, NULL, &attr); 1150 /* On failure we'll have time zero, which is OK */ 1151 1152 tree->t_create_time = attr.sa_crtime; 1153 } 1154 1155 /* 1156 * Extract the volume name. 1157 */ 1158 static void 1159 smb_tree_get_volname(vfs_t *vfsp, smb_tree_t *tree) 1160 { 1161 #ifdef _FAKE_KERNEL 1162 _NOTE(ARGUNUSED(vfsp)) 1163 (void) strlcpy(tree->t_volume, "fake", SMB_VOLNAMELEN); 1164 #else /* _FAKE_KERNEL */ 1165 refstr_t *vfs_mntpoint; 1166 const char *s; 1167 char *name; 1168 1169 vfs_mntpoint = vfs_getmntpoint(vfsp); 1170 1171 s = refstr_value(vfs_mntpoint); 1172 s += strspn(s, "/"); 1173 (void) strlcpy(tree->t_volume, s, SMB_VOLNAMELEN); 1174 1175 refstr_rele(vfs_mntpoint); 1176 1177 name = tree->t_volume; 1178 (void) strsep((char **)&name, "/"); 1179 #endif /* _FAKE_KERNEL */ 1180 } 1181 1182 /* 1183 * Get flags from the VFS (and other places) for a new tree. 1184 * Called only with DISK and PRINTQ shares. 1185 * 1186 * Always set "unicode on disk" because we always use utf8 names locally. 1187 * Always set ACL support because the VFS will fake ACLs for file systems 1188 * that don't support them. 1189 * 1190 * Some flags are dependent on the typename, which is also set up here. 1191 * File system types are hardcoded in uts/common/os/vfs_conf.c. 1192 */ 1193 static void 1194 smb_tree_get_flags(const smb_kshare_t *si, vfs_t *vfsp, smb_tree_t *tree) 1195 { 1196 smb_session_t *ssn = tree->t_session; 1197 struct vfssw *vswp; 1198 1199 typedef struct smb_mtype { 1200 char *mt_name; 1201 size_t mt_namelen; 1202 uint32_t mt_flags; 1203 } smb_mtype_t; 1204 1205 static smb_mtype_t smb_mtype[] = { 1206 #ifdef _FAKE_KERNEL 1207 /* See libfksmbsrv:fake_vfs.c */ 1208 { "fake", 3, SMB_TREE_SPARSE}, 1209 #endif /* _FAKE_KERNEL */ 1210 { "zfs", 3, SMB_TREE_QUOTA | SMB_TREE_SPARSE}, 1211 { "ufs", 3, 0 }, 1212 { "nfs", 3, SMB_TREE_NFS_MOUNTED }, 1213 { "tmpfs", 5, SMB_TREE_NO_EXPORT } 1214 }; 1215 smb_mtype_t *mtype; 1216 char *name; 1217 uint32_t flags = 1218 SMB_TREE_SUPPORTS_ACLS | 1219 SMB_TREE_UNICODE_ON_DISK; 1220 int i; 1221 1222 if (si->shr_flags & SMB_SHRF_DFSROOT) 1223 flags |= SMB_TREE_DFSROOT; 1224 1225 if (si->shr_flags & SMB_SHRF_CATIA) 1226 flags |= SMB_TREE_CATIA; 1227 1228 if (si->shr_flags & SMB_SHRF_ABE) 1229 flags |= SMB_TREE_ABE; 1230 1231 if (si->shr_flags & SMB_SHRF_CA) 1232 flags |= SMB_TREE_CA; 1233 1234 if (si->shr_flags & SMB_SHRF_FSO) 1235 flags |= SMB_TREE_FORCE_L2_OPLOCK; 1236 1237 if (ssn->s_cfg.skc_oplock_enable) 1238 flags |= SMB_TREE_OPLOCKS; 1239 1240 if (ssn->s_cfg.skc_traverse_mounts) 1241 flags |= SMB_TREE_TRAVERSE_MOUNTS; 1242 1243 if (ssn->s_cfg.skc_short_names) 1244 flags |= SMB_TREE_SHORTNAMES; 1245 1246 if (vfsp->vfs_flag & VFS_RDONLY) 1247 flags |= SMB_TREE_READONLY; 1248 1249 if (vfsp->vfs_flag & VFS_XATTR) 1250 flags |= SMB_TREE_STREAMS; 1251 1252 vswp = vfs_getvfsswbyvfsops(vfs_getops(vfsp)); 1253 if (vswp != NULL) { 1254 name = vswp->vsw_name; 1255 vfs_unrefvfssw(vswp); 1256 } else { 1257 name = "?"; 1258 } 1259 1260 for (i = 0; i < sizeof (smb_mtype) / sizeof (smb_mtype[0]); ++i) { 1261 mtype = &smb_mtype[i]; 1262 if (strncasecmp(name, mtype->mt_name, mtype->mt_namelen) == 0) 1263 flags |= mtype->mt_flags; 1264 } 1265 1266 /* 1267 * SMB_TREE_QUOTA will be on here if the FS is ZFS. We want to 1268 * turn it OFF when the share property says false. 1269 */ 1270 if ((si->shr_flags & SMB_SHRF_QUOTAS) == 0) 1271 flags &= ~SMB_TREE_QUOTA; 1272 1273 (void) strlcpy(tree->t_typename, name, SMB_TYPENAMELEN); 1274 (void) smb_strupr((char *)tree->t_typename); 1275 1276 if (vfs_has_feature(vfsp, VFSFT_XVATTR)) 1277 flags |= SMB_TREE_XVATTR; 1278 1279 if (vfs_has_feature(vfsp, VFSFT_CASEINSENSITIVE)) 1280 flags |= SMB_TREE_CASEINSENSITIVE; 1281 1282 if (vfs_has_feature(vfsp, VFSFT_NOCASESENSITIVE)) 1283 flags |= SMB_TREE_NO_CASESENSITIVE; 1284 1285 if (vfs_has_feature(vfsp, VFSFT_DIRENTFLAGS)) 1286 flags |= SMB_TREE_DIRENTFLAGS; 1287 1288 if (vfs_has_feature(vfsp, VFSFT_ACLONCREATE)) 1289 flags |= SMB_TREE_ACLONCREATE; 1290 1291 if (vfs_has_feature(vfsp, VFSFT_ACEMASKONACCESS)) 1292 flags |= SMB_TREE_ACEMASKONACCESS; 1293 1294 DTRACE_PROBE2(smb__tree__flags, uint32_t, flags, char *, name); 1295 1296 1297 tree->t_flags = flags; 1298 } 1299 1300 /* 1301 * Report share access result to syslog. 1302 */ 1303 static void 1304 smb_tree_log(smb_request_t *sr, const char *sharename, const char *fmt, ...) 1305 { 1306 va_list ap; 1307 char buf[128]; 1308 smb_user_t *user = sr->uid_user; 1309 1310 ASSERT(user); 1311 1312 if (smb_tcon_mute) 1313 return; 1314 1315 if ((user->u_name) && (strcasecmp(sharename, "IPC$") == 0)) { 1316 /* 1317 * Only report normal users, i.e. ignore W2K misuse 1318 * of the IPC connection by filtering out internal 1319 * names such as nobody and root. 1320 */ 1321 if ((strcmp(user->u_name, "root") == 0) || 1322 (strcmp(user->u_name, "nobody") == 0)) { 1323 return; 1324 } 1325 } 1326 1327 va_start(ap, fmt); 1328 (void) vsnprintf(buf, 128, fmt, ap); 1329 va_end(ap); 1330 1331 cmn_err(CE_NOTE, "smbd[%s\\%s]: %s %s", 1332 user->u_domain, user->u_name, sharename, buf); 1333 } 1334 1335 /* 1336 * smb_tree_lookup_odir 1337 * 1338 * Find the specified odir in the tree's list of odirs, and 1339 * attempt to obtain a hold on the odir. 1340 * 1341 * Returns NULL if odir not found or a hold cannot be obtained. 1342 */ 1343 smb_odir_t * 1344 smb_tree_lookup_odir(smb_request_t *sr, uint16_t odid) 1345 { 1346 smb_odir_t *od; 1347 smb_llist_t *od_list; 1348 smb_tree_t *tree = sr->tid_tree; 1349 1350 ASSERT(tree->t_magic == SMB_TREE_MAGIC); 1351 1352 od_list = &tree->t_odir_list; 1353 1354 smb_llist_enter(od_list, RW_READER); 1355 od = smb_llist_head(od_list); 1356 while (od) { 1357 if (od->d_odid == odid) 1358 break; 1359 od = smb_llist_next(od_list, od); 1360 } 1361 if (od == NULL) 1362 goto out; 1363 1364 /* 1365 * Only allow use of a given Search ID with the same UID that 1366 * was used to create it. MS-CIFS 3.3.5.14 1367 */ 1368 if (od->d_user != sr->uid_user) { 1369 od = NULL; 1370 goto out; 1371 } 1372 if (!smb_odir_hold(od)) 1373 od = NULL; 1374 1375 out: 1376 smb_llist_exit(od_list); 1377 return (od); 1378 } 1379 1380 boolean_t 1381 smb_tree_is_connected(smb_tree_t *tree) 1382 { 1383 boolean_t rb; 1384 1385 mutex_enter(&tree->t_mutex); 1386 rb = smb_tree_is_connected_locked(tree); 1387 mutex_exit(&tree->t_mutex); 1388 return (rb); 1389 } 1390 1391 /* 1392 * smb_tree_close_odirs 1393 * 1394 * Close all open odirs in the tree's list which were opened by 1395 * the process identified by pid. 1396 * If pid is zero, close all open odirs in the tree's list. 1397 */ 1398 static void 1399 smb_tree_close_odirs(smb_tree_t *tree, uint32_t pid) 1400 { 1401 smb_llist_t *od_list; 1402 smb_odir_t *od; 1403 1404 ASSERT(tree); 1405 ASSERT(tree->t_magic == SMB_TREE_MAGIC); 1406 1407 od_list = &tree->t_odir_list; 1408 smb_llist_enter(od_list, RW_READER); 1409 1410 for (od = smb_llist_head(od_list); 1411 od != NULL; 1412 od = smb_llist_next(od_list, od)) { 1413 1414 ASSERT(od->d_magic == SMB_ODIR_MAGIC); 1415 ASSERT(od->d_tree == tree); 1416 1417 if (pid != 0 && od->d_opened_by_pid != pid) 1418 continue; 1419 1420 if (smb_odir_hold(od)) { 1421 smb_odir_close(od); 1422 smb_odir_release(od); 1423 } 1424 } 1425 1426 smb_llist_exit(od_list); 1427 } 1428 1429 static void 1430 smb_tree_set_execinfo(smb_tree_t *tree, smb_shr_execinfo_t *exec, 1431 int exec_type) 1432 { 1433 exec->e_sharename = tree->t_sharename; 1434 exec->e_winname = tree->t_owner->u_name; 1435 exec->e_userdom = tree->t_owner->u_domain; 1436 exec->e_srv_ipaddr = tree->t_session->local_ipaddr; 1437 exec->e_cli_ipaddr = tree->t_session->ipaddr; 1438 exec->e_cli_netbiosname = tree->t_session->workstation; 1439 exec->e_uid = crgetuid(tree->t_owner->u_cred); 1440 exec->e_type = exec_type; 1441 } 1442 1443 /* 1444 * Private function to support smb_tree_enum. 1445 */ 1446 static int 1447 smb_tree_enum_private(smb_tree_t *tree, smb_svcenum_t *svcenum) 1448 { 1449 uint8_t *pb; 1450 uint_t nbytes; 1451 int rc; 1452 1453 if (svcenum->se_nskip > 0) { 1454 svcenum->se_nskip--; 1455 return (0); 1456 } 1457 1458 if (svcenum->se_nitems >= svcenum->se_nlimit) { 1459 svcenum->se_nitems = svcenum->se_nlimit; 1460 return (0); 1461 } 1462 1463 pb = &svcenum->se_buf[svcenum->se_bused]; 1464 rc = smb_tree_netinfo_encode(tree, pb, svcenum->se_bavail, &nbytes); 1465 if (rc == 0) { 1466 svcenum->se_bavail -= nbytes; 1467 svcenum->se_bused += nbytes; 1468 svcenum->se_nitems++; 1469 } 1470 1471 return (rc); 1472 } 1473 1474 /* 1475 * Encode connection information into a buffer: connection information 1476 * needed in user space to support RPC requests. 1477 */ 1478 static int 1479 smb_tree_netinfo_encode(smb_tree_t *tree, uint8_t *buf, size_t buflen, 1480 uint32_t *nbytes) 1481 { 1482 smb_netconnectinfo_t info; 1483 int rc; 1484 1485 smb_tree_netinfo_init(tree, &info); 1486 rc = smb_netconnectinfo_encode(&info, buf, buflen, nbytes); 1487 smb_tree_netinfo_fini(&info); 1488 1489 return (rc); 1490 } 1491 1492 static void 1493 smb_tree_netinfo_username(smb_tree_t *tree, char **namestr, uint32_t *namelen) 1494 { 1495 smb_user_t *user = tree->t_owner; 1496 1497 /* 1498 * u_domain_len and u_name_len include the '\0' in their 1499 * lengths, hence the sum of the two lengths gives us room 1500 * for both the '\\' and '\0' chars. 1501 */ 1502 ASSERT(namestr); 1503 ASSERT(namelen); 1504 ASSERT(user->u_domain_len > 0); 1505 ASSERT(user->u_name_len > 0); 1506 *namelen = user->u_domain_len + user->u_name_len; 1507 *namestr = kmem_alloc(*namelen, KM_SLEEP); 1508 (void) snprintf(*namestr, *namelen, "%s\\%s", user->u_domain, 1509 user->u_name); 1510 } 1511 1512 /* 1513 * Note: ci_numusers should be the number of users connected to 1514 * the share rather than the number of references on the tree but 1515 * we don't have a mechanism to track users/share in smbsrv yet. 1516 */ 1517 static void 1518 smb_tree_netinfo_init(smb_tree_t *tree, smb_netconnectinfo_t *info) 1519 { 1520 ASSERT(tree); 1521 1522 info->ci_id = tree->t_tid; 1523 info->ci_type = tree->t_res_type; 1524 info->ci_numopens = tree->t_open_files; 1525 info->ci_numusers = tree->t_refcnt; 1526 info->ci_time = gethrestime_sec() - tree->t_connect_time; 1527 1528 info->ci_sharelen = strlen(tree->t_sharename) + 1; 1529 info->ci_share = smb_mem_strdup(tree->t_sharename); 1530 1531 smb_tree_netinfo_username(tree, &info->ci_username, &info->ci_namelen); 1532 } 1533 1534 static void 1535 smb_tree_netinfo_fini(smb_netconnectinfo_t *info) 1536 { 1537 if (info == NULL) 1538 return; 1539 1540 if (info->ci_username) 1541 kmem_free(info->ci_username, info->ci_namelen); 1542 if (info->ci_share) 1543 smb_mem_free(info->ci_share); 1544 1545 bzero(info, sizeof (smb_netconnectinfo_t)); 1546 } 1547