void
MBC_ATTACH_MBUF(struct mbuf_chain *MBC, struct mbuf *MBUF)
{
if (MBC->chain != 0)
MBC_FLUSH(MBC);
(MBC)->chain_offset = 0;
(MBC)->chain = (MBUF);
}
/*
* 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);
}
/*
* Dispatch an async request using saved information.
* See smb2sr_save_async and [MS-SMB2] 3.3.4.2
*/
void
smb2sr_do_async(smb_request_t *sr)
{
smb2_async_req_t *ar;
int rc;
/*
* Restore what smb2_decode_header found.
*/
ar = sr->sr_async_req;
sr->smb2_cmd_hdr = ar->ar_cmd_hdr;
sr->smb2_cmd_code = ar->ar_cmd_code;
sr->smb2_hdr_flags = ar->ar_hdr_flags;
sr->smb2_async_id = (uintptr_t)ar;
sr->smb2_messageid = ar->ar_messageid;
sr->smb_pid = ar->ar_pid;
sr->smb_tid = ar->ar_tid;
sr->smb2_status = 0;
/*
* Async requests don't grant credits, because any credits
* should have gone out with the interim reply.
*/
sr->smb2_credit_response = 0;
/*
* Setup input mbuf_chain
*/
ASSERT(ar->ar_cmd_len >= SMB2_HDR_SIZE);
(void) MBC_SHADOW_CHAIN(&sr->smb_data, &sr->command,
sr->smb2_cmd_hdr + SMB2_HDR_SIZE,
ar->ar_cmd_len - SMB2_HDR_SIZE);
/*
* Setup output mbuf_chain
*/
MBC_FLUSH(&sr->reply);
sr->smb2_reply_hdr = sr->reply.chain_offset;
(void) smb_mbc_encodef(&sr->reply, "#.", SMB2_HDR_SIZE);
/*
* Call the common dispatch code, but override the
* command handler function with the async handler
* (ar->ar_func) which will be used instead of the
* normal handler from the dispatch table.
* The SMB signature was already checked.
*/
rc = smb2sr_dispatch(sr, ar->ar_func);
if (rc != 0 && sr->smb2_status == 0)
sr->smb2_status = NT_STATUS_INTERNAL_ERROR;
/*
* Overwrite the SMB2 header for the response of
* this command (possibly part of a compound).
*/
sr->smb2_hdr_flags |= SMB2_FLAGS_SERVER_TO_REDIR;
sr->smb2_next_reply = 0;
(void) smb2_encode_header(sr, B_TRUE);
if (sr->smb2_hdr_flags & SMB2_FLAGS_SIGNED)
smb2_sign_reply(sr);
/*
* An async reply goes alone (no compound).
*/
smb2_send_reply(sr);
/*
* Done. Unlink and free.
*/
sr->sr_async_req = NULL;
kmem_free(ar, sizeof (*ar));
}
