1da6c28aaSamw /* 2da6c28aaSamw * CDDL HEADER START 3da6c28aaSamw * 4da6c28aaSamw * The contents of this file are subject to the terms of the 5da6c28aaSamw * Common Development and Distribution License (the "License"). 6da6c28aaSamw * You may not use this file except in compliance with the License. 7da6c28aaSamw * 8da6c28aaSamw * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9da6c28aaSamw * or http://www.opensolaris.org/os/licensing. 10da6c28aaSamw * See the License for the specific language governing permissions 11da6c28aaSamw * and limitations under the License. 12da6c28aaSamw * 13da6c28aaSamw * When distributing Covered Code, include this CDDL HEADER in each 14da6c28aaSamw * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15da6c28aaSamw * If applicable, add the following below this CDDL HEADER, with the 16da6c28aaSamw * fields enclosed by brackets "[]" replaced with your own identifying 17da6c28aaSamw * information: Portions Copyright [yyyy] [name of copyright owner] 18da6c28aaSamw * 19da6c28aaSamw * CDDL HEADER END 20da6c28aaSamw */ 21da6c28aaSamw /* 22148c5f43SAlan Wright * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved. 238f70e16bSGordon Ross * Copyright 2018 Nexenta Systems, Inc. All rights reserved. 24da6c28aaSamw */ 25b819cea2SGordon Ross 26da6c28aaSamw #include <sys/atomic.h> 27da6c28aaSamw #include <sys/synch.h> 28da6c28aaSamw #include <sys/types.h> 29da6c28aaSamw #include <sys/sdt.h> 30f9bc6dadSDmitry.Savitsky@nexenta.com #include <sys/random.h> 31da6c28aaSamw #include <smbsrv/netbios.h> 32a90cf9f2SGordon Ross #include <smbsrv/smb2_kproto.h> 33bbf6f00cSJordan Brown #include <smbsrv/string.h> 34b819cea2SGordon Ross #include <netinet/tcp.h> 35b819cea2SGordon Ross 36a90cf9f2SGordon Ross /* How many iovec we'll handle as a local array (no allocation) */ 37a90cf9f2SGordon Ross #define SMB_LOCAL_IOV_MAX 16 38a90cf9f2SGordon Ross 39b819cea2SGordon Ross #define SMB_NEW_KID() atomic_inc_64_nv(&smb_kids) 40da6c28aaSamw 41faa1795aSjb150015 static volatile uint64_t smb_kids; 42da6c28aaSamw 43b819cea2SGordon Ross /* 44b819cea2SGordon Ross * We track the keepalive in minutes, but this constant 45b819cea2SGordon Ross * specifies it in seconds, so convert to minutes. 46b819cea2SGordon Ross */ 47b819cea2SGordon Ross uint32_t smb_keep_alive = SMB_PI_KEEP_ALIVE_MIN / 60; 48da6c28aaSamw 49a90cf9f2SGordon Ross static int smbsr_newrq_initial(smb_request_t *); 50a90cf9f2SGordon Ross 512c2961f8Sjose borrego static void smb_session_cancel(smb_session_t *); 52a90cf9f2SGordon Ross static int smb_session_reader(smb_session_t *); 53a90cf9f2SGordon Ross static int smb_session_xprt_puthdr(smb_session_t *, 54a90cf9f2SGordon Ross uint8_t msg_type, uint32_t msg_len, 55a90cf9f2SGordon Ross uint8_t *dst, size_t dstlen); 563b13a1efSThomas Keiser static smb_tree_t *smb_session_get_tree(smb_session_t *, smb_tree_t *); 579fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States static void smb_session_logoff(smb_session_t *); 58faa1795aSjb150015 static void smb_request_init_command_mbuf(smb_request_t *sr); 59f9bc6dadSDmitry.Savitsky@nexenta.com static void smb_session_genkey(smb_session_t *); 60da6c28aaSamw 61da6c28aaSamw void 624163af6aSjose borrego smb_session_timers(smb_llist_t *ll) 63da6c28aaSamw { 64faa1795aSjb150015 smb_session_t *session; 65da6c28aaSamw 664163af6aSjose borrego smb_llist_enter(ll, RW_READER); 674163af6aSjose borrego session = smb_llist_head(ll); 684163af6aSjose borrego while (session != NULL) { 69da6c28aaSamw /* 70da6c28aaSamw * Walk through the table and decrement each keep_alive 71da6c28aaSamw * timer that has not timed out yet. (keepalive > 0) 72da6c28aaSamw */ 734163af6aSjose borrego SMB_SESSION_VALID(session); 74faa1795aSjb150015 if (session->keep_alive && 75faa1795aSjb150015 (session->keep_alive != (uint32_t)-1)) 76faa1795aSjb150015 session->keep_alive--; 774163af6aSjose borrego session = smb_llist_next(ll, session); 78faa1795aSjb150015 } 794163af6aSjose borrego smb_llist_exit(ll); 80faa1795aSjb150015 } 81da6c28aaSamw 82faa1795aSjb150015 void 834163af6aSjose borrego smb_session_correct_keep_alive_values(smb_llist_t *ll, uint32_t new_keep_alive) 84faa1795aSjb150015 { 85faa1795aSjb150015 smb_session_t *sn; 86faa1795aSjb150015 87b819cea2SGordon Ross /* 88b819cea2SGordon Ross * Caller specifies seconds, but we track in minutes, so 89b819cea2SGordon Ross * convert to minutes (rounded up). 90b819cea2SGordon Ross */ 91b819cea2SGordon Ross new_keep_alive = (new_keep_alive + 59) / 60; 92b819cea2SGordon Ross 93faa1795aSjb150015 if (new_keep_alive == smb_keep_alive) 94faa1795aSjb150015 return; 95faa1795aSjb150015 /* 96faa1795aSjb150015 * keep alive == 0 means do not drop connection if it's idle 97faa1795aSjb150015 */ 98faa1795aSjb150015 smb_keep_alive = (new_keep_alive) ? new_keep_alive : -1; 99faa1795aSjb150015 100faa1795aSjb150015 /* 101faa1795aSjb150015 * Walk through the table and set each session to the new keep_alive 102faa1795aSjb150015 * value if they have not already timed out. Block clock interrupts. 103faa1795aSjb150015 */ 1044163af6aSjose borrego smb_llist_enter(ll, RW_READER); 1054163af6aSjose borrego sn = smb_llist_head(ll); 1064163af6aSjose borrego while (sn != NULL) { 1074163af6aSjose borrego SMB_SESSION_VALID(sn); 1084163af6aSjose borrego if (sn->keep_alive != 0) 109faa1795aSjb150015 sn->keep_alive = new_keep_alive; 1104163af6aSjose borrego sn = smb_llist_next(ll, sn); 111da6c28aaSamw } 1124163af6aSjose borrego smb_llist_exit(ll); 113da6c28aaSamw } 114da6c28aaSamw 115da6c28aaSamw /* 116da6c28aaSamw * Send a session message - supports SMB-over-NBT and SMB-over-TCP. 117a90cf9f2SGordon Ross * If an mbuf chain is provided (optional), it will be freed and 118a90cf9f2SGordon Ross * set to NULL -- unconditionally! (error or not) 119da6c28aaSamw * 120a90cf9f2SGordon Ross * Builds a I/O vector (uio/iov) to do the send from mbufs, plus one 121a90cf9f2SGordon Ross * segment for the 4-byte NBT header. 122da6c28aaSamw */ 123da6c28aaSamw int 124a90cf9f2SGordon Ross smb_session_send(smb_session_t *session, uint8_t nbt_type, mbuf_chain_t *mbc) 125da6c28aaSamw { 126a90cf9f2SGordon Ross uio_t uio; 127a90cf9f2SGordon Ross iovec_t local_iov[SMB_LOCAL_IOV_MAX]; 128a90cf9f2SGordon Ross iovec_t *alloc_iov = NULL; 129a90cf9f2SGordon Ross int alloc_sz = 0; 130a90cf9f2SGordon Ross mbuf_t *m; 131a90cf9f2SGordon Ross uint8_t nbt_hdr[NETBIOS_HDR_SZ]; 132a90cf9f2SGordon Ross uint32_t nbt_len; 133a90cf9f2SGordon Ross int i, nseg; 134da6c28aaSamw int rc; 135da6c28aaSamw 136da6c28aaSamw switch (session->s_state) { 137da6c28aaSamw case SMB_SESSION_STATE_DISCONNECTED: 138da6c28aaSamw case SMB_SESSION_STATE_TERMINATED: 139a90cf9f2SGordon Ross rc = ENOTCONN; 140a90cf9f2SGordon Ross goto out; 141a90cf9f2SGordon Ross default: 142a90cf9f2SGordon Ross break; 143a90cf9f2SGordon Ross } 144a90cf9f2SGordon Ross 145a90cf9f2SGordon Ross /* 146a90cf9f2SGordon Ross * Setup the IOV. First, count the number of IOV segments 147a90cf9f2SGordon Ross * (plus one for the NBT header) and decide whether we 148a90cf9f2SGordon Ross * need to allocate an iovec or can use local_iov; 149a90cf9f2SGordon Ross */ 150a90cf9f2SGordon Ross bzero(&uio, sizeof (uio)); 151a90cf9f2SGordon Ross nseg = 1; 152a90cf9f2SGordon Ross m = (mbc != NULL) ? mbc->chain : NULL; 153a90cf9f2SGordon Ross while (m != NULL) { 154a90cf9f2SGordon Ross nseg++; 155a90cf9f2SGordon Ross m = m->m_next; 156a90cf9f2SGordon Ross } 157a90cf9f2SGordon Ross if (nseg <= SMB_LOCAL_IOV_MAX) { 158a90cf9f2SGordon Ross uio.uio_iov = local_iov; 159a90cf9f2SGordon Ross } else { 160a90cf9f2SGordon Ross alloc_sz = nseg * sizeof (iovec_t); 161a90cf9f2SGordon Ross alloc_iov = kmem_alloc(alloc_sz, KM_SLEEP); 162a90cf9f2SGordon Ross uio.uio_iov = alloc_iov; 163a90cf9f2SGordon Ross } 164a90cf9f2SGordon Ross uio.uio_iovcnt = nseg; 165a90cf9f2SGordon Ross uio.uio_segflg = UIO_SYSSPACE; 166a90cf9f2SGordon Ross uio.uio_extflg = UIO_COPY_DEFAULT; 167a90cf9f2SGordon Ross 168a90cf9f2SGordon Ross /* 169a90cf9f2SGordon Ross * Build the iov list, meanwhile computing the length of 170a90cf9f2SGordon Ross * the SMB payload (to put in the NBT header). 171a90cf9f2SGordon Ross */ 172a90cf9f2SGordon Ross uio.uio_iov[0].iov_base = (void *)nbt_hdr; 173a90cf9f2SGordon Ross uio.uio_iov[0].iov_len = sizeof (nbt_hdr); 174a90cf9f2SGordon Ross i = 1; 175a90cf9f2SGordon Ross nbt_len = 0; 176a90cf9f2SGordon Ross m = (mbc != NULL) ? mbc->chain : NULL; 177a90cf9f2SGordon Ross while (m != NULL) { 178a90cf9f2SGordon Ross uio.uio_iov[i].iov_base = m->m_data; 179a90cf9f2SGordon Ross uio.uio_iov[i++].iov_len = m->m_len; 180a90cf9f2SGordon Ross nbt_len += m->m_len; 181a90cf9f2SGordon Ross m = m->m_next; 182a90cf9f2SGordon Ross } 183a90cf9f2SGordon Ross ASSERT3S(i, ==, nseg); 184a90cf9f2SGordon Ross 185a90cf9f2SGordon Ross /* 186a90cf9f2SGordon Ross * Set the NBT header, set uio_resid 187a90cf9f2SGordon Ross */ 188a90cf9f2SGordon Ross uio.uio_resid = nbt_len + NETBIOS_HDR_SZ; 189a90cf9f2SGordon Ross rc = smb_session_xprt_puthdr(session, nbt_type, nbt_len, 190a90cf9f2SGordon Ross nbt_hdr, NETBIOS_HDR_SZ); 191a90cf9f2SGordon Ross if (rc != 0) 192a90cf9f2SGordon Ross goto out; 193a90cf9f2SGordon Ross 194a90cf9f2SGordon Ross smb_server_add_txb(session->s_server, (int64_t)uio.uio_resid); 195a90cf9f2SGordon Ross rc = smb_net_send_uio(session, &uio); 196a90cf9f2SGordon Ross 197a90cf9f2SGordon Ross out: 198a90cf9f2SGordon Ross if (alloc_iov != NULL) 199a90cf9f2SGordon Ross kmem_free(alloc_iov, alloc_sz); 200da6c28aaSamw if ((mbc != NULL) && (mbc->chain != NULL)) { 201da6c28aaSamw m_freem(mbc->chain); 202da6c28aaSamw mbc->chain = NULL; 203da6c28aaSamw mbc->flags = 0; 204da6c28aaSamw } 20521b7895dSjb150015 return (rc); 206da6c28aaSamw } 207da6c28aaSamw 208da6c28aaSamw /* 209da6c28aaSamw * Read, process and respond to a NetBIOS session request. 210da6c28aaSamw * 211da6c28aaSamw * A NetBIOS session must be established for SMB-over-NetBIOS. Validate 212da6c28aaSamw * the calling and called name format and save the client NetBIOS name, 213da6c28aaSamw * which is used when a NetBIOS session is established to check for and 214da6c28aaSamw * cleanup leftover state from a previous session. 215da6c28aaSamw * 216da6c28aaSamw * Session requests are not valid for SMB-over-TCP, which is unfortunate 217da6c28aaSamw * because without the client name leftover state cannot be cleaned up 218da6c28aaSamw * if the client is behind a NAT server. 219da6c28aaSamw */ 220da6c28aaSamw static int 221a90cf9f2SGordon Ross smb_netbios_session_request(struct smb_session *session) 222da6c28aaSamw { 223da6c28aaSamw int rc; 224da6c28aaSamw char *calling_name; 225da6c28aaSamw char *called_name; 226da6c28aaSamw char client_name[NETBIOS_NAME_SZ]; 227da6c28aaSamw struct mbuf_chain mbc; 228da6c28aaSamw char *names = NULL; 229bbf6f00cSJordan Brown smb_wchar_t *wbuf = NULL; 230da6c28aaSamw smb_xprt_t hdr; 231da6c28aaSamw char *p; 232da6c28aaSamw int rc1, rc2; 233da6c28aaSamw 234da6c28aaSamw session->keep_alive = smb_keep_alive; 235da6c28aaSamw 236faa1795aSjb150015 if ((rc = smb_session_xprt_gethdr(session, &hdr)) != 0) 237faa1795aSjb150015 return (rc); 238da6c28aaSamw 239da6c28aaSamw DTRACE_PROBE2(receive__session__req__xprthdr, struct session *, session, 240da6c28aaSamw smb_xprt_t *, &hdr); 241da6c28aaSamw 242da6c28aaSamw if ((hdr.xh_type != SESSION_REQUEST) || 243da6c28aaSamw (hdr.xh_length != NETBIOS_SESSION_REQUEST_DATA_LENGTH)) { 244da6c28aaSamw DTRACE_PROBE1(receive__session__req__failed, 245da6c28aaSamw struct session *, session); 246da6c28aaSamw return (EINVAL); 247da6c28aaSamw } 248da6c28aaSamw 249da6c28aaSamw names = kmem_alloc(hdr.xh_length, KM_SLEEP); 250da6c28aaSamw 251da6c28aaSamw if ((rc = smb_sorecv(session->sock, names, hdr.xh_length)) != 0) { 252da6c28aaSamw kmem_free(names, hdr.xh_length); 253da6c28aaSamw DTRACE_PROBE1(receive__session__req__failed, 254da6c28aaSamw struct session *, session); 255da6c28aaSamw return (rc); 256da6c28aaSamw } 257da6c28aaSamw 258da6c28aaSamw DTRACE_PROBE3(receive__session__req__data, struct session *, session, 259da6c28aaSamw char *, names, uint32_t, hdr.xh_length); 260da6c28aaSamw 261da6c28aaSamw called_name = &names[0]; 262da6c28aaSamw calling_name = &names[NETBIOS_ENCODED_NAME_SZ + 2]; 263da6c28aaSamw 264da6c28aaSamw rc1 = netbios_name_isvalid(called_name, 0); 265da6c28aaSamw rc2 = netbios_name_isvalid(calling_name, client_name); 266da6c28aaSamw 267da6c28aaSamw if (rc1 == 0 || rc2 == 0) { 268da6c28aaSamw 269da6c28aaSamw DTRACE_PROBE3(receive__invalid__session__req, 270da6c28aaSamw struct session *, session, char *, names, 271da6c28aaSamw uint32_t, hdr.xh_length); 272da6c28aaSamw 273da6c28aaSamw kmem_free(names, hdr.xh_length); 274da6c28aaSamw MBC_INIT(&mbc, MAX_DATAGRAM_LENGTH); 2753db3f65cSamw (void) smb_mbc_encodef(&mbc, "b", 276da6c28aaSamw DATAGRAM_INVALID_SOURCE_NAME_FORMAT); 277da6c28aaSamw (void) smb_session_send(session, NEGATIVE_SESSION_RESPONSE, 278da6c28aaSamw &mbc); 279da6c28aaSamw return (EINVAL); 280da6c28aaSamw } 281da6c28aaSamw 282da6c28aaSamw DTRACE_PROBE3(receive__session__req__calling__decoded, 283da6c28aaSamw struct session *, session, 284da6c28aaSamw char *, calling_name, char *, client_name); 285da6c28aaSamw 286da6c28aaSamw /* 287da6c28aaSamw * The client NetBIOS name is in oem codepage format. 288da6c28aaSamw * We need to convert it to unicode and store it in 289da6c28aaSamw * multi-byte format. We also need to strip off any 290da6c28aaSamw * spaces added as part of the NetBIOS name encoding. 291da6c28aaSamw */ 292bbf6f00cSJordan Brown wbuf = kmem_alloc((SMB_PI_MAX_HOST * sizeof (smb_wchar_t)), KM_SLEEP); 293bbf6f00cSJordan Brown (void) oemtoucs(wbuf, client_name, SMB_PI_MAX_HOST, OEM_CPG_850); 294bbf6f00cSJordan Brown (void) smb_wcstombs(session->workstation, wbuf, SMB_PI_MAX_HOST); 295bbf6f00cSJordan Brown kmem_free(wbuf, (SMB_PI_MAX_HOST * sizeof (smb_wchar_t))); 296da6c28aaSamw 297da6c28aaSamw if ((p = strchr(session->workstation, ' ')) != 0) 298da6c28aaSamw *p = '\0'; 299da6c28aaSamw 300da6c28aaSamw kmem_free(names, hdr.xh_length); 301da6c28aaSamw return (smb_session_send(session, POSITIVE_SESSION_RESPONSE, NULL)); 302da6c28aaSamw } 303da6c28aaSamw 304da6c28aaSamw /* 305da6c28aaSamw * Read 4-byte header from the session socket and build an in-memory 306da6c28aaSamw * session transport header. See smb_xprt_t definition for header 307da6c28aaSamw * format information. 308da6c28aaSamw * 309da6c28aaSamw * Direct hosted NetBIOS-less SMB (SMB-over-TCP) uses port 445. The 310da6c28aaSamw * first byte of the four-byte header must be 0 and the next three 311da6c28aaSamw * bytes contain the length of the remaining data. 312da6c28aaSamw */ 313da6c28aaSamw int 314da6c28aaSamw smb_session_xprt_gethdr(smb_session_t *session, smb_xprt_t *ret_hdr) 315da6c28aaSamw { 316faa1795aSjb150015 int rc; 317da6c28aaSamw unsigned char buf[NETBIOS_HDR_SZ]; 318da6c28aaSamw 319faa1795aSjb150015 if ((rc = smb_sorecv(session->sock, buf, NETBIOS_HDR_SZ)) != 0) 320faa1795aSjb150015 return (rc); 321da6c28aaSamw 322da6c28aaSamw switch (session->s_local_port) { 323a0aa776eSAlan Wright case IPPORT_NETBIOS_SSN: 324da6c28aaSamw ret_hdr->xh_type = buf[0]; 325da6c28aaSamw ret_hdr->xh_length = (((uint32_t)buf[1] & 1) << 16) | 326da6c28aaSamw ((uint32_t)buf[2] << 8) | 327da6c28aaSamw ((uint32_t)buf[3]); 328da6c28aaSamw break; 329da6c28aaSamw 330a0aa776eSAlan Wright case IPPORT_SMB: 331da6c28aaSamw ret_hdr->xh_type = buf[0]; 332da6c28aaSamw 333da6c28aaSamw if (ret_hdr->xh_type != 0) { 33449b5df1eSGordon Ross cmn_err(CE_WARN, "invalid NBT type (%u) from %s", 33549b5df1eSGordon Ross ret_hdr->xh_type, session->ip_addr_str); 336faa1795aSjb150015 return (EPROTO); 337da6c28aaSamw } 338da6c28aaSamw 339da6c28aaSamw ret_hdr->xh_length = ((uint32_t)buf[1] << 16) | 340da6c28aaSamw ((uint32_t)buf[2] << 8) | 341da6c28aaSamw ((uint32_t)buf[3]); 342da6c28aaSamw break; 343da6c28aaSamw 344da6c28aaSamw default: 3457f667e74Sjose borrego cmn_err(CE_WARN, "invalid port %u", session->s_local_port); 346faa1795aSjb150015 return (EPROTO); 347da6c28aaSamw } 348da6c28aaSamw 349da6c28aaSamw return (0); 350da6c28aaSamw } 351da6c28aaSamw 352da6c28aaSamw /* 353da6c28aaSamw * Encode a transport session packet header into a 4-byte buffer. 354da6c28aaSamw */ 355da6c28aaSamw static int 356a90cf9f2SGordon Ross smb_session_xprt_puthdr(smb_session_t *session, 357a90cf9f2SGordon Ross uint8_t msg_type, uint32_t msg_length, 358da6c28aaSamw uint8_t *buf, size_t buflen) 359da6c28aaSamw { 360a90cf9f2SGordon Ross if (buf == NULL || buflen < NETBIOS_HDR_SZ) { 361da6c28aaSamw return (-1); 362da6c28aaSamw } 363da6c28aaSamw 364da6c28aaSamw switch (session->s_local_port) { 365a0aa776eSAlan Wright case IPPORT_NETBIOS_SSN: 366a90cf9f2SGordon Ross /* Per RFC 1001, 1002: msg. len < 128KB */ 367a90cf9f2SGordon Ross if (msg_length >= (1 << 17)) 368a90cf9f2SGordon Ross return (-1); 369a90cf9f2SGordon Ross buf[0] = msg_type; 370a90cf9f2SGordon Ross buf[1] = ((msg_length >> 16) & 1); 371a90cf9f2SGordon Ross buf[2] = (msg_length >> 8) & 0xff; 372a90cf9f2SGordon Ross buf[3] = msg_length & 0xff; 373da6c28aaSamw break; 374da6c28aaSamw 375a0aa776eSAlan Wright case IPPORT_SMB: 376a90cf9f2SGordon Ross /* 377a90cf9f2SGordon Ross * SMB over TCP is like NetBIOS but the one byte 378a90cf9f2SGordon Ross * message type is always zero, and the length 379a90cf9f2SGordon Ross * part is three bytes. It could actually use 380a90cf9f2SGordon Ross * longer messages, but this is conservative. 381a90cf9f2SGordon Ross */ 382a90cf9f2SGordon Ross if (msg_length >= (1 << 24)) 383a90cf9f2SGordon Ross return (-1); 384a90cf9f2SGordon Ross buf[0] = msg_type; 385a90cf9f2SGordon Ross buf[1] = (msg_length >> 16) & 0xff; 386a90cf9f2SGordon Ross buf[2] = (msg_length >> 8) & 0xff; 387a90cf9f2SGordon Ross buf[3] = msg_length & 0xff; 388da6c28aaSamw break; 389da6c28aaSamw 390da6c28aaSamw default: 3917f667e74Sjose borrego cmn_err(CE_WARN, "invalid port %u", session->s_local_port); 392da6c28aaSamw return (-1); 393da6c28aaSamw } 394da6c28aaSamw 395da6c28aaSamw return (0); 396da6c28aaSamw } 397da6c28aaSamw 398faa1795aSjb150015 static void 399da6c28aaSamw smb_request_init_command_mbuf(smb_request_t *sr) 400da6c28aaSamw { 401da6c28aaSamw 402da6c28aaSamw /* 4037f3ef643SGordon Ross * Setup mbuf using the buffer we allocated. 404da6c28aaSamw */ 4057f3ef643SGordon Ross MBC_ATTACH_BUF(&sr->command, sr->sr_request_buf, sr->sr_req_length); 406da6c28aaSamw 407da6c28aaSamw sr->command.flags = 0; 4087f3ef643SGordon Ross sr->command.shadow_of = NULL; 409da6c28aaSamw } 410da6c28aaSamw 411da6c28aaSamw /* 412da6c28aaSamw * smb_request_cancel 413da6c28aaSamw * 414da6c28aaSamw * Handle a cancel for a request properly depending on the current request 415da6c28aaSamw * state. 416da6c28aaSamw */ 417da6c28aaSamw void 418da6c28aaSamw smb_request_cancel(smb_request_t *sr) 419da6c28aaSamw { 4205677e049SGordon Ross void (*cancel_method)(smb_request_t *) = NULL; 4215677e049SGordon Ross 422da6c28aaSamw mutex_enter(&sr->sr_mutex); 423da6c28aaSamw switch (sr->sr_state) { 424da6c28aaSamw 425584e0fceSGordon Ross case SMB_REQ_STATE_INITIALIZING: 426da6c28aaSamw case SMB_REQ_STATE_SUBMITTED: 427da6c28aaSamw case SMB_REQ_STATE_ACTIVE: 428da6c28aaSamw case SMB_REQ_STATE_CLEANED_UP: 4295677e049SGordon Ross sr->sr_state = SMB_REQ_STATE_CANCELLED; 430da6c28aaSamw break; 431da6c28aaSamw 432b210fedeSGordon Ross case SMB_REQ_STATE_WAITING_AUTH: 433*bfe5e737SGordon Ross case SMB_REQ_STATE_WAITING_FCN1: 434*bfe5e737SGordon Ross case SMB_REQ_STATE_WAITING_LOCK: 435b210fedeSGordon Ross case SMB_REQ_STATE_WAITING_PIPE: 436da6c28aaSamw /* 4375677e049SGordon Ross * These are states that have a cancel_method. 4385677e049SGordon Ross * Make the state change now, to ensure that 4395677e049SGordon Ross * we call cancel_method exactly once. Do the 4405677e049SGordon Ross * method call below, after we drop sr_mutex. 4415677e049SGordon Ross * When the cancelled request thread resumes, 4425677e049SGordon Ross * it should re-take sr_mutex and set sr_state 4435677e049SGordon Ross * to CANCELLED, then return STATUS_CANCELLED. 444da6c28aaSamw */ 4455677e049SGordon Ross sr->sr_state = SMB_REQ_STATE_CANCEL_PENDING; 4465677e049SGordon Ross cancel_method = sr->cancel_method; 4475677e049SGordon Ross VERIFY(cancel_method != NULL); 448da6c28aaSamw break; 449da6c28aaSamw 450*bfe5e737SGordon Ross case SMB_REQ_STATE_WAITING_FCN2: 451da6c28aaSamw case SMB_REQ_STATE_COMPLETED: 452*bfe5e737SGordon Ross case SMB_REQ_STATE_CANCEL_PENDING: 4535677e049SGordon Ross case SMB_REQ_STATE_CANCELLED: 454da6c28aaSamw /* 455da6c28aaSamw * No action required for these states since the request 456da6c28aaSamw * is completing. 457da6c28aaSamw */ 458da6c28aaSamw break; 459584e0fceSGordon Ross 460584e0fceSGordon Ross case SMB_REQ_STATE_FREE: 461da6c28aaSamw default: 4622c2961f8Sjose borrego SMB_PANIC(); 463da6c28aaSamw } 464da6c28aaSamw mutex_exit(&sr->sr_mutex); 4655677e049SGordon Ross 4665677e049SGordon Ross if (cancel_method != NULL) { 4675677e049SGordon Ross cancel_method(sr); 4685677e049SGordon Ross } 469da6c28aaSamw } 470da6c28aaSamw 471da6c28aaSamw /* 4724163af6aSjose borrego * smb_session_receiver 473da6c28aaSamw * 4744163af6aSjose borrego * Receives request from the network and dispatches them to a worker. 475da6c28aaSamw */ 4764163af6aSjose borrego void 4774163af6aSjose borrego smb_session_receiver(smb_session_t *session) 478da6c28aaSamw { 479b819cea2SGordon Ross int rc = 0; 480da6c28aaSamw 4814163af6aSjose borrego SMB_SESSION_VALID(session); 4824163af6aSjose borrego 4834163af6aSjose borrego session->s_thread = curthread; 484da6c28aaSamw 485a0aa776eSAlan Wright if (session->s_local_port == IPPORT_NETBIOS_SSN) { 486a90cf9f2SGordon Ross rc = smb_netbios_session_request(session); 4874163af6aSjose borrego if (rc != 0) { 488faa1795aSjb150015 smb_rwx_rwenter(&session->s_lock, RW_WRITER); 489faa1795aSjb150015 session->s_state = SMB_SESSION_STATE_DISCONNECTED; 490faa1795aSjb150015 smb_rwx_rwexit(&session->s_lock); 4914163af6aSjose borrego return; 492faa1795aSjb150015 } 493faa1795aSjb150015 } 494da6c28aaSamw 495da6c28aaSamw smb_rwx_rwenter(&session->s_lock, RW_WRITER); 496da6c28aaSamw session->s_state = SMB_SESSION_STATE_ESTABLISHED; 497da6c28aaSamw smb_rwx_rwexit(&session->s_lock); 498da6c28aaSamw 499a90cf9f2SGordon Ross (void) smb_session_reader(session); 500da6c28aaSamw 501da6c28aaSamw smb_rwx_rwenter(&session->s_lock, RW_WRITER); 502da6c28aaSamw session->s_state = SMB_SESSION_STATE_DISCONNECTED; 503da6c28aaSamw smb_rwx_rwexit(&session->s_lock); 504da6c28aaSamw 505faa1795aSjb150015 smb_soshutdown(session->sock); 506faa1795aSjb150015 507da6c28aaSamw DTRACE_PROBE2(session__drop, struct session *, session, int, rc); 508da6c28aaSamw 509da6c28aaSamw smb_session_cancel(session); 510da6c28aaSamw /* 511da6c28aaSamw * At this point everything related to the session should have been 512da6c28aaSamw * cleaned up and we expect that nothing will attempt to use the 513da6c28aaSamw * socket. 514da6c28aaSamw */ 5154163af6aSjose borrego } 516da6c28aaSamw 5174163af6aSjose borrego /* 5184163af6aSjose borrego * smb_session_disconnect 5194163af6aSjose borrego * 5204163af6aSjose borrego * Disconnects the session passed in. 5214163af6aSjose borrego */ 5224163af6aSjose borrego void 5234163af6aSjose borrego smb_session_disconnect(smb_session_t *session) 5244163af6aSjose borrego { 5254163af6aSjose borrego SMB_SESSION_VALID(session); 5264163af6aSjose borrego 5274163af6aSjose borrego smb_rwx_rwenter(&session->s_lock, RW_WRITER); 5284163af6aSjose borrego switch (session->s_state) { 5294163af6aSjose borrego case SMB_SESSION_STATE_INITIALIZED: 5304163af6aSjose borrego case SMB_SESSION_STATE_CONNECTED: 5314163af6aSjose borrego case SMB_SESSION_STATE_ESTABLISHED: 5324163af6aSjose borrego case SMB_SESSION_STATE_NEGOTIATED: 5334163af6aSjose borrego smb_soshutdown(session->sock); 5344163af6aSjose borrego session->s_state = SMB_SESSION_STATE_DISCONNECTED; 5354163af6aSjose borrego _NOTE(FALLTHRU) 5364163af6aSjose borrego case SMB_SESSION_STATE_DISCONNECTED: 5374163af6aSjose borrego case SMB_SESSION_STATE_TERMINATED: 5384163af6aSjose borrego break; 5394163af6aSjose borrego } 5404163af6aSjose borrego smb_rwx_rwexit(&session->s_lock); 541da6c28aaSamw } 542da6c28aaSamw 543da6c28aaSamw /* 544da6c28aaSamw * Read and process SMB requests. 545da6c28aaSamw * 546da6c28aaSamw * Returns: 547da6c28aaSamw * 0 Success 548da6c28aaSamw * 1 Unable to read transport header 549da6c28aaSamw * 2 Invalid transport header type 550da6c28aaSamw * 3 Invalid SMB length (too small) 551da6c28aaSamw * 4 Unable to read SMB header 552da6c28aaSamw * 5 Invalid SMB header (bad magic number) 553da6c28aaSamw * 6 Unable to read SMB data 554da6c28aaSamw */ 555da6c28aaSamw static int 556a90cf9f2SGordon Ross smb_session_reader(smb_session_t *session) 557da6c28aaSamw { 558148c5f43SAlan Wright smb_server_t *sv; 559faa1795aSjb150015 smb_request_t *sr = NULL; 560da6c28aaSamw smb_xprt_t hdr; 561da6c28aaSamw uint8_t *req_buf; 562da6c28aaSamw uint32_t resid; 563da6c28aaSamw int rc; 564da6c28aaSamw 565148c5f43SAlan Wright sv = session->s_server; 566148c5f43SAlan Wright 567faa1795aSjb150015 for (;;) { 568da6c28aaSamw 569faa1795aSjb150015 rc = smb_session_xprt_gethdr(session, &hdr); 570faa1795aSjb150015 if (rc) 571faa1795aSjb150015 return (rc); 572faa1795aSjb150015 573faa1795aSjb150015 DTRACE_PROBE2(session__receive__xprthdr, session_t *, session, 574da6c28aaSamw smb_xprt_t *, &hdr); 575da6c28aaSamw 576da6c28aaSamw if (hdr.xh_type != SESSION_MESSAGE) { 577da6c28aaSamw /* 578faa1795aSjb150015 * Anything other than SESSION_MESSAGE or 579faa1795aSjb150015 * SESSION_KEEP_ALIVE is an error. A SESSION_REQUEST 580faa1795aSjb150015 * may indicate a new session request but we need to 581faa1795aSjb150015 * close this session and we can treat it as an error 582faa1795aSjb150015 * here. 583da6c28aaSamw */ 584da6c28aaSamw if (hdr.xh_type == SESSION_KEEP_ALIVE) { 585da6c28aaSamw session->keep_alive = smb_keep_alive; 586faa1795aSjb150015 continue; 587da6c28aaSamw } 588faa1795aSjb150015 return (EPROTO); 589da6c28aaSamw } 590da6c28aaSamw 591a90cf9f2SGordon Ross if (hdr.xh_length == 0) { 592a90cf9f2SGordon Ross /* zero length is another form of keep alive */ 593a90cf9f2SGordon Ross session->keep_alive = smb_keep_alive; 594a90cf9f2SGordon Ross continue; 595a90cf9f2SGordon Ross } 596a90cf9f2SGordon Ross 597da6c28aaSamw if (hdr.xh_length < SMB_HEADER_LEN) 598faa1795aSjb150015 return (EPROTO); 599a90cf9f2SGordon Ross if (hdr.xh_length > session->cmd_max_bytes) 600a90cf9f2SGordon Ross return (EPROTO); 601da6c28aaSamw 602da6c28aaSamw session->keep_alive = smb_keep_alive; 603a90cf9f2SGordon Ross 604da6c28aaSamw /* 605a90cf9f2SGordon Ross * Allocate a request context, read the whole message. 6069c856e86SMatt Barden * If the request alloc fails, we've disconnected and 6079c856e86SMatt Barden * won't be able to send the reply anyway, so bail now. 608da6c28aaSamw */ 6099c856e86SMatt Barden if ((sr = smb_request_alloc(session, hdr.xh_length)) == NULL) 6109c856e86SMatt Barden break; 611da6c28aaSamw 612da6c28aaSamw req_buf = (uint8_t *)sr->sr_request_buf; 613da6c28aaSamw resid = hdr.xh_length; 614da6c28aaSamw 615faa1795aSjb150015 rc = smb_sorecv(session->sock, req_buf, resid); 616faa1795aSjb150015 if (rc) { 617da6c28aaSamw smb_request_free(sr); 618a90cf9f2SGordon Ross break; 619da6c28aaSamw } 620a90cf9f2SGordon Ross 621ac2bf314SMatt Barden /* accounting: received bytes */ 622148c5f43SAlan Wright smb_server_add_rxb(sv, 623148c5f43SAlan Wright (int64_t)(hdr.xh_length + NETBIOS_HDR_SZ)); 624a90cf9f2SGordon Ross 625da6c28aaSamw /* 626da6c28aaSamw * Initialize command MBC to represent the received data. 627da6c28aaSamw */ 628da6c28aaSamw smb_request_init_command_mbuf(sr); 629da6c28aaSamw 630da6c28aaSamw DTRACE_PROBE1(session__receive__smb, smb_request_t *, sr); 631da6c28aaSamw 632a90cf9f2SGordon Ross rc = session->newrq_func(sr); 633a90cf9f2SGordon Ross sr = NULL; /* enqueued or freed */ 634a90cf9f2SGordon Ross if (rc != 0) 635a90cf9f2SGordon Ross break; 636148c5f43SAlan Wright } 637a90cf9f2SGordon Ross return (rc); 638148c5f43SAlan Wright } 639a90cf9f2SGordon Ross 640a90cf9f2SGordon Ross /* 641a90cf9f2SGordon Ross * This is the initial handler for new smb requests, called from 642a90cf9f2SGordon Ross * from smb_session_reader when we have not yet seen any requests. 643a90cf9f2SGordon Ross * The first SMB request must be "negotiate", which determines 644a90cf9f2SGordon Ross * which protocol and dialect we'll be using. That's the ONLY 645a90cf9f2SGordon Ross * request type handled here, because with all later requests, 646a90cf9f2SGordon Ross * we know the protocol and handle those with either the SMB1 or 647a90cf9f2SGordon Ross * SMB2 handlers: smb1sr_post() or smb2sr_post(). 648a90cf9f2SGordon Ross * Those do NOT allow SMB negotiate, because that's only allowed 649a90cf9f2SGordon Ross * as the first request on new session. 650a90cf9f2SGordon Ross * 651a90cf9f2SGordon Ross * This and other "post a request" handlers must either enqueue 652a90cf9f2SGordon Ross * the new request for the session taskq, or smb_request_free it 653a90cf9f2SGordon Ross * (in case we've decided to drop this connection). In this 654a90cf9f2SGordon Ross * (special) new request handler, we always free the request. 655a90cf9f2SGordon Ross */ 656a90cf9f2SGordon Ross static int 657a90cf9f2SGordon Ross smbsr_newrq_initial(smb_request_t *sr) 658a90cf9f2SGordon Ross { 659a90cf9f2SGordon Ross uint32_t magic; 660a90cf9f2SGordon Ross int rc = EPROTO; 661a90cf9f2SGordon Ross 662a90cf9f2SGordon Ross mutex_enter(&sr->sr_mutex); 663a90cf9f2SGordon Ross sr->sr_state = SMB_REQ_STATE_ACTIVE; 664a90cf9f2SGordon Ross mutex_exit(&sr->sr_mutex); 665a90cf9f2SGordon Ross 666a90cf9f2SGordon Ross magic = SMB_READ_PROTOCOL(sr->sr_request_buf); 667a90cf9f2SGordon Ross if (magic == SMB_PROTOCOL_MAGIC) 668a90cf9f2SGordon Ross rc = smb1_newrq_negotiate(sr); 669a90cf9f2SGordon Ross if (magic == SMB2_PROTOCOL_MAGIC) 670a90cf9f2SGordon Ross rc = smb2_newrq_negotiate(sr); 671a90cf9f2SGordon Ross 672a90cf9f2SGordon Ross mutex_enter(&sr->sr_mutex); 673a90cf9f2SGordon Ross sr->sr_state = SMB_REQ_STATE_COMPLETED; 674a90cf9f2SGordon Ross mutex_exit(&sr->sr_mutex); 675a90cf9f2SGordon Ross 676a90cf9f2SGordon Ross smb_request_free(sr); 677a90cf9f2SGordon Ross return (rc); 678da6c28aaSamw } 679da6c28aaSamw 680da6c28aaSamw /* 681a0aa776eSAlan Wright * Port will be IPPORT_NETBIOS_SSN or IPPORT_SMB. 682da6c28aaSamw */ 683da6c28aaSamw smb_session_t * 6847f667e74Sjose borrego smb_session_create(ksocket_t new_so, uint16_t port, smb_server_t *sv, 6857f667e74Sjose borrego int family) 686da6c28aaSamw { 687da6c28aaSamw struct sockaddr_in sin; 6880f1702c5SYu Xiangning socklen_t slen; 6897f667e74Sjose borrego struct sockaddr_in6 sin6; 690da6c28aaSamw smb_session_t *session; 691d3d50737SRafael Vanoni int64_t now; 692a90cf9f2SGordon Ross uint16_t rport; 693da6c28aaSamw 6948622ec45SGordon Ross session = kmem_cache_alloc(smb_cache_session, KM_SLEEP); 695da6c28aaSamw bzero(session, sizeof (smb_session_t)); 696da6c28aaSamw 697da6c28aaSamw if (smb_idpool_constructor(&session->s_uid_pool)) { 6988622ec45SGordon Ross kmem_cache_free(smb_cache_session, session); 699da6c28aaSamw return (NULL); 700da6c28aaSamw } 7013b13a1efSThomas Keiser if (smb_idpool_constructor(&session->s_tid_pool)) { 7023b13a1efSThomas Keiser smb_idpool_destructor(&session->s_uid_pool); 7038622ec45SGordon Ross kmem_cache_free(smb_cache_session, session); 7043b13a1efSThomas Keiser return (NULL); 7053b13a1efSThomas Keiser } 706da6c28aaSamw 707d3d50737SRafael Vanoni now = ddi_get_lbolt64(); 708d3d50737SRafael Vanoni 709da6c28aaSamw session->s_kid = SMB_NEW_KID(); 710faa1795aSjb150015 session->s_state = SMB_SESSION_STATE_INITIALIZED; 711da6c28aaSamw session->native_os = NATIVE_OS_UNKNOWN; 712d3d50737SRafael Vanoni session->opentime = now; 713da6c28aaSamw session->keep_alive = smb_keep_alive; 714d3d50737SRafael Vanoni session->activity_timestamp = now; 715da6c28aaSamw 716f9bc6dadSDmitry.Savitsky@nexenta.com smb_session_genkey(session); 717f9bc6dadSDmitry.Savitsky@nexenta.com 718a90cf9f2SGordon Ross mutex_init(&session->s_credits_mutex, NULL, MUTEX_DEFAULT, NULL); 719a90cf9f2SGordon Ross 720da6c28aaSamw smb_slist_constructor(&session->s_req_list, sizeof (smb_request_t), 721da6c28aaSamw offsetof(smb_request_t, sr_session_lnd)); 722da6c28aaSamw 723da6c28aaSamw smb_llist_constructor(&session->s_user_list, sizeof (smb_user_t), 724da6c28aaSamw offsetof(smb_user_t, u_lnd)); 725da6c28aaSamw 7263b13a1efSThomas Keiser smb_llist_constructor(&session->s_tree_list, sizeof (smb_tree_t), 7273b13a1efSThomas Keiser offsetof(smb_tree_t, t_lnd)); 7283b13a1efSThomas Keiser 729da6c28aaSamw smb_llist_constructor(&session->s_xa_list, sizeof (smb_xa_t), 730da6c28aaSamw offsetof(smb_xa_t, xa_lnd)); 731da6c28aaSamw 7325cdbe942Sjb150015 smb_net_txl_constructor(&session->s_txlst); 7335cdbe942Sjb150015 734da6c28aaSamw smb_rwx_init(&session->s_lock); 735da6c28aaSamw 736148c5f43SAlan Wright if (new_so != NULL) { 7377f667e74Sjose borrego if (family == AF_INET) { 7380f1702c5SYu Xiangning slen = sizeof (sin); 7397f667e74Sjose borrego (void) ksocket_getsockname(new_so, 7407f667e74Sjose borrego (struct sockaddr *)&sin, &slen, CRED()); 741fc724630SAlan Wright bcopy(&sin.sin_addr, 742fc724630SAlan Wright &session->local_ipaddr.au_addr.au_ipv4, 743fc724630SAlan Wright sizeof (in_addr_t)); 744fc724630SAlan Wright slen = sizeof (sin); 7457f667e74Sjose borrego (void) ksocket_getpeername(new_so, 7467f667e74Sjose borrego (struct sockaddr *)&sin, &slen, CRED()); 747fc724630SAlan Wright bcopy(&sin.sin_addr, 748fc724630SAlan Wright &session->ipaddr.au_addr.au_ipv4, 749fc724630SAlan Wright sizeof (in_addr_t)); 750a90cf9f2SGordon Ross rport = sin.sin_port; 7517f667e74Sjose borrego } else { 7527f667e74Sjose borrego slen = sizeof (sin6); 7537f667e74Sjose borrego (void) ksocket_getsockname(new_so, 7547f667e74Sjose borrego (struct sockaddr *)&sin6, &slen, CRED()); 755fc724630SAlan Wright bcopy(&sin6.sin6_addr, 756fc724630SAlan Wright &session->local_ipaddr.au_addr.au_ipv6, 757fc724630SAlan Wright sizeof (in6_addr_t)); 758fc724630SAlan Wright slen = sizeof (sin6); 7597f667e74Sjose borrego (void) ksocket_getpeername(new_so, 7607f667e74Sjose borrego (struct sockaddr *)&sin6, &slen, CRED()); 761fc724630SAlan Wright bcopy(&sin6.sin6_addr, 762fc724630SAlan Wright &session->ipaddr.au_addr.au_ipv6, 763fc724630SAlan Wright sizeof (in6_addr_t)); 764a90cf9f2SGordon Ross rport = sin6.sin6_port; 7657f667e74Sjose borrego } 7667f667e74Sjose borrego session->ipaddr.a_family = family; 7677f667e74Sjose borrego session->local_ipaddr.a_family = family; 768da6c28aaSamw session->s_local_port = port; 769a90cf9f2SGordon Ross session->s_remote_port = ntohs(rport); 770da6c28aaSamw session->sock = new_so; 77149b5df1eSGordon Ross (void) smb_inet_ntop(&session->ipaddr, 77249b5df1eSGordon Ross session->ip_addr_str, INET6_ADDRSTRLEN); 773148c5f43SAlan Wright if (port == IPPORT_NETBIOS_SSN) 774148c5f43SAlan Wright smb_server_inc_nbt_sess(sv); 775148c5f43SAlan Wright else 776148c5f43SAlan Wright smb_server_inc_tcp_sess(sv); 777faa1795aSjb150015 } 778faa1795aSjb150015 session->s_server = sv; 779faa1795aSjb150015 smb_server_get_cfg(sv, &session->s_cfg); 780148c5f43SAlan Wright session->s_srqueue = &sv->sv_srqueue; 781148c5f43SAlan Wright 782a90cf9f2SGordon Ross /* 783a90cf9f2SGordon Ross * The initial new request handler is special, 784a90cf9f2SGordon Ross * and only accepts negotiation requests. 785a90cf9f2SGordon Ross */ 786a90cf9f2SGordon Ross session->newrq_func = smbsr_newrq_initial; 787a90cf9f2SGordon Ross 788a90cf9f2SGordon Ross /* These may increase in SMB2 negotiate. */ 789a90cf9f2SGordon Ross session->cmd_max_bytes = SMB_REQ_MAX_SIZE; 790a90cf9f2SGordon Ross session->reply_max_bytes = SMB_REQ_MAX_SIZE; 791a90cf9f2SGordon Ross 792da6c28aaSamw session->s_magic = SMB_SESSION_MAGIC; 793da6c28aaSamw return (session); 794da6c28aaSamw } 795da6c28aaSamw 796da6c28aaSamw void 797da6c28aaSamw smb_session_delete(smb_session_t *session) 798da6c28aaSamw { 7992c2961f8Sjose borrego 800da6c28aaSamw ASSERT(session->s_magic == SMB_SESSION_MAGIC); 801da6c28aaSamw 802b819cea2SGordon Ross if (session->sign_fini != NULL) 803b819cea2SGordon Ross session->sign_fini(session); 804b819cea2SGordon Ross 80512b65585SGordon Ross if (session->signing.mackey != NULL) { 80612b65585SGordon Ross kmem_free(session->signing.mackey, 80712b65585SGordon Ross session->signing.mackey_len); 80812b65585SGordon Ross } 80912b65585SGordon Ross 81012b65585SGordon Ross session->s_magic = 0; 81112b65585SGordon Ross 812da6c28aaSamw smb_rwx_destroy(&session->s_lock); 8135cdbe942Sjb150015 smb_net_txl_destructor(&session->s_txlst); 8142c2961f8Sjose borrego 815a90cf9f2SGordon Ross mutex_destroy(&session->s_credits_mutex); 816a90cf9f2SGordon Ross 817da6c28aaSamw smb_slist_destructor(&session->s_req_list); 8183b13a1efSThomas Keiser smb_llist_destructor(&session->s_tree_list); 819da6c28aaSamw smb_llist_destructor(&session->s_user_list); 820da6c28aaSamw smb_llist_destructor(&session->s_xa_list); 821da6c28aaSamw 822da6c28aaSamw ASSERT(session->s_tree_cnt == 0); 823da6c28aaSamw ASSERT(session->s_file_cnt == 0); 824da6c28aaSamw ASSERT(session->s_dir_cnt == 0); 825da6c28aaSamw 8263b13a1efSThomas Keiser smb_idpool_destructor(&session->s_tid_pool); 827da6c28aaSamw smb_idpool_destructor(&session->s_uid_pool); 8284163af6aSjose borrego if (session->sock != NULL) { 8294163af6aSjose borrego if (session->s_local_port == IPPORT_NETBIOS_SSN) 8304163af6aSjose borrego smb_server_dec_nbt_sess(session->s_server); 8314163af6aSjose borrego else 8324163af6aSjose borrego smb_server_dec_tcp_sess(session->s_server); 8334163af6aSjose borrego smb_sodestroy(session->sock); 8344163af6aSjose borrego } 8358622ec45SGordon Ross kmem_cache_free(smb_cache_session, session); 836da6c28aaSamw } 837da6c28aaSamw 8382c2961f8Sjose borrego static void 839da6c28aaSamw smb_session_cancel(smb_session_t *session) 840da6c28aaSamw { 841da6c28aaSamw smb_xa_t *xa, *nextxa; 842da6c28aaSamw 843da6c28aaSamw /* All the request currently being treated must be canceled. */ 844c8ec8eeaSjose borrego smb_session_cancel_requests(session, NULL, NULL); 845da6c28aaSamw 846da6c28aaSamw /* 847da6c28aaSamw * We wait for the completion of all the requests associated with 848da6c28aaSamw * this session. 849da6c28aaSamw */ 850da6c28aaSamw smb_slist_wait_for_empty(&session->s_req_list); 851da6c28aaSamw 852da6c28aaSamw /* 853da6c28aaSamw * At this point the reference count of the users, trees, files, 854da6c28aaSamw * directories should be zero. It should be possible to destroy them 855da6c28aaSamw * without any problem. 856da6c28aaSamw */ 857da6c28aaSamw xa = smb_llist_head(&session->s_xa_list); 858da6c28aaSamw while (xa) { 859da6c28aaSamw nextxa = smb_llist_next(&session->s_xa_list, xa); 860da6c28aaSamw smb_xa_close(xa); 861da6c28aaSamw xa = nextxa; 862da6c28aaSamw } 8639fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States 8649fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States smb_session_logoff(session); 865da6c28aaSamw } 866da6c28aaSamw 867c8ec8eeaSjose borrego /* 868c8ec8eeaSjose borrego * Cancel requests. If a non-null tree is specified, only requests specific 869c8ec8eeaSjose borrego * to that tree will be cancelled. If a non-null sr is specified, that sr 870c8ec8eeaSjose borrego * will be not be cancelled - this would typically be the caller's sr. 871c8ec8eeaSjose borrego */ 872da6c28aaSamw void 873da6c28aaSamw smb_session_cancel_requests( 874c8ec8eeaSjose borrego smb_session_t *session, 875c8ec8eeaSjose borrego smb_tree_t *tree, 876c8ec8eeaSjose borrego smb_request_t *exclude_sr) 877da6c28aaSamw { 878da6c28aaSamw smb_request_t *sr; 879da6c28aaSamw 880da6c28aaSamw smb_slist_enter(&session->s_req_list); 881da6c28aaSamw sr = smb_slist_head(&session->s_req_list); 882c8ec8eeaSjose borrego 883da6c28aaSamw while (sr) { 884da6c28aaSamw ASSERT(sr->sr_magic == SMB_REQ_MAGIC); 885c8ec8eeaSjose borrego if ((sr != exclude_sr) && 886c8ec8eeaSjose borrego (tree == NULL || sr->tid_tree == tree)) 887da6c28aaSamw smb_request_cancel(sr); 888da6c28aaSamw 889c8ec8eeaSjose borrego sr = smb_slist_next(&session->s_req_list, sr); 890da6c28aaSamw } 891c8ec8eeaSjose borrego 892da6c28aaSamw smb_slist_exit(&session->s_req_list); 893da6c28aaSamw } 894da6c28aaSamw 895faa1795aSjb150015 /* 8969fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States * Find a user on the specified session by SMB UID. 8979fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States */ 8989fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States smb_user_t * 8999fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States smb_session_lookup_uid(smb_session_t *session, uint16_t uid) 9009fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States { 90112b65585SGordon Ross return (smb_session_lookup_uid_st(session, uid, 90212b65585SGordon Ross SMB_USER_STATE_LOGGED_ON)); 90312b65585SGordon Ross } 90412b65585SGordon Ross 90512b65585SGordon Ross smb_user_t * 90612b65585SGordon Ross smb_session_lookup_uid_st(smb_session_t *session, uint16_t uid, 90712b65585SGordon Ross smb_user_state_t st) 90812b65585SGordon Ross { 9099fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States smb_user_t *user; 9109fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States smb_llist_t *user_list; 9119fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States 9129fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States SMB_SESSION_VALID(session); 9139fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States 9149fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States user_list = &session->s_user_list; 9159fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States smb_llist_enter(user_list, RW_READER); 9169fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States 9179fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States user = smb_llist_head(user_list); 9189fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States while (user) { 9199fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States SMB_USER_VALID(user); 9209fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States ASSERT(user->u_session == session); 9219fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States 92212b65585SGordon Ross if (user->u_uid == uid && user->u_state == st) { 92312b65585SGordon Ross smb_user_hold_internal(user); 9249fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States break; 9259fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States } 9269fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States 9279fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States user = smb_llist_next(user_list, user); 9289fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States } 9299fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States 9309fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States smb_llist_exit(user_list); 93112b65585SGordon Ross return (user); 9329fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States } 9339fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States 9349fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States void 9359fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States smb_session_post_user(smb_session_t *session, smb_user_t *user) 9369fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States { 9379fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States SMB_USER_VALID(user); 9389fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States ASSERT(user->u_refcnt == 0); 9399fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States ASSERT(user->u_state == SMB_USER_STATE_LOGGED_OFF); 9409fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States ASSERT(user->u_session == session); 9419fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States 9429fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States smb_llist_post(&session->s_user_list, user, smb_user_delete); 9439fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States } 9449fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States 9459fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States /* 9463b13a1efSThomas Keiser * Find a tree by tree-id. 9473b13a1efSThomas Keiser */ 9483b13a1efSThomas Keiser smb_tree_t * 9493b13a1efSThomas Keiser smb_session_lookup_tree( 9503b13a1efSThomas Keiser smb_session_t *session, 9513b13a1efSThomas Keiser uint16_t tid) 9523b13a1efSThomas Keiser 9533b13a1efSThomas Keiser { 9543b13a1efSThomas Keiser smb_tree_t *tree; 9553b13a1efSThomas Keiser 9563b13a1efSThomas Keiser SMB_SESSION_VALID(session); 9573b13a1efSThomas Keiser 9583b13a1efSThomas Keiser smb_llist_enter(&session->s_tree_list, RW_READER); 9593b13a1efSThomas Keiser tree = smb_llist_head(&session->s_tree_list); 9603b13a1efSThomas Keiser 9613b13a1efSThomas Keiser while (tree) { 9623b13a1efSThomas Keiser ASSERT3U(tree->t_magic, ==, SMB_TREE_MAGIC); 9633b13a1efSThomas Keiser ASSERT(tree->t_session == session); 9643b13a1efSThomas Keiser 9653b13a1efSThomas Keiser if (tree->t_tid == tid) { 9663b13a1efSThomas Keiser if (smb_tree_hold(tree)) { 9673b13a1efSThomas Keiser smb_llist_exit(&session->s_tree_list); 9683b13a1efSThomas Keiser return (tree); 9693b13a1efSThomas Keiser } else { 9703b13a1efSThomas Keiser smb_llist_exit(&session->s_tree_list); 9713b13a1efSThomas Keiser return (NULL); 9723b13a1efSThomas Keiser } 9733b13a1efSThomas Keiser } 9743b13a1efSThomas Keiser 9753b13a1efSThomas Keiser tree = smb_llist_next(&session->s_tree_list, tree); 9763b13a1efSThomas Keiser } 9773b13a1efSThomas Keiser 9783b13a1efSThomas Keiser smb_llist_exit(&session->s_tree_list); 9793b13a1efSThomas Keiser return (NULL); 9803b13a1efSThomas Keiser } 9813b13a1efSThomas Keiser 9823b13a1efSThomas Keiser /* 9833b13a1efSThomas Keiser * Find the first connected tree that matches the specified sharename. 9843b13a1efSThomas Keiser * If the specified tree is NULL the search starts from the beginning of 9853b13a1efSThomas Keiser * the user's tree list. If a tree is provided the search starts just 9863b13a1efSThomas Keiser * after that tree. 9873b13a1efSThomas Keiser */ 9883b13a1efSThomas Keiser smb_tree_t * 9893b13a1efSThomas Keiser smb_session_lookup_share( 9903b13a1efSThomas Keiser smb_session_t *session, 9913b13a1efSThomas Keiser const char *sharename, 9923b13a1efSThomas Keiser smb_tree_t *tree) 9933b13a1efSThomas Keiser { 9943b13a1efSThomas Keiser SMB_SESSION_VALID(session); 9953b13a1efSThomas Keiser ASSERT(sharename); 9963b13a1efSThomas Keiser 9973b13a1efSThomas Keiser smb_llist_enter(&session->s_tree_list, RW_READER); 9983b13a1efSThomas Keiser 9993b13a1efSThomas Keiser if (tree) { 10003b13a1efSThomas Keiser ASSERT3U(tree->t_magic, ==, SMB_TREE_MAGIC); 10013b13a1efSThomas Keiser ASSERT(tree->t_session == session); 10023b13a1efSThomas Keiser tree = smb_llist_next(&session->s_tree_list, tree); 10033b13a1efSThomas Keiser } else { 10043b13a1efSThomas Keiser tree = smb_llist_head(&session->s_tree_list); 10053b13a1efSThomas Keiser } 10063b13a1efSThomas Keiser 10073b13a1efSThomas Keiser while (tree) { 10083b13a1efSThomas Keiser ASSERT3U(tree->t_magic, ==, SMB_TREE_MAGIC); 10093b13a1efSThomas Keiser ASSERT(tree->t_session == session); 10103b13a1efSThomas Keiser if (smb_strcasecmp(tree->t_sharename, sharename, 0) == 0) { 10113b13a1efSThomas Keiser if (smb_tree_hold(tree)) { 10123b13a1efSThomas Keiser smb_llist_exit(&session->s_tree_list); 10133b13a1efSThomas Keiser return (tree); 10143b13a1efSThomas Keiser } 10153b13a1efSThomas Keiser } 10163b13a1efSThomas Keiser tree = smb_llist_next(&session->s_tree_list, tree); 10173b13a1efSThomas Keiser } 10183b13a1efSThomas Keiser 10193b13a1efSThomas Keiser smb_llist_exit(&session->s_tree_list); 10203b13a1efSThomas Keiser return (NULL); 10213b13a1efSThomas Keiser } 10223b13a1efSThomas Keiser 10233b13a1efSThomas Keiser /* 10243b13a1efSThomas Keiser * Find the first connected tree that matches the specified volume name. 10253b13a1efSThomas Keiser * If the specified tree is NULL the search starts from the beginning of 10263b13a1efSThomas Keiser * the user's tree list. If a tree is provided the search starts just 10273b13a1efSThomas Keiser * after that tree. 10283b13a1efSThomas Keiser */ 10293b13a1efSThomas Keiser smb_tree_t * 10303b13a1efSThomas Keiser smb_session_lookup_volume( 10313b13a1efSThomas Keiser smb_session_t *session, 10323b13a1efSThomas Keiser const char *name, 10333b13a1efSThomas Keiser smb_tree_t *tree) 10343b13a1efSThomas Keiser { 10353b13a1efSThomas Keiser SMB_SESSION_VALID(session); 10363b13a1efSThomas Keiser ASSERT(name); 10373b13a1efSThomas Keiser 10383b13a1efSThomas Keiser smb_llist_enter(&session->s_tree_list, RW_READER); 10393b13a1efSThomas Keiser 10403b13a1efSThomas Keiser if (tree) { 10413b13a1efSThomas Keiser ASSERT3U(tree->t_magic, ==, SMB_TREE_MAGIC); 10423b13a1efSThomas Keiser ASSERT(tree->t_session == session); 10433b13a1efSThomas Keiser tree = smb_llist_next(&session->s_tree_list, tree); 10443b13a1efSThomas Keiser } else { 10453b13a1efSThomas Keiser tree = smb_llist_head(&session->s_tree_list); 10463b13a1efSThomas Keiser } 10473b13a1efSThomas Keiser 10483b13a1efSThomas Keiser while (tree) { 10493b13a1efSThomas Keiser ASSERT3U(tree->t_magic, ==, SMB_TREE_MAGIC); 10503b13a1efSThomas Keiser ASSERT(tree->t_session == session); 10513b13a1efSThomas Keiser 10523b13a1efSThomas Keiser if (smb_strcasecmp(tree->t_volume, name, 0) == 0) { 10533b13a1efSThomas Keiser if (smb_tree_hold(tree)) { 10543b13a1efSThomas Keiser smb_llist_exit(&session->s_tree_list); 10553b13a1efSThomas Keiser return (tree); 10563b13a1efSThomas Keiser } 10573b13a1efSThomas Keiser } 10583b13a1efSThomas Keiser 10593b13a1efSThomas Keiser tree = smb_llist_next(&session->s_tree_list, tree); 10603b13a1efSThomas Keiser } 10613b13a1efSThomas Keiser 10623b13a1efSThomas Keiser smb_llist_exit(&session->s_tree_list); 10633b13a1efSThomas Keiser return (NULL); 10643b13a1efSThomas Keiser } 10653b13a1efSThomas Keiser 10663b13a1efSThomas Keiser /* 10673b13a1efSThomas Keiser * Disconnect all trees that match the specified client process-id. 10683b13a1efSThomas Keiser */ 10693b13a1efSThomas Keiser void 10703b13a1efSThomas Keiser smb_session_close_pid( 10713b13a1efSThomas Keiser smb_session_t *session, 1072a90cf9f2SGordon Ross uint32_t pid) 10733b13a1efSThomas Keiser { 10743b13a1efSThomas Keiser smb_tree_t *tree; 10753b13a1efSThomas Keiser 10763b13a1efSThomas Keiser SMB_SESSION_VALID(session); 10773b13a1efSThomas Keiser 10783b13a1efSThomas Keiser tree = smb_session_get_tree(session, NULL); 10793b13a1efSThomas Keiser while (tree) { 10803b13a1efSThomas Keiser smb_tree_t *next; 10813b13a1efSThomas Keiser ASSERT3U(tree->t_magic, ==, SMB_TREE_MAGIC); 10823b13a1efSThomas Keiser ASSERT(tree->t_session == session); 10833b13a1efSThomas Keiser smb_tree_close_pid(tree, pid); 10843b13a1efSThomas Keiser next = smb_session_get_tree(session, tree); 10853b13a1efSThomas Keiser smb_tree_release(tree); 10863b13a1efSThomas Keiser tree = next; 10873b13a1efSThomas Keiser } 10883b13a1efSThomas Keiser } 10893b13a1efSThomas Keiser 10903b13a1efSThomas Keiser static void 10913b13a1efSThomas Keiser smb_session_tree_dtor(void *t) 10923b13a1efSThomas Keiser { 10933b13a1efSThomas Keiser smb_tree_t *tree = (smb_tree_t *)t; 10943b13a1efSThomas Keiser 10953b13a1efSThomas Keiser smb_tree_disconnect(tree, B_TRUE); 10963b13a1efSThomas Keiser /* release the ref acquired during the traversal loop */ 10973b13a1efSThomas Keiser smb_tree_release(tree); 10983b13a1efSThomas Keiser } 10993b13a1efSThomas Keiser 11003b13a1efSThomas Keiser 11013b13a1efSThomas Keiser /* 11023b13a1efSThomas Keiser * Disconnect all trees that this user has connected. 11033b13a1efSThomas Keiser */ 11043b13a1efSThomas Keiser void 11053b13a1efSThomas Keiser smb_session_disconnect_owned_trees( 11063b13a1efSThomas Keiser smb_session_t *session, 11073b13a1efSThomas Keiser smb_user_t *owner) 11083b13a1efSThomas Keiser { 11093b13a1efSThomas Keiser smb_tree_t *tree; 11103b13a1efSThomas Keiser smb_llist_t *tree_list = &session->s_tree_list; 11113b13a1efSThomas Keiser 11123b13a1efSThomas Keiser SMB_SESSION_VALID(session); 11133b13a1efSThomas Keiser SMB_USER_VALID(owner); 11143b13a1efSThomas Keiser 11153b13a1efSThomas Keiser smb_llist_enter(tree_list, RW_READER); 11163b13a1efSThomas Keiser 11173b13a1efSThomas Keiser tree = smb_llist_head(tree_list); 11183b13a1efSThomas Keiser while (tree) { 11193b13a1efSThomas Keiser if ((tree->t_owner == owner) && 11203b13a1efSThomas Keiser smb_tree_hold(tree)) { 11213b13a1efSThomas Keiser /* 11223b13a1efSThomas Keiser * smb_tree_hold() succeeded, hence we are in state 11233b13a1efSThomas Keiser * SMB_TREE_STATE_CONNECTED; schedule this tree 11243b13a1efSThomas Keiser * for asynchronous disconnect, which will fire 11253b13a1efSThomas Keiser * after we drop the llist traversal lock. 11263b13a1efSThomas Keiser */ 11273b13a1efSThomas Keiser smb_llist_post(tree_list, tree, smb_session_tree_dtor); 11283b13a1efSThomas Keiser } 11293b13a1efSThomas Keiser tree = smb_llist_next(tree_list, tree); 11303b13a1efSThomas Keiser } 11313b13a1efSThomas Keiser 11323b13a1efSThomas Keiser /* drop the lock and flush the dtor queue */ 11333b13a1efSThomas Keiser smb_llist_exit(tree_list); 11343b13a1efSThomas Keiser } 11353b13a1efSThomas Keiser 11363b13a1efSThomas Keiser /* 11373b13a1efSThomas Keiser * Disconnect all trees that this user has connected. 11383b13a1efSThomas Keiser */ 11393b13a1efSThomas Keiser void 11403b13a1efSThomas Keiser smb_session_disconnect_trees( 11413b13a1efSThomas Keiser smb_session_t *session) 11423b13a1efSThomas Keiser { 11433b13a1efSThomas Keiser smb_tree_t *tree; 11443b13a1efSThomas Keiser 11453b13a1efSThomas Keiser SMB_SESSION_VALID(session); 11463b13a1efSThomas Keiser 11473b13a1efSThomas Keiser tree = smb_session_get_tree(session, NULL); 11483b13a1efSThomas Keiser while (tree) { 11493b13a1efSThomas Keiser ASSERT3U(tree->t_magic, ==, SMB_TREE_MAGIC); 11503b13a1efSThomas Keiser ASSERT(tree->t_session == session); 11513b13a1efSThomas Keiser smb_tree_disconnect(tree, B_TRUE); 11523b13a1efSThomas Keiser smb_tree_release(tree); 11533b13a1efSThomas Keiser tree = smb_session_get_tree(session, NULL); 11543b13a1efSThomas Keiser } 11553b13a1efSThomas Keiser } 11563b13a1efSThomas Keiser 11573b13a1efSThomas Keiser /* 11583b13a1efSThomas Keiser * Disconnect all trees that match the specified share name. 11593b13a1efSThomas Keiser */ 11603b13a1efSThomas Keiser void 11613b13a1efSThomas Keiser smb_session_disconnect_share( 11623b13a1efSThomas Keiser smb_session_t *session, 11633b13a1efSThomas Keiser const char *sharename) 11643b13a1efSThomas Keiser { 11653b13a1efSThomas Keiser smb_tree_t *tree; 11663b13a1efSThomas Keiser smb_tree_t *next; 11673b13a1efSThomas Keiser 11683b13a1efSThomas Keiser SMB_SESSION_VALID(session); 11693b13a1efSThomas Keiser 11703b13a1efSThomas Keiser tree = smb_session_lookup_share(session, sharename, NULL); 11713b13a1efSThomas Keiser while (tree) { 11723b13a1efSThomas Keiser ASSERT3U(tree->t_magic, ==, SMB_TREE_MAGIC); 11733b13a1efSThomas Keiser ASSERT(tree->t_session == session); 11743b13a1efSThomas Keiser smb_session_cancel_requests(session, tree, NULL); 11753b13a1efSThomas Keiser smb_tree_disconnect(tree, B_TRUE); 11763b13a1efSThomas Keiser next = smb_session_lookup_share(session, sharename, tree); 11773b13a1efSThomas Keiser smb_tree_release(tree); 11783b13a1efSThomas Keiser tree = next; 11793b13a1efSThomas Keiser } 11803b13a1efSThomas Keiser } 11813b13a1efSThomas Keiser 11823b13a1efSThomas Keiser void 11833b13a1efSThomas Keiser smb_session_post_tree(smb_session_t *session, smb_tree_t *tree) 11843b13a1efSThomas Keiser { 11853b13a1efSThomas Keiser SMB_SESSION_VALID(session); 11863b13a1efSThomas Keiser SMB_TREE_VALID(tree); 11873b13a1efSThomas Keiser ASSERT0(tree->t_refcnt); 11883b13a1efSThomas Keiser ASSERT(tree->t_state == SMB_TREE_STATE_DISCONNECTED); 11893b13a1efSThomas Keiser ASSERT(tree->t_session == session); 11903b13a1efSThomas Keiser 11913b13a1efSThomas Keiser smb_llist_post(&session->s_tree_list, tree, smb_tree_dealloc); 11923b13a1efSThomas Keiser } 11933b13a1efSThomas Keiser 11943b13a1efSThomas Keiser /* 11953b13a1efSThomas Keiser * Get the next connected tree in the list. A reference is taken on 11963b13a1efSThomas Keiser * the tree, which can be released later with smb_tree_release(). 11973b13a1efSThomas Keiser * 11983b13a1efSThomas Keiser * If the specified tree is NULL the search starts from the beginning of 11993b13a1efSThomas Keiser * the tree list. If a tree is provided the search starts just after 12003b13a1efSThomas Keiser * that tree. 12013b13a1efSThomas Keiser * 12023b13a1efSThomas Keiser * Returns NULL if there are no connected trees in the list. 12033b13a1efSThomas Keiser */ 12043b13a1efSThomas Keiser static smb_tree_t * 12053b13a1efSThomas Keiser smb_session_get_tree( 12063b13a1efSThomas Keiser smb_session_t *session, 12073b13a1efSThomas Keiser smb_tree_t *tree) 12083b13a1efSThomas Keiser { 12093b13a1efSThomas Keiser smb_llist_t *tree_list; 12103b13a1efSThomas Keiser 12113b13a1efSThomas Keiser SMB_SESSION_VALID(session); 12123b13a1efSThomas Keiser tree_list = &session->s_tree_list; 12133b13a1efSThomas Keiser 12143b13a1efSThomas Keiser smb_llist_enter(tree_list, RW_READER); 12153b13a1efSThomas Keiser 12163b13a1efSThomas Keiser if (tree) { 12173b13a1efSThomas Keiser ASSERT3U(tree->t_magic, ==, SMB_TREE_MAGIC); 12183b13a1efSThomas Keiser tree = smb_llist_next(tree_list, tree); 12193b13a1efSThomas Keiser } else { 12203b13a1efSThomas Keiser tree = smb_llist_head(tree_list); 12213b13a1efSThomas Keiser } 12223b13a1efSThomas Keiser 12233b13a1efSThomas Keiser while (tree) { 12243b13a1efSThomas Keiser if (smb_tree_hold(tree)) 12253b13a1efSThomas Keiser break; 12263b13a1efSThomas Keiser 12273b13a1efSThomas Keiser tree = smb_llist_next(tree_list, tree); 12283b13a1efSThomas Keiser } 12293b13a1efSThomas Keiser 12303b13a1efSThomas Keiser smb_llist_exit(tree_list); 12313b13a1efSThomas Keiser return (tree); 12323b13a1efSThomas Keiser } 12333b13a1efSThomas Keiser 12343b13a1efSThomas Keiser /* 12359fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States * Logoff all users associated with the specified session. 12369fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States */ 12379fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States static void 12389fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States smb_session_logoff(smb_session_t *session) 12399fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States { 12409fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States smb_user_t *user; 12419fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States 12429fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States SMB_SESSION_VALID(session); 12439fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States 12443b13a1efSThomas Keiser smb_session_disconnect_trees(session); 12453b13a1efSThomas Keiser 12469fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States smb_llist_enter(&session->s_user_list, RW_READER); 12479fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States 12489fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States user = smb_llist_head(&session->s_user_list); 12499fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States while (user) { 12509fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States SMB_USER_VALID(user); 12519fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States ASSERT(user->u_session == session); 12529fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States 125312b65585SGordon Ross switch (user->u_state) { 125412b65585SGordon Ross case SMB_USER_STATE_LOGGING_ON: 125512b65585SGordon Ross case SMB_USER_STATE_LOGGED_ON: 125612b65585SGordon Ross smb_user_hold_internal(user); 12579fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States smb_user_logoff(user); 12589fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States smb_user_release(user); 125912b65585SGordon Ross break; 126012b65585SGordon Ross 126112b65585SGordon Ross case SMB_USER_STATE_LOGGED_OFF: 126212b65585SGordon Ross case SMB_USER_STATE_LOGGING_OFF: 126312b65585SGordon Ross break; 126412b65585SGordon Ross 126512b65585SGordon Ross default: 126612b65585SGordon Ross ASSERT(0); 126712b65585SGordon Ross break; 12689fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States } 12699fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States 12709fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States user = smb_llist_next(&session->s_user_list, user); 12719fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States } 12729fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States 12739fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States smb_llist_exit(&session->s_user_list); 12749fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States } 12759fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States 12769fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States /* 12771fcced4cSJordan Brown * Copy the session workstation/client name to buf. If the workstation 12781fcced4cSJordan Brown * is an empty string (which it will be on TCP connections), use the 12791fcced4cSJordan Brown * client IP address. 12801fcced4cSJordan Brown */ 12811fcced4cSJordan Brown void 12821fcced4cSJordan Brown smb_session_getclient(smb_session_t *sn, char *buf, size_t buflen) 12831fcced4cSJordan Brown { 12841fcced4cSJordan Brown 12851fcced4cSJordan Brown *buf = '\0'; 12861fcced4cSJordan Brown 12871fcced4cSJordan Brown if (sn->workstation[0] != '\0') { 12881fcced4cSJordan Brown (void) strlcpy(buf, sn->workstation, buflen); 12891fcced4cSJordan Brown return; 12901fcced4cSJordan Brown } 12911fcced4cSJordan Brown 129249b5df1eSGordon Ross (void) strlcpy(buf, sn->ip_addr_str, buflen); 12931fcced4cSJordan Brown } 12941fcced4cSJordan Brown 12951fcced4cSJordan Brown /* 12961fcced4cSJordan Brown * Check whether or not the specified client name is the client of this 12971fcced4cSJordan Brown * session. The name may be in UNC format (\\CLIENT). 12981fcced4cSJordan Brown * 12991fcced4cSJordan Brown * A workstation/client name is setup on NBT connections as part of the 13001fcced4cSJordan Brown * NetBIOS session request but that isn't available on TCP connections. 13011fcced4cSJordan Brown * If the session doesn't have a client name we typically return the 13021fcced4cSJordan Brown * client IP address as the workstation name on MSRPC requests. So we 13031fcced4cSJordan Brown * check for the IP address here in addition to the workstation name. 13041fcced4cSJordan Brown */ 13051fcced4cSJordan Brown boolean_t 13061fcced4cSJordan Brown smb_session_isclient(smb_session_t *sn, const char *client) 13071fcced4cSJordan Brown { 13081fcced4cSJordan Brown 13091fcced4cSJordan Brown client += strspn(client, "\\"); 13101fcced4cSJordan Brown 1311bbf6f00cSJordan Brown if (smb_strcasecmp(client, sn->workstation, 0) == 0) 13121fcced4cSJordan Brown return (B_TRUE); 13131fcced4cSJordan Brown 131449b5df1eSGordon Ross if (smb_strcasecmp(client, sn->ip_addr_str, 0) == 0) 13151fcced4cSJordan Brown return (B_TRUE); 13161fcced4cSJordan Brown 13171fcced4cSJordan Brown return (B_FALSE); 13181fcced4cSJordan Brown } 13191fcced4cSJordan Brown 13201fcced4cSJordan Brown /* 1321faa1795aSjb150015 * smb_request_alloc 1322faa1795aSjb150015 * 1323faa1795aSjb150015 * Allocate an smb_request_t structure from the kmem_cache. Partially 1324faa1795aSjb150015 * initialize the found/new request. 1325faa1795aSjb150015 * 13269c856e86SMatt Barden * Returns pointer to a request, or NULL if the session state is 13279c856e86SMatt Barden * one in which new requests are no longer allowed. 1328faa1795aSjb150015 */ 1329faa1795aSjb150015 smb_request_t * 1330faa1795aSjb150015 smb_request_alloc(smb_session_t *session, int req_length) 1331faa1795aSjb150015 { 1332faa1795aSjb150015 smb_request_t *sr; 1333faa1795aSjb150015 1334faa1795aSjb150015 ASSERT(session->s_magic == SMB_SESSION_MAGIC); 1335a90cf9f2SGordon Ross ASSERT(req_length <= session->cmd_max_bytes); 1336faa1795aSjb150015 13378622ec45SGordon Ross sr = kmem_cache_alloc(smb_cache_request, KM_SLEEP); 1338faa1795aSjb150015 1339faa1795aSjb150015 /* 1340faa1795aSjb150015 * Future: Use constructor to pre-initialize some fields. For now 1341faa1795aSjb150015 * there are so many fields that it is easiest just to zero the 1342faa1795aSjb150015 * whole thing and start over. 1343faa1795aSjb150015 */ 1344faa1795aSjb150015 bzero(sr, sizeof (smb_request_t)); 1345faa1795aSjb150015 1346faa1795aSjb150015 mutex_init(&sr->sr_mutex, NULL, MUTEX_DEFAULT, NULL); 1347bbf6f00cSJordan Brown smb_srm_init(sr); 1348faa1795aSjb150015 sr->session = session; 1349faa1795aSjb150015 sr->sr_server = session->s_server; 1350faa1795aSjb150015 sr->sr_gmtoff = session->s_server->si_gmtoff; 1351faa1795aSjb150015 sr->sr_cfg = &session->s_cfg; 1352faa1795aSjb150015 sr->command.max_bytes = req_length; 1353a90cf9f2SGordon Ross sr->reply.max_bytes = session->reply_max_bytes; 1354faa1795aSjb150015 sr->sr_req_length = req_length; 1355faa1795aSjb150015 if (req_length) 1356faa1795aSjb150015 sr->sr_request_buf = kmem_alloc(req_length, KM_SLEEP); 1357faa1795aSjb150015 sr->sr_magic = SMB_REQ_MAGIC; 1358faa1795aSjb150015 sr->sr_state = SMB_REQ_STATE_INITIALIZING; 13599c856e86SMatt Barden 13609c856e86SMatt Barden /* 13619c856e86SMatt Barden * Only allow new SMB requests in some states. 13629c856e86SMatt Barden */ 13639c856e86SMatt Barden smb_rwx_rwenter(&session->s_lock, RW_WRITER); 13649c856e86SMatt Barden switch (session->s_state) { 13659c856e86SMatt Barden case SMB_SESSION_STATE_CONNECTED: 13669c856e86SMatt Barden case SMB_SESSION_STATE_INITIALIZED: 13679c856e86SMatt Barden case SMB_SESSION_STATE_ESTABLISHED: 13689c856e86SMatt Barden case SMB_SESSION_STATE_NEGOTIATED: 1369faa1795aSjb150015 smb_slist_insert_tail(&session->s_req_list, sr); 13709c856e86SMatt Barden break; 13719c856e86SMatt Barden 13729c856e86SMatt Barden default: 13739c856e86SMatt Barden ASSERT(0); 13749c856e86SMatt Barden /* FALLTHROUGH */ 13759c856e86SMatt Barden case SMB_SESSION_STATE_DISCONNECTED: 13769c856e86SMatt Barden case SMB_SESSION_STATE_TERMINATED: 13779c856e86SMatt Barden /* Disallow new requests in these states. */ 13789c856e86SMatt Barden if (sr->sr_request_buf) 13799c856e86SMatt Barden kmem_free(sr->sr_request_buf, sr->sr_req_length); 13809c856e86SMatt Barden sr->session = NULL; 13819c856e86SMatt Barden sr->sr_magic = 0; 13829c856e86SMatt Barden mutex_destroy(&sr->sr_mutex); 13839c856e86SMatt Barden kmem_cache_free(smb_cache_request, sr); 13849c856e86SMatt Barden sr = NULL; 13859c856e86SMatt Barden break; 13869c856e86SMatt Barden } 13879c856e86SMatt Barden smb_rwx_rwexit(&session->s_lock); 13889c856e86SMatt Barden 1389faa1795aSjb150015 return (sr); 1390faa1795aSjb150015 } 1391faa1795aSjb150015 1392faa1795aSjb150015 /* 1393faa1795aSjb150015 * smb_request_free 1394faa1795aSjb150015 * 1395faa1795aSjb150015 * release the memories which have been allocated for a smb request. 1396faa1795aSjb150015 */ 1397faa1795aSjb150015 void 1398faa1795aSjb150015 smb_request_free(smb_request_t *sr) 1399faa1795aSjb150015 { 1400faa1795aSjb150015 ASSERT(sr->sr_magic == SMB_REQ_MAGIC); 1401faa1795aSjb150015 ASSERT(sr->session); 1402faa1795aSjb150015 ASSERT(sr->r_xa == NULL); 1403faa1795aSjb150015 1404cb174861Sjoyce mcintosh if (sr->fid_ofile != NULL) { 1405cb174861Sjoyce mcintosh smb_ofile_request_complete(sr->fid_ofile); 14062c2961f8Sjose borrego smb_ofile_release(sr->fid_ofile); 1407cb174861Sjoyce mcintosh } 14082c2961f8Sjose borrego 14092c2961f8Sjose borrego if (sr->tid_tree != NULL) 1410faa1795aSjb150015 smb_tree_release(sr->tid_tree); 1411faa1795aSjb150015 14122c2961f8Sjose borrego if (sr->uid_user != NULL) 1413faa1795aSjb150015 smb_user_release(sr->uid_user); 1414faa1795aSjb150015 14158f70e16bSGordon Ross /* 14168f70e16bSGordon Ross * The above may have left work on the delete queues 14178f70e16bSGordon Ross */ 14188f70e16bSGordon Ross smb_llist_flush(&sr->session->s_tree_list); 14198f70e16bSGordon Ross smb_llist_flush(&sr->session->s_user_list); 14208f70e16bSGordon Ross 1421faa1795aSjb150015 smb_slist_remove(&sr->session->s_req_list, sr); 1422faa1795aSjb150015 1423faa1795aSjb150015 sr->session = NULL; 1424faa1795aSjb150015 1425bbf6f00cSJordan Brown smb_srm_fini(sr); 1426faa1795aSjb150015 1427faa1795aSjb150015 if (sr->sr_request_buf) 1428faa1795aSjb150015 kmem_free(sr->sr_request_buf, sr->sr_req_length); 1429faa1795aSjb150015 if (sr->command.chain) 1430faa1795aSjb150015 m_freem(sr->command.chain); 1431faa1795aSjb150015 if (sr->reply.chain) 1432faa1795aSjb150015 m_freem(sr->reply.chain); 1433faa1795aSjb150015 if (sr->raw_data.chain) 1434faa1795aSjb150015 m_freem(sr->raw_data.chain); 1435faa1795aSjb150015 1436faa1795aSjb150015 sr->sr_magic = 0; 1437faa1795aSjb150015 mutex_destroy(&sr->sr_mutex); 14388622ec45SGordon Ross kmem_cache_free(smb_cache_request, sr); 1439da6c28aaSamw } 14407f667e74Sjose borrego 14412c2961f8Sjose borrego boolean_t 14422c2961f8Sjose borrego smb_session_oplocks_enable(smb_session_t *session) 14432c2961f8Sjose borrego { 14442c2961f8Sjose borrego SMB_SESSION_VALID(session); 14452c2961f8Sjose borrego if (session->s_cfg.skc_oplock_enable == 0) 14462c2961f8Sjose borrego return (B_FALSE); 14472c2961f8Sjose borrego else 14482c2961f8Sjose borrego return (B_TRUE); 14492c2961f8Sjose borrego } 14502c2961f8Sjose borrego 1451cb174861Sjoyce mcintosh boolean_t 1452cb174861Sjoyce mcintosh smb_session_levelII_oplocks(smb_session_t *session) 1453cb174861Sjoyce mcintosh { 1454cb174861Sjoyce mcintosh SMB_SESSION_VALID(session); 1455a90cf9f2SGordon Ross 1456a90cf9f2SGordon Ross /* Clients using SMB2 and later always know about oplocks. */ 1457a90cf9f2SGordon Ross if (session->dialect > NT_LM_0_12) 1458a90cf9f2SGordon Ross return (B_TRUE); 1459a90cf9f2SGordon Ross 1460a90cf9f2SGordon Ross /* Older clients only do Level II oplocks if negotiated. */ 1461a90cf9f2SGordon Ross if ((session->capabilities & CAP_LEVEL_II_OPLOCKS) != 0) 1462a90cf9f2SGordon Ross return (B_TRUE); 1463a90cf9f2SGordon Ross 1464a90cf9f2SGordon Ross return (B_FALSE); 1465cb174861Sjoyce mcintosh } 1466cb174861Sjoyce mcintosh 14672c2961f8Sjose borrego /* 1468cb174861Sjoyce mcintosh * smb_session_oplock_break 14692c2961f8Sjose borrego * 1470a90cf9f2SGordon Ross * Send an oplock break request to the client, 1471a90cf9f2SGordon Ross * recalling some cache delegation. 14722c2961f8Sjose borrego */ 14732c2961f8Sjose borrego void 1474a90cf9f2SGordon Ross smb_session_oplock_break(smb_request_t *sr, uint8_t brk) 14752c2961f8Sjose borrego { 1476a90cf9f2SGordon Ross smb_session_t *session = sr->session; 1477a90cf9f2SGordon Ross mbuf_chain_t *mbc = &sr->reply; 14782c2961f8Sjose borrego 14792c2961f8Sjose borrego SMB_SESSION_VALID(session); 14802c2961f8Sjose borrego 1481a90cf9f2SGordon Ross /* 1482a90cf9f2SGordon Ross * Build the break message in sr->reply and then send it. 1483a90cf9f2SGordon Ross * The mbc is free'd later, in smb_request_free(). 1484a90cf9f2SGordon Ross */ 1485a90cf9f2SGordon Ross mbc->max_bytes = MLEN; 1486a90cf9f2SGordon Ross if (session->dialect <= NT_LM_0_12) { 1487a90cf9f2SGordon Ross smb1_oplock_break_notification(sr, brk); 1488a90cf9f2SGordon Ross } else { 1489a90cf9f2SGordon Ross smb2_oplock_break_notification(sr, brk); 14902c2961f8Sjose borrego } 1491a90cf9f2SGordon Ross 1492a90cf9f2SGordon Ross (void) smb_session_send(session, 0, mbc); 14932c2961f8Sjose borrego } 1494f9bc6dadSDmitry.Savitsky@nexenta.com 1495f9bc6dadSDmitry.Savitsky@nexenta.com static void 1496f9bc6dadSDmitry.Savitsky@nexenta.com smb_session_genkey(smb_session_t *session) 1497f9bc6dadSDmitry.Savitsky@nexenta.com { 1498f9bc6dadSDmitry.Savitsky@nexenta.com uint8_t tmp_key[SMB_CHALLENGE_SZ]; 1499f9bc6dadSDmitry.Savitsky@nexenta.com 1500f9bc6dadSDmitry.Savitsky@nexenta.com (void) random_get_pseudo_bytes(tmp_key, SMB_CHALLENGE_SZ); 1501f9bc6dadSDmitry.Savitsky@nexenta.com bcopy(tmp_key, &session->challenge_key, SMB_CHALLENGE_SZ); 1502f9bc6dadSDmitry.Savitsky@nexenta.com session->challenge_len = SMB_CHALLENGE_SZ; 1503f9bc6dadSDmitry.Savitsky@nexenta.com 1504f9bc6dadSDmitry.Savitsky@nexenta.com (void) random_get_pseudo_bytes(tmp_key, 4); 1505f9bc6dadSDmitry.Savitsky@nexenta.com session->sesskey = tmp_key[0] | tmp_key[1] << 8 | 1506f9bc6dadSDmitry.Savitsky@nexenta.com tmp_key[2] << 16 | tmp_key[3] << 24; 1507f9bc6dadSDmitry.Savitsky@nexenta.com } 1508