smb_sdrc_t smb_com_open(smb_request_t *sr) { struct open_param *op = &sr->arg.open; smb_node_t *node; smb_attr_t attr; uint16_t file_attr; int rc; op->desired_access = smb_omode_to_amask(op->omode); op->share_access = smb_denymode_to_sharemode(op->omode, op->fqi.fq_path.pn_path); op->crtime.tv_sec = op->crtime.tv_nsec = 0; op->create_disposition = FILE_OPEN; op->create_options = FILE_NON_DIRECTORY_FILE; if (op->omode & SMB_DA_WRITE_THROUGH) op->create_options |= FILE_WRITE_THROUGH; if (sr->smb_flg & SMB_FLAGS_OPLOCK) { if (sr->smb_flg & SMB_FLAGS_OPLOCK_NOTIFY_ANY) op->op_oplock_level = SMB_OPLOCK_BATCH; else op->op_oplock_level = SMB_OPLOCK_EXCLUSIVE; } else { op->op_oplock_level = SMB_OPLOCK_NONE; } if (smb_common_open(sr) != NT_STATUS_SUCCESS) return (SDRC_ERROR); if (op->op_oplock_level == SMB_OPLOCK_NONE) { sr->smb_flg &= ~(SMB_FLAGS_OPLOCK | SMB_FLAGS_OPLOCK_NOTIFY_ANY); } if (smb_open_dsize_check && op->dsize > UINT_MAX) { smbsr_error(sr, 0, ERRDOS, ERRbadaccess); return (SDRC_ERROR); } file_attr = op->dattr & FILE_ATTRIBUTE_MASK; node = sr->fid_ofile->f_node; if (smb_node_getattr(sr, node, &attr) != 0) { smbsr_error(sr, NT_STATUS_INTERNAL_ERROR, ERRDOS, ERROR_INTERNAL_ERROR); return (SDRC_ERROR); } rc = smbsr_encode_result(sr, 7, 0, "bwwllww", 7, sr->smb_fid, file_attr, smb_time_gmt_to_local(sr, attr.sa_vattr.va_mtime.tv_sec), (uint32_t)op->dsize, op->omode, (uint16_t)0); /* bcc */ return ((rc == 0) ? SDRC_SUCCESS : SDRC_ERROR); }
smb_sdrc_t smb_com_write_print_file(smb_request_t *sr) { smb_rw_param_t *param = sr->arg.rw; smb_node_t *node; smb_attr_t attr; int rc; if (sr->sr_server->sv_cfg.skc_print_enable == 0 || !STYPE_ISPRN(sr->tid_tree->t_res_type)) { smbsr_error(sr, NT_STATUS_BAD_DEVICE_TYPE, ERRDOS, ERROR_BAD_DEV_TYPE); return (SDRC_ERROR); } smbsr_lookup_file(sr); if (sr->fid_ofile == NULL) { smbsr_error(sr, NT_STATUS_INVALID_HANDLE, ERRDOS, ERRbadfid); return (SDRC_ERROR); } node = sr->fid_ofile->f_node; sr->user_cr = smb_ofile_getcred(sr->fid_ofile); if (smb_node_getattr(sr, node, &attr) != 0) { smbsr_error(sr, NT_STATUS_INTERNAL_ERROR, ERRDOS, ERROR_INTERNAL_ERROR); return (SDRC_ERROR); } if ((smbsr_decode_data(sr, "D", ¶m->rw_vdb)) != 0) { smbsr_error(sr, NT_STATUS_INVALID_PARAMETER, ERRDOS, ERROR_INVALID_PARAMETER); return (SDRC_ERROR); } param->rw_count = param->rw_vdb.vdb_len; param->rw_offset = attr.sa_vattr.va_size; param->rw_vdb.vdb_uio.uio_loffset = (offset_t)param->rw_offset; if ((rc = smb_common_write(sr, param)) != 0) { if (sr->smb_error.status != NT_STATUS_FILE_LOCK_CONFLICT) smbsr_errno(sr, rc); return (SDRC_ERROR); } rc = smbsr_encode_empty_result(sr); return ((rc == 0) ? SDRC_SUCCESS : SDRC_ERROR); }
static int smb_rename_check_attr(smb_request_t *sr, smb_node_t *node, uint16_t sattr) { smb_attr_t attr; bzero(&attr, sizeof (attr)); attr.sa_mask = SMB_AT_DOSATTR; if (smb_node_getattr(sr, node, zone_kcred(), NULL, &attr) != 0) return (EACCES); if ((attr.sa_dosattr & FILE_ATTRIBUTE_HIDDEN) && !(SMB_SEARCH_HIDDEN(sattr))) return (ESRCH); if ((attr.sa_dosattr & FILE_ATTRIBUTE_SYSTEM) && !(SMB_SEARCH_SYSTEM(sattr))) return (ESRCH); return (0); }
/* * 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_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); }
smb_sdrc_t smb_com_nt_create_andx(struct smb_request *sr) { struct open_param *op = &sr->arg.open; unsigned char DirFlag; smb_attr_t attr; smb_node_t *node; int rc; if ((op->create_options & FILE_DELETE_ON_CLOSE) && !(op->desired_access & DELETE)) { smbsr_error(sr, NT_STATUS_INVALID_PARAMETER, ERRDOS, ERRbadaccess); return (SDRC_ERROR); } if (op->create_disposition > FILE_MAXIMUM_DISPOSITION) { smbsr_error(sr, NT_STATUS_INVALID_PARAMETER, ERRDOS, ERRbadaccess); return (SDRC_ERROR); } if (op->dattr & FILE_FLAG_WRITE_THROUGH) op->create_options |= FILE_WRITE_THROUGH; if (op->dattr & FILE_FLAG_DELETE_ON_CLOSE) op->create_options |= FILE_DELETE_ON_CLOSE; if (op->dattr & FILE_FLAG_BACKUP_SEMANTICS) op->create_options |= FILE_OPEN_FOR_BACKUP_INTENT; if (op->create_options & FILE_OPEN_FOR_BACKUP_INTENT) sr->user_cr = smb_user_getprivcred(sr->uid_user); if (op->rootdirfid == 0) { op->fqi.fq_dnode = sr->tid_tree->t_snode; } else { op->dir = smb_ofile_lookup_by_fid(sr->tid_tree, (uint16_t)op->rootdirfid); if (op->dir == NULL) { smbsr_error(sr, NT_STATUS_INVALID_HANDLE, ERRDOS, ERRbadfid); return (SDRC_ERROR); } op->fqi.fq_dnode = op->dir->f_node; } op->op_oplock_levelII = B_TRUE; if (smb_common_open(sr) != NT_STATUS_SUCCESS) return (SDRC_ERROR); switch (sr->tid_tree->t_res_type & STYPE_MASK) { case STYPE_DISKTREE: case STYPE_PRINTQ: if (op->create_options & FILE_DELETE_ON_CLOSE) smb_ofile_set_delete_on_close(sr->fid_ofile); node = sr->fid_ofile->f_node; DirFlag = smb_node_is_dir(node) ? 1 : 0; if (smb_node_getattr(sr, node, &attr) != 0) { smbsr_error(sr, NT_STATUS_INTERNAL_ERROR, ERRDOS, ERROR_INTERNAL_ERROR); return (SDRC_ERROR); } rc = smbsr_encode_result(sr, 34, 0, "bb.wbwlTTTTlqqwwbw", 34, sr->andx_com, 0x67, op->op_oplock_level, sr->smb_fid, op->action_taken, &attr.sa_crtime, &attr.sa_vattr.va_atime, &attr.sa_vattr.va_mtime, &attr.sa_vattr.va_ctime, op->dattr & FILE_ATTRIBUTE_MASK, attr.sa_allocsz, attr.sa_vattr.va_size, op->ftype, op->devstate, DirFlag, 0); break; case STYPE_IPC: rc = smbsr_encode_result(sr, 34, 0, "bb.wbwlqqqqlqqwwbw", 34, sr->andx_com, 0x67, 0, sr->smb_fid, op->action_taken, 0LL, 0LL, 0LL, 0LL, FILE_ATTRIBUTE_NORMAL, 0x1000LL, 0LL, op->ftype, op->devstate, 0, 0); break; default: smbsr_error(sr, NT_STATUS_INVALID_DEVICE_REQUEST, ERRDOS, ERROR_INVALID_FUNCTION); return (SDRC_ERROR); } return ((rc == 0) ? SDRC_SUCCESS : SDRC_ERROR); }
/* * 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_sdrc_t smb_com_open_andx(smb_request_t *sr) { struct open_param *op = &sr->arg.open; uint16_t file_attr; smb_attr_t attr; int rc; op->desired_access = smb_omode_to_amask(op->omode); op->share_access = smb_denymode_to_sharemode(op->omode, op->fqi.fq_path.pn_path); if (op->create_disposition > FILE_MAXIMUM_DISPOSITION) { smbsr_error(sr, 0, ERRDOS, ERRbadaccess); return (SDRC_ERROR); } op->create_options = FILE_NON_DIRECTORY_FILE; if (op->omode & SMB_DA_WRITE_THROUGH) op->create_options |= FILE_WRITE_THROUGH; if (smb_common_open(sr) != NT_STATUS_SUCCESS) return (SDRC_ERROR); if (smb_open_dsize_check && op->dsize > UINT_MAX) { smbsr_error(sr, 0, ERRDOS, ERRbadaccess); return (SDRC_ERROR); } if (op->op_oplock_level != SMB_OPLOCK_NONE) op->action_taken |= SMB_OACT_LOCK; else op->action_taken &= ~SMB_OACT_LOCK; file_attr = op->dattr & FILE_ATTRIBUTE_MASK; if (STYPE_ISDSK(sr->tid_tree->t_res_type)) { smb_node_t *node = sr->fid_ofile->f_node; if (smb_node_getattr(sr, node, &attr) != 0) { smbsr_error(sr, NT_STATUS_INTERNAL_ERROR, ERRDOS, ERROR_INTERNAL_ERROR); return (SDRC_ERROR); } rc = smbsr_encode_result(sr, 15, 0, "bb.wwwllwwwwl2.w", 15, sr->andx_com, VAR_BCC, sr->smb_fid, file_attr, smb_time_gmt_to_local(sr, attr.sa_vattr.va_mtime.tv_sec), (uint32_t)op->dsize, op->omode, op->ftype, op->devstate, op->action_taken, op->fileid, 0); } else { rc = smbsr_encode_result(sr, 15, 0, "bb.wwwllwwwwl2.w", 15, sr->andx_com, VAR_BCC, sr->smb_fid, file_attr, 0L, 0L, op->omode, op->ftype, op->devstate, op->action_taken, op->fileid, 0); } return ((rc == 0) ? SDRC_SUCCESS : SDRC_ERROR); }
/* * smb_query_fileinfo * * Populate smb_queryinfo_t structure for SMB_FTYPE_DISK * (This should become an smb_ofile / smb_node function.) */ int smb_query_fileinfo(smb_request_t *sr, smb_node_t *node, uint16_t infolev, smb_queryinfo_t *qinfo) { int rc = 0; /* If shortname required but not supported -> OBJECT_NAME_NOT_FOUND */ if ((infolev == SMB_QUERY_FILE_ALT_NAME_INFO) || (infolev == SMB_FILE_ALT_NAME_INFORMATION)) { if (!smb_tree_has_feature(sr->tid_tree, SMB_TREE_SHORTNAMES)) { smbsr_error(sr, NT_STATUS_OBJECT_NAME_NOT_FOUND, ERRDOS, ERROR_FILE_NOT_FOUND); return (-1); } } (void) bzero(qinfo, sizeof (smb_queryinfo_t)); /* See: smb_query_encode_response */ qinfo->qi_attr.sa_mask = SMB_AT_ALL; rc = smb_node_getattr(sr, node, sr->user_cr, sr->fid_ofile, &qinfo->qi_attr); if (rc != 0) { smbsr_error(sr, NT_STATUS_INTERNAL_ERROR, ERRDOS, ERROR_INTERNAL_ERROR); return (-1); } qinfo->qi_node = node; qinfo->qi_delete_on_close = (node->flags & NODE_FLAGS_DELETE_ON_CLOSE) != 0; /* * The number of links reported should be the number of * non-deleted links. Thus if delete_on_close is set, * decrement the link count. */ if (qinfo->qi_delete_on_close && qinfo->qi_attr.sa_vattr.va_nlink > 0) { --(qinfo->qi_attr.sa_vattr.va_nlink); } /* * populate name, namelen and shortname ONLY for the information * levels that require these fields */ switch (infolev) { case SMB_QUERY_FILE_ALL_INFO: case SMB_FILE_ALL_INFORMATION: rc = smb_query_pathname(sr, node, B_TRUE, qinfo); break; case SMB_QUERY_FILE_NAME_INFO: case SMB_FILE_NAME_INFORMATION: rc = smb_query_pathname(sr, node, B_FALSE, qinfo); break; case SMB_QUERY_FILE_ALT_NAME_INFO: case SMB_FILE_ALT_NAME_INFORMATION: smb_query_shortname(node, qinfo); break; default: break; } if (rc != 0) { smbsr_errno(sr, rc); return (-1); } return (0); }
smb_sdrc_t smb_nt_transact_create(smb_request_t *sr, smb_xa_t *xa) { struct open_param *op = &sr->arg.open; uint8_t DirFlag; smb_attr_t attr; smb_ofile_t *of; int rc; if ((op->create_options & FILE_DELETE_ON_CLOSE) && !(op->desired_access & DELETE)) { smbsr_error(sr, NT_STATUS_INVALID_PARAMETER, ERRDOS, ERRbadaccess); return (SDRC_ERROR); } if (op->create_disposition > FILE_MAXIMUM_DISPOSITION) { smbsr_error(sr, NT_STATUS_INVALID_PARAMETER, ERRDOS, ERRbadaccess); return (SDRC_ERROR); } if (op->dattr & FILE_FLAG_WRITE_THROUGH) op->create_options |= FILE_WRITE_THROUGH; if (op->dattr & FILE_FLAG_DELETE_ON_CLOSE) op->create_options |= FILE_DELETE_ON_CLOSE; if (op->dattr & FILE_FLAG_BACKUP_SEMANTICS) op->create_options |= FILE_OPEN_FOR_BACKUP_INTENT; if (op->create_options & FILE_OPEN_FOR_BACKUP_INTENT) sr->user_cr = smb_user_getprivcred(sr->uid_user); if (op->rootdirfid == 0) { op->fqi.fq_dnode = sr->tid_tree->t_snode; } else { op->dir = smb_ofile_lookup_by_fid(sr, (uint16_t)op->rootdirfid); if (op->dir == NULL) { smbsr_error(sr, NT_STATUS_INVALID_HANDLE, ERRDOS, ERRbadfid); return (SDRC_ERROR); } op->fqi.fq_dnode = op->dir->f_node; } op->op_oplock_levelII = B_TRUE; if (smb_common_open(sr) != NT_STATUS_SUCCESS) return (SDRC_ERROR); /* * NB: after the above smb_common_open() success, * we have a handle allocated (sr->fid_ofile). * If we don't return success, we must close it. */ of = sr->fid_ofile; switch (sr->tid_tree->t_res_type & STYPE_MASK) { case STYPE_DISKTREE: case STYPE_PRINTQ: if (op->create_options & FILE_DELETE_ON_CLOSE) smb_ofile_set_delete_on_close(of); DirFlag = smb_node_is_dir(of->f_node) ? 1 : 0; bzero(&attr, sizeof (attr)); attr.sa_mask = SMB_AT_ALL; rc = smb_node_getattr(sr, of->f_node, of->f_cr, of, &attr); if (rc != 0) { smbsr_errno(sr, rc); goto errout; } (void) smb_mbc_encodef(&xa->rep_param_mb, "b.wllTTTTlqqwwb", op->op_oplock_level, sr->smb_fid, op->action_taken, 0, /* EaErrorOffset */ &attr.sa_crtime, &attr.sa_vattr.va_atime, &attr.sa_vattr.va_mtime, &attr.sa_vattr.va_ctime, op->dattr & FILE_ATTRIBUTE_MASK, attr.sa_allocsz, attr.sa_vattr.va_size, op->ftype, op->devstate, DirFlag); break; case STYPE_IPC: bzero(&attr, sizeof (smb_attr_t)); (void) smb_mbc_encodef(&xa->rep_param_mb, "b.wllTTTTlqqwwb", 0, sr->smb_fid, op->action_taken, 0, /* EaErrorOffset */ &attr.sa_crtime, &attr.sa_vattr.va_atime, &attr.sa_vattr.va_mtime, &attr.sa_vattr.va_ctime, op->dattr, 0x1000LL, 0LL, op->ftype, op->devstate, 0); break; default: smbsr_error(sr, NT_STATUS_INVALID_DEVICE_REQUEST, ERRDOS, ERROR_INVALID_FUNCTION); goto errout; } return (SDRC_SUCCESS); errout: smb_ofile_close(of, 0); return (SDRC_ERROR); }
/* * smb_query_fileinfo * * Populate smb_queryinfo_t structure for SMB_FTYPE_DISK * (This should become an smb_ofile / smb_node function.) */ int smb_query_fileinfo(smb_request_t *sr, smb_node_t *node, uint16_t infolev, smb_queryinfo_t *qinfo) { int rc; boolean_t include_sharename = B_FALSE; (void) bzero(qinfo, sizeof (smb_queryinfo_t)); if (smb_node_getattr(sr, node, &qinfo->qi_attr) != 0) { smbsr_error(sr, NT_STATUS_INTERNAL_ERROR, ERRDOS, ERROR_INTERNAL_ERROR); return (-1); } qinfo->qi_node = node; qinfo->qi_delete_on_close = (node->flags & NODE_FLAGS_DELETE_ON_CLOSE) != 0; /* * The number of links reported should be the number of * non-deleted links. Thus if delete_on_close is set, * decrement the link count. */ if (qinfo->qi_delete_on_close && qinfo->qi_attr.sa_vattr.va_nlink > 0) { --(qinfo->qi_attr.sa_vattr.va_nlink); } /* populate name, namelen and shortname */ /* ALL_INFO levels include the sharename in the name field */ if ((infolev == SMB_QUERY_FILE_ALL_INFO) || (infolev == SMB_FILE_ALL_INFORMATION)) { include_sharename = B_TRUE; } rc = smb_query_pathname(sr->tid_tree, node, include_sharename, qinfo->qi_name, MAXPATHLEN); if (rc != 0) { smbsr_errno(sr, rc); return (-1); } qinfo->qi_namelen = smb_ascii_or_unicode_strlen(sr, qinfo->qi_name); /* * For some reason NT will not show the security tab in the root * directory of a mapped drive unless the filename length is * greater than one. So we hack the length here to persuade NT * to show the tab. It should be safe because of the null * terminator character. */ if (qinfo->qi_namelen == 1) qinfo->qi_namelen = 2; /* * If the shortname is generated by smb_mangle_name() * it will be returned as the alternative name. * Otherwise, convert the original name to upper-case * and return it as the alternative name. */ (void) smb_mangle_name(qinfo->qi_attr.sa_vattr.va_nodeid, node->od_name, qinfo->qi_shortname, qinfo->qi_name83, 0); if (*qinfo->qi_shortname == 0) { (void) strlcpy(qinfo->qi_shortname, node->od_name, SMB_SHORTNAMELEN); (void) smb_strupr(qinfo->qi_shortname); } return (0); }
smb_sdrc_t smb_com_delete_directory(smb_request_t *sr) { int rc; uint32_t flags = 0; smb_fqi_t *fqi; smb_node_t *tnode; if (!STYPE_ISDSK(sr->tid_tree->t_res_type)) { smbsr_error(sr, NT_STATUS_ACCESS_DENIED, ERRDOS, ERROR_ACCESS_DENIED); return (SDRC_ERROR); } fqi = &sr->arg.dirop.fqi; tnode = sr->tid_tree->t_snode; smb_pathname_init(sr, &fqi->fq_path, fqi->fq_path.pn_path); if (!smb_pathname_validate(sr, &fqi->fq_path) || !smb_validate_dirname(sr, &fqi->fq_path)) { return (SDRC_ERROR); } rc = smb_pathname_reduce(sr, sr->user_cr, fqi->fq_path.pn_path, tnode, tnode, &fqi->fq_dnode, fqi->fq_last_comp); if (rc != 0) { smbsr_errno(sr, rc); return (SDRC_ERROR); } rc = smb_fsop_lookup(sr, sr->user_cr, SMB_FOLLOW_LINKS, tnode, fqi->fq_dnode, fqi->fq_last_comp, &fqi->fq_fnode); if (rc != 0) { if (rc == ENOENT) smbsr_error(sr, NT_STATUS_OBJECT_NAME_NOT_FOUND, ERRDOS, ERROR_FILE_NOT_FOUND); else smbsr_errno(sr, rc); smb_node_release(fqi->fq_dnode); return (SDRC_ERROR); } /* * Delete should fail if this is the root of a share * or a DFS link */ if ((fqi->fq_fnode == tnode) || smb_node_is_dfslink(fqi->fq_fnode)) { smbsr_error(sr, NT_STATUS_ACCESS_DENIED, ERRDOS, ERROR_ACCESS_DENIED); smb_node_release(fqi->fq_dnode); smb_node_release(fqi->fq_fnode); return (SDRC_ERROR); } if (!smb_node_is_dir(fqi->fq_fnode)) { smbsr_error(sr, NT_STATUS_NOT_A_DIRECTORY, ERRDOS, ERROR_PATH_NOT_FOUND); smb_node_release(fqi->fq_dnode); smb_node_release(fqi->fq_fnode); return (SDRC_ERROR); } /* * Using kcred because we just want the DOS attrs * and don't want access errors for this. */ fqi->fq_fattr.sa_mask = SMB_AT_DOSATTR; rc = smb_node_getattr(sr, fqi->fq_fnode, zone_kcred(), NULL, &fqi->fq_fattr); if (rc != 0) { smbsr_errno(sr, rc); smb_node_release(fqi->fq_dnode); smb_node_release(fqi->fq_fnode); return (SDRC_ERROR); } if ((fqi->fq_fattr.sa_dosattr & FILE_ATTRIBUTE_READONLY) || (smb_fsop_access(sr, sr->user_cr, fqi->fq_fnode, DELETE) != NT_STATUS_SUCCESS)) { smbsr_error(sr, NT_STATUS_CANNOT_DELETE, ERRDOS, ERROR_ACCESS_DENIED); smb_node_release(fqi->fq_dnode); smb_node_release(fqi->fq_fnode); return (SDRC_ERROR); } if (SMB_TREE_SUPPORTS_CATIA(sr)) flags |= SMB_CATIA; rc = smb_fsop_rmdir(sr, sr->user_cr, fqi->fq_dnode, fqi->fq_fnode->od_name, flags); smb_node_release(fqi->fq_fnode); smb_node_release(fqi->fq_dnode); if (rc != 0) { if (rc == EEXIST) smbsr_error(sr, NT_STATUS_DIRECTORY_NOT_EMPTY, ERRDOS, ERROR_DIR_NOT_EMPTY); else smbsr_errno(sr, rc); return (SDRC_ERROR); } rc = smbsr_encode_empty_result(sr); return ((rc == 0) ? SDRC_SUCCESS : SDRC_ERROR); }
/* * smb_odir_read_streaminfo * * Find the next directory entry whose name begins with SMB_STREAM_PREFIX, * and thus represents an NTFS named stream. * No search attribute matching is performed. * No case conflict name mangling is required for NTFS named stream names. * * Returns: * 0 - success. * - If a matching entry was found eof will be B_FALSE and * sinfo will be populated. * - If there are no matching entries eof will be B_TRUE. * -1 - error, error details set in sr. */ int smb_odir_read_streaminfo(smb_request_t *sr, smb_odir_t *od, smb_streaminfo_t *sinfo, boolean_t *eof) { int rc; smb_odirent_t *odirent; smb_node_t *fnode; smb_attr_t attr; ASSERT(sr); ASSERT(sr->sr_magic == SMB_REQ_MAGIC); ASSERT(od); ASSERT(od->d_magic == SMB_ODIR_MAGIC); ASSERT(sinfo); mutex_enter(&od->d_mutex); ASSERT(od->d_refcnt > 0); switch (od->d_state) { case SMB_ODIR_STATE_IN_USE: case SMB_ODIR_STATE_CLOSING: break; case SMB_ODIR_STATE_OPEN: case SMB_ODIR_STATE_CLOSED: default: mutex_exit(&od->d_mutex); return (-1); } /* Check that odir represents an xattr directory */ if (!(od->d_flags & SMB_ODIR_FLAG_XATTR)) { *eof = B_TRUE; mutex_exit(&od->d_mutex); return (0); } odirent = kmem_alloc(sizeof (smb_odirent_t), KM_SLEEP); bzero(&attr, sizeof (attr)); for (;;) { bzero(sinfo, sizeof (smb_streaminfo_t)); if ((rc = smb_odir_next_odirent(od, odirent)) != 0) break; if (strncmp(odirent->od_name, SMB_STREAM_PREFIX, SMB_STREAM_PREFIX_LEN)) { continue; } rc = smb_fsop_lookup(sr, od->d_cred, 0, od->d_tree->t_snode, od->d_dnode, odirent->od_name, &fnode); if (rc == 0) { attr.sa_mask = SMB_AT_SIZE | SMB_AT_ALLOCSZ; rc = smb_node_getattr(sr, fnode, od->d_cred, NULL, &attr); smb_node_release(fnode); } if (rc == 0) { (void) strlcpy(sinfo->si_name, odirent->od_name + SMB_STREAM_PREFIX_LEN, sizeof (sinfo->si_name)); sinfo->si_size = attr.sa_vattr.va_size; sinfo->si_alloc_size = attr.sa_allocsz; break; } } mutex_exit(&od->d_mutex); kmem_free(odirent, sizeof (smb_odirent_t)); switch (rc) { case 0: *eof = B_FALSE; return (0); case ENOENT: *eof = B_TRUE; return (0); default: smbsr_errno(sr, rc); return (-1); } }
/* * smb_odir_wildcard_fileinfo * * odirent contains a directory entry, obtained from a vop_readdir. * If a case conflict is identified the filename is mangled and the * shortname is used as 'name', in place of odirent->od_name. * * If the looked up file is a link, we attempt to lookup the link target * to use its attributes in place of those of the files's. * If we fail to lookup the target of the link we use the original * file's attributes. * Check if the attributes match the search attributes. * * Although some file systems can have directories larger than * SMB_MAXDIRSIZE smb_odir_next_odirent ensures that no offset larger * than SMB_MAXDIRSIZE is returned. It is therefore safe to use the * offset as the cookie (uint32_t). * * Returns: 0 - success * ENOENT - no match, proceed to next entry * errno - error */ static int smb_odir_wildcard_fileinfo(smb_request_t *sr, smb_odir_t *od, smb_odirent_t *odirent, smb_fileinfo_t *fileinfo) { int rc; cred_t *cr; smb_node_t *fnode, *tgt_node; smb_attr_t attr; char *name; boolean_t case_conflict; ASSERT(sr); ASSERT(sr->sr_magic == SMB_REQ_MAGIC); ASSERT(od); ASSERT(od->d_magic == SMB_ODIR_MAGIC); ASSERT(MUTEX_HELD(&od->d_mutex)); bzero(fileinfo, sizeof (smb_fileinfo_t)); rc = smb_fsop_lookup(sr, od->d_cred, SMB_CASE_SENSITIVE, od->d_tree->t_snode, od->d_dnode, odirent->od_name, &fnode); if (rc != 0) return (rc); /* follow link to get target node & attr */ if (smb_node_is_symlink(fnode) && smb_odir_lookup_link(sr, od, odirent->od_name, &tgt_node)) { smb_node_release(fnode); fnode = tgt_node; } /* skip system files */ if (smb_node_is_system(fnode)) { smb_node_release(fnode); return (ENOENT); } /* * Windows directory listings return not only names, but * also some attributes. In Unix, you need some access to * get those attributes. Which credential should we use to * get those? If we're doing Access Based Enumeration (ABE) * we want this getattr to fail, which will cause the caller * to skip this entry. If we're NOT doing ABE, we normally * want to show all the directory entries (including their * attributes) so we want this getattr to succeed! */ if (smb_tree_has_feature(od->d_tree, SMB_TREE_ABE)) cr = od->d_cred; else cr = zone_kcred(); bzero(&attr, sizeof (attr)); attr.sa_mask = SMB_AT_ALL; rc = smb_node_getattr(NULL, fnode, cr, NULL, &attr); if (rc != 0) { smb_node_release(fnode); return (rc); } /* check search attributes */ if (!smb_sattr_check(attr.sa_dosattr, od->d_sattr)) { smb_node_release(fnode); return (ENOENT); } name = odirent->od_name; if (od->d_flags & SMB_ODIR_FLAG_SHORTNAMES) { case_conflict = ((od->d_flags & SMB_ODIR_FLAG_IGNORE_CASE) && (odirent->od_eflags & ED_CASE_CONFLICT)); if (case_conflict || smb_needs_mangled(name)) { smb_mangle(name, odirent->od_ino, fileinfo->fi_shortname, SMB_SHORTNAMELEN); } if (case_conflict) name = fileinfo->fi_shortname; } (void) strlcpy(fileinfo->fi_name, name, sizeof (fileinfo->fi_name)); fileinfo->fi_cookie = (uint32_t)od->d_offset; fileinfo->fi_dosattr = attr.sa_dosattr; fileinfo->fi_nodeid = attr.sa_vattr.va_nodeid; fileinfo->fi_size = attr.sa_vattr.va_size; fileinfo->fi_alloc_size = attr.sa_allocsz; fileinfo->fi_atime = attr.sa_vattr.va_atime; fileinfo->fi_mtime = attr.sa_vattr.va_mtime; fileinfo->fi_ctime = attr.sa_vattr.va_ctime; if (attr.sa_crtime.tv_sec) fileinfo->fi_crtime = attr.sa_crtime; else fileinfo->fi_crtime = attr.sa_vattr.va_mtime; smb_node_release(fnode); return (0); }
/* * smb_odir_single_fileinfo * * Lookup the file identified by od->d_pattern. * * If the looked up file is a link, we attempt to lookup the link target * to use its attributes in place of those of the files's. * If we fail to lookup the target of the link we use the original * file's attributes. * Check if the attributes match the search attributes. * * Returns: 0 - success * ENOENT - no match * errno - error */ static int smb_odir_single_fileinfo(smb_request_t *sr, smb_odir_t *od, smb_fileinfo_t *fileinfo) { int rc; smb_node_t *fnode, *tgt_node; smb_attr_t attr; ino64_t fid; char *name; boolean_t case_conflict = B_FALSE; int lookup_flags, flags = 0; vnode_t *vp; ASSERT(sr); ASSERT(sr->sr_magic == SMB_REQ_MAGIC); ASSERT(od); ASSERT(od->d_magic == SMB_ODIR_MAGIC); ASSERT(MUTEX_HELD(&od->d_mutex)); bzero(fileinfo, sizeof (smb_fileinfo_t)); rc = smb_fsop_lookup(sr, od->d_cred, 0, od->d_tree->t_snode, od->d_dnode, od->d_pattern, &fnode); if (rc != 0) return (rc); /* * If case sensitive, do a case insensitive smb_vop_lookup to * check for case conflict */ if (od->d_flags & SMB_ODIR_FLAG_IGNORE_CASE) { lookup_flags = SMB_IGNORE_CASE; if (od->d_flags & SMB_ODIR_FLAG_CATIA) lookup_flags |= SMB_CATIA; rc = smb_vop_lookup(od->d_dnode->vp, fnode->od_name, &vp, NULL, lookup_flags, &flags, od->d_tree->t_snode->vp, NULL, od->d_cred); if (rc != 0) return (rc); VN_RELE(vp); if (flags & ED_CASE_CONFLICT) case_conflict = B_TRUE; } bzero(&attr, sizeof (attr)); attr.sa_mask = SMB_AT_ALL; rc = smb_node_getattr(sr, fnode, zone_kcred(), NULL, &attr); if (rc != 0) { smb_node_release(fnode); return (rc); } /* follow link to get target node & attr */ if (smb_node_is_symlink(fnode) && smb_odir_lookup_link(sr, od, fnode->od_name, &tgt_node)) { smb_node_release(fnode); fnode = tgt_node; attr.sa_mask = SMB_AT_ALL; rc = smb_node_getattr(sr, fnode, zone_kcred(), NULL, &attr); if (rc != 0) { smb_node_release(fnode); return (rc); } } /* check search attributes */ if (!smb_sattr_check(attr.sa_dosattr, od->d_sattr)) { smb_node_release(fnode); return (ENOENT); } name = fnode->od_name; if (od->d_flags & SMB_ODIR_FLAG_SHORTNAMES) { fid = attr.sa_vattr.va_nodeid; if (case_conflict || smb_needs_mangled(name)) { smb_mangle(name, fid, fileinfo->fi_shortname, SMB_SHORTNAMELEN); } if (case_conflict) name = fileinfo->fi_shortname; } (void) strlcpy(fileinfo->fi_name, name, sizeof (fileinfo->fi_name)); fileinfo->fi_dosattr = attr.sa_dosattr; fileinfo->fi_nodeid = attr.sa_vattr.va_nodeid; fileinfo->fi_size = attr.sa_vattr.va_size; fileinfo->fi_alloc_size = attr.sa_allocsz; fileinfo->fi_atime = attr.sa_vattr.va_atime; fileinfo->fi_mtime = attr.sa_vattr.va_mtime; fileinfo->fi_ctime = attr.sa_vattr.va_ctime; if (attr.sa_crtime.tv_sec) fileinfo->fi_crtime = attr.sa_crtime; else fileinfo->fi_crtime = attr.sa_vattr.va_mtime; smb_node_release(fnode); return (0); }