smb_dispatch.c revision eb1d736b1c19f6abeee90c921a9320b67fedd016
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2009 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/*
* SMB requests.
*
* Request
* Header
* Magic 0xFF 'S' 'M' 'B'
* smb_com a byte, the "first" command
* Error a 4-byte union, ignored in a request
* smb_flg a one byte set of eight flags
* smb_flg2 a two byte set of 16 flags
* . twelve reserved bytes, have a role
* in connectionless transports (IPX, UDP?)
* smb_tid a 16-bit tree ID, a mount point sorta,
* 0xFFFF is this command does not have
* or require a tree context
* smb_pid a 16-bit process ID
* smb_uid a 16-bit user ID, specific to this "session"
* and mapped to a system (bona-fide) UID
* smb_mid a 16-bit multiplex ID, used to differentiate
* multiple simultaneous requests from the same
* process (pid) (ref RPC "xid")
*
* Chained (AndX) commands (0 or more)
* smb_wct a byte, number of 16-bit words containing
* command parameters, min 2 for chained command
* andx_com a byte, the "next" command, 0xFF for none
* . an unused byte
* andx_off a 16-bit offset, byte displacement from &Magic
* to the smb_wct field of the "next" command,
* ignore if andx_com is 0xFF, s/b 0 if no next
* smb_vwv[] 0 or more 16-bit (sorta) parameters for
* "this" command (i.e. smb_com if this is the
* first parameters, or the andx_com of the just
* previous block.
* smb_bcc a 16-bit count of smb_data[] bytes
* smb_data[] 0 or more bytes, format specific to commands
* padding[] Optional padding
*
* Last command
* smb_wct a byte, number of 16-bit words containing
* command parameters, min 0 for chained command
* smb_vwv[] 0 or more 16-bit (sorta) parameters for
* "this" command (i.e. smb_com if this is the
* first parameters, or the andx_com of the just
* previous block.
* smb_bcc a 16-bit count of smb_data[] bytes
* smb_data[] 0 or more bytes, format specific to commands
*
* Reply
* Header
* Magic 0xFF 'S' 'M' 'B'
* smb_com a byte, the "first" command, corresponds
* to request
* Error a 4-byte union, coding depends on dialect in use
* for "DOS" errors
* a byte for error class
* an unused byte
* a 16-bit word for error code
* for "NT" errors
* a 32-bit error code which
* is a packed class and specifier
* for "OS/2" errors
* I don't know
* The error information is specific to the
* last command in the reply chain.
* smb_flg a one byte set of eight flags, 0x80 bit set
* indicating this message is a reply
* smb_flg2 a two byte set of 16 flags
* . twelve reserved bytes, have a role
* in connectionless transports (IPX, UDP?)
* smb_tid a 16-bit tree ID, a mount point sorta,
* should be the same as the request
* smb_pid a 16-bit process ID, MUST BE the same as request
* smb_uid a 16-bit user ID, specific to this "session"
* and mapped to a system (bona-fide) UID,
* should be the same as request
* smb_mid a 16-bit multiplex ID, used to differentiate
* multiple simultaneous requests from the same
* process (pid) (ref RPC "xid"), MUST BE the
* same as request
* padding[] Optional padding
*
* Chained (AndX) commands (0 or more)
* smb_wct a byte, number of 16-bit words containing
* command parameters, min 2 for chained command,
* andx_com a byte, the "next" command, 0xFF for none,
* corresponds to request, if this is the chained
* command that had an error set to 0xFF
* . an unused byte
* andx_off a 16-bit offset, byte displacement from &Magic
* to the smb_wct field of the "next" command,
* ignore if andx_com is 0xFF, s/b 0 if no next
* smb_vwv[] 0 or more 16-bit (sorta) parameters for
* "this" command (i.e. smb_com if this is the
* first parameters, or the andx_com of the just
* previous block. Empty if an error.
* smb_bcc a 16-bit count of smb_data[] bytes
* smb_data[] 0 or more bytes, format specific to commands
* empty if an error.
*
* Last command
* smb_wct a byte, number of 16-bit words containing
* command parameters, min 0 for chained command
* smb_vwv[] 0 or more 16-bit (sorta) parameters for
* "this" command (i.e. smb_com if this is the
* first parameters, or the andx_com of the just
* previous block, empty if an error.
* smb_bcc a 16-bit count of smb_data[] bytes
* smb_data[] 0 or more bytes, format specific to commands,
* empty if an error.
*/
#include <smbsrv/smb_incl.h>
#include <smbsrv/smb_kstat.h>
#define SMB_COM_NUM 256
static kmutex_t smb_dispatch_ksmtx;
static int is_andx_com(unsigned char);
static int smbsr_check_result(struct smb_request *, int, int);
{ "SmbCreateDirectory", KSTAT_DATA_UINT64 } },
{ "SmbDeleteDirectory", KSTAT_DATA_UINT64 } },
{ "SmbOpen", KSTAT_DATA_UINT64 } },
{ "SmbCreate", KSTAT_DATA_UINT64 } },
{ "SmbClose", KSTAT_DATA_UINT64 } },
{ "SmbFlush", KSTAT_DATA_UINT64 } },
{ "SmbDelete", KSTAT_DATA_UINT64 } },
{ "SmbRename", KSTAT_DATA_UINT64 } },
{ "SmbQueryInformation", KSTAT_DATA_UINT64 } },
{ "SmbSetInformation", KSTAT_DATA_UINT64 } },
{ "SmbRead", KSTAT_DATA_UINT64 } },
{ "SmbWrite", KSTAT_DATA_UINT64 } },
{ "SmbLockByteRange", KSTAT_DATA_UINT64 } },
{ "SmbUnlockByteRange", KSTAT_DATA_UINT64 } },
{ "SmbCreateTemporary", KSTAT_DATA_UINT64 } },
{ "SmbCreateNew", KSTAT_DATA_UINT64 } },
{ "SmbCheckDirectory", KSTAT_DATA_UINT64 } },
{ "SmbProcessExit", KSTAT_DATA_UINT64 } },
{ "SmbSeek", KSTAT_DATA_UINT64 } },
LANMAN1_0, 0,
{ "SmbLockAndRead", KSTAT_DATA_UINT64 } },
LANMAN1_0, 0,
{ "SmbWriteAndUnlock", KSTAT_DATA_UINT64 } },
LANMAN1_0, 0,
{ "SmbReadRaw", KSTAT_DATA_UINT64 } },
LANMAN1_0, 0,
{ "SmbWriteRaw", KSTAT_DATA_UINT64 } },
LANMAN1_0, 0,
{ "SmbSetInformation2", KSTAT_DATA_UINT64 } },
LANMAN1_0, 0,
{ "SmbQueryInformation2", KSTAT_DATA_UINT64 } },
LANMAN1_0, 0,
{ "SmbLockingX", KSTAT_DATA_UINT64 } },
LANMAN1_0, 0,
{ "SmbTransaction", KSTAT_DATA_UINT64 } },
LANMAN1_0, 0,
{ "SmbTransactionSecondary", KSTAT_DATA_UINT64 } },
LANMAN1_0, 0,
{ "SmbIoctl", KSTAT_DATA_UINT64 } },
{ "SmbEcho", KSTAT_DATA_UINT64 } },
LANMAN1_0, 0,
{ "SmbWriteAndClose", KSTAT_DATA_UINT64 } },
LANMAN1_0, 0,
{ "SmbOpenX", KSTAT_DATA_UINT64 } },
LANMAN1_0, 0,
{ "SmbReadX", KSTAT_DATA_UINT64 } },
LANMAN1_0, 0,
{ "SmbWriteX", KSTAT_DATA_UINT64 } },
LANMAN1_0, 0,
{ "SmbCloseAndTreeDisconnect", KSTAT_DATA_UINT64 } },
LM1_2X002, 0,
{ "SmbTransaction2", KSTAT_DATA_UINT64 } },
LM1_2X002, 0,
{ "SmbTransaction2Secondary", KSTAT_DATA_UINT64 } },
LM1_2X002, 0,
{ "SmbFindClose2", KSTAT_DATA_UINT64 } },
{ "SmbTreeConnect", KSTAT_DATA_UINT64 } },
{ "SmbTreeDisconnect", KSTAT_DATA_UINT64 } },
{ "SmbNegotiate", KSTAT_DATA_UINT64 } },
{ "SmbSessionSetupX", KSTAT_DATA_UINT64 } },
{ "SmbLogoffX", KSTAT_DATA_UINT64 } },
{ "SmbTreeConnectX", KSTAT_DATA_UINT64 } },
{ "SmbQueryInformationDisk", KSTAT_DATA_UINT64 } },
{ "SmbSearch", KSTAT_DATA_UINT64 } },
LANMAN1_0, 0,
{ "SmbFind", KSTAT_DATA_UINT64 } },
LANMAN1_0, 0,
{ "SmbFindUnique", KSTAT_DATA_UINT64 } },
LANMAN1_0, 0,
{ "SmbFindClose", KSTAT_DATA_UINT64 } },
NT_LM_0_12, 0,
{ "SmbNtTransact", KSTAT_DATA_UINT64 } },
NT_LM_0_12, 0,
{ "SmbNtTransactSecondary", KSTAT_DATA_UINT64 } },
NT_LM_0_12, 0,
{ "SmbNtCreateX", KSTAT_DATA_UINT64 } },
NT_LM_0_12, 0,
{ "SmbNtCancel", KSTAT_DATA_UINT64 } },
{ "SmbOpenPrintFile", KSTAT_DATA_UINT64 } },
{ "SmbWritePrintFile", KSTAT_DATA_UINT64 } },
{ "SmbClosePrintFile", KSTAT_DATA_UINT64 } },
{ "SmbGetPrintQueue", KSTAT_DATA_UINT64 } },
{ "SmbInvalidCommand", KSTAT_DATA_UINT64 } },
};
/*
* smbsr_cleanup
*
* the reference count for that resource has been incremented.
* This function decrements the reference count and close
* the resource if it's needed.
*/
void
{
}
/*
* Mark this request so we know that we've already cleaned it up.
* A request should only get cleaned up once so multiple calls to
* smbsr_cleanup for the same request indicate a bug.
*/
}
/*
* smb_dispatch_request
*
* Returns:
*
* B_TRUE The caller must free the smb request passed in.
* B_FALSE The caller must not access the smb request passed in. It has
* been kept in an internal queue and may have already been freed.
*/
{
/* temporary until we identify a user */
/* If this connection is shutting down just kill request */
&sr->smb_pid_high,
disconnect = B_TRUE;
goto drop_connection;
}
/*
* The reply "header" is filled in now even though it will,
* most likely, be rewritten under reply_ready below. We
* could reserve the space but this is convenient in case
* the dialect dispatcher has to send a special reply (like
* TRANSACT).
*
* Ensure that the 32-bit error code flag is turned off.
* Clients seem to set it in transact requests and they may
* get confused if we return success or a 16-bit SMB code.
*/
/*
* Verify SMB signature if signing is enabled, dialect is NT LM 0.12,
* signing was negotiated and authentication has occurred.
*/
if (smb_sign_check_request(sr) != 0) {
disconnect = B_TRUE;
goto report_error;
}
}
disconnect = B_TRUE;
goto report_error;
}
disconnect = B_TRUE;
goto report_error;
}
/*
* Ignore smb_bcc if CAP_LARGE_READX/CAP_LARGE_WRITEX
*/
(capabilities & CAP_LARGE_READX)) ||
(capabilities & CAP_LARGE_WRITEX))) {
} else {
}
disconnect = B_TRUE;
goto report_error;
}
/* Store pointers for later */
/* Peek ahead and don't disturb vwv */
disconnect = B_TRUE;
goto report_error;
}
} else {
}
case SMB_REQ_STATE_SUBMITTED:
case SMB_REQ_STATE_CLEANED_UP:
break;
case SMB_REQ_STATE_CANCELED:
break;
default:
ASSERT(0);
break;
}
/*
* Setup UID and TID information (if required). Both functions
* will set the sr credentials. In domain mode, the user and
* tree credentials should be the same. In share mode, the
* tree credentials (defined in the share definition) should
* override the user credentials.
*/
goto report_error;
}
goto report_error;
}
}
}
/*
* If the command is not a read raw request we can set the
* state of the session back to SMB_SESSION_STATE_NEGOTIATED
* (if the current state is SMB_SESSION_STATE_OPLOCK_BREAKING).
* Otherwise we let the read raw handler to deal with it.
*/
}
/*
* Increment method invocation count. This value is exposed
* via kstats, and it represents a count of all the dispatched
* requests, including the ones that have a return value, other
* than SDRC_SUCCESS.
*/
if (sdrc != SDRC_SR_KEPT) {
}
if (sdrc != SDRC_SUCCESS) {
/*
* Handle errors from raw write.
*/
/*
* Set state so that the netbios session
* daemon will start accepting data again.
*/
session->s_write_raw_status = 0;
}
}
switch (sdrc) {
case SDRC_SUCCESS:
break;
case SDRC_DROP_VC:
disconnect = B_TRUE;
goto drop_connection;
case SDRC_NO_REPLY:
return (B_TRUE);
case SDRC_SR_KEPT:
return (B_FALSE);
case SDRC_ERROR:
goto report_error;
case SDRC_NOT_IMPLEMENTED:
default:
goto report_error;
}
/*
* If there's no AndX command, we're done.
*/
goto reply_ready;
/*
* Otherwise, we have to back-patch the AndXCommand and AndXOffset
* and continue processing.
*/
goto andx_more;
if (disconnect) {
break;
default:
break;
}
}
return (B_TRUE);
}
int
{
}
int
{
return (-1);
return (-1);
return (0);
}
static int
{
int total_bytes;
struct mbuf *m;
total_bytes = 0;
while (m != 0) {
total_bytes += m->m_len;
m = m->m_next;
}
return (-1);
return (-1);
return (-1);
/* reply wct & vwv seem ok, consider data now */
return (-1);
return (-1);
} else {
}
} else {
return (-1);
}
if (offset != total_bytes)
return (-1);
return (0);
}
int
{
int rc;
if (rc)
return (rc);
}
int
{
int rc;
if (rc)
return (rc);
}
void
{
else
}
/*
* Map errno values to SMB and NT status values.
* Note: ESRCH is a special case to handle a streams lookup failure.
*/
static struct {
int errnum;
int errcls;
int errcode;
} smb_errno_map[] = {
/*
* It's not clear why smb_read_common effectively returns
* ERRnoaccess if a range lock prevents access and smb_write_common
* effectively returns ERRaccess. This table entry is used by
* smb_read_common and preserves the behavior that was there before.
*/
};
void
{
int i;
for (i = 0; i < sizeof (smb_errno_map)/sizeof (smb_errno_map[0]); ++i) {
return;
}
}
}
void
{
}
/*
* Report a request processing warning.
*/
void
{
}
/*
* Report a request processing error. This function will not return.
*/
void
{
}
/*
* Setup a request processing error. This function can be used to
* report 32-bit status codes or DOS errors. Set the status code
* to 0 (NT_STATUS_SUCCESS) to explicitly report a DOS error,
* regardless of the client capabilities.
*
* If status is non-zero and the client supports 32-bit status
* codes, report the status. Otherwise, report the DOS error.
*/
void
{
if (status == 0)
}
} else {
} else {
}
}
}
smb_xa_t *
{
}
void
{
(void) smb_ofile_release(of);
}
void
{
}
static int
is_andx_com(unsigned char com)
{
switch (com) {
case SMB_COM_LOCKING_ANDX:
case SMB_COM_OPEN_ANDX:
case SMB_COM_READ_ANDX:
case SMB_COM_WRITE_ANDX:
case SMB_COM_LOGOFF_ANDX:
case SMB_COM_NT_CREATE_ANDX:
return (1);
}
return (0);
}
/*
* Invalid command stubs.
*
* SmbWriteComplete is sent to acknowledge completion of raw write requests.
* We never send raw write commands to other servers so, if we receive
* SmbWriteComplete, we treat it as an error.
*
* protocol is not supported because we support only connection oriented
* transports and NT supports mpx only over connectionless transports.
*/
{
return (SDRC_SUCCESS);
}
void
{
}
{
case SMB_COM_WRITE_COMPLETE:
sdrc = SDRC_ERROR;
break;
default:
break;
}
return (sdrc);
}
/*
* smb_dispatch_kstat_update
*
* This callback function updates the smb_dispatch_kstat_data when kstat
* command is invoked.
*/
static int
{
int i;
if (rw == KSTAT_WRITE)
return (EACCES);
for (i = 0; i < SMB_COM_NUM; i++) {
sizeof (kstat_named_t));
++ks_named;
}
}
return (0);
}
/*
* smb_dispatch_kstat_init
*
* Initialize dispatch kstats.
*/
void
smb_dispatch_kstat_init(void)
{
int ks_ndata;
int i;
for (i = 0, ks_ndata = 0; i < SMB_COM_NUM; i++) {
ks_ndata++;
}
KSTAT_TYPE_NAMED, ks_ndata, 0);
if (smb_dispatch_ksp) {
}
}
/*
* smb_dispatch_kstat_fini
*
* Remove dispatch kstats.
*/
void
smb_dispatch_kstat_fini(void)
{
if (smb_dispatch_ksp != NULL) {
}
}