/* * 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); }
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_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_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); }
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_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); }
/* * 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_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)); }
/* * Allocate a tree. */ static smb_tree_t * smb_tree_alloc( smb_user_t *user, const smb_share_t *si, int32_t stype, smb_node_t *snode, uint32_t access) { smb_tree_t *tree; uint16_t tid; if (smb_idpool_alloc(&user->u_tid_pool, &tid)) return (NULL); tree = kmem_cache_alloc(user->u_server->si_cache_tree, KM_SLEEP); bzero(tree, sizeof (smb_tree_t)); if (STYPE_ISDSK(stype)) { if (smb_tree_getattr(si, snode, tree) != 0) { smb_idpool_free(&user->u_tid_pool, tid); kmem_cache_free(user->u_server->si_cache_tree, tree); return (NULL); } } if (smb_idpool_constructor(&tree->t_fid_pool)) { smb_idpool_free(&user->u_tid_pool, tid); kmem_cache_free(user->u_server->si_cache_tree, tree); return (NULL); } if (smb_idpool_constructor(&tree->t_odid_pool)) { smb_idpool_destructor(&tree->t_fid_pool); smb_idpool_free(&user->u_tid_pool, tid); kmem_cache_free(user->u_server->si_cache_tree, tree); return (NULL); } smb_llist_constructor(&tree->t_ofile_list, sizeof (smb_ofile_t), offsetof(smb_ofile_t, f_lnd)); smb_llist_constructor(&tree->t_odir_list, sizeof (smb_odir_t), offsetof(smb_odir_t, d_lnd)); (void) strlcpy(tree->t_sharename, si->shr_name, sizeof (tree->t_sharename)); (void) strlcpy(tree->t_resource, si->shr_path, sizeof (tree->t_resource)); mutex_init(&tree->t_mutex, NULL, MUTEX_DEFAULT, NULL); tree->t_user = user; tree->t_session = user->u_session; tree->t_server = user->u_server; tree->t_refcnt = 1; tree->t_tid = tid; tree->t_res_type = stype; tree->t_state = SMB_TREE_STATE_CONNECTED; tree->t_magic = SMB_TREE_MAGIC; tree->t_access = access; tree->t_connect_time = gethrestime_sec(); /* if FS is readonly, enforce that here */ if (tree->t_flags & SMB_TREE_READONLY) tree->t_access &= ~ACE_ALL_WRITE_PERMS; if (STYPE_ISDSK(stype)) { smb_node_ref(snode); tree->t_snode = snode; tree->t_acltype = smb_fsop_acltype(snode); } smb_llist_enter(&user->u_tree_list, RW_WRITER); smb_llist_insert_head(&user->u_tree_list, tree); smb_llist_exit(&user->u_tree_list); atomic_inc_32(&user->u_session->s_tree_cnt); atomic_inc_32(&user->u_server->sv_open_trees); return (tree); }
/* * smb_odir_create * Allocate and populate an odir obect and add it to the tree's list. */ static uint16_t smb_odir_create(smb_request_t *sr, smb_node_t *dnode, char *pattern, uint16_t sattr, cred_t *cr) { smb_odir_t *od; smb_tree_t *tree; uint16_t odid; ASSERT(sr); ASSERT(sr->sr_magic == SMB_REQ_MAGIC); ASSERT(sr->tid_tree); ASSERT(sr->tid_tree->t_magic == SMB_TREE_MAGIC); ASSERT(dnode); ASSERT(dnode->n_magic == SMB_NODE_MAGIC); tree = sr->tid_tree; if (smb_idpool_alloc(&tree->t_odid_pool, &odid)) { smbsr_error(sr, NT_STATUS_TOO_MANY_OPENED_FILES, ERRDOS, ERROR_TOO_MANY_OPEN_FILES); return (0); } od = kmem_cache_alloc(smb_cache_odir, KM_SLEEP); bzero(od, sizeof (smb_odir_t)); mutex_init(&od->d_mutex, NULL, MUTEX_DEFAULT, NULL); od->d_refcnt = 0; od->d_state = SMB_ODIR_STATE_OPEN; od->d_magic = SMB_ODIR_MAGIC; od->d_opened_by_pid = sr->smb_pid; od->d_session = tree->t_session; od->d_cred = cr; /* * grab a ref for od->d_user * released in smb_odir_delete() */ smb_user_hold_internal(sr->uid_user); od->d_user = sr->uid_user; od->d_tree = tree; od->d_dnode = dnode; smb_node_ref(dnode); od->d_odid = odid; od->d_sattr = sattr; (void) strlcpy(od->d_pattern, pattern, sizeof (od->d_pattern)); od->d_flags = 0; if (smb_contains_wildcards(od->d_pattern)) od->d_flags |= SMB_ODIR_FLAG_WILDCARDS; if (vfs_has_feature(dnode->vp->v_vfsp, VFSFT_DIRENTFLAGS)) od->d_flags |= SMB_ODIR_FLAG_EDIRENT; if (smb_tree_has_feature(tree, SMB_TREE_CASEINSENSITIVE)) od->d_flags |= SMB_ODIR_FLAG_IGNORE_CASE; if (smb_tree_has_feature(tree, SMB_TREE_SHORTNAMES)) od->d_flags |= SMB_ODIR_FLAG_SHORTNAMES; if (SMB_TREE_SUPPORTS_CATIA(sr)) od->d_flags |= SMB_ODIR_FLAG_CATIA; if (SMB_TREE_SUPPORTS_ABE(sr)) od->d_flags |= SMB_ODIR_FLAG_ABE; if (dnode->flags & NODE_XATTR_DIR) od->d_flags |= SMB_ODIR_FLAG_XATTR; od->d_eof = B_FALSE; smb_llist_enter(&tree->t_odir_list, RW_WRITER); smb_llist_insert_tail(&tree->t_odir_list, od); smb_llist_exit(&tree->t_odir_list); atomic_inc_32(&tree->t_session->s_dir_cnt); return (odid); }