/*
* 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_ofile_close
*/
void
smb_ofile_close(smb_ofile_t *of, int32_t mtime_sec)
{
timestruc_t now;
uint32_t flags = 0;
SMB_OFILE_VALID(of);
mutex_enter(&of->f_mutex);
ASSERT(of->f_refcnt);
switch (of->f_state) {
case SMB_OFILE_STATE_OPEN: {
of->f_state = SMB_OFILE_STATE_CLOSING;
mutex_exit(&of->f_mutex);
if (of->f_ftype == SMB_FTYPE_MESG_PIPE) {
smb_opipe_close(of);
smb_server_dec_pipes(of->f_server);
} else {
smb_attr_t *pa = &of->f_pending_attr;
/*
* In here we make changes to of->f_pending_attr
* while not holding of->f_mutex. This is OK
* because we've changed f_state to CLOSING,
* so no more threads will take this path.
*/
if (mtime_sec != 0) {
pa->sa_vattr.va_mtime.tv_sec = mtime_sec;
pa->sa_mask |= SMB_AT_MTIME;
}
/*
* If we have ever modified data via this handle
* (write or truncate) and if the mtime was not
* set via this handle, update the mtime again
* during the close. Windows expects this.
* [ MS-FSA 2.1.5.4 "Update Timestamps" ]
*/
if (of->f_written &&
(pa->sa_mask & SMB_AT_MTIME) == 0) {
pa->sa_mask |= SMB_AT_MTIME;
gethrestime(&now);
pa->sa_vattr.va_mtime = now;
}
if (of->f_flags & SMB_OFLAGS_SET_DELETE_ON_CLOSE) {
if (smb_tree_has_feature(of->f_tree,
SMB_TREE_CATIA)) {
flags |= SMB_CATIA;
}
(void) smb_node_set_delete_on_close(of->f_node,
of->f_cr, flags);
}
smb_fsop_unshrlock(of->f_cr, of->f_node, of->f_uniqid);
smb_node_destroy_lock_by_ofile(of->f_node, of);
if (smb_node_is_file(of->f_node)) {
(void) smb_fsop_close(of->f_node, of->f_mode,
of->f_cr);
smb_oplock_release(of->f_node, of);
}
if (smb_node_dec_open_ofiles(of->f_node) == 0) {
/*
* Last close. The f_pending_attr has
* only times (atime,ctime,mtime) so
* we can borrow it to commit the
* n_pending_dosattr from the node.
*/
pa->sa_dosattr =
of->f_node->n_pending_dosattr;
if (pa->sa_dosattr != 0)
pa->sa_mask |= SMB_AT_DOSATTR;
/* Let's leave this zero when not in use. */
of->f_node->n_allocsz = 0;
}
if (pa->sa_mask != 0) {
/*
* Commit any pending attributes from
* the ofile we're closing. Note that
* we pass NULL as the ofile to setattr
* so it will write to the file system
* and not keep anything on the ofile.
* This clears n_pending_dosattr if
* there are no opens, otherwise the
* dosattr will be pending again.
*/
(void) smb_node_setattr(NULL, of->f_node,
of->f_cr, NULL, pa);
}
/*
* Cancel any notify change requests that
* may be using this open instance.
*/
if (of->f_node->n_fcn.fcn_count)
smb_notify_file_closed(of);
smb_server_dec_files(of->f_server);
}
atomic_dec_32(&of->f_tree->t_open_files);
mutex_enter(&of->f_mutex);
ASSERT(of->f_refcnt);
ASSERT(of->f_state == SMB_OFILE_STATE_CLOSING);
of->f_state = SMB_OFILE_STATE_CLOSED;
break;
}
case SMB_OFILE_STATE_CLOSED:
case SMB_OFILE_STATE_CLOSING:
break;
default:
ASSERT(0);
break;
}
mutex_exit(&of->f_mutex);
}
/*
* 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_ofile_open
*/
smb_ofile_t *
smb_ofile_open(
smb_tree_t *tree,
smb_node_t *node,
uint16_t pid,
struct open_param *op,
uint16_t ftype,
uint32_t uniqid,
smb_error_t *err)
{
smb_ofile_t *of;
uint16_t fid;
smb_attr_t attr;
int rc;
if (smb_idpool_alloc(&tree->t_fid_pool, &fid)) {
err->status = NT_STATUS_TOO_MANY_OPENED_FILES;
err->errcls = ERRDOS;
err->errcode = ERROR_TOO_MANY_OPEN_FILES;
return (NULL);
}
of = kmem_cache_alloc(tree->t_server->si_cache_ofile, KM_SLEEP);
bzero(of, sizeof (smb_ofile_t));
of->f_magic = SMB_OFILE_MAGIC;
of->f_refcnt = 1;
of->f_fid = fid;
of->f_uniqid = uniqid;
of->f_opened_by_pid = pid;
of->f_granted_access = op->desired_access;
of->f_share_access = op->share_access;
of->f_create_options = op->create_options;
of->f_cr = (op->create_options & FILE_OPEN_FOR_BACKUP_INTENT) ?
smb_user_getprivcred(tree->t_user) : tree->t_user->u_cred;
crhold(of->f_cr);
of->f_ftype = ftype;
of->f_server = tree->t_server;
of->f_session = tree->t_user->u_session;
of->f_user = tree->t_user;
of->f_tree = tree;
of->f_node = node;
mutex_init(&of->f_mutex, NULL, MUTEX_DEFAULT, NULL);
of->f_state = SMB_OFILE_STATE_OPEN;
if (ftype == SMB_FTYPE_MESG_PIPE) {
of->f_pipe = smb_opipe_alloc(tree->t_server);
smb_server_inc_pipes(of->f_server);
} else {
ASSERT(ftype == SMB_FTYPE_DISK); /* Regular file, not a pipe */
ASSERT(node);
if (of->f_granted_access == FILE_EXECUTE)
of->f_flags |= SMB_OFLAGS_EXECONLY;
bzero(&attr, sizeof (smb_attr_t));
attr.sa_mask = SMB_AT_UID | SMB_AT_DOSATTR;
rc = smb_node_getattr(NULL, node, of->f_cr, NULL, &attr);
if (rc != 0) {
of->f_magic = 0;
mutex_destroy(&of->f_mutex);
crfree(of->f_cr);
smb_idpool_free(&tree->t_fid_pool, of->f_fid);
kmem_cache_free(tree->t_server->si_cache_ofile, of);
err->status = NT_STATUS_INTERNAL_ERROR;
err->errcls = ERRDOS;
err->errcode = ERROR_INTERNAL_ERROR;
return (NULL);
}
if (crgetuid(of->f_cr) == attr.sa_vattr.va_uid) {
/*
* Add this bit for the file's owner even if it's not
* specified in the request (Windows behavior).
*/
of->f_granted_access |= FILE_READ_ATTRIBUTES;
}
if (smb_node_is_file(node)) {
of->f_mode =
smb_fsop_amask_to_omode(of->f_granted_access);
if (smb_fsop_open(node, of->f_mode, of->f_cr) != 0) {
of->f_magic = 0;
mutex_destroy(&of->f_mutex);
crfree(of->f_cr);
smb_idpool_free(&tree->t_fid_pool, of->f_fid);
kmem_cache_free(tree->t_server->si_cache_ofile,
of);
err->status = NT_STATUS_ACCESS_DENIED;
err->errcls = ERRDOS;
err->errcode = ERROR_ACCESS_DENIED;
return (NULL);
}
}
if (tree->t_flags & SMB_TREE_READONLY)
of->f_flags |= SMB_OFLAGS_READONLY;
/*
* Note that if we created_readonly, that
* will _not_ yet show in attr.sa_dosattr
* so creating a readonly file gives the
* caller a writable handle as it should.
*/
if (attr.sa_dosattr & FILE_ATTRIBUTE_READONLY)
of->f_flags |= SMB_OFLAGS_READONLY;
smb_node_inc_open_ofiles(node);
smb_node_add_ofile(node, of);
smb_node_ref(node);
smb_server_inc_files(of->f_server);
}
smb_llist_enter(&tree->t_ofile_list, RW_WRITER);
smb_llist_insert_tail(&tree->t_ofile_list, of);
smb_llist_exit(&tree->t_ofile_list);
atomic_inc_32(&tree->t_open_files);
atomic_inc_32(&of->f_session->s_file_cnt);
return (of);
}
/*
* smb_ofile_open
*/
smb_ofile_t *
smb_ofile_open(
smb_request_t *sr,
smb_node_t *node,
struct open_param *op,
uint16_t ftype,
uint32_t uniqid,
smb_error_t *err)
{
smb_tree_t *tree = sr->tid_tree;
smb_ofile_t *of;
uint16_t fid;
smb_attr_t attr;
int rc;
enum errstates { EMPTY, FIDALLOC, CRHELD, MUTEXINIT };
enum errstates state = EMPTY;
if (smb_idpool_alloc(&tree->t_fid_pool, &fid)) {
err->status = NT_STATUS_TOO_MANY_OPENED_FILES;
err->errcls = ERRDOS;
err->errcode = ERROR_TOO_MANY_OPEN_FILES;
return (NULL);
}
state = FIDALLOC;
of = kmem_cache_alloc(smb_cache_ofile, KM_SLEEP);
bzero(of, sizeof (smb_ofile_t));
of->f_magic = SMB_OFILE_MAGIC;
of->f_refcnt = 1;
of->f_fid = fid;
of->f_uniqid = uniqid;
of->f_opened_by_pid = sr->smb_pid;
of->f_granted_access = op->desired_access;
of->f_share_access = op->share_access;
of->f_create_options = op->create_options;
of->f_cr = (op->create_options & FILE_OPEN_FOR_BACKUP_INTENT) ?
smb_user_getprivcred(sr->uid_user) : sr->uid_user->u_cred;
crhold(of->f_cr);
state = CRHELD;
of->f_ftype = ftype;
of->f_server = tree->t_server;
of->f_session = tree->t_session;
/*
* grab a ref for of->f_user
* released in smb_ofile_delete()
*/
smb_user_hold_internal(sr->uid_user);
of->f_user = sr->uid_user;
of->f_tree = tree;
of->f_node = node;
mutex_init(&of->f_mutex, NULL, MUTEX_DEFAULT, NULL);
state = MUTEXINIT;
of->f_state = SMB_OFILE_STATE_OPEN;
if (ftype == SMB_FTYPE_MESG_PIPE) {
/* See smb_opipe_open. */
of->f_pipe = op->pipe;
smb_server_inc_pipes(of->f_server);
} else {
ASSERT(ftype == SMB_FTYPE_DISK); /* Regular file, not a pipe */
ASSERT(node);
/*
* Note that the common open path often adds bits like
* READ_CONTROL, so the logic "is this open exec-only"
* needs to look at only the FILE_DATA_ALL bits.
*/
if ((of->f_granted_access & FILE_DATA_ALL) == FILE_EXECUTE)
of->f_flags |= SMB_OFLAGS_EXECONLY;
bzero(&attr, sizeof (smb_attr_t));
attr.sa_mask = SMB_AT_UID | SMB_AT_DOSATTR;
rc = smb_node_getattr(NULL, node, of->f_cr, NULL, &attr);
if (rc != 0) {
err->status = NT_STATUS_INTERNAL_ERROR;
err->errcls = ERRDOS;
err->errcode = ERROR_INTERNAL_ERROR;
goto errout;
}
if (crgetuid(of->f_cr) == attr.sa_vattr.va_uid) {
/*
* Add this bit for the file's owner even if it's not
* specified in the request (Windows behavior).
*/
of->f_granted_access |= FILE_READ_ATTRIBUTES;
}
if (smb_node_is_file(node)) {
of->f_mode =
smb_fsop_amask_to_omode(of->f_granted_access);
if (smb_fsop_open(node, of->f_mode, of->f_cr) != 0) {
err->status = NT_STATUS_ACCESS_DENIED;
err->errcls = ERRDOS;
err->errcode = ERROR_ACCESS_DENIED;
goto errout;
}
}
if (tree->t_flags & SMB_TREE_READONLY)
of->f_flags |= SMB_OFLAGS_READONLY;
/*
* Note that if we created_readonly, that
* will _not_ yet show in attr.sa_dosattr
* so creating a readonly file gives the
* caller a writable handle as it should.
*/
if (attr.sa_dosattr & FILE_ATTRIBUTE_READONLY)
of->f_flags |= SMB_OFLAGS_READONLY;
smb_node_inc_open_ofiles(node);
smb_node_add_ofile(node, of);
smb_node_ref(node);
smb_server_inc_files(of->f_server);
}
smb_llist_enter(&tree->t_ofile_list, RW_WRITER);
smb_llist_insert_tail(&tree->t_ofile_list, of);
smb_llist_exit(&tree->t_ofile_list);
atomic_inc_32(&tree->t_open_files);
atomic_inc_32(&of->f_session->s_file_cnt);
return (of);
errout:
switch (state) {
case MUTEXINIT:
mutex_destroy(&of->f_mutex);
smb_user_release(of->f_user);
/*FALLTHROUGH*/
case CRHELD:
crfree(of->f_cr);
of->f_magic = 0;
kmem_cache_free(smb_cache_ofile, of);
/*FALLTHROUGH*/
case FIDALLOC:
smb_idpool_free(&tree->t_fid_pool, fid);
/*FALLTHROUGH*/
case EMPTY:
break;
}
return (NULL);
}