smb_sdrc_t
smb_com_create_directory(smb_request_t *sr)
{
int rc = 0;
smb_pathname_t *pn = &sr->arg.dirop.fqi.fq_path;
if (!STYPE_ISDSK(sr->tid_tree->t_res_type)) {
smbsr_error(sr, NT_STATUS_ACCESS_DENIED,
ERRDOS, ERROR_ACCESS_DENIED);
return (SDRC_ERROR);
}
smb_pathname_init(sr, pn, pn->pn_path);
if (!smb_pathname_validate(sr, pn) ||
!smb_validate_dirname(sr, pn)) {
return (SDRC_ERROR);
}
if ((rc = smb_common_create_directory(sr)) != 0) {
smbsr_errno(sr, rc);
return (SDRC_ERROR);
}
rc = smbsr_encode_empty_result(sr);
return ((rc == 0) ? SDRC_SUCCESS : SDRC_ERROR);
}
/*
* smb_odir_open
*
* Create an odir representing the directory specified in pathname.
*
* Returns:
* odid - Unique identifier of newly created odir.
* 0 - error, error details set in sr.
*/
uint16_t
smb_odir_open(smb_request_t *sr, char *path, uint16_t sattr, uint32_t flags)
{
int rc;
smb_tree_t *tree;
smb_node_t *dnode;
char pattern[MAXNAMELEN];
uint16_t odid;
cred_t *cr;
ASSERT(sr);
ASSERT(sr->sr_magic == SMB_REQ_MAGIC);
ASSERT(sr->tid_tree);
ASSERT(sr->tid_tree->t_magic == SMB_TREE_MAGIC);
tree = sr->tid_tree;
if (sr->session->dialect < NT_LM_0_12)
smb_convert_wildcards(path);
rc = smb_pathname_reduce(sr, sr->user_cr, path,
tree->t_snode, tree->t_snode, &dnode, pattern);
if (rc != 0) {
smbsr_errno(sr, rc);
return (0);
}
if (!smb_node_is_dir(dnode)) {
smbsr_error(sr, NT_STATUS_OBJECT_PATH_NOT_FOUND,
ERRDOS, ERROR_PATH_NOT_FOUND);
smb_node_release(dnode);
return (0);
}
if (smb_fsop_access(sr, sr->user_cr, dnode, FILE_LIST_DIRECTORY) != 0) {
smbsr_error(sr, NT_STATUS_ACCESS_DENIED,
ERRDOS, ERROR_ACCESS_DENIED);
smb_node_release(dnode);
return (0);
}
if (flags & SMB_ODIR_OPENF_BACKUP_INTENT)
cr = smb_user_getprivcred(sr->uid_user);
else
cr = sr->uid_user->u_cred;
odid = smb_odir_create(sr, dnode, pattern, sattr, cr);
smb_node_release(dnode);
return (odid);
}
smb_sdrc_t
smb_com_query_information_disk(smb_request_t *sr)
{
int rc;
struct statvfs64 df;
fsblkcnt64_t total_blocks, free_blocks;
unsigned long block_size, unit_size;
unsigned short blocks_per_unit, bytes_per_block;
unsigned short total_units, free_units;
if (!STYPE_ISDSK(sr->tid_tree->t_res_type)) {
smbsr_error(sr, NT_STATUS_ACCESS_DENIED, ERRDOS, ERRnoaccess);
return (SDRC_ERROR);
}
rc = smb_fsop_statfs(sr->user_cr, sr->tid_tree->t_snode, &df);
if (rc != 0) {
smbsr_errno(sr, rc);
return (SDRC_ERROR);
}
unit_size = 1;
block_size = df.f_frsize;
total_blocks = df.f_blocks;
free_blocks = df.f_bavail;
/*
* It seems that DOS clients cannot handle block sizes
* bigger than 512 KB. So we have to set the block size at
* most to 512
*/
while (block_size > 512) {
block_size >>= 1;
unit_size <<= 1;
}
/* adjust blocks and sizes until they fit into a word */
while (total_blocks >= 0xFFFF) {
total_blocks >>= 1;
free_blocks >>= 1;
if ((unit_size <<= 1) > 0xFFFF) {
unit_size >>= 1;
total_blocks = 0xFFFF;
free_blocks <<= 1;
break;
}
}
smb_sdrc_t
smb_com_write_print_file(smb_request_t *sr)
{
smb_rw_param_t *param = sr->arg.rw;
smb_node_t *node;
smb_attr_t attr;
int rc;
if (sr->sr_server->sv_cfg.skc_print_enable == 0 ||
!STYPE_ISPRN(sr->tid_tree->t_res_type)) {
smbsr_error(sr, NT_STATUS_BAD_DEVICE_TYPE,
ERRDOS, ERROR_BAD_DEV_TYPE);
return (SDRC_ERROR);
}
smbsr_lookup_file(sr);
if (sr->fid_ofile == NULL) {
smbsr_error(sr, NT_STATUS_INVALID_HANDLE, ERRDOS, ERRbadfid);
return (SDRC_ERROR);
}
node = sr->fid_ofile->f_node;
sr->user_cr = smb_ofile_getcred(sr->fid_ofile);
if (smb_node_getattr(sr, node, &attr) != 0) {
smbsr_error(sr, NT_STATUS_INTERNAL_ERROR,
ERRDOS, ERROR_INTERNAL_ERROR);
return (SDRC_ERROR);
}
if ((smbsr_decode_data(sr, "D", ¶m->rw_vdb)) != 0) {
smbsr_error(sr, NT_STATUS_INVALID_PARAMETER,
ERRDOS, ERROR_INVALID_PARAMETER);
return (SDRC_ERROR);
}
param->rw_count = param->rw_vdb.vdb_len;
param->rw_offset = attr.sa_vattr.va_size;
param->rw_vdb.vdb_uio.uio_loffset = (offset_t)param->rw_offset;
if ((rc = smb_common_write(sr, param)) != 0) {
if (sr->smb_error.status != NT_STATUS_FILE_LOCK_CONFLICT)
smbsr_errno(sr, rc);
return (SDRC_ERROR);
}
rc = smbsr_encode_empty_result(sr);
return ((rc == 0) ? SDRC_SUCCESS : SDRC_ERROR);
}
/*
* smb_odir_openat
*
* Create an odir representing the extended attribute directory
* associated with the file (or directory) represented by unode.
*
* Returns:
* odid - Unique identifier of newly created odir.
* 0 - error, error details set in sr.
*/
uint16_t
smb_odir_openat(smb_request_t *sr, smb_node_t *unode)
{
int rc;
vnode_t *xattr_dvp;
uint16_t odid;
cred_t *cr;
char pattern[SMB_STREAM_PREFIX_LEN + 2];
smb_node_t *xattr_dnode;
ASSERT(sr);
ASSERT(sr->sr_magic == SMB_REQ_MAGIC);
ASSERT(unode);
ASSERT(unode->n_magic == SMB_NODE_MAGIC);
if (SMB_TREE_CONTAINS_NODE(sr, unode) == 0 ||
SMB_TREE_HAS_ACCESS(sr, ACE_LIST_DIRECTORY) == 0) {
smbsr_error(sr, NT_STATUS_ACCESS_DENIED,
ERRDOS, ERROR_ACCESS_DENIED);
return (0);
}
cr = zone_kcred();
/* find the xattrdir vnode */
rc = smb_vop_lookup_xattrdir(unode->vp, &xattr_dvp, LOOKUP_XATTR, cr);
if (rc != 0) {
smbsr_errno(sr, rc);
return (0);
}
/* lookup the xattrdir's smb_node */
xattr_dnode = smb_node_lookup(sr, NULL, cr, xattr_dvp, XATTR_DIR,
unode, NULL);
VN_RELE(xattr_dvp);
if (xattr_dnode == NULL) {
smbsr_error(sr, NT_STATUS_NO_MEMORY,
ERRDOS, ERROR_NOT_ENOUGH_MEMORY);
return (0);
}
(void) snprintf(pattern, sizeof (pattern), "%s*", SMB_STREAM_PREFIX);
odid = smb_odir_create(sr, xattr_dnode, pattern, SMB_SEARCH_ATTRIBUTES,
cr);
smb_node_release(xattr_dnode);
return (odid);
}
/*
* smb_odir_read
*
* Find the next directory entry matching the search pattern.
* No search attribute matching is performed.
*
* Returns:
* 0 - success.
* - If a matching entry was found eof will be B_FALSE and
* odirent will be populated.
* - If there are no matching entries eof will be B_TRUE.
* -1 - error, error details set in sr.
*/
int
smb_odir_read(smb_request_t *sr, smb_odir_t *od,
smb_odirent_t *odirent, boolean_t *eof)
{
int rc;
ASSERT(sr);
ASSERT(sr->sr_magic == SMB_REQ_MAGIC);
ASSERT(od);
ASSERT(od->d_magic == SMB_ODIR_MAGIC);
ASSERT(odirent);
mutex_enter(&od->d_mutex);
ASSERT(od->d_refcnt > 0);
switch (od->d_state) {
case SMB_ODIR_STATE_IN_USE:
case SMB_ODIR_STATE_CLOSING:
break;
case SMB_ODIR_STATE_OPEN:
case SMB_ODIR_STATE_CLOSED:
default:
mutex_exit(&od->d_mutex);
return (-1);
}
for (;;) {
if ((rc = smb_odir_next_odirent(od, odirent)) != 0)
break;
if (smb_odir_match_name(od, odirent))
break;
}
mutex_exit(&od->d_mutex);
switch (rc) {
case 0:
*eof = B_FALSE;
return (0);
case ENOENT:
*eof = B_TRUE;
return (0);
default:
smbsr_errno(sr, rc);
return (-1);
}
}
/*
* smb_open_subr
*
* Notes on write-through behaviour. It looks like pre-LM0.12 versions
* of the protocol specify the write-through mode when a file is opened,
* (SmbOpen, SmbOpenAndX) so the write calls (SmbWrite, SmbWriteAndClose,
* SmbWriteAndUnlock) don't need to contain a write-through flag.
*
* With LM0.12, the open calls (SmbCreateAndX, SmbNtTransactCreate)
* don't indicate which write-through mode to use. Instead the write
* calls (SmbWriteAndX, SmbWriteRaw) specify the mode on a per call
* basis.
*
* We don't care which open call was used to get us here, we just need
* to ensure that the write-through mode flag is copied from the open
* parameters to the node. We test the omode write-through flag in all
* write functions.
*
* This function will return NT status codes but it also raises errors,
* in which case it won't return to the caller. Be careful how you
* handle things in here.
*
* The following rules apply when processing a file open request:
*
* - Oplocks must be broken prior to share checking as the break may
* cause other clients to close the file, which would affect sharing
* checks.
*
* - Share checks must take place prior to access checks for correct
* Windows semantics and to prevent unnecessary NFS delegation recalls.
*
* - Oplocks must be acquired after open to ensure the correct
* synchronization with NFS delegation and FEM installation.
*
* DOS readonly bit rules
*
* 1. The creator of a readonly file can write to/modify the size of the file
* using the original create fid, even though the file will appear as readonly
* to all other fids and via a CIFS getattr call.
* The readonly bit therefore cannot be set in the filesystem until the file
* is closed (smb_ofile_close). It is accounted for via ofile and node flags.
*
* 2. A setinfo operation (using either an open fid or a path) to set/unset
* readonly will be successful regardless of whether a creator of a readonly
* file has an open fid (and has the special privilege mentioned in #1,
* above). I.e., the creator of a readonly fid holding that fid will no longer
* have a special privilege.
*
* 3. The DOS readonly bit affects only data and some metadata.
* The following metadata can be changed regardless of the readonly bit:
* - security descriptors
* - DOS attributes
* - timestamps
*
* In the current implementation, the file size cannot be changed (except for
* the exceptions in #1 and #2, above).
*
*
* DOS attribute rules
*
* These rules are specific to creating / opening files and directories.
* How the attribute value (specifically ZERO or FILE_ATTRIBUTE_NORMAL)
* should be interpreted may differ in other requests.
*
* - An attribute value equal to ZERO or FILE_ATTRIBUTE_NORMAL means that the
* file's attributes should be cleared.
* - If FILE_ATTRIBUTE_NORMAL is specified with any other attributes,
* FILE_ATTRIBUTE_NORMAL is ignored.
*
* 1. Creating a new file
* - The request attributes + FILE_ATTRIBUTE_ARCHIVE are applied to the file.
*
* 2. Creating a new directory
* - The request attributes + FILE_ATTRIBUTE_DIRECTORY are applied to the file.
* - FILE_ATTRIBUTE_ARCHIVE does not get set.
*
* 3. Overwriting an existing file
* - the request attributes are used as search attributes. If the existing
* file does not meet the search criteria access is denied.
* - otherwise, applies attributes + FILE_ATTRIBUTE_ARCHIVE.
*
* 4. Opening an existing file or directory
* The request attributes are ignored.
*/
static uint32_t
smb_open_subr(smb_request_t *sr)
{
boolean_t created = B_FALSE;
boolean_t last_comp_found = B_FALSE;
smb_node_t *node = NULL;
smb_node_t *dnode = NULL;
smb_node_t *cur_node = NULL;
smb_arg_open_t *op = &sr->sr_open;
int rc;
smb_ofile_t *of;
smb_attr_t new_attr;
int max_requested = 0;
uint32_t max_allowed;
uint32_t status = NT_STATUS_SUCCESS;
int is_dir;
smb_error_t err;
boolean_t is_stream = B_FALSE;
int lookup_flags = SMB_FOLLOW_LINKS;
uint32_t uniq_fid;
smb_pathname_t *pn = &op->fqi.fq_path;
smb_server_t *sv = sr->sr_server;
is_dir = (op->create_options & FILE_DIRECTORY_FILE) ? 1 : 0;
/*
* If the object being created or opened is a directory
* the Disposition parameter must be one of FILE_CREATE,
* FILE_OPEN, or FILE_OPEN_IF
*/
if (is_dir) {
if ((op->create_disposition != FILE_CREATE) &&
(op->create_disposition != FILE_OPEN_IF) &&
(op->create_disposition != FILE_OPEN)) {
smbsr_error(sr, NT_STATUS_INVALID_PARAMETER,
ERRDOS, ERROR_INVALID_ACCESS);
return (NT_STATUS_INVALID_PARAMETER);
}
}
if (op->desired_access & MAXIMUM_ALLOWED) {
max_requested = 1;
op->desired_access &= ~MAXIMUM_ALLOWED;
}
op->desired_access = smb_access_generic_to_file(op->desired_access);
if (sr->session->s_file_cnt >= SMB_SESSION_OFILE_MAX) {
ASSERT(sr->uid_user);
cmn_err(CE_NOTE, "smbsrv[%s\\%s]: TOO_MANY_OPENED_FILES",
sr->uid_user->u_domain, sr->uid_user->u_name);
smbsr_error(sr, NT_STATUS_TOO_MANY_OPENED_FILES,
ERRDOS, ERROR_TOO_MANY_OPEN_FILES);
return (NT_STATUS_TOO_MANY_OPENED_FILES);
}
/* This must be NULL at this point */
sr->fid_ofile = NULL;
op->devstate = 0;
switch (sr->tid_tree->t_res_type & STYPE_MASK) {
case STYPE_DISKTREE:
case STYPE_PRINTQ:
break;
case STYPE_IPC:
if ((rc = smb_threshold_enter(&sv->sv_opipe_ct)) != 0) {
status = RPC_NT_SERVER_TOO_BUSY;
smbsr_error(sr, status, 0, 0);
return (status);
}
/*
* No further processing for IPC, we need to either
* raise an exception or return success here.
*/
if ((status = smb_opipe_open(sr)) != NT_STATUS_SUCCESS)
smbsr_error(sr, status, 0, 0);
smb_threshold_exit(&sv->sv_opipe_ct, sv);
return (status);
default:
smbsr_error(sr, NT_STATUS_BAD_DEVICE_TYPE,
ERRDOS, ERROR_BAD_DEV_TYPE);
return (NT_STATUS_BAD_DEVICE_TYPE);
}
smb_pathname_init(sr, pn, pn->pn_path);
if (!smb_pathname_validate(sr, pn))
return (sr->smb_error.status);
if (strlen(pn->pn_path) >= MAXPATHLEN) {
smbsr_error(sr, 0, ERRSRV, ERRfilespecs);
return (NT_STATUS_NAME_TOO_LONG);
}
if (is_dir) {
if (!smb_validate_dirname(sr, pn))
return (sr->smb_error.status);
} else {
if (!smb_validate_object_name(sr, pn))
return (sr->smb_error.status);
}
cur_node = op->fqi.fq_dnode ?
op->fqi.fq_dnode : sr->tid_tree->t_snode;
/*
* if no path or filename are specified the stream should be
* created on cur_node
*/
if (!is_dir && !pn->pn_pname && !pn->pn_fname && pn->pn_sname) {
/*
* Can't currently handle a stream on the tree root.
* If a stream is being opened return "not found", otherwise
* return "access denied".
*/
if (cur_node == sr->tid_tree->t_snode) {
if (op->create_disposition == FILE_OPEN) {
smbsr_error(sr, NT_STATUS_OBJECT_NAME_NOT_FOUND,
ERRDOS, ERROR_FILE_NOT_FOUND);
return (NT_STATUS_OBJECT_NAME_NOT_FOUND);
}
smbsr_error(sr, NT_STATUS_ACCESS_DENIED, ERRDOS,
ERROR_ACCESS_DENIED);
return (NT_STATUS_ACCESS_DENIED);
}
(void) snprintf(op->fqi.fq_last_comp,
sizeof (op->fqi.fq_last_comp),
"%s%s", cur_node->od_name, pn->pn_sname);
op->fqi.fq_dnode = cur_node->n_dnode;
smb_node_ref(op->fqi.fq_dnode);
} else {
if (rc = smb_pathname_reduce(sr, sr->user_cr, pn->pn_path,
sr->tid_tree->t_snode, cur_node, &op->fqi.fq_dnode,
op->fqi.fq_last_comp)) {
smbsr_errno(sr, rc);
return (sr->smb_error.status);
}
}
/*
* If the access mask has only DELETE set (ignore
* FILE_READ_ATTRIBUTES), then assume that this
* is a request to delete the link (if a link)
* and do not follow links. Otherwise, follow
* the link to the target.
*/
if ((op->desired_access & ~FILE_READ_ATTRIBUTES) == DELETE)
lookup_flags &= ~SMB_FOLLOW_LINKS;
rc = smb_fsop_lookup_name(sr, kcred, lookup_flags,
sr->tid_tree->t_snode, op->fqi.fq_dnode, op->fqi.fq_last_comp,
&op->fqi.fq_fnode);
if (rc == 0) {
last_comp_found = B_TRUE;
rc = smb_node_getattr(sr, op->fqi.fq_fnode,
&op->fqi.fq_fattr);
if (rc != 0) {
smb_node_release(op->fqi.fq_fnode);
smb_node_release(op->fqi.fq_dnode);
smbsr_error(sr, NT_STATUS_INTERNAL_ERROR,
ERRDOS, ERROR_INTERNAL_ERROR);
return (sr->smb_error.status);
}
} else if (rc == ENOENT) {
last_comp_found = B_FALSE;
op->fqi.fq_fnode = NULL;
rc = 0;
} else {
smb_node_release(op->fqi.fq_dnode);
smbsr_errno(sr, rc);
return (sr->smb_error.status);
}
/*
* The uniq_fid is a CIFS-server-wide unique identifier for an ofile
* which is used to uniquely identify open instances for the
* VFS share reservation and POSIX locks.
*/
uniq_fid = SMB_UNIQ_FID();
if (last_comp_found) {
node = op->fqi.fq_fnode;
dnode = op->fqi.fq_dnode;
if (!smb_node_is_file(node) && !smb_node_is_dir(node) &&
!smb_node_is_symlink(node)) {
smb_node_release(node);
smb_node_release(dnode);
smbsr_error(sr, NT_STATUS_ACCESS_DENIED, ERRDOS,
ERRnoaccess);
return (NT_STATUS_ACCESS_DENIED);
}
/*
* Reject this request if either:
* - the target IS a directory and the client requires that
* it must NOT be (required by Lotus Notes)
* - the target is NOT a directory and client requires that
* it MUST be.
*/
if (smb_node_is_dir(node)) {
if (op->create_options & FILE_NON_DIRECTORY_FILE) {
smb_node_release(node);
smb_node_release(dnode);
smbsr_error(sr, NT_STATUS_FILE_IS_A_DIRECTORY,
ERRDOS, ERROR_ACCESS_DENIED);
return (NT_STATUS_FILE_IS_A_DIRECTORY);
}
} else {
if ((op->create_options & FILE_DIRECTORY_FILE) ||
(op->nt_flags & NT_CREATE_FLAG_OPEN_TARGET_DIR)) {
smb_node_release(node);
smb_node_release(dnode);
smbsr_error(sr, NT_STATUS_NOT_A_DIRECTORY,
ERRDOS, ERROR_DIRECTORY);
return (NT_STATUS_NOT_A_DIRECTORY);
}
}
/*
* No more open should be accepted when "Delete on close"
* flag is set.
*/
if (node->flags & NODE_FLAGS_DELETE_ON_CLOSE) {
smb_node_release(node);
smb_node_release(dnode);
smbsr_error(sr, NT_STATUS_DELETE_PENDING,
ERRDOS, ERROR_ACCESS_DENIED);
return (NT_STATUS_DELETE_PENDING);
}
/*
* Specified file already exists so the operation should fail.
*/
if (op->create_disposition == FILE_CREATE) {
smb_node_release(node);
smb_node_release(dnode);
smbsr_error(sr, NT_STATUS_OBJECT_NAME_COLLISION,
ERRDOS, ERROR_FILE_EXISTS);
return (NT_STATUS_OBJECT_NAME_COLLISION);
}
/*
* Windows seems to check read-only access before file
* sharing check.
*
* Check to see if the file is currently readonly (irrespective
* of whether this open will make it readonly).
*/
if (SMB_PATHFILE_IS_READONLY(sr, node)) {
/* Files data only */
if (!smb_node_is_dir(node)) {
if (op->desired_access & (FILE_WRITE_DATA |
FILE_APPEND_DATA)) {
smb_node_release(node);
smb_node_release(dnode);
smbsr_error(sr, NT_STATUS_ACCESS_DENIED,
ERRDOS, ERRnoaccess);
return (NT_STATUS_ACCESS_DENIED);
}
}
}
/*
* Oplock break is done prior to sharing checks as the break
* may cause other clients to close the file which would
* affect the sharing checks.
*/
smb_node_inc_opening_count(node);
smb_open_oplock_break(sr, node);
smb_node_wrlock(node);
if ((op->create_disposition == FILE_SUPERSEDE) ||
(op->create_disposition == FILE_OVERWRITE_IF) ||
(op->create_disposition == FILE_OVERWRITE)) {
if ((!(op->desired_access &
(FILE_WRITE_DATA | FILE_APPEND_DATA |
FILE_WRITE_ATTRIBUTES | FILE_WRITE_EA))) ||
(!smb_sattr_check(op->fqi.fq_fattr.sa_dosattr,
op->dattr))) {
smb_node_unlock(node);
smb_node_dec_opening_count(node);
smb_node_release(node);
smb_node_release(dnode);
smbsr_error(sr, NT_STATUS_ACCESS_DENIED,
ERRDOS, ERRnoaccess);
return (NT_STATUS_ACCESS_DENIED);
}
}
status = smb_fsop_shrlock(sr->user_cr, node, uniq_fid,
op->desired_access, op->share_access);
if (status == NT_STATUS_SHARING_VIOLATION) {
smb_node_unlock(node);
smb_node_dec_opening_count(node);
smb_node_release(node);
smb_node_release(dnode);
return (status);
}
status = smb_fsop_access(sr, sr->user_cr, node,
op->desired_access);
if (status != NT_STATUS_SUCCESS) {
smb_fsop_unshrlock(sr->user_cr, node, uniq_fid);
smb_node_unlock(node);
smb_node_dec_opening_count(node);
smb_node_release(node);
smb_node_release(dnode);
if (status == NT_STATUS_PRIVILEGE_NOT_HELD) {
smbsr_error(sr, status,
ERRDOS, ERROR_PRIVILEGE_NOT_HELD);
return (status);
} else {
smbsr_error(sr, NT_STATUS_ACCESS_DENIED,
ERRDOS, ERROR_ACCESS_DENIED);
return (NT_STATUS_ACCESS_DENIED);
}
}
switch (op->create_disposition) {
case FILE_SUPERSEDE:
case FILE_OVERWRITE_IF:
case FILE_OVERWRITE:
if (smb_node_is_dir(node)) {
smb_fsop_unshrlock(sr->user_cr, node, uniq_fid);
smb_node_unlock(node);
smb_node_dec_opening_count(node);
smb_node_release(node);
smb_node_release(dnode);
smbsr_error(sr, NT_STATUS_ACCESS_DENIED,
ERRDOS, ERROR_ACCESS_DENIED);
return (NT_STATUS_ACCESS_DENIED);
}
op->dattr |= FILE_ATTRIBUTE_ARCHIVE;
/* Don't apply readonly bit until smb_ofile_close */
if (op->dattr & FILE_ATTRIBUTE_READONLY) {
op->created_readonly = B_TRUE;
op->dattr &= ~FILE_ATTRIBUTE_READONLY;
}
bzero(&new_attr, sizeof (new_attr));
new_attr.sa_dosattr = op->dattr;
new_attr.sa_vattr.va_size = op->dsize;
new_attr.sa_mask = SMB_AT_DOSATTR | SMB_AT_SIZE;
rc = smb_fsop_setattr(sr, sr->user_cr, node, &new_attr);
if (rc != 0) {
smb_fsop_unshrlock(sr->user_cr, node, uniq_fid);
smb_node_unlock(node);
smb_node_dec_opening_count(node);
smb_node_release(node);
smb_node_release(dnode);
smbsr_errno(sr, rc);
return (sr->smb_error.status);
}
/*
* If file is being replaced, remove existing streams
*/
if (SMB_IS_STREAM(node) == 0) {
rc = smb_fsop_remove_streams(sr, sr->user_cr,
node);
if (rc != 0) {
smb_fsop_unshrlock(sr->user_cr, node,
uniq_fid);
smb_node_unlock(node);
smb_node_dec_opening_count(node);
smb_node_release(node);
smb_node_release(dnode);
return (sr->smb_error.status);
}
}
op->action_taken = SMB_OACT_TRUNCATED;
break;
default:
/*
* FILE_OPEN or FILE_OPEN_IF.
*/
op->action_taken = SMB_OACT_OPENED;
break;
}
} else {
/* Last component was not found. */
dnode = op->fqi.fq_dnode;
if (is_dir == 0)
is_stream = smb_is_stream_name(pn->pn_path);
if ((op->create_disposition == FILE_OPEN) ||
(op->create_disposition == FILE_OVERWRITE)) {
smb_node_release(dnode);
smbsr_error(sr, NT_STATUS_OBJECT_NAME_NOT_FOUND,
ERRDOS, ERROR_FILE_NOT_FOUND);
return (NT_STATUS_OBJECT_NAME_NOT_FOUND);
}
if (pn->pn_fname && smb_is_invalid_filename(pn->pn_fname)) {
smb_node_release(dnode);
smbsr_error(sr, NT_STATUS_OBJECT_NAME_INVALID,
ERRDOS, ERROR_INVALID_NAME);
return (NT_STATUS_OBJECT_NAME_INVALID);
}
/*
* lock the parent dir node in case another create
* request to the same parent directory comes in.
*/
smb_node_wrlock(dnode);
/* Don't apply readonly bit until smb_ofile_close */
if (op->dattr & FILE_ATTRIBUTE_READONLY) {
op->dattr &= ~FILE_ATTRIBUTE_READONLY;
op->created_readonly = B_TRUE;
}
bzero(&new_attr, sizeof (new_attr));
if ((op->crtime.tv_sec != 0) &&
(op->crtime.tv_sec != UINT_MAX)) {
new_attr.sa_mask |= SMB_AT_CRTIME;
new_attr.sa_crtime = op->crtime;
}
if (is_dir == 0) {
op->dattr |= FILE_ATTRIBUTE_ARCHIVE;
new_attr.sa_dosattr = op->dattr;
new_attr.sa_vattr.va_type = VREG;
new_attr.sa_vattr.va_mode = is_stream ? S_IRUSR :
S_IRUSR | S_IRGRP | S_IROTH |
S_IWUSR | S_IWGRP | S_IWOTH;
new_attr.sa_mask |=
SMB_AT_DOSATTR | SMB_AT_TYPE | SMB_AT_MODE;
if (op->dsize) {
new_attr.sa_vattr.va_size = op->dsize;
new_attr.sa_mask |= SMB_AT_SIZE;
}
rc = smb_fsop_create(sr, sr->user_cr, dnode,
op->fqi.fq_last_comp, &new_attr, &op->fqi.fq_fnode);
if (rc != 0) {
smb_node_unlock(dnode);
smb_node_release(dnode);
smbsr_errno(sr, rc);
return (sr->smb_error.status);
}
node = op->fqi.fq_fnode;
smb_node_inc_opening_count(node);
smb_node_wrlock(node);
status = smb_fsop_shrlock(sr->user_cr, node, uniq_fid,
op->desired_access, op->share_access);
if (status == NT_STATUS_SHARING_VIOLATION) {
smb_node_unlock(node);
smb_node_dec_opening_count(node);
smb_delete_new_object(sr);
smb_node_release(node);
smb_node_unlock(dnode);
smb_node_release(dnode);
return (status);
}
} else {
op->dattr |= FILE_ATTRIBUTE_DIRECTORY;
new_attr.sa_dosattr = op->dattr;
new_attr.sa_vattr.va_type = VDIR;
new_attr.sa_vattr.va_mode = 0777;
new_attr.sa_mask |=
SMB_AT_DOSATTR | SMB_AT_TYPE | SMB_AT_MODE;
rc = smb_fsop_mkdir(sr, sr->user_cr, dnode,
op->fqi.fq_last_comp, &new_attr, &op->fqi.fq_fnode);
if (rc != 0) {
smb_node_unlock(dnode);
smb_node_release(dnode);
smbsr_errno(sr, rc);
return (sr->smb_error.status);
}
node = op->fqi.fq_fnode;
smb_node_inc_opening_count(node);
smb_node_wrlock(node);
}
created = B_TRUE;
op->action_taken = SMB_OACT_CREATED;
}
if (max_requested) {
smb_fsop_eaccess(sr, sr->user_cr, node, &max_allowed);
op->desired_access |= max_allowed;
}
status = NT_STATUS_SUCCESS;
of = smb_ofile_open(sr->tid_tree, node, sr->smb_pid, op, SMB_FTYPE_DISK,
uniq_fid, &err);
if (of == NULL) {
smbsr_error(sr, err.status, err.errcls, err.errcode);
status = err.status;
}
if (status == NT_STATUS_SUCCESS) {
if (!smb_tree_is_connected(sr->tid_tree)) {
smbsr_error(sr, 0, ERRSRV, ERRinvnid);
status = NT_STATUS_UNSUCCESSFUL;
}
}
/*
* This MUST be done after ofile creation, so that explicitly
* set timestamps can be remembered on the ofile.
*/
if (status == NT_STATUS_SUCCESS) {
if ((rc = smb_set_open_timestamps(sr, of, created)) != 0) {
smbsr_errno(sr, rc);
status = sr->smb_error.status;
}
}
if (status == NT_STATUS_SUCCESS) {
if (smb_node_getattr(sr, node, &op->fqi.fq_fattr) != 0) {
smbsr_error(sr, NT_STATUS_INTERNAL_ERROR,
ERRDOS, ERROR_INTERNAL_ERROR);
status = NT_STATUS_INTERNAL_ERROR;
}
}
/*
* smb_fsop_unshrlock is a no-op if node is a directory
* smb_fsop_unshrlock is done in smb_ofile_close
*/
if (status != NT_STATUS_SUCCESS) {
if (of == NULL) {
smb_fsop_unshrlock(sr->user_cr, node, uniq_fid);
} else {
smb_ofile_close(of, 0);
smb_ofile_release(of);
}
if (created)
smb_delete_new_object(sr);
smb_node_unlock(node);
smb_node_dec_opening_count(node);
smb_node_release(node);
if (created)
smb_node_unlock(dnode);
smb_node_release(dnode);
return (status);
}
/*
* Propagate the write-through mode from the open params
* to the node: see the notes in the function header.
*/
if (sr->sr_cfg->skc_sync_enable ||
(op->create_options & FILE_WRITE_THROUGH))
node->flags |= NODE_FLAGS_WRITE_THROUGH;
/*
* Set up the fileid and dosattr in open_param for response
*/
op->fileid = op->fqi.fq_fattr.sa_vattr.va_nodeid;
op->dattr = op->fqi.fq_fattr.sa_dosattr;
/*
* Set up the file type in open_param for the response
*/
op->ftype = SMB_FTYPE_DISK;
sr->smb_fid = of->f_fid;
sr->fid_ofile = of;
if (smb_node_is_file(node)) {
smb_oplock_acquire(sr, node, of);
op->dsize = op->fqi.fq_fattr.sa_vattr.va_size;
} else {
/* directory or symlink */
op->op_oplock_level = SMB_OPLOCK_NONE;
op->dsize = 0;
}
smb_node_dec_opening_count(node);
smb_node_unlock(node);
if (created)
smb_node_unlock(dnode);
smb_node_release(node);
smb_node_release(dnode);
return (NT_STATUS_SUCCESS);
}
/*
* smb_com_trans2_find_first2
*
* Client Request Value
* ============================ ==================================
*
* UCHAR WordCount 15
* UCHAR TotalDataCount Total size of extended attribute list
* UCHAR SetupCount 1
* UCHAR Setup[0] TRANS2_FIND_FIRST2
*
* Parameter Block Encoding Description
* ============================ ==================================
* USHORT SearchAttributes;
* USHORT SearchCount; Maximum number of entries to return
* USHORT Flags; Additional information:
* Bit 0 - close search after this request
* Bit 1 - close search if end of search
* reached
* Bit 2 - return resume keys for each
* entry found
* Bit 3 - continue search from previous
* ending place
* Bit 4 - find with backup intent
* USHORT InformationLevel; See below
* ULONG SearchStorageType;
* STRING FileName; Pattern for the search
* UCHAR Data[ TotalDataCount ] FEAList if InformationLevel is
* QUERY_EAS_FROM_LIST
*
* Response Parameter Block Description
* ============================ ==================================
*
* USHORT Sid; Search handle
* USHORT SearchCount; Number of entries returned
* USHORT EndOfSearch; Was last entry returned?
* USHORT EaErrorOffset; Offset into EA list if EA error
* USHORT LastNameOffset; Offset into data to file name of last
* entry, if server needs it to resume
* search; else 0
* UCHAR Data[ TotalDataCount ] Level dependent info about the matches
* found in the search
*/
smb_sdrc_t
smb_com_trans2_find_first2(smb_request_t *sr, smb_xa_t *xa)
{
int count;
uint16_t sattr, odid;
smb_pathname_t *pn;
smb_odir_t *od;
smb_find_args_t args;
uint32_t odir_flags = 0;
bzero(&args, sizeof (smb_find_args_t));
if (!STYPE_ISDSK(sr->tid_tree->t_res_type)) {
smbsr_error(sr, NT_STATUS_ACCESS_DENIED,
ERRDOS, ERROR_ACCESS_DENIED);
return (SDRC_ERROR);
}
pn = &sr->arg.dirop.fqi.fq_path;
if (smb_mbc_decodef(&xa->req_param_mb, "%wwww4.u", sr, &sattr,
&args.fa_maxcount, &args.fa_fflag, &args.fa_infolev,
&pn->pn_path) != 0) {
return (SDRC_ERROR);
}
smb_pathname_init(sr, pn, pn->pn_path);
if (!smb_pathname_validate(sr, pn))
return (-1);
if (smb_is_stream_name(pn->pn_path)) {
smbsr_error(sr, NT_STATUS_OBJECT_NAME_INVALID,
ERRDOS, ERROR_INVALID_NAME);
return (SDRC_ERROR);
}
if (args.fa_fflag & SMB_FIND_WITH_BACKUP_INTENT) {
sr->user_cr = smb_user_getprivcred(sr->uid_user);
odir_flags = SMB_ODIR_OPENF_BACKUP_INTENT;
}
args.fa_maxdata =
smb_trans2_find_get_maxdata(sr, args.fa_infolev, args.fa_fflag);
if (args.fa_maxdata == 0)
return (SDRC_ERROR);
odid = smb_odir_open(sr, pn->pn_path, sattr, odir_flags);
if (odid == 0) {
if (sr->smb_error.status == NT_STATUS_OBJECT_PATH_NOT_FOUND) {
smbsr_error(sr, NT_STATUS_OBJECT_NAME_NOT_FOUND,
ERRDOS, ERROR_FILE_NOT_FOUND);
}
return (SDRC_ERROR);
}
od = smb_tree_lookup_odir(sr->tid_tree, odid);
if (od == NULL)
return (SDRC_ERROR);
count = smb_trans2_find_entries(sr, xa, od, &args);
if (count == -1) {
smb_odir_close(od);
smb_odir_release(od);
return (SDRC_ERROR);
}
if (count == 0) {
smb_odir_close(od);
smb_odir_release(od);
smbsr_errno(sr, ENOENT);
return (SDRC_ERROR);
}
if ((args.fa_fflag & SMB_FIND_CLOSE_AFTER_REQUEST) ||
(args.fa_eos && (args.fa_fflag & SMB_FIND_CLOSE_AT_EOS))) {
smb_odir_close(od);
} /* else leave odir open for trans2_find_next2 */
smb_odir_release(od);
(void) smb_mbc_encodef(&xa->rep_param_mb, "wwwww",
odid, /* Search ID */
count, /* Search Count */
args.fa_eos, /* End Of Search */
0, /* EA Error Offset */
args.fa_lno); /* Last Name Offset */
return (SDRC_SUCCESS);
}
smb_sdrc_t
smb_nt_transact_create(smb_request_t *sr, smb_xa_t *xa)
{
struct open_param *op = &sr->arg.open;
uint8_t DirFlag;
smb_attr_t attr;
smb_ofile_t *of;
int rc;
if ((op->create_options & FILE_DELETE_ON_CLOSE) &&
!(op->desired_access & DELETE)) {
smbsr_error(sr, NT_STATUS_INVALID_PARAMETER,
ERRDOS, ERRbadaccess);
return (SDRC_ERROR);
}
if (op->create_disposition > FILE_MAXIMUM_DISPOSITION) {
smbsr_error(sr, NT_STATUS_INVALID_PARAMETER,
ERRDOS, ERRbadaccess);
return (SDRC_ERROR);
}
if (op->dattr & FILE_FLAG_WRITE_THROUGH)
op->create_options |= FILE_WRITE_THROUGH;
if (op->dattr & FILE_FLAG_DELETE_ON_CLOSE)
op->create_options |= FILE_DELETE_ON_CLOSE;
if (op->dattr & FILE_FLAG_BACKUP_SEMANTICS)
op->create_options |= FILE_OPEN_FOR_BACKUP_INTENT;
if (op->create_options & FILE_OPEN_FOR_BACKUP_INTENT)
sr->user_cr = smb_user_getprivcred(sr->uid_user);
if (op->rootdirfid == 0) {
op->fqi.fq_dnode = sr->tid_tree->t_snode;
} else {
op->dir = smb_ofile_lookup_by_fid(sr, (uint16_t)op->rootdirfid);
if (op->dir == NULL) {
smbsr_error(sr, NT_STATUS_INVALID_HANDLE,
ERRDOS, ERRbadfid);
return (SDRC_ERROR);
}
op->fqi.fq_dnode = op->dir->f_node;
}
op->op_oplock_levelII = B_TRUE;
if (smb_common_open(sr) != NT_STATUS_SUCCESS)
return (SDRC_ERROR);
/*
* NB: after the above smb_common_open() success,
* we have a handle allocated (sr->fid_ofile).
* If we don't return success, we must close it.
*/
of = sr->fid_ofile;
switch (sr->tid_tree->t_res_type & STYPE_MASK) {
case STYPE_DISKTREE:
case STYPE_PRINTQ:
if (op->create_options & FILE_DELETE_ON_CLOSE)
smb_ofile_set_delete_on_close(of);
DirFlag = smb_node_is_dir(of->f_node) ? 1 : 0;
bzero(&attr, sizeof (attr));
attr.sa_mask = SMB_AT_ALL;
rc = smb_node_getattr(sr, of->f_node, of->f_cr, of, &attr);
if (rc != 0) {
smbsr_errno(sr, rc);
goto errout;
}
(void) smb_mbc_encodef(&xa->rep_param_mb, "b.wllTTTTlqqwwb",
op->op_oplock_level,
sr->smb_fid,
op->action_taken,
0, /* EaErrorOffset */
&attr.sa_crtime,
&attr.sa_vattr.va_atime,
&attr.sa_vattr.va_mtime,
&attr.sa_vattr.va_ctime,
op->dattr & FILE_ATTRIBUTE_MASK,
attr.sa_allocsz,
attr.sa_vattr.va_size,
op->ftype,
op->devstate,
DirFlag);
break;
case STYPE_IPC:
bzero(&attr, sizeof (smb_attr_t));
(void) smb_mbc_encodef(&xa->rep_param_mb, "b.wllTTTTlqqwwb",
0,
sr->smb_fid,
op->action_taken,
0, /* EaErrorOffset */
&attr.sa_crtime,
&attr.sa_vattr.va_atime,
&attr.sa_vattr.va_mtime,
&attr.sa_vattr.va_ctime,
op->dattr,
0x1000LL,
0LL,
op->ftype,
op->devstate,
0);
break;
default:
smbsr_error(sr, NT_STATUS_INVALID_DEVICE_REQUEST,
ERRDOS, ERROR_INVALID_FUNCTION);
goto errout;
}
return (SDRC_SUCCESS);
errout:
smb_ofile_close(of, 0);
return (SDRC_ERROR);
}
/*
* smb_query_fileinfo
*
* Populate smb_queryinfo_t structure for SMB_FTYPE_DISK
* (This should become an smb_ofile / smb_node function.)
*/
int
smb_query_fileinfo(smb_request_t *sr, smb_node_t *node, uint16_t infolev,
smb_queryinfo_t *qinfo)
{
int rc = 0;
/* If shortname required but not supported -> OBJECT_NAME_NOT_FOUND */
if ((infolev == SMB_QUERY_FILE_ALT_NAME_INFO) ||
(infolev == SMB_FILE_ALT_NAME_INFORMATION)) {
if (!smb_tree_has_feature(sr->tid_tree, SMB_TREE_SHORTNAMES)) {
smbsr_error(sr, NT_STATUS_OBJECT_NAME_NOT_FOUND,
ERRDOS, ERROR_FILE_NOT_FOUND);
return (-1);
}
}
(void) bzero(qinfo, sizeof (smb_queryinfo_t));
/* See: smb_query_encode_response */
qinfo->qi_attr.sa_mask = SMB_AT_ALL;
rc = smb_node_getattr(sr, node, sr->user_cr, sr->fid_ofile,
&qinfo->qi_attr);
if (rc != 0) {
smbsr_error(sr, NT_STATUS_INTERNAL_ERROR,
ERRDOS, ERROR_INTERNAL_ERROR);
return (-1);
}
qinfo->qi_node = node;
qinfo->qi_delete_on_close =
(node->flags & NODE_FLAGS_DELETE_ON_CLOSE) != 0;
/*
* The number of links reported should be the number of
* non-deleted links. Thus if delete_on_close is set,
* decrement the link count.
*/
if (qinfo->qi_delete_on_close &&
qinfo->qi_attr.sa_vattr.va_nlink > 0) {
--(qinfo->qi_attr.sa_vattr.va_nlink);
}
/*
* populate name, namelen and shortname ONLY for the information
* levels that require these fields
*/
switch (infolev) {
case SMB_QUERY_FILE_ALL_INFO:
case SMB_FILE_ALL_INFORMATION:
rc = smb_query_pathname(sr, node, B_TRUE, qinfo);
break;
case SMB_QUERY_FILE_NAME_INFO:
case SMB_FILE_NAME_INFORMATION:
rc = smb_query_pathname(sr, node, B_FALSE, qinfo);
break;
case SMB_QUERY_FILE_ALT_NAME_INFO:
case SMB_FILE_ALT_NAME_INFORMATION:
smb_query_shortname(node, qinfo);
break;
default:
break;
}
if (rc != 0) {
smbsr_errno(sr, rc);
return (-1);
}
return (0);
}
/*
* smb_query_by_path
*
* Common code for querying file information by file name.
* Use the file name to identify the node object and request the
* smb_queryinfo_t data for that node.
*
* Path should be set in sr->arg.dirop.fqi.fq_path prior to
* calling smb_query_by_path.
*
* Querying attributes on a named pipe by name is an error and
* is handled in the calling functions so that they can return
* the appropriate error status code (which differs by caller).
*/
static int
smb_query_by_path(smb_request_t *sr, smb_xa_t *xa, uint16_t infolev)
{
smb_queryinfo_t *qinfo;
smb_node_t *node, *dnode;
smb_pathname_t *pn;
int rc;
/*
* The function smb_query_fileinfo is used here and in
* smb_query_by_fid. That common function needs this
* one to call it with a NULL fid_ofile, so check here.
* Note: smb_query_by_fid enforces the opposite.
*
* In theory we could ASSERT this, but whether we have
* fid_ofile set here depends on what sequence of SMB
* commands the client has sent in this message, so
* let's be cautious and handle it as an error.
*/
if (sr->fid_ofile != NULL)
return (-1);
/* VALID, but not yet supported */
if (infolev == SMB_FILE_ACCESS_INFORMATION) {
smbsr_error(sr, 0, ERRDOS, ERROR_INVALID_LEVEL);
return (-1);
}
pn = &sr->arg.dirop.fqi.fq_path;
smb_pathname_init(sr, pn, pn->pn_path);
if (!smb_pathname_validate(sr, pn))
return (-1);
qinfo = kmem_alloc(sizeof (smb_queryinfo_t), KM_SLEEP);
rc = smb_pathname_reduce(sr, sr->user_cr, pn->pn_path,
sr->tid_tree->t_snode, sr->tid_tree->t_snode, &dnode,
qinfo->qi_name);
if (rc == 0) {
rc = smb_fsop_lookup_name(sr, sr->user_cr, SMB_FOLLOW_LINKS,
sr->tid_tree->t_snode, dnode, qinfo->qi_name, &node);
smb_node_release(dnode);
}
if (rc != 0) {
if (rc == ENOENT)
smbsr_error(sr, NT_STATUS_OBJECT_NAME_NOT_FOUND,
ERRDOS, ERROR_FILE_NOT_FOUND);
else
smbsr_errno(sr, rc);
kmem_free(qinfo, sizeof (smb_queryinfo_t));
return (-1);
}
if ((sr->smb_flg2 & SMB_FLAGS2_DFS) && smb_node_is_dfslink(node)) {
smbsr_error(sr, NT_STATUS_PATH_NOT_COVERED, ERRSRV, ERRbadpath);
kmem_free(qinfo, sizeof (smb_queryinfo_t));
smb_node_release(node);
return (-1);
}
rc = smb_query_fileinfo(sr, node, infolev, qinfo);
if (rc != 0) {
kmem_free(qinfo, sizeof (smb_queryinfo_t));
smb_node_release(node);
return (rc);
}
/* If delete_on_close - NT_STATUS_DELETE_PENDING */
if (qinfo->qi_delete_on_close) {
smbsr_error(sr, NT_STATUS_DELETE_PENDING,
ERRDOS, ERROR_ACCESS_DENIED);
kmem_free(qinfo, sizeof (smb_queryinfo_t));
smb_node_release(node);
return (-1);
}
rc = smb_query_encode_response(sr, xa, infolev, qinfo);
kmem_free(qinfo, sizeof (smb_queryinfo_t));
smb_node_release(node);
return (rc);
}
/*
* smb_query_fileinfo
*
* Populate smb_queryinfo_t structure for SMB_FTYPE_DISK
* (This should become an smb_ofile / smb_node function.)
*/
int
smb_query_fileinfo(smb_request_t *sr, smb_node_t *node, uint16_t infolev,
smb_queryinfo_t *qinfo)
{
int rc;
boolean_t include_sharename = B_FALSE;
(void) bzero(qinfo, sizeof (smb_queryinfo_t));
if (smb_node_getattr(sr, node, &qinfo->qi_attr) != 0) {
smbsr_error(sr, NT_STATUS_INTERNAL_ERROR,
ERRDOS, ERROR_INTERNAL_ERROR);
return (-1);
}
qinfo->qi_node = node;
qinfo->qi_delete_on_close =
(node->flags & NODE_FLAGS_DELETE_ON_CLOSE) != 0;
/*
* The number of links reported should be the number of
* non-deleted links. Thus if delete_on_close is set,
* decrement the link count.
*/
if (qinfo->qi_delete_on_close &&
qinfo->qi_attr.sa_vattr.va_nlink > 0) {
--(qinfo->qi_attr.sa_vattr.va_nlink);
}
/* populate name, namelen and shortname */
/* ALL_INFO levels include the sharename in the name field */
if ((infolev == SMB_QUERY_FILE_ALL_INFO) ||
(infolev == SMB_FILE_ALL_INFORMATION)) {
include_sharename = B_TRUE;
}
rc = smb_query_pathname(sr->tid_tree, node, include_sharename,
qinfo->qi_name, MAXPATHLEN);
if (rc != 0) {
smbsr_errno(sr, rc);
return (-1);
}
qinfo->qi_namelen = smb_ascii_or_unicode_strlen(sr, qinfo->qi_name);
/*
* For some reason NT will not show the security tab in the root
* directory of a mapped drive unless the filename length is
* greater than one. So we hack the length here to persuade NT
* to show the tab. It should be safe because of the null
* terminator character.
*/
if (qinfo->qi_namelen == 1)
qinfo->qi_namelen = 2;
/*
* If the shortname is generated by smb_mangle_name()
* it will be returned as the alternative name.
* Otherwise, convert the original name to upper-case
* and return it as the alternative name.
*/
(void) smb_mangle_name(qinfo->qi_attr.sa_vattr.va_nodeid,
node->od_name, qinfo->qi_shortname, qinfo->qi_name83, 0);
if (*qinfo->qi_shortname == 0) {
(void) strlcpy(qinfo->qi_shortname, node->od_name,
SMB_SHORTNAMELEN);
(void) smb_strupr(qinfo->qi_shortname);
}
return (0);
}
/*
* smb_query_by_path
*
* Common code for querying file information by file name.
* Use the file name to identify the node object and request the
* smb_queryinfo_t data for that node.
*
* Querying attributes on a named pipe by name is an error and
* is handled in the calling functions so that they can return
* the appropriate error status code (which differs by caller).
*/
static int
smb_query_by_path(smb_request_t *sr, smb_xa_t *xa, uint16_t infolev, char *path)
{
smb_queryinfo_t *qinfo;
smb_node_t *node, *dnode;
int rc;
int len;
/* VALID, but not yet supported */
if (infolev == SMB_FILE_ACCESS_INFORMATION) {
smbsr_error(sr, 0, ERRDOS, ERRunknownlevel);
return (-1);
}
/*
* Some MS clients pass NULL file names. NT interprets this as "\".
* Otherwise, if path is not "\\", remove the terminating slash.
*/
if ((len = strlen(path)) == 0)
path = "\\";
else {
if ((len > 1) && (path[len - 1] == '\\')) {
path[len - 1] = 0;
}
}
qinfo = kmem_alloc(sizeof (smb_queryinfo_t), KM_SLEEP);
rc = smb_pathname_reduce(sr, sr->user_cr, path, sr->tid_tree->t_snode,
sr->tid_tree->t_snode, &dnode, qinfo->qi_name);
if (rc == 0) {
rc = smb_fsop_lookup_name(sr, sr->user_cr, SMB_FOLLOW_LINKS,
sr->tid_tree->t_snode, dnode, qinfo->qi_name, &node);
smb_node_release(dnode);
}
if (rc != 0) {
if (rc == ENOENT)
smbsr_error(sr, NT_STATUS_OBJECT_NAME_NOT_FOUND,
ERRDOS, ERROR_FILE_NOT_FOUND);
else
smbsr_errno(sr, rc);
kmem_free(qinfo, sizeof (smb_queryinfo_t));
return (-1);
}
rc = smb_query_fileinfo(sr, node, infolev, qinfo);
if (rc != 0) {
kmem_free(qinfo, sizeof (smb_queryinfo_t));
smb_node_release(node);
return (rc);
}
/* If delete_on_close - NT_STATUS_DELETE_PENDING */
if (qinfo->qi_delete_on_close) {
smbsr_error(sr, NT_STATUS_DELETE_PENDING,
ERRDOS, ERROR_ACCESS_DENIED);
kmem_free(qinfo, sizeof (smb_queryinfo_t));
smb_node_release(node);
return (-1);
}
rc = smb_query_encode_response(sr, xa, infolev, qinfo);
kmem_free(qinfo, sizeof (smb_queryinfo_t));
smb_node_release(node);
return (rc);
}
smb_sdrc_t
smb_com_check_directory(smb_request_t *sr)
{
int rc;
smb_fqi_t *fqi;
smb_node_t *tnode;
smb_node_t *node;
char *path;
smb_pathname_t *pn;
if (STYPE_ISIPC(sr->tid_tree->t_res_type)) {
smbsr_error(sr, NT_STATUS_ACCESS_DENIED, ERRDOS,
ERROR_ACCESS_DENIED);
return (SDRC_ERROR);
}
fqi = &sr->arg.dirop.fqi;
pn = &fqi->fq_path;
if (pn->pn_path[0] == '\0') {
rc = smbsr_encode_empty_result(sr);
return ((rc == 0) ? SDRC_SUCCESS : SDRC_ERROR);
}
smb_pathname_init(sr, pn, pn->pn_path);
if (!smb_pathname_validate(sr, pn) ||
!smb_validate_dirname(sr, pn)) {
return (SDRC_ERROR);
}
path = pn->pn_path;
tnode = sr->tid_tree->t_snode;
rc = smb_pathname_reduce(sr, sr->user_cr, path, tnode, tnode,
&fqi->fq_dnode, fqi->fq_last_comp);
if (rc != 0) {
smbsr_errno(sr, rc);
return (SDRC_ERROR);
}
rc = smb_fsop_lookup(sr, sr->user_cr, SMB_FOLLOW_LINKS,
tnode, fqi->fq_dnode, fqi->fq_last_comp, &fqi->fq_fnode);
smb_node_release(fqi->fq_dnode);
if (rc != 0) {
if (rc == ENOENT)
smbsr_error(sr, NT_STATUS_OBJECT_NAME_NOT_FOUND,
ERRDOS, ERROR_PATH_NOT_FOUND);
else
smbsr_errno(sr, rc);
return (SDRC_ERROR);
}
node = fqi->fq_fnode;
if (!smb_node_is_dir(node)) {
smbsr_error(sr, NT_STATUS_NOT_A_DIRECTORY,
ERRDOS, ERROR_PATH_NOT_FOUND);
smb_node_release(node);
return (SDRC_ERROR);
}
if ((sr->smb_flg2 & SMB_FLAGS2_DFS) && smb_node_is_dfslink(node)) {
smbsr_error(sr, NT_STATUS_PATH_NOT_COVERED, ERRSRV, ERRbadpath);
smb_node_release(node);
return (SDRC_ERROR);
}
rc = smb_fsop_access(sr, sr->user_cr, node, FILE_TRAVERSE);
smb_node_release(node);
if (rc != 0) {
smbsr_error(sr, NT_STATUS_ACCESS_DENIED,
ERRDOS, ERROR_ACCESS_DENIED);
return (SDRC_ERROR);
}
rc = smbsr_encode_empty_result(sr);
return ((rc == 0) ? SDRC_SUCCESS : SDRC_ERROR);
}
smb_sdrc_t
smb_com_delete_directory(smb_request_t *sr)
{
int rc;
uint32_t flags = 0;
smb_fqi_t *fqi;
smb_node_t *tnode;
if (!STYPE_ISDSK(sr->tid_tree->t_res_type)) {
smbsr_error(sr, NT_STATUS_ACCESS_DENIED,
ERRDOS, ERROR_ACCESS_DENIED);
return (SDRC_ERROR);
}
fqi = &sr->arg.dirop.fqi;
tnode = sr->tid_tree->t_snode;
smb_pathname_init(sr, &fqi->fq_path, fqi->fq_path.pn_path);
if (!smb_pathname_validate(sr, &fqi->fq_path) ||
!smb_validate_dirname(sr, &fqi->fq_path)) {
return (SDRC_ERROR);
}
rc = smb_pathname_reduce(sr, sr->user_cr, fqi->fq_path.pn_path,
tnode, tnode, &fqi->fq_dnode, fqi->fq_last_comp);
if (rc != 0) {
smbsr_errno(sr, rc);
return (SDRC_ERROR);
}
rc = smb_fsop_lookup(sr, sr->user_cr, SMB_FOLLOW_LINKS,
tnode, fqi->fq_dnode, fqi->fq_last_comp, &fqi->fq_fnode);
if (rc != 0) {
if (rc == ENOENT)
smbsr_error(sr, NT_STATUS_OBJECT_NAME_NOT_FOUND,
ERRDOS, ERROR_FILE_NOT_FOUND);
else
smbsr_errno(sr, rc);
smb_node_release(fqi->fq_dnode);
return (SDRC_ERROR);
}
/*
* Delete should fail if this is the root of a share
* or a DFS link
*/
if ((fqi->fq_fnode == tnode) || smb_node_is_dfslink(fqi->fq_fnode)) {
smbsr_error(sr, NT_STATUS_ACCESS_DENIED,
ERRDOS, ERROR_ACCESS_DENIED);
smb_node_release(fqi->fq_dnode);
smb_node_release(fqi->fq_fnode);
return (SDRC_ERROR);
}
if (!smb_node_is_dir(fqi->fq_fnode)) {
smbsr_error(sr, NT_STATUS_NOT_A_DIRECTORY,
ERRDOS, ERROR_PATH_NOT_FOUND);
smb_node_release(fqi->fq_dnode);
smb_node_release(fqi->fq_fnode);
return (SDRC_ERROR);
}
/*
* Using kcred because we just want the DOS attrs
* and don't want access errors for this.
*/
fqi->fq_fattr.sa_mask = SMB_AT_DOSATTR;
rc = smb_node_getattr(sr, fqi->fq_fnode, zone_kcred(), NULL,
&fqi->fq_fattr);
if (rc != 0) {
smbsr_errno(sr, rc);
smb_node_release(fqi->fq_dnode);
smb_node_release(fqi->fq_fnode);
return (SDRC_ERROR);
}
if ((fqi->fq_fattr.sa_dosattr & FILE_ATTRIBUTE_READONLY) ||
(smb_fsop_access(sr, sr->user_cr, fqi->fq_fnode, DELETE)
!= NT_STATUS_SUCCESS)) {
smbsr_error(sr, NT_STATUS_CANNOT_DELETE,
ERRDOS, ERROR_ACCESS_DENIED);
smb_node_release(fqi->fq_dnode);
smb_node_release(fqi->fq_fnode);
return (SDRC_ERROR);
}
if (SMB_TREE_SUPPORTS_CATIA(sr))
flags |= SMB_CATIA;
rc = smb_fsop_rmdir(sr, sr->user_cr, fqi->fq_dnode,
fqi->fq_fnode->od_name, flags);
smb_node_release(fqi->fq_fnode);
smb_node_release(fqi->fq_dnode);
if (rc != 0) {
if (rc == EEXIST)
smbsr_error(sr, NT_STATUS_DIRECTORY_NOT_EMPTY,
ERRDOS, ERROR_DIR_NOT_EMPTY);
else
smbsr_errno(sr, rc);
return (SDRC_ERROR);
}
rc = smbsr_encode_empty_result(sr);
return ((rc == 0) ? SDRC_SUCCESS : SDRC_ERROR);
}
/*
* smb_com_trans2_find_first2
*
* Client Request Value
* ============================ ==================================
*
* UCHAR WordCount 15
* UCHAR TotalDataCount Total size of extended attribute list
* UCHAR SetupCount 1
* UCHAR Setup[0] TRANS2_FIND_FIRST2
*
* Parameter Block Encoding Description
* ============================ ==================================
* USHORT SearchAttributes;
* USHORT SearchCount; Maximum number of entries to return
* USHORT Flags; Additional information:
* Bit 0 - close search after this request
* Bit 1 - close search if end of search
* reached
* Bit 2 - return resume keys for each
* entry found
* Bit 3 - continue search from previous
* ending place
* Bit 4 - find with backup intent
* USHORT InformationLevel; See below
* ULONG SearchStorageType;
* STRING FileName; Pattern for the search
* UCHAR Data[ TotalDataCount ] FEAList if InformationLevel is
* QUERY_EAS_FROM_LIST
*
* Response Parameter Block Description
* ============================ ==================================
*
* USHORT Sid; Search handle
* USHORT SearchCount; Number of entries returned
* USHORT EndOfSearch; Was last entry returned?
* USHORT EaErrorOffset; Offset into EA list if EA error
* USHORT LastNameOffset; Offset into data to file name of last
* entry, if server needs it to resume
* search; else 0
* UCHAR Data[ TotalDataCount ] Level dependent info about the matches
* found in the search
*/
smb_sdrc_t
smb_com_trans2_find_first2(smb_request_t *sr, smb_xa_t *xa)
{
int count;
uint16_t sattr, odid;
char *path;
smb_odir_t *od;
smb_find_args_t args;
boolean_t eos;
uint32_t odir_flags = 0;
bzero(&args, sizeof (smb_find_args_t));
if (!STYPE_ISDSK(sr->tid_tree->t_res_type)) {
smbsr_error(sr, NT_STATUS_ACCESS_DENIED,
ERRDOS, ERROR_ACCESS_DENIED);
return (SDRC_ERROR);
}
if (smb_mbc_decodef(&xa->req_param_mb, "%wwww4.u", sr, &sattr,
&args.fa_maxcount, &args.fa_fflag, &args.fa_infolev, &path) != 0) {
return (SDRC_ERROR);
}
if (smb_is_stream_name(path)) {
smbsr_error(sr, NT_STATUS_OBJECT_NAME_INVALID,
ERRDOS, ERROR_INVALID_NAME);
return (SDRC_ERROR);
}
if (args.fa_fflag & SMB_FIND_WITH_BACKUP_INTENT) {
sr->user_cr = smb_user_getprivcred(sr->uid_user);
odir_flags = SMB_ODIR_OPENF_BACKUP_INTENT;
}
args.fa_maxdata =
smb_trans2_find_get_maxdata(sr, args.fa_infolev, args.fa_fflag);
if (args.fa_maxdata == 0)
return (SDRC_ERROR);
if (sr->smb_flg2 & SMB_FLAGS2_UNICODE)
(void) smb_convert_wildcards(path);
odid = smb_odir_open(sr, path, sattr, odir_flags);
if (odid == 0)
return (SDRC_ERROR);
od = smb_tree_lookup_odir(sr->tid_tree, odid);
if (od == NULL)
return (SDRC_ERROR);
count = smb_trans2_find_entries(sr, xa, od, &args, &eos);
if (count == -1) {
smb_odir_close(od);
smb_odir_release(od);
return (SDRC_ERROR);
}
if (count == 0) {
smb_odir_close(od);
smb_odir_release(od);
smbsr_errno(sr, ENOENT);
return (SDRC_ERROR);
}
if ((args.fa_fflag & SMB_FIND_CLOSE_AFTER_REQUEST) ||
(eos && (args.fa_fflag & SMB_FIND_CLOSE_AT_EOS))) {
smb_odir_close(od);
} /* else leave odir open for trans2_find_next2 */
smb_odir_release(od);
(void) smb_mbc_encodef(&xa->rep_param_mb, "wwwww",
odid, count, (eos) ? 1 : 0, 0, 0);
return (SDRC_SUCCESS);
}
/*
* smb_odir_read_streaminfo
*
* Find the next directory entry whose name begins with SMB_STREAM_PREFIX,
* and thus represents an NTFS named stream.
* No search attribute matching is performed.
* No case conflict name mangling is required for NTFS named stream names.
*
* Returns:
* 0 - success.
* - If a matching entry was found eof will be B_FALSE and
* sinfo will be populated.
* - If there are no matching entries eof will be B_TRUE.
* -1 - error, error details set in sr.
*/
int
smb_odir_read_streaminfo(smb_request_t *sr, smb_odir_t *od,
smb_streaminfo_t *sinfo, boolean_t *eof)
{
int rc;
smb_odirent_t *odirent;
smb_node_t *fnode;
smb_attr_t attr;
ASSERT(sr);
ASSERT(sr->sr_magic == SMB_REQ_MAGIC);
ASSERT(od);
ASSERT(od->d_magic == SMB_ODIR_MAGIC);
ASSERT(sinfo);
mutex_enter(&od->d_mutex);
ASSERT(od->d_refcnt > 0);
switch (od->d_state) {
case SMB_ODIR_STATE_IN_USE:
case SMB_ODIR_STATE_CLOSING:
break;
case SMB_ODIR_STATE_OPEN:
case SMB_ODIR_STATE_CLOSED:
default:
mutex_exit(&od->d_mutex);
return (-1);
}
/* Check that odir represents an xattr directory */
if (!(od->d_flags & SMB_ODIR_FLAG_XATTR)) {
*eof = B_TRUE;
mutex_exit(&od->d_mutex);
return (0);
}
odirent = kmem_alloc(sizeof (smb_odirent_t), KM_SLEEP);
bzero(&attr, sizeof (attr));
for (;;) {
bzero(sinfo, sizeof (smb_streaminfo_t));
if ((rc = smb_odir_next_odirent(od, odirent)) != 0)
break;
if (strncmp(odirent->od_name, SMB_STREAM_PREFIX,
SMB_STREAM_PREFIX_LEN)) {
continue;
}
rc = smb_fsop_lookup(sr, od->d_cred, 0, od->d_tree->t_snode,
od->d_dnode, odirent->od_name, &fnode);
if (rc == 0) {
attr.sa_mask = SMB_AT_SIZE | SMB_AT_ALLOCSZ;
rc = smb_node_getattr(sr, fnode, od->d_cred,
NULL, &attr);
smb_node_release(fnode);
}
if (rc == 0) {
(void) strlcpy(sinfo->si_name,
odirent->od_name + SMB_STREAM_PREFIX_LEN,
sizeof (sinfo->si_name));
sinfo->si_size = attr.sa_vattr.va_size;
sinfo->si_alloc_size = attr.sa_allocsz;
break;
}
}
mutex_exit(&od->d_mutex);
kmem_free(odirent, sizeof (smb_odirent_t));
switch (rc) {
case 0:
*eof = B_FALSE;
return (0);
case ENOENT:
*eof = B_TRUE;
return (0);
default:
smbsr_errno(sr, rc);
return (-1);
}
}
/*
* smb_odir_read_fileinfo
*
* Find the next directory entry matching the search pattern
* and attributes: od->d_pattern and od->d_sattr.
*
* If the search pattern specifies a single filename call
* smb_odir_single_fileinfo to get the file attributes and
* populate the caller's smb_fileinfo_t.
*
* If the search pattern contains wildcards call smb_odir_next_odirent
* to get the next directory entry then. Repeat until a matching
* filename is found. Call smb_odir_wildcard_fileinfo to get the
* file attributes and populate the caller's smb_fileinfo_t.
* This is repeated until a file matching the search criteria is found.
*
* Returns:
* 0 - success.
* - If a matching entry was found eof will be B_FALSE and
* fileinfo will be populated.
* - If there are no matching entries eof will be B_TRUE.
* -1 - error, error details set in sr.
*/
int
smb_odir_read_fileinfo(smb_request_t *sr, smb_odir_t *od,
smb_fileinfo_t *fileinfo, uint16_t *eof)
{
int rc, errnum;
smb_odirent_t *odirent;
ASSERT(sr);
ASSERT(sr->sr_magic == SMB_REQ_MAGIC);
ASSERT(od);
ASSERT(od->d_magic == SMB_ODIR_MAGIC);
ASSERT(fileinfo);
mutex_enter(&od->d_mutex);
ASSERT(od->d_refcnt > 0);
switch (od->d_state) {
case SMB_ODIR_STATE_IN_USE:
case SMB_ODIR_STATE_CLOSING:
break;
case SMB_ODIR_STATE_OPEN:
case SMB_ODIR_STATE_CLOSED:
default:
mutex_exit(&od->d_mutex);
return (-1);
}
if ((od->d_flags & SMB_ODIR_FLAG_WILDCARDS) == 0) {
if (od->d_eof)
rc = ENOENT;
else
rc = smb_odir_single_fileinfo(sr, od, fileinfo);
od->d_eof = B_TRUE;
} else {
odirent = kmem_alloc(sizeof (smb_odirent_t), KM_SLEEP);
for (;;) {
bzero(fileinfo, sizeof (smb_fileinfo_t));
if ((rc = smb_odir_next_odirent(od, odirent)) != 0)
break;
/* skip non utf8 filename */
if (u8_validate(odirent->od_name,
strlen(odirent->od_name), NULL,
U8_VALIDATE_ENTIRE, &errnum) < 0)
continue;
if (!smb_odir_match_name(od, odirent))
continue;
rc = smb_odir_wildcard_fileinfo(sr, od, odirent,
fileinfo);
if (rc == 0)
break;
}
kmem_free(odirent, sizeof (smb_odirent_t));
}
mutex_exit(&od->d_mutex);
switch (rc) {
case 0:
*eof = 0;
return (0);
case ENOENT:
*eof = 1; /* per. FindFirst, FindNext spec. */
return (0);
default:
smbsr_errno(sr, rc);
return (-1);
}
}
