/*
* smb_rename_release_src
*/
static void
smb_rename_release_src(smb_request_t *sr)
{
smb_fqi_t *src_fqi = &sr->arg.dirop.fqi;
smb_node_end_crit(src_fqi->fq_fnode);
smb_node_release(src_fqi->fq_fnode);
smb_node_release(src_fqi->fq_dnode);
}
/*
* 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);
}
/*
* Delete an odir.
*
* Remove the odir from the tree list before freeing resources
* associated with the odir.
*/
void
smb_odir_delete(void *arg)
{
smb_tree_t *tree;
smb_odir_t *od = (smb_odir_t *)arg;
SMB_ODIR_VALID(od);
ASSERT(od->d_refcnt == 0);
ASSERT(od->d_state == SMB_ODIR_STATE_CLOSED);
tree = od->d_tree;
smb_llist_enter(&tree->t_odir_list, RW_WRITER);
smb_llist_remove(&tree->t_odir_list, od);
smb_idpool_free(&tree->t_odid_pool, od->d_odid);
atomic_dec_32(&tree->t_session->s_dir_cnt);
smb_llist_exit(&tree->t_odir_list);
mutex_enter(&od->d_mutex);
mutex_exit(&od->d_mutex);
od->d_magic = 0;
smb_node_release(od->d_dnode);
smb_user_release(od->d_user);
mutex_destroy(&od->d_mutex);
kmem_cache_free(smb_cache_odir, od);
}
/*
* Deallocate a tree: release all resources associated with a tree and
* remove the tree from the user's tree list.
*
* The tree being destroyed must be in the "destroying" state and the
* reference count must be zero. This function assumes it's single threaded
* i.e. only one thread will attempt to destroy a specific tree, which
* should be the case if the tree is in disconnected and has a reference
* count of zero.
*/
static void
smb_tree_dealloc(smb_tree_t *tree)
{
ASSERT(tree);
ASSERT(tree->t_magic == SMB_TREE_MAGIC);
ASSERT(tree->t_state == SMB_TREE_STATE_DISCONNECTED);
ASSERT(tree->t_refcnt == 0);
/*
* Remove the tree from the user's tree list. This must be done
* before any resources associated with the tree are released.
*/
smb_llist_enter(&tree->t_user->u_tree_list, RW_WRITER);
smb_llist_remove(&tree->t_user->u_tree_list, tree);
smb_llist_exit(&tree->t_user->u_tree_list);
tree->t_magic = (uint32_t)~SMB_TREE_MAGIC;
smb_idpool_free(&tree->t_user->u_tid_pool, tree->t_tid);
atomic_dec_32(&tree->t_session->s_tree_cnt);
if (tree->t_snode)
smb_node_release(tree->t_snode);
mutex_destroy(&tree->t_mutex);
/*
* The list of open files and open directories should be empty.
*/
smb_llist_destructor(&tree->t_ofile_list);
smb_llist_destructor(&tree->t_odir_list);
smb_idpool_destructor(&tree->t_fid_pool);
smb_idpool_destructor(&tree->t_odid_pool);
kmem_cache_free(tree->t_server->si_cache_tree, tree);
}
/*
* 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);
}
/*
* Delete an ofile.
*
* Remove the ofile from the tree list before freeing resources
* associated with the ofile.
*/
void
smb_ofile_delete(void *arg)
{
smb_tree_t *tree;
smb_ofile_t *of = (smb_ofile_t *)arg;
SMB_OFILE_VALID(of);
ASSERT(of->f_refcnt == 0);
ASSERT(of->f_state == SMB_OFILE_STATE_CLOSED);
ASSERT(!SMB_OFILE_OPLOCK_GRANTED(of));
tree = of->f_tree;
smb_llist_enter(&tree->t_ofile_list, RW_WRITER);
smb_llist_remove(&tree->t_ofile_list, of);
smb_idpool_free(&tree->t_fid_pool, of->f_fid);
atomic_dec_32(&tree->t_session->s_file_cnt);
smb_llist_exit(&tree->t_ofile_list);
mutex_enter(&of->f_mutex);
mutex_exit(&of->f_mutex);
switch (of->f_ftype) {
case SMB_FTYPE_BYTE_PIPE:
case SMB_FTYPE_MESG_PIPE:
smb_opipe_dealloc(of->f_pipe);
of->f_pipe = NULL;
break;
case SMB_FTYPE_DISK:
if (of->f_odir != NULL)
smb_odir_release(of->f_odir);
smb_node_rem_ofile(of->f_node, of);
smb_node_release(of->f_node);
break;
default:
ASSERT(!"f_ftype");
break;
}
of->f_magic = (uint32_t)~SMB_OFILE_MAGIC;
mutex_destroy(&of->f_mutex);
crfree(of->f_cr);
smb_user_release(of->f_user);
kmem_cache_free(smb_cache_ofile, of);
}
/*
* smb_odir_lookup_link
*
* If the file is a symlink we lookup the object to which the
* symlink refers so that we can return its attributes.
* This can cause a problem if a symlink in a sub-directory
* points to a parent directory (some UNIX GUI's create a symlink
* in $HOME/.desktop that points to the user's home directory).
* Some Windows applications (e.g. virus scanning) loop/hang
* trying to follow this recursive path and there is little
* we can do because the path is constructed on the client.
* smb_dirsymlink_enable allows an end-user to disable
* symlinks to directories. Symlinks to other object types
* should be unaffected.
*
* Returns: B_TRUE - followed link. tgt_node and tgt_attr set
* B_FALSE - link not followed
*/
static boolean_t
smb_odir_lookup_link(smb_request_t *sr, smb_odir_t *od,
char *fname, smb_node_t **tgt_node)
{
int rc;
uint32_t flags = SMB_FOLLOW_LINKS | SMB_CASE_SENSITIVE;
rc = smb_fsop_lookup(sr, od->d_cred, flags,
od->d_tree->t_snode, od->d_dnode, fname, tgt_node);
if (rc != 0) {
*tgt_node = NULL;
return (B_FALSE);
}
if (smb_node_is_dir(*tgt_node) && (!smb_dirsymlink_enable)) {
smb_node_release(*tgt_node);
*tgt_node = NULL;
return (B_FALSE);
}
return (B_TRUE);
}
/*
* smb_rename_lookup_src
*
* Lookup the src node, checking for sharing violations and
* breaking any existing BATCH oplock.
* Populate sr->arg.dirop.fqi
*
* Upon success, the dnode and fnode will have holds and the
* fnode will be in a critical section. These should be
* released using smb_rename_release_src().
*
* Returns errno values.
*/
static int
smb_rename_lookup_src(smb_request_t *sr)
{
smb_node_t *src_node, *tnode;
DWORD status;
int rc;
int count;
char *path;
smb_fqi_t *src_fqi = &sr->arg.dirop.fqi;
if (smb_is_stream_name(src_fqi->fq_path.pn_path))
return (EINVAL);
/* Lookup the source node */
tnode = sr->tid_tree->t_snode;
path = src_fqi->fq_path.pn_path;
rc = smb_pathname_reduce(sr, sr->user_cr, path, tnode, tnode,
&src_fqi->fq_dnode, src_fqi->fq_last_comp);
if (rc != 0)
return (rc);
rc = smb_fsop_lookup(sr, sr->user_cr, 0, tnode,
src_fqi->fq_dnode, src_fqi->fq_last_comp, &src_fqi->fq_fnode);
if (rc != 0) {
smb_node_release(src_fqi->fq_dnode);
return (rc);
}
src_node = src_fqi->fq_fnode;
rc = smb_rename_check_attr(sr, src_node, src_fqi->fq_sattr);
if (rc != 0) {
smb_node_release(src_fqi->fq_fnode);
smb_node_release(src_fqi->fq_dnode);
return (rc);
}
/*
* Break BATCH oplock before ofile checks. If a client
* has a file open, this will force a flush or close,
* which may affect the outcome of any share checking.
*/
(void) smb_oplock_break(sr, src_node,
SMB_OPLOCK_BREAK_TO_LEVEL_II | SMB_OPLOCK_BREAK_BATCH);
/*
* Wait (a little) for the oplock break to be
* responded to by clients closing handles.
* Hold node->n_lock as reader to keep new
* ofiles from showing up after we check.
*/
smb_node_rdlock(src_node);
for (count = 0; count <= 12; count++) {
status = smb_node_rename_check(src_node);
if (status != NT_STATUS_SHARING_VIOLATION)
break;
smb_node_unlock(src_node);
delay(MSEC_TO_TICK(100));
smb_node_rdlock(src_node);
}
if (status != NT_STATUS_SUCCESS) {
smb_node_unlock(src_node);
smb_node_release(src_fqi->fq_fnode);
smb_node_release(src_fqi->fq_dnode);
return (EPIPE); /* = ERRbadshare */
}
/*
* Note, the combination of these two:
* smb_node_rdlock(node);
* nbl_start_crit(node->vp, RW_READER);
* is equivalent to this call:
* smb_node_start_crit(node, RW_READER)
*
* Cleanup after this point should use:
* smb_node_end_crit(src_node)
*/
nbl_start_crit(src_node->vp, RW_READER);
/*
* This checks nbl_share_conflict, nbl_lock_conflict
*/
status = smb_nbl_conflict(src_node, 0, UINT64_MAX, NBL_RENAME);
if (status != NT_STATUS_SUCCESS) {
smb_node_end_crit(src_node);
smb_node_release(src_fqi->fq_fnode);
smb_node_release(src_fqi->fq_dnode);
if (status == NT_STATUS_SHARING_VIOLATION)
return (EPIPE); /* = ERRbadshare */
return (EACCES);
}
/* NB: Caller expects holds on src_fqi fnode, dnode */
return (0);
}
/*
* smb_make_link
*
* Creating a hard link (adding an additional name) for a file.
*
* If the source and destination are identical, we go through all
* the checks but we don't create a link.
*
* If the file is a symlink we create the hardlink on the target
* of the symlink (i.e. use SMB_FOLLOW_LINKS when looking up src).
* If the target of the symlink does not exist we fail with ENOENT.
*
* Returns NT status values.
*
* Similar to smb_common_rename() above.
*/
uint32_t
smb_make_link(smb_request_t *sr, smb_fqi_t *src_fqi, smb_fqi_t *dst_fqi)
{
smb_node_t *tnode;
char *path;
int rc;
tnode = sr->tid_tree->t_snode;
path = dst_fqi->fq_path.pn_path;
/* Cannnot create link on named stream */
if (smb_is_stream_name(src_fqi->fq_path.pn_path) ||
smb_is_stream_name(dst_fqi->fq_path.pn_path)) {
return (NT_STATUS_INVALID_PARAMETER);
}
/* The source node may already have been provided */
if (src_fqi->fq_fnode) {
smb_node_start_crit(src_fqi->fq_fnode, RW_READER);
smb_node_ref(src_fqi->fq_fnode);
smb_node_ref(src_fqi->fq_dnode);
} else {
/* lookup and validate src node */
rc = smb_rename_lookup_src(sr);
if (rc != 0)
return (smb_rename_errno2status(rc));
}
/* Not valid to create hardlink for directory */
if (smb_node_is_dir(src_fqi->fq_fnode)) {
smb_rename_release_src(sr);
return (NT_STATUS_FILE_IS_A_DIRECTORY);
}
/*
* Find the destination dnode and last component.
* May already be provided, i.e. when called via
* SMB1 trans2 setinfo.
*/
if (dst_fqi->fq_dnode) {
smb_node_ref(dst_fqi->fq_dnode);
} else {
rc = smb_pathname_reduce(sr, sr->user_cr, path, tnode, tnode,
&dst_fqi->fq_dnode, dst_fqi->fq_last_comp);
if (rc != 0) {
smb_rename_release_src(sr);
return (smb_rename_errno2status(rc));
}
}
/* If CI name match in same directory, we're done */
if ((src_fqi->fq_dnode == dst_fqi->fq_dnode) &&
(smb_strcasecmp(src_fqi->fq_fnode->od_name,
dst_fqi->fq_last_comp, 0) == 0)) {
smb_rename_release_src(sr);
smb_node_release(dst_fqi->fq_dnode);
return (0);
}
if (smb_is_invalid_filename(dst_fqi->fq_last_comp)) {
smb_rename_release_src(sr);
smb_node_release(dst_fqi->fq_dnode);
return (NT_STATUS_OBJECT_NAME_INVALID);
}
/* Lookup the destination node. It MUST NOT exist. */
rc = smb_fsop_lookup(sr, sr->user_cr, 0, tnode,
dst_fqi->fq_dnode, dst_fqi->fq_last_comp, &dst_fqi->fq_fnode);
if (rc == 0) {
smb_node_release(dst_fqi->fq_fnode);
rc = EEXIST;
}
if (rc != ENOENT) {
smb_rename_release_src(sr);
smb_node_release(dst_fqi->fq_dnode);
return (smb_rename_errno2status(rc));
}
rc = smb_fsop_link(sr, sr->user_cr, src_fqi->fq_fnode,
dst_fqi->fq_dnode, dst_fqi->fq_last_comp);
if (rc == 0) {
smb_node_notify_change(dst_fqi->fq_dnode,
FILE_ACTION_ADDED, dst_fqi->fq_last_comp);
}
smb_rename_release_src(sr);
smb_node_release(dst_fqi->fq_dnode);
return (smb_rename_errno2status(rc));
}
/*
* 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_odir_wildcard_fileinfo
*
* odirent contains a directory entry, obtained from a vop_readdir.
* If a case conflict is identified the filename is mangled and the
* shortname is used as 'name', in place of odirent->od_name.
*
* If the looked up file is a link, we attempt to lookup the link target
* to use its attributes in place of those of the files's.
* If we fail to lookup the target of the link we use the original
* file's attributes.
* Check if the attributes match the search attributes.
*
* Although some file systems can have directories larger than
* SMB_MAXDIRSIZE smb_odir_next_odirent ensures that no offset larger
* than SMB_MAXDIRSIZE is returned. It is therefore safe to use the
* offset as the cookie (uint32_t).
*
* Returns: 0 - success
* ENOENT - no match, proceed to next entry
* errno - error
*/
static int
smb_odir_wildcard_fileinfo(smb_request_t *sr, smb_odir_t *od,
smb_odirent_t *odirent, smb_fileinfo_t *fileinfo)
{
int rc;
cred_t *cr;
smb_node_t *fnode, *tgt_node;
smb_attr_t attr;
char *name;
boolean_t case_conflict;
ASSERT(sr);
ASSERT(sr->sr_magic == SMB_REQ_MAGIC);
ASSERT(od);
ASSERT(od->d_magic == SMB_ODIR_MAGIC);
ASSERT(MUTEX_HELD(&od->d_mutex));
bzero(fileinfo, sizeof (smb_fileinfo_t));
rc = smb_fsop_lookup(sr, od->d_cred, SMB_CASE_SENSITIVE,
od->d_tree->t_snode, od->d_dnode, odirent->od_name, &fnode);
if (rc != 0)
return (rc);
/* follow link to get target node & attr */
if (smb_node_is_symlink(fnode) &&
smb_odir_lookup_link(sr, od, odirent->od_name, &tgt_node)) {
smb_node_release(fnode);
fnode = tgt_node;
}
/* skip system files */
if (smb_node_is_system(fnode)) {
smb_node_release(fnode);
return (ENOENT);
}
/*
* Windows directory listings return not only names, but
* also some attributes. In Unix, you need some access to
* get those attributes. Which credential should we use to
* get those? If we're doing Access Based Enumeration (ABE)
* we want this getattr to fail, which will cause the caller
* to skip this entry. If we're NOT doing ABE, we normally
* want to show all the directory entries (including their
* attributes) so we want this getattr to succeed!
*/
if (smb_tree_has_feature(od->d_tree, SMB_TREE_ABE))
cr = od->d_cred;
else
cr = zone_kcred();
bzero(&attr, sizeof (attr));
attr.sa_mask = SMB_AT_ALL;
rc = smb_node_getattr(NULL, fnode, cr, NULL, &attr);
if (rc != 0) {
smb_node_release(fnode);
return (rc);
}
/* check search attributes */
if (!smb_sattr_check(attr.sa_dosattr, od->d_sattr)) {
smb_node_release(fnode);
return (ENOENT);
}
name = odirent->od_name;
if (od->d_flags & SMB_ODIR_FLAG_SHORTNAMES) {
case_conflict = ((od->d_flags & SMB_ODIR_FLAG_IGNORE_CASE) &&
(odirent->od_eflags & ED_CASE_CONFLICT));
if (case_conflict || smb_needs_mangled(name)) {
smb_mangle(name, odirent->od_ino,
fileinfo->fi_shortname, SMB_SHORTNAMELEN);
}
if (case_conflict)
name = fileinfo->fi_shortname;
}
(void) strlcpy(fileinfo->fi_name, name, sizeof (fileinfo->fi_name));
fileinfo->fi_cookie = (uint32_t)od->d_offset;
fileinfo->fi_dosattr = attr.sa_dosattr;
fileinfo->fi_nodeid = attr.sa_vattr.va_nodeid;
fileinfo->fi_size = attr.sa_vattr.va_size;
fileinfo->fi_alloc_size = attr.sa_allocsz;
fileinfo->fi_atime = attr.sa_vattr.va_atime;
fileinfo->fi_mtime = attr.sa_vattr.va_mtime;
fileinfo->fi_ctime = attr.sa_vattr.va_ctime;
if (attr.sa_crtime.tv_sec)
fileinfo->fi_crtime = attr.sa_crtime;
else
fileinfo->fi_crtime = attr.sa_vattr.va_mtime;
smb_node_release(fnode);
return (0);
}
int
smb_pathname(smb_request_t *sr, char *path, int flags,
smb_node_t *root_node, smb_node_t *cur_node, smb_node_t **dir_node,
smb_node_t **ret_node, cred_t *cred)
{
char *component, *real_name, *namep;
pathname_t pn, rpn, upn, link_pn;
smb_node_t *dnode, *fnode;
smb_attr_t attr;
vnode_t *rootvp, *vp;
size_t pathleft;
int err = 0;
int nlink = 0;
int local_flags;
uint32_t abe_flag = 0;
char namebuf[MAXNAMELEN];
if (path == NULL)
return (EINVAL);
ASSERT(root_node);
ASSERT(cur_node);
ASSERT(ret_node);
*ret_node = NULL;
if (dir_node)
*dir_node = NULL;
(void) pn_alloc(&upn);
if ((err = pn_set(&upn, path)) != 0) {
(void) pn_free(&upn);
return (err);
}
if (SMB_TREE_SUPPORTS_ABE(sr))
abe_flag = SMB_ABE;
(void) pn_alloc(&pn);
(void) pn_alloc(&rpn);
component = kmem_alloc(MAXNAMELEN, KM_SLEEP);
real_name = kmem_alloc(MAXNAMELEN, KM_SLEEP);
fnode = NULL;
dnode = cur_node;
smb_node_ref(dnode);
rootvp = root_node->vp;
while ((pathleft = pn_pathleft(&upn)) != 0) {
if (fnode) {
smb_node_release(dnode);
dnode = fnode;
fnode = NULL;
}
if ((err = pn_getcomponent(&upn, component)) != 0)
break;
if ((namep = smb_pathname_catia_v5tov4(sr, component,
namebuf, sizeof (namebuf))) == NULL) {
err = EILSEQ;
break;
}
if ((err = pn_set(&pn, namep)) != 0)
break;
local_flags = flags & FIGNORECASE;
err = smb_pathname_lookup(&pn, &rpn, local_flags,
&vp, rootvp, dnode->vp, &attr, cred);
if (err) {
if (!SMB_TREE_SUPPORTS_SHORTNAMES(sr) ||
!smb_maybe_mangled(component))
break;
if ((err = smb_unmangle(dnode, component,
real_name, MAXNAMELEN, abe_flag)) != 0)
break;
if ((namep = smb_pathname_catia_v5tov4(sr, real_name,
namebuf, sizeof (namebuf))) == NULL) {
err = EILSEQ;
break;
}
if ((err = pn_set(&pn, namep)) != 0)
break;
local_flags = 0;
err = smb_pathname_lookup(&pn, &rpn, local_flags,
&vp, rootvp, dnode->vp, &attr, cred);
if (err)
break;
}
/*
* This check MUST be done before symlink check
* since a reparse point is of type VLNK but should
* not be handled like a regular symlink.
*/
if (attr.sa_dosattr & FILE_ATTRIBUTE_REPARSE_POINT) {
err = EREMOTE;
VN_RELE(vp);
break;
}
if ((vp->v_type == VLNK) &&
((flags & FOLLOW) || pn_pathleft(&upn))) {
if (++nlink > MAXSYMLINKS) {
err = ELOOP;
VN_RELE(vp);
break;
}
(void) pn_alloc(&link_pn);
err = pn_getsymlink(vp, &link_pn, cred);
VN_RELE(vp);
if (err == 0) {
if (pn_pathleft(&link_pn) == 0)
(void) pn_set(&link_pn, ".");
err = pn_insert(&upn, &link_pn,
strlen(component));
}
pn_free(&link_pn);
if (err)
break;
if (upn.pn_pathlen == 0) {
err = ENOENT;
break;
}
if (upn.pn_path[0] == '/') {
fnode = root_node;
smb_node_ref(fnode);
}
if (pn_fixslash(&upn))
flags |= FOLLOW;
} else {
if (flags & FIGNORECASE) {
if (strcmp(rpn.pn_path, "/") != 0)
pn_setlast(&rpn);
namep = rpn.pn_path;
} else {
namep = pn.pn_path;
}
namep = smb_pathname_catia_v4tov5(sr, namep,
namebuf, sizeof (namebuf));
fnode = smb_node_lookup(sr, NULL, cred, vp, namep,
dnode, NULL);
VN_RELE(vp);
if (fnode == NULL) {
err = ENOMEM;
break;
}
}
while (upn.pn_path[0] == '/') {
upn.pn_path++;
upn.pn_pathlen--;
}
}
if ((pathleft) && (err == ENOENT))
err = ENOTDIR;
if (err) {
if (fnode)
smb_node_release(fnode);
if (dnode)
smb_node_release(dnode);
} else {
*ret_node = fnode;
if (dir_node)
*dir_node = dnode;
else
smb_node_release(dnode);
}
kmem_free(component, MAXNAMELEN);
kmem_free(real_name, MAXNAMELEN);
(void) pn_free(&pn);
(void) pn_free(&rpn);
(void) pn_free(&upn);
return (err);
}
/*
* 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 returns NT status codes.
*
* 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)) {
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);
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:
/*
* Security descriptors for pipes are not implemented,
* so just setup a reasonable access mask.
*/
op->desired_access = (READ_CONTROL | SYNCHRONIZE |
FILE_READ_DATA | FILE_READ_ATTRIBUTES |
FILE_WRITE_DATA | FILE_APPEND_DATA);
/*
* Limit the number of open pipe instances.
*/
if ((rc = smb_threshold_enter(&sv->sv_opipe_ct)) != 0) {
status = RPC_NT_SERVER_TOO_BUSY;
return (status);
}
/*
* No further processing for IPC, we need to either
* raise an exception or return success here.
*/
uniq_fid = SMB_UNIQ_FID();
status = smb_opipe_open(sr, uniq_fid);
smb_threshold_exit(&sv->sv_opipe_ct);
return (status);
default:
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) >= SMB_MAXPATHLEN) {
return (NT_STATUS_OBJECT_PATH_INVALID);
}
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) {
return (NT_STATUS_OBJECT_NAME_NOT_FOUND);
}
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 {
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);
if (rc != 0) {
return (smb_errno2status(rc));
}
}
/*
* 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, zone_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;
/*
* Need the DOS attributes below, where we
* check the search attributes (sattr).
*/
op->fqi.fq_fattr.sa_mask = SMB_AT_DOSATTR;
rc = smb_node_getattr(sr, op->fqi.fq_fnode, zone_kcred(),
NULL, &op->fqi.fq_fattr);
if (rc != 0) {
smb_node_release(op->fqi.fq_fnode);
smb_node_release(op->fqi.fq_dnode);
return (NT_STATUS_INTERNAL_ERROR);
}
} else if (rc == ENOENT) {
last_comp_found = B_FALSE;
op->fqi.fq_fnode = NULL;
rc = 0;
} else {
smb_node_release(op->fqi.fq_dnode);
return (smb_errno2status(rc));
}
/*
* 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);
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);
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);
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);
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);
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);
return (NT_STATUS_ACCESS_DENIED);
}
}
}
if ((op->create_disposition == FILE_SUPERSEDE) ||
(op->create_disposition == FILE_OVERWRITE_IF) ||
(op->create_disposition == FILE_OVERWRITE)) {
if (!smb_sattr_check(op->fqi.fq_fattr.sa_dosattr,
op->dattr)) {
smb_node_release(node);
smb_node_release(dnode);
return (NT_STATUS_ACCESS_DENIED);
}
if (smb_node_is_dir(node)) {
smb_node_release(node);
smb_node_release(dnode);
return (NT_STATUS_ACCESS_DENIED);
}
}
/* MS-FSA 2.1.5.1.2 */
if (op->create_disposition == FILE_SUPERSEDE)
op->desired_access |= DELETE;
if ((op->create_disposition == FILE_OVERWRITE_IF) ||
(op->create_disposition == FILE_OVERWRITE))
op->desired_access |= FILE_WRITE_DATA;
status = smb_fsop_access(sr, sr->user_cr, node,
op->desired_access);
if (status != NT_STATUS_SUCCESS) {
smb_node_release(node);
smb_node_release(dnode);
/* SMB1 specific? NT_STATUS_PRIVILEGE_NOT_HELD */
if (status == NT_STATUS_PRIVILEGE_NOT_HELD) {
return (status);
} else {
return (NT_STATUS_ACCESS_DENIED);
}
}
if (max_requested) {
smb_fsop_eaccess(sr, sr->user_cr, node, &max_allowed);
op->desired_access |= max_allowed;
}
/*
* According to MS "dochelp" mail in Mar 2015, any handle
* on which read or write access is granted implicitly
* gets "read attributes", even if it was not requested.
* This avoids unexpected access failures later that
* would happen if these were not granted.
*/
if ((op->desired_access & FILE_DATA_ALL) != 0) {
op->desired_access |= (READ_CONTROL |
FILE_READ_ATTRIBUTES);
}
/*
* 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. This may block, so set the
* file opening count before oplock stuff.
*/
smb_node_inc_opening_count(node);
smb_open_oplock_break(sr, node);
smb_node_wrlock(node);
/*
* Check for sharing violations
*/
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);
}
/*
* Go ahead with modifications as necessary.
*/
switch (op->create_disposition) {
case FILE_SUPERSEDE:
case FILE_OVERWRITE_IF:
case FILE_OVERWRITE:
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;
}
/*
* Truncate the file data here.
* We set alloc_size = op->dsize later,
* after we have an ofile. See:
* smb_set_open_attributes
*/
bzero(&new_attr, sizeof (new_attr));
new_attr.sa_dosattr = op->dattr;
new_attr.sa_vattr.va_size = 0;
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);
return (smb_errno2status(rc));
}
/*
* If file is being replaced, remove existing streams
*/
if (SMB_IS_STREAM(node) == 0) {
status = smb_fsop_remove_streams(sr,
sr->user_cr, node);
if (status != 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 (status);
}
}
op->action_taken = SMB_OACT_TRUNCATED;
break;
default:
/*
* FILE_OPEN or FILE_OPEN_IF.
*/
/*
* Ignore any user-specified alloc_size for
* existing files, to avoid truncation in
* smb_set_open_attributes
*/
op->dsize = 0L;
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);
return (NT_STATUS_OBJECT_NAME_NOT_FOUND);
}
if (pn->pn_fname && smb_is_invalid_filename(pn->pn_fname)) {
smb_node_release(dnode);
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;
/*
* We set alloc_size = op->dsize later,
* after we have an ofile. See:
* smb_set_open_attributes
*/
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);
return (smb_errno2status(rc));
}
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);
return (smb_errno2status(rc));
}
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;
}
/*
* We created created this object (we own it) so
* grant read/write attributes on this handle,
* even if that was not requested. This avoids
* unexpected access failures later that would
* happen if these were not granted.
*/
op->desired_access |= (READ_CONTROL |
FILE_READ_ATTRIBUTES | FILE_WRITE_ATTRIBUTES);
}
status = NT_STATUS_SUCCESS;
of = smb_ofile_open(sr, node, op, SMB_FTYPE_DISK, uniq_fid,
&err);
if (of == NULL) {
status = err.status;
}
/*
* We might have blocked in smb_ofile_open long enough so a
* tree disconnect might have happened. In that case, we've
* just added an ofile to a tree that's disconnecting, and
* need to undo that to avoid interfering with tear-down of
* the tree connection.
*/
if (status == NT_STATUS_SUCCESS &&
!smb_tree_is_connected(sr->tid_tree)) {
status = NT_STATUS_INVALID_PARAMETER;
}
/*
* This MUST be done after ofile creation, so that explicitly
* set timestamps can be remembered on the ofile, and the
* readonly flag will be stored "pending" on the node.
*/
if (status == NT_STATUS_SUCCESS) {
if ((rc = smb_set_open_attributes(sr, of)) != 0) {
status = smb_errno2status(rc);
}
}
if (status == NT_STATUS_SUCCESS) {
/*
* We've already done access checks above,
* and want this call to succeed even when
* !(desired_access & FILE_READ_ATTRIBUTES),
* so pass kcred here.
*/
op->fqi.fq_fattr.sa_mask = SMB_AT_ALL;
rc = smb_node_getattr(sr, node, zone_kcred(), of,
&op->fqi.fq_fattr);
if (rc != 0) {
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_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_common_create_directory
*
* Currently called from:
* smb_com_create_directory
* smb_com_trans2_create_directory
*
* Returns errno values.
*/
int
smb_common_create_directory(smb_request_t *sr)
{
int rc;
smb_attr_t new_attr;
smb_fqi_t *fqi;
smb_node_t *tnode;
fqi = &sr->arg.dirop.fqi;
tnode = sr->tid_tree->t_snode;
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)
return (rc);
if (smb_is_invalid_filename(fqi->fq_last_comp)) {
smb_node_release(fqi->fq_dnode);
return (EILSEQ); /* NT_STATUS_OBJECT_NAME_INVALID */
}
/* lookup node - to ensure that it does NOT exist */
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) {
smb_node_release(fqi->fq_dnode);
smb_node_release(fqi->fq_fnode);
return (EEXIST);
}
if (rc != ENOENT) {
smb_node_release(fqi->fq_dnode);
return (rc);
}
rc = smb_fsop_access(sr, sr->user_cr, fqi->fq_dnode,
FILE_ADD_SUBDIRECTORY);
if (rc != NT_STATUS_SUCCESS) {
smb_node_release(fqi->fq_dnode);
return (EACCES);
}
/*
* Explicitly set sa_dosattr, otherwise the file system may
* automatically apply FILE_ATTRIBUTE_ARCHIVE which, for
* compatibility with windows servers, should not be set.
*/
bzero(&new_attr, sizeof (new_attr));
new_attr.sa_dosattr = FILE_ATTRIBUTE_DIRECTORY;
new_attr.sa_vattr.va_type = VDIR;
new_attr.sa_vattr.va_mode = 0777;
new_attr.sa_mask = SMB_AT_TYPE | SMB_AT_MODE | SMB_AT_DOSATTR;
rc = smb_fsop_mkdir(sr, sr->user_cr, fqi->fq_dnode, fqi->fq_last_comp,
&new_attr, &fqi->fq_fnode);
if (rc != 0) {
smb_node_release(fqi->fq_dnode);
return (rc);
}
sr->arg.open.create_options = FILE_DIRECTORY_FILE;
smb_node_release(fqi->fq_dnode);
smb_node_release(fqi->fq_fnode);
return (0);
}
/*
* 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_common_rename
*
* Common code for renaming a file.
*
* If the source and destination are identical, we go through all
* the checks but we don't actually do the rename. If the source
* and destination files differ only in case, we do a case-sensitive
* rename. Otherwise, we do a full case-insensitive rename.
*
* Returns NT status values.
*
* Similar to smb_make_link(), below.
*/
uint32_t
smb_common_rename(smb_request_t *sr, smb_fqi_t *src_fqi, smb_fqi_t *dst_fqi)
{
smb_node_t *src_fnode, *src_dnode, *dst_dnode;
smb_node_t *dst_fnode = 0;
smb_node_t *tnode;
char *new_name, *path;
DWORD status;
int rc, count;
tnode = sr->tid_tree->t_snode;
path = dst_fqi->fq_path.pn_path;
/* Check if attempting to rename a stream - not yet supported */
rc = smb_rename_check_stream(src_fqi, dst_fqi);
if (rc != 0)
return (smb_rename_errno2status(rc));
/*
* The source node may already have been provided,
* i.e. when called by SMB1/SMB2 smb_setinfo_rename.
* Not provided by smb_com_rename, smb_com_nt_rename.
*/
if (src_fqi->fq_fnode) {
smb_node_start_crit(src_fqi->fq_fnode, RW_READER);
smb_node_ref(src_fqi->fq_fnode);
smb_node_ref(src_fqi->fq_dnode);
} else {
/* lookup and validate src node */
rc = smb_rename_lookup_src(sr);
if (rc != 0)
return (smb_rename_errno2status(rc));
}
src_fnode = src_fqi->fq_fnode;
src_dnode = src_fqi->fq_dnode;
/*
* Find the destination dnode and last component.
* May already be provided, i.e. when called via
* SMB1 trans2 setinfo.
*/
if (dst_fqi->fq_dnode) {
/* called via smb_set_rename_info */
smb_node_ref(dst_fqi->fq_dnode);
} else {
/* called via smb2_setf_rename, smb_com_rename, etc. */
rc = smb_pathname_reduce(sr, sr->user_cr, path, tnode, tnode,
&dst_fqi->fq_dnode, dst_fqi->fq_last_comp);
if (rc != 0) {
smb_rename_release_src(sr);
return (smb_rename_errno2status(rc));
}
}
dst_dnode = dst_fqi->fq_dnode;
new_name = dst_fqi->fq_last_comp;
/* If exact name match in same directory, we're done */
if ((src_dnode == dst_dnode) &&
(strcmp(src_fnode->od_name, new_name) == 0)) {
smb_rename_release_src(sr);
smb_node_release(dst_dnode);
return (0);
}
/* Lookup destination node */
rc = smb_fsop_lookup(sr, sr->user_cr, 0, tnode,
dst_dnode, new_name, &dst_fqi->fq_fnode);
/* If the destination node doesn't already exist, validate new_name. */
if (rc == ENOENT) {
if (smb_is_invalid_filename(new_name)) {
smb_rename_release_src(sr);
smb_node_release(dst_dnode);
return (NT_STATUS_OBJECT_NAME_INVALID);
}
}
/*
* Handle case where changing case of the same directory entry.
*
* If we found the dst node in the same directory as the src node,
* and their names differ only in case:
*
* If the tree is case sensitive (or mixed):
* Do case sensitive lookup to see if exact match exists.
* If the exact match is the same node as src_node we're done.
*
* If the tree is case insensitive:
* There is currently no way to tell if the case is different
* or not, so do the rename (unless the specified new name was
* mangled).
*/
if ((rc == 0) &&
(src_dnode == dst_dnode) &&
(smb_strcasecmp(src_fnode->od_name,
dst_fqi->fq_fnode->od_name, 0) == 0)) {
smb_node_release(dst_fqi->fq_fnode);
dst_fqi->fq_fnode = NULL;
if (smb_tree_has_feature(sr->tid_tree,
SMB_TREE_NO_CASESENSITIVE)) {
if (smb_strcasecmp(src_fnode->od_name,
dst_fqi->fq_last_comp, 0) != 0) {
smb_rename_release_src(sr);
smb_node_release(dst_dnode);
return (0);
}
} else {
rc = smb_fsop_lookup(sr, sr->user_cr,
SMB_CASE_SENSITIVE, tnode, dst_dnode, new_name,
&dst_fqi->fq_fnode);
if ((rc == 0) &&
(dst_fqi->fq_fnode == src_fnode)) {
smb_rename_release_src(sr);
smb_node_release(dst_fqi->fq_fnode);
smb_node_release(dst_dnode);
return (0);
}
}
}
if ((rc != 0) && (rc != ENOENT)) {
smb_rename_release_src(sr);
smb_node_release(dst_fqi->fq_dnode);
return (smb_rename_errno2status(rc));
}
if (dst_fqi->fq_fnode) {
/*
* Destination already exists. Do delete checks.
*/
dst_fnode = dst_fqi->fq_fnode;
if (!(sr->arg.dirop.flags && SMB_RENAME_FLAG_OVERWRITE)) {
smb_rename_release_src(sr);
smb_node_release(dst_fnode);
smb_node_release(dst_dnode);
return (NT_STATUS_OBJECT_NAME_COLLISION);
}
(void) smb_oplock_break(sr, dst_fnode,
SMB_OPLOCK_BREAK_TO_NONE | SMB_OPLOCK_BREAK_BATCH);
/*
* Wait (a little) for the oplock break to be
* responded to by clients closing handles.
* Hold node->n_lock as reader to keep new
* ofiles from showing up after we check.
*/
smb_node_rdlock(dst_fnode);
for (count = 0; count <= 12; count++) {
status = smb_node_delete_check(dst_fnode);
if (status != NT_STATUS_SHARING_VIOLATION)
break;
smb_node_unlock(dst_fnode);
delay(MSEC_TO_TICK(100));
smb_node_rdlock(dst_fnode);
}
if (status != NT_STATUS_SUCCESS) {
smb_node_unlock(dst_fnode);
smb_rename_release_src(sr);
smb_node_release(dst_fnode);
smb_node_release(dst_dnode);
return (NT_STATUS_ACCESS_DENIED);
}
/*
* Note, the combination of these two:
* smb_node_rdlock(node);
* nbl_start_crit(node->vp, RW_READER);
* is equivalent to this call:
* smb_node_start_crit(node, RW_READER)
*
* Cleanup after this point should use:
* smb_node_end_crit(dst_fnode)
*/
nbl_start_crit(dst_fnode->vp, RW_READER);
/*
* This checks nbl_share_conflict, nbl_lock_conflict
*/
status = smb_nbl_conflict(dst_fnode, 0, UINT64_MAX, NBL_REMOVE);
if (status != NT_STATUS_SUCCESS) {
smb_node_end_crit(dst_fnode);
smb_rename_release_src(sr);
smb_node_release(dst_fnode);
smb_node_release(dst_dnode);
return (NT_STATUS_ACCESS_DENIED);
}
new_name = dst_fnode->od_name;
}
rc = smb_fsop_rename(sr, sr->user_cr,
src_dnode, src_fnode->od_name,
dst_dnode, new_name);
if (rc == 0) {
/*
* Note that renames in the same directory are normally
* delivered in {old,new} pairs, and clients expect them
* in that order, if both events are delivered.
*/
int a_src, a_dst; /* action codes */
if (src_dnode == dst_dnode) {
a_src = FILE_ACTION_RENAMED_OLD_NAME;
a_dst = FILE_ACTION_RENAMED_NEW_NAME;
} else {
a_src = FILE_ACTION_REMOVED;
a_dst = FILE_ACTION_ADDED;
}
smb_node_notify_change(src_dnode, a_src, src_fnode->od_name);
smb_node_notify_change(dst_dnode, a_dst, new_name);
}
smb_rename_release_src(sr);
if (dst_fqi->fq_fnode) {
smb_node_end_crit(dst_fnode);
smb_node_release(dst_fnode);
}
smb_node_release(dst_dnode);
return (smb_rename_errno2status(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);
}
/*
* sr - the request info, used to find root of dataset,
* unicode or ascii, where the share is rooted in the
* dataset
* root_node - root of the share
* cur_node - where in the share for the command
* buf - is the path for the command to be processed
* returned without @GMT if processed
* vss_cur_node - returned value for the snapshot version
* of the cur_node
* vss_root_node - returned value for the snapshot version
* of the root_node
*
* This routine is the processing for handling the
* SMB_FLAGS2_REPARSE_PATH bit being set in the smb header.
*
* By using the cur_node passed in, a new node is found or
* created that is the same place in the directory tree, but
* in the snapshot. We also use root_node to do the same for
* the root.
* Once the new smb node is found, the path is modified by
* removing the @GMT token from the path in the buf.
*/
int
smb_vss_lookup_nodes(smb_request_t *sr, smb_node_t *root_node,
smb_node_t *cur_node, char *buf, smb_node_t **vss_cur_node,
smb_node_t **vss_root_node)
{
smb_arg_open_t *op = &sr->arg.open;
smb_node_t *tnode;
char *snapname, *path;
char *gmttoken;
char gmttok_buf[SMB_VSS_GMT_SIZE];
vnode_t *fsrootvp = NULL;
time_t toktime;
int err = 0;
boolean_t smb1;
if (sr->tid_tree == NULL)
return (ESTALE);
tnode = sr->tid_tree->t_snode;
ASSERT(tnode);
ASSERT(tnode->vp);
ASSERT(tnode->vp->v_vfsp);
smb1 = (sr->session->dialect < 0x200);
if (smb1) {
const char *p;
/* get gmttoken from buf */
if ((p = smb_vss_find_gmttoken(buf)) == NULL)
return (ENOENT);
bcopy(p, gmttok_buf, SMB_VSS_GMT_SIZE);
gmttok_buf[SMB_VSS_GMT_SIZE - 1] = '\0';
gmttoken = gmttok_buf;
toktime = 0;
} else {
/* SMB2 and later */
gmttoken = NULL;
toktime = op->timewarp.tv_sec;
}
path = smb_srm_alloc(sr, MAXPATHLEN);
snapname = smb_srm_alloc(sr, MAXPATHLEN);
err = smb_node_getmntpath(tnode, path, MAXPATHLEN);
if (err != 0)
return (err);
/*
* Find the corresponding snapshot name. If snapname is
* empty after the map call, no such snapshot was found.
*/
*snapname = '\0';
smb_vss_map_gmttoken(sr->tid_tree, path, gmttoken, toktime,
snapname);
if (*snapname == '\0')
return (ENOENT);
/* find snapshot nodes */
err = VFS_ROOT(tnode->vp->v_vfsp, &fsrootvp);
if (err != 0)
return (err);
/* find snapshot node corresponding to root_node */
err = smb_vss_lookup_node(sr, root_node, fsrootvp,
snapname, cur_node, vss_root_node);
if (err == 0) {
/* find snapshot node corresponding to cur_node */
err = smb_vss_lookup_node(sr, cur_node, fsrootvp,
snapname, cur_node, vss_cur_node);
if (err != 0)
smb_node_release(*vss_root_node);
}
VN_RELE(fsrootvp);
if (smb1)
smb_vss_remove_first_token_from_path(buf);
return (err);
}
static smb_tree_t *
smb_tree_connect_disk(smb_request_t *sr, const char *sharename)
{
smb_user_t *user = sr->uid_user;
smb_node_t *dnode = NULL;
smb_node_t *snode = NULL;
char last_component[MAXNAMELEN];
smb_tree_t *tree;
smb_share_t *si;
cred_t *u_cred;
int rc;
uint32_t access = 0; /* read/write is assumed */
uint32_t hostaccess = ACE_ALL_PERMS;
uint32_t aclaccess;
smb_execsub_info_t subs;
ASSERT(user);
u_cred = user->u_cred;
ASSERT(u_cred);
if (user->u_flags & SMB_USER_FLAG_IPC) {
smb_tree_log(sr, sharename, "access denied: IPC only");
smbsr_error(sr, NT_STATUS_ACCESS_DENIED, ERRSRV, ERRaccess);
return (NULL);
}
si = kmem_zalloc(sizeof (smb_share_t), KM_SLEEP);
if (smb_kshare_getinfo(sr->sr_server->sv_lmshrd, (char *)sharename, si,
&sr->session->ipaddr) != NERR_Success) {
smb_tree_log(sr, sharename, "share not found");
smbsr_error(sr, 0, ERRSRV, ERRinvnetname);
kmem_free(si, sizeof (smb_share_t));
return (NULL);
}
if (user->u_flags & SMB_USER_FLAG_GUEST) {
if ((si->shr_flags & SMB_SHRF_GUEST_OK) == 0) {
smb_tree_log(sr, sharename,
"access denied: guest disabled");
smbsr_error(sr, NT_STATUS_ACCESS_DENIED, ERRSRV,
ERRaccess);
kmem_free(si, sizeof (smb_share_t));
return (NULL);
}
}
/*
* Handle the default administration shares: C$, D$ etc.
* Only a user with admin rights is allowed to map these
* shares.
*/
if (si->shr_flags & SMB_SHRF_ADMIN) {
if (!smb_user_is_admin(user)) {
smb_tree_log(sr, sharename, "access denied: not admin");
smbsr_error(sr, NT_STATUS_ACCESS_DENIED,
ERRSRV, ERRaccess);
kmem_free(si, sizeof (smb_share_t));
return (NULL);
}
}
/*
* Set up the OptionalSupport for this share.
*/
sr->arg.tcon.optional_support = SMB_SUPPORT_SEARCH_BITS;
switch (si->shr_flags & SMB_SHRF_CSC_MASK) {
case SMB_SHRF_CSC_DISABLED:
sr->arg.tcon.optional_support |= SMB_CSC_CACHE_NONE;
break;
case SMB_SHRF_CSC_AUTO:
sr->arg.tcon.optional_support |= SMB_CSC_CACHE_AUTO_REINT;
break;
case SMB_SHRF_CSC_VDO:
sr->arg.tcon.optional_support |= SMB_CSC_CACHE_VDO;
break;
case SMB_SHRF_CSC_MANUAL:
default:
/*
* Default to SMB_CSC_CACHE_MANUAL_REINT.
*/
break;
}
/* ABE support */
if (si->shr_flags & SMB_SHRF_ABE)
sr->arg.tcon.optional_support |=
SHI1005_FLAGS_ACCESS_BASED_DIRECTORY_ENUM;
access = si->shr_access_value & SMB_SHRF_ACC_ALL;
if (access == SMB_SHRF_ACC_RO) {
hostaccess &= ~ACE_ALL_WRITE_PERMS;
} else if (access == SMB_SHRF_ACC_NONE) {
kmem_free(si, sizeof (smb_share_t));
smb_tree_log(sr, sharename, "access denied: host access");
smbsr_error(sr, NT_STATUS_ACCESS_DENIED, ERRSRV, ERRaccess);
return (NULL);
}
/*
* Check that the shared directory exists.
*/
rc = smb_pathname_reduce(sr, u_cred, si->shr_path, 0, 0, &dnode,
last_component);
if (rc == 0) {
rc = smb_fsop_lookup(sr, u_cred, SMB_FOLLOW_LINKS,
sr->sr_server->si_root_smb_node, dnode, last_component,
&snode);
smb_node_release(dnode);
}
if (rc) {
if (snode)
smb_node_release(snode);
smb_tree_log(sr, sharename, "bad path: %s", si->shr_path);
smbsr_error(sr, 0, ERRSRV, ERRinvnetname);
kmem_free(si, sizeof (smb_share_t));
return (NULL);
}
/*
* Find share level ACL if it exists in the designated
* location. Needs to be done after finding a valid path but
* before the tree is allocated.
*/
smb_tree_acl_access(u_cred, sharename, snode->vp, &aclaccess);
if ((aclaccess & ACE_ALL_PERMS) == 0) {
smb_tree_log(sr, sharename, "access denied: share ACL");
smbsr_error(sr, 0, ERRSRV, ERRaccess);
kmem_free(si, sizeof (smb_share_t));
smb_node_release(snode);
return (NULL);
}
/*
* Set tree ACL access to the minimum ACL permissions based on
* hostaccess (those allowed by host based access) and
* aclaccess (those from the ACL object for the share). This
* is done during the alloc.
*/
(void) strlcpy(si->shr_name, sharename, MAXNAMELEN);
tree = smb_tree_alloc(user, si, STYPE_DISKTREE, snode,
hostaccess & aclaccess);
smb_node_release(snode);
if (tree == NULL)
smbsr_error(sr, NT_STATUS_ACCESS_DENIED, ERRSRV, ERRaccess);
else {
tree->t_shr_flags = si->shr_flags;
if (tree->t_shr_flags & SMB_SHRF_MAP) {
(void) smb_tree_set_execsub_info(tree, &subs);
rc = smb_kshare_exec(sr->sr_server->sv_lmshrd,
(char *)sharename, &subs, SMB_SHR_MAP);
if (rc != 0 && tree->t_shr_flags & SMB_SHRF_DISP_TERM) {
smb_tree_disconnect(tree, B_FALSE);
smb_tree_release(tree);
smbsr_error(sr, NT_STATUS_ACCESS_DENIED, ERRSRV,
ERRaccess);
kmem_free(si, sizeof (smb_share_t));
return (NULL);
}
}
}
kmem_free(si, sizeof (smb_share_t));
return (tree);
}
int
smb_pathname_reduce(
smb_request_t *sr,
cred_t *cred,
const char *path,
smb_node_t *share_root_node,
smb_node_t *cur_node,
smb_node_t **dir_node,
char *last_component)
{
smb_node_t *root_node;
pathname_t ppn;
char *usepath;
int lookup_flags = FOLLOW;
int trailing_slash = 0;
int err = 0;
int len;
smb_node_t *vss_cur_node;
smb_node_t *vss_root_node;
smb_node_t *local_cur_node;
smb_node_t *local_root_node;
ASSERT(dir_node);
ASSERT(last_component);
*dir_node = NULL;
*last_component = '\0';
vss_cur_node = NULL;
vss_root_node = NULL;
if (sr && sr->tid_tree) {
if (STYPE_ISIPC(sr->tid_tree->t_res_type))
return (EACCES);
}
if (SMB_TREE_IS_CASEINSENSITIVE(sr))
lookup_flags |= FIGNORECASE;
if (path == NULL)
return (EINVAL);
if (*path == '\0')
return (ENOENT);
usepath = kmem_alloc(MAXPATHLEN, KM_SLEEP);
if ((len = strlcpy(usepath, path, MAXPATHLEN)) >= MAXPATHLEN) {
kmem_free(usepath, MAXPATHLEN);
return (ENAMETOOLONG);
}
(void) strsubst(usepath, '\\', '/');
if (share_root_node)
root_node = share_root_node;
else
root_node = sr->sr_server->si_root_smb_node;
if (cur_node == NULL)
cur_node = root_node;
local_cur_node = cur_node;
local_root_node = root_node;
if (SMB_TREE_IS_DFSROOT(sr) && (sr->smb_flg2 & SMB_FLAGS2_DFS)) {
err = smb_pathname_dfs_preprocess(sr, usepath, MAXPATHLEN);
if (err != 0) {
kmem_free(usepath, MAXPATHLEN);
return (err);
}
len = strlen(usepath);
}
if (sr && (sr->smb_flg2 & SMB_FLAGS2_REPARSE_PATH)) {
err = smb_vss_lookup_nodes(sr, root_node, cur_node,
usepath, &vss_cur_node, &vss_root_node);
if (err != 0) {
kmem_free(usepath, MAXPATHLEN);
return (err);
}
len = strlen(usepath);
local_cur_node = vss_cur_node;
local_root_node = vss_root_node;
}
if (usepath[len - 1] == '/')
trailing_slash = 1;
(void) strcanon(usepath, "/");
(void) pn_alloc(&ppn);
if ((err = pn_set(&ppn, usepath)) != 0) {
(void) pn_free(&ppn);
kmem_free(usepath, MAXPATHLEN);
if (vss_cur_node != NULL)
(void) smb_node_release(vss_cur_node);
if (vss_root_node != NULL)
(void) smb_node_release(vss_root_node);
return (err);
}
/*
* If a path does not have a trailing slash, strip off the
* last component. (We only need to return an smb_node for
* the second to last component; a name is returned for the
* last component.)
*/
if (trailing_slash) {
(void) strlcpy(last_component, ".", MAXNAMELEN);
} else {
(void) pn_setlast(&ppn);
(void) strlcpy(last_component, ppn.pn_path, MAXNAMELEN);
ppn.pn_path[0] = '\0';
}
if ((strcmp(ppn.pn_buf, "/") == 0) || (ppn.pn_buf[0] == '\0')) {
smb_node_ref(local_cur_node);
*dir_node = local_cur_node;
} else {
err = smb_pathname(sr, ppn.pn_buf, lookup_flags,
local_root_node, local_cur_node, NULL, dir_node, cred);
}
(void) pn_free(&ppn);
kmem_free(usepath, MAXPATHLEN);
/*
* Prevent traversal to another file system if mount point
* traversal is disabled.
*
* Note that we disregard whether the traversal of the path went
* outside of the file system and then came back (say via a link).
* This means that only symlinks that are expressed relatively to
* the share root work.
*
* share_root_node is NULL when mapping a share, so we disregard
* that case.
*/
if ((err == 0) && share_root_node) {
if (share_root_node->vp->v_vfsp != (*dir_node)->vp->v_vfsp) {
err = EACCES;
if ((sr) && (sr)->tid_tree &&
smb_tree_has_feature((sr)->tid_tree,
SMB_TREE_TRAVERSE_MOUNTS))
err = 0;
}
}
if (err) {
if (*dir_node) {
(void) smb_node_release(*dir_node);
*dir_node = NULL;
}
*last_component = 0;
}
if (vss_cur_node != NULL)
(void) smb_node_release(vss_cur_node);
if (vss_root_node != NULL)
(void) smb_node_release(vss_root_node);
return (err);
}
/*
* 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_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_odir_single_fileinfo
*
* Lookup the file identified by od->d_pattern.
*
* If the looked up file is a link, we attempt to lookup the link target
* to use its attributes in place of those of the files's.
* If we fail to lookup the target of the link we use the original
* file's attributes.
* Check if the attributes match the search attributes.
*
* Returns: 0 - success
* ENOENT - no match
* errno - error
*/
static int
smb_odir_single_fileinfo(smb_request_t *sr, smb_odir_t *od,
smb_fileinfo_t *fileinfo)
{
int rc;
smb_node_t *fnode, *tgt_node;
smb_attr_t attr;
ino64_t fid;
char *name;
boolean_t case_conflict = B_FALSE;
int lookup_flags, flags = 0;
vnode_t *vp;
ASSERT(sr);
ASSERT(sr->sr_magic == SMB_REQ_MAGIC);
ASSERT(od);
ASSERT(od->d_magic == SMB_ODIR_MAGIC);
ASSERT(MUTEX_HELD(&od->d_mutex));
bzero(fileinfo, sizeof (smb_fileinfo_t));
rc = smb_fsop_lookup(sr, od->d_cred, 0, od->d_tree->t_snode,
od->d_dnode, od->d_pattern, &fnode);
if (rc != 0)
return (rc);
/*
* If case sensitive, do a case insensitive smb_vop_lookup to
* check for case conflict
*/
if (od->d_flags & SMB_ODIR_FLAG_IGNORE_CASE) {
lookup_flags = SMB_IGNORE_CASE;
if (od->d_flags & SMB_ODIR_FLAG_CATIA)
lookup_flags |= SMB_CATIA;
rc = smb_vop_lookup(od->d_dnode->vp, fnode->od_name, &vp,
NULL, lookup_flags, &flags, od->d_tree->t_snode->vp,
NULL, od->d_cred);
if (rc != 0)
return (rc);
VN_RELE(vp);
if (flags & ED_CASE_CONFLICT)
case_conflict = B_TRUE;
}
bzero(&attr, sizeof (attr));
attr.sa_mask = SMB_AT_ALL;
rc = smb_node_getattr(sr, fnode, zone_kcred(), NULL, &attr);
if (rc != 0) {
smb_node_release(fnode);
return (rc);
}
/* follow link to get target node & attr */
if (smb_node_is_symlink(fnode) &&
smb_odir_lookup_link(sr, od, fnode->od_name, &tgt_node)) {
smb_node_release(fnode);
fnode = tgt_node;
attr.sa_mask = SMB_AT_ALL;
rc = smb_node_getattr(sr, fnode, zone_kcred(), NULL, &attr);
if (rc != 0) {
smb_node_release(fnode);
return (rc);
}
}
/* check search attributes */
if (!smb_sattr_check(attr.sa_dosattr, od->d_sattr)) {
smb_node_release(fnode);
return (ENOENT);
}
name = fnode->od_name;
if (od->d_flags & SMB_ODIR_FLAG_SHORTNAMES) {
fid = attr.sa_vattr.va_nodeid;
if (case_conflict || smb_needs_mangled(name)) {
smb_mangle(name, fid, fileinfo->fi_shortname,
SMB_SHORTNAMELEN);
}
if (case_conflict)
name = fileinfo->fi_shortname;
}
(void) strlcpy(fileinfo->fi_name, name, sizeof (fileinfo->fi_name));
fileinfo->fi_dosattr = attr.sa_dosattr;
fileinfo->fi_nodeid = attr.sa_vattr.va_nodeid;
fileinfo->fi_size = attr.sa_vattr.va_size;
fileinfo->fi_alloc_size = attr.sa_allocsz;
fileinfo->fi_atime = attr.sa_vattr.va_atime;
fileinfo->fi_mtime = attr.sa_vattr.va_mtime;
fileinfo->fi_ctime = attr.sa_vattr.va_ctime;
if (attr.sa_crtime.tv_sec)
fileinfo->fi_crtime = attr.sa_crtime;
else
fileinfo->fi_crtime = attr.sa_vattr.va_mtime;
smb_node_release(fnode);
return (0);
}
