static smb_tree_t * smb_tree_connect_disk(smb_request_t *sr, const char *sharename) { smb_user_t *user = sr->uid_user; smb_node_t *dnode = NULL; smb_node_t *snode = NULL; char last_component[MAXNAMELEN]; smb_tree_t *tree; smb_share_t *si; cred_t *u_cred; int rc; uint32_t access = 0; /* read/write is assumed */ uint32_t hostaccess = ACE_ALL_PERMS; uint32_t aclaccess; smb_execsub_info_t subs; ASSERT(user); u_cred = user->u_cred; ASSERT(u_cred); if (user->u_flags & SMB_USER_FLAG_IPC) { smb_tree_log(sr, sharename, "access denied: IPC only"); smbsr_error(sr, NT_STATUS_ACCESS_DENIED, ERRSRV, ERRaccess); return (NULL); } si = kmem_zalloc(sizeof (smb_share_t), KM_SLEEP); if (smb_kshare_getinfo(sr->sr_server->sv_lmshrd, (char *)sharename, si, &sr->session->ipaddr) != NERR_Success) { smb_tree_log(sr, sharename, "share not found"); smbsr_error(sr, 0, ERRSRV, ERRinvnetname); kmem_free(si, sizeof (smb_share_t)); return (NULL); } if (user->u_flags & SMB_USER_FLAG_GUEST) { if ((si->shr_flags & SMB_SHRF_GUEST_OK) == 0) { smb_tree_log(sr, sharename, "access denied: guest disabled"); smbsr_error(sr, NT_STATUS_ACCESS_DENIED, ERRSRV, ERRaccess); kmem_free(si, sizeof (smb_share_t)); return (NULL); } } /* * Handle the default administration shares: C$, D$ etc. * Only a user with admin rights is allowed to map these * shares. */ if (si->shr_flags & SMB_SHRF_ADMIN) { if (!smb_user_is_admin(user)) { smb_tree_log(sr, sharename, "access denied: not admin"); smbsr_error(sr, NT_STATUS_ACCESS_DENIED, ERRSRV, ERRaccess); kmem_free(si, sizeof (smb_share_t)); return (NULL); } } /* * Set up the OptionalSupport for this share. */ sr->arg.tcon.optional_support = SMB_SUPPORT_SEARCH_BITS; switch (si->shr_flags & SMB_SHRF_CSC_MASK) { case SMB_SHRF_CSC_DISABLED: sr->arg.tcon.optional_support |= SMB_CSC_CACHE_NONE; break; case SMB_SHRF_CSC_AUTO: sr->arg.tcon.optional_support |= SMB_CSC_CACHE_AUTO_REINT; break; case SMB_SHRF_CSC_VDO: sr->arg.tcon.optional_support |= SMB_CSC_CACHE_VDO; break; case SMB_SHRF_CSC_MANUAL: default: /* * Default to SMB_CSC_CACHE_MANUAL_REINT. */ break; } /* ABE support */ if (si->shr_flags & SMB_SHRF_ABE) sr->arg.tcon.optional_support |= SHI1005_FLAGS_ACCESS_BASED_DIRECTORY_ENUM; access = si->shr_access_value & SMB_SHRF_ACC_ALL; if (access == SMB_SHRF_ACC_RO) { hostaccess &= ~ACE_ALL_WRITE_PERMS; } else if (access == SMB_SHRF_ACC_NONE) { kmem_free(si, sizeof (smb_share_t)); smb_tree_log(sr, sharename, "access denied: host access"); smbsr_error(sr, NT_STATUS_ACCESS_DENIED, ERRSRV, ERRaccess); return (NULL); } /* * Check that the shared directory exists. */ rc = smb_pathname_reduce(sr, u_cred, si->shr_path, 0, 0, &dnode, last_component); if (rc == 0) { rc = smb_fsop_lookup(sr, u_cred, SMB_FOLLOW_LINKS, sr->sr_server->si_root_smb_node, dnode, last_component, &snode); smb_node_release(dnode); } if (rc) { if (snode) smb_node_release(snode); smb_tree_log(sr, sharename, "bad path: %s", si->shr_path); smbsr_error(sr, 0, ERRSRV, ERRinvnetname); kmem_free(si, sizeof (smb_share_t)); return (NULL); } /* * Find share level ACL if it exists in the designated * location. Needs to be done after finding a valid path but * before the tree is allocated. */ smb_tree_acl_access(u_cred, sharename, snode->vp, &aclaccess); if ((aclaccess & ACE_ALL_PERMS) == 0) { smb_tree_log(sr, sharename, "access denied: share ACL"); smbsr_error(sr, 0, ERRSRV, ERRaccess); kmem_free(si, sizeof (smb_share_t)); smb_node_release(snode); return (NULL); } /* * Set tree ACL access to the minimum ACL permissions based on * hostaccess (those allowed by host based access) and * aclaccess (those from the ACL object for the share). This * is done during the alloc. */ (void) strlcpy(si->shr_name, sharename, MAXNAMELEN); tree = smb_tree_alloc(user, si, STYPE_DISKTREE, snode, hostaccess & aclaccess); smb_node_release(snode); if (tree == NULL) smbsr_error(sr, NT_STATUS_ACCESS_DENIED, ERRSRV, ERRaccess); else { tree->t_shr_flags = si->shr_flags; if (tree->t_shr_flags & SMB_SHRF_MAP) { (void) smb_tree_set_execsub_info(tree, &subs); rc = smb_kshare_exec(sr->sr_server->sv_lmshrd, (char *)sharename, &subs, SMB_SHR_MAP); if (rc != 0 && tree->t_shr_flags & SMB_SHRF_DISP_TERM) { smb_tree_disconnect(tree, B_FALSE); smb_tree_release(tree); smbsr_error(sr, NT_STATUS_ACCESS_DENIED, ERRSRV, ERRaccess); kmem_free(si, sizeof (smb_share_t)); return (NULL); } } } kmem_free(si, sizeof (smb_share_t)); return (tree); }
/* * This is the common dispatch function for SMB2, used for both * synchronous and asynchronous requests. In the async case, * this runs twice: once for the initial processing where the * initial handler returns NT_STATUS_PENDING, and then a second * time (with async_func != NULL) for the "real work". * Note the async_func == NULL for "normal" calls, and the * handler function is taken from the dispatch table. */ static int smb2sr_dispatch(smb_request_t *sr, smb_sdrc_t (*async_func)(smb_request_t *)) { const smb_disp_entry_t *sdd; smb_disp_stats_t *sds; smb_session_t *session; smb_server_t *server; boolean_t related; int rc = 0; session = sr->session; server = session->s_server; /* * Validate the commmand code, get dispatch table entries. * [MS-SMB2] 3.3.5.2.6 Handling Incorrectly Formatted... * * The last slot in the dispatch table is used to handle * invalid commands. Same for statistics. */ if (sr->smb2_cmd_code < SMB2_INVALID_CMD) { sdd = &smb2_disp_table[sr->smb2_cmd_code]; sds = &server->sv_disp_stats2[sr->smb2_cmd_code]; } else { sdd = &smb2_disp_table[SMB2_INVALID_CMD]; sds = &server->sv_disp_stats2[SMB2_INVALID_CMD]; } if (sr->smb2_hdr_flags & SMB2_FLAGS_SERVER_TO_REDIR) { smb2sr_put_error(sr, NT_STATUS_INVALID_PARAMETER); goto done; } /* * If this command is NOT "related" to the previous, * clear out the UID, TID, FID state that might be * left over from the previous command. * * Also, if the command IS related, but is declining to * inherit the previous UID or TID, then clear out the * previous session or tree now. This simplifies the * inheritance logic below. Similar logic for FIDs * happens in smb2sr_lookup_fid() */ related = (sr->smb2_hdr_flags & SMB2_FLAGS_RELATED_OPERATIONS); if (!related && sr->fid_ofile != NULL) { smb_ofile_request_complete(sr->fid_ofile); smb_ofile_release(sr->fid_ofile); sr->fid_ofile = NULL; } if ((!related || sr->smb_tid != INHERIT_ID) && sr->tid_tree != NULL) { smb_tree_release(sr->tid_tree); sr->tid_tree = NULL; } if ((!related || sr->smb_uid != INHERIT_ID) && sr->uid_user != NULL) { smb_user_release(sr->uid_user); sr->uid_user = NULL; } /* * Make sure we have a user and tree as needed * according to the flags for the this command. * In a compound, a "related" command may inherit * the UID, TID, and FID from previous commands * using the special INHERIT_ID (all ones). */ if ((sdd->sdt_flags & SDDF_SUPPRESS_UID) == 0) { /* * This command requires a user session. */ if (related && sr->smb_uid == INHERIT_ID && sr->uid_user != NULL) { sr->smb_uid = sr->uid_user->u_uid; } else { ASSERT3P(sr->uid_user, ==, NULL); sr->uid_user = smb_session_lookup_uid(session, sr->smb_uid); } if (sr->uid_user == NULL) { /* [MS-SMB2] 3.3.5.2.9 Verifying the Session */ smb2sr_put_error(sr, NT_STATUS_USER_SESSION_DELETED); goto done; } sr->user_cr = smb_user_getcred(sr->uid_user); } if ((sdd->sdt_flags & SDDF_SUPPRESS_TID) == 0) { /* * This command requires a tree connection. */ if (related && sr->smb_tid == INHERIT_ID && sr->tid_tree != NULL) { sr->smb_tid = sr->tid_tree->t_tid; } else { ASSERT3P(sr->tid_tree, ==, NULL); sr->tid_tree = smb_session_lookup_tree(session, sr->smb_tid); } if (sr->tid_tree == NULL) { /* [MS-SMB2] 3.3.5.2.11 Verifying the Tree Connect */ smb2sr_put_error(sr, NT_STATUS_NETWORK_NAME_DELETED); goto done; } } /* * The real work: call the SMB2 command handler. */ sr->sr_time_start = gethrtime(); if (async_func != NULL) { rc = (*async_func)(sr); } else { /* NB: not using pre_op */ rc = (*sdd->sdt_function)(sr); /* NB: not using post_op */ } MBC_FLUSH(&sr->raw_data); done: /* * Pad the reply to align(8) if necessary. */ if (sr->reply.chain_offset & 7) { int padsz = 8 - (sr->reply.chain_offset & 7); (void) smb_mbc_encodef(&sr->reply, "#.", padsz); } ASSERT((sr->reply.chain_offset & 7) == 0); /* * Record some statistics: latency, rx bytes, tx bytes */ smb_latency_add_sample(&sds->sdt_lat, gethrtime() - sr->sr_time_start); atomic_add_64(&sds->sdt_rxb, (int64_t)(sr->command.chain_offset - sr->smb2_cmd_hdr)); atomic_add_64(&sds->sdt_txb, (int64_t)(sr->reply.chain_offset - sr->smb2_reply_hdr)); return (rc); }