static int smb_delete_check_path(smb_request_t *, boolean_t *);

static int smb_delete_single_file(smb_request_t *, smb_error_t *);

static int smb_delete_multiple_files(smb_request_t *, smb_error_t *);

static int smb_delete_find_fname(smb_request_t *, uint32_t *);

static int smb_delete_check_attr(smb_request_t *, smb_error_t *);

static int smb_delete_remove_file(smb_request_t *, smb_error_t *);

static void smb_delete_error(smb_error_t *, uint32_t, uint16_t, uint16_t);

	smb_fqi_t *fqi;

	fqi = &sr->arg.dirop.fqi;

	DTRACE_SMB_2(op__Delete__start, smb_request_t *, sr, smb_fqi_t *, fqi);

 * 1. pre-process pathname -  smb_delete_check_path()

 *    checks dot, bad path syntax, wildcards in path

 * 2. process the path to get directory node & last_comp,

 *    store these in fqi

 *    - If smb_pathname_reduce cannot find the specified path,

 *      the error (ENOTDIR) is translated to NT_STATUS_OBJECT_PATH_NOT_FOUND

 *      if the target is a single file (no wildcards).  If there are

 *      wildcards in the last_comp, NT_STATUS_OBJECT_NAME_NOT_FOUND is

 *      used instead.

 *    - If the directory node is the mount point and the last component

 *      is ".." NT_STATUS_OBJECT_PATH_SYNTAX_BAD is returned.

 * 3. check access permissions

 * 4. invoke the appropriate deletion routine to find and remove

 *    the specified file(s).

 *    - if target is a single file (no wildcards) - smb_delete_single_file

 *    - if the target contains wildcards - smb_delete_multiple_files

 *

 * Returns: SDRC_SUCCESS or SDRC_ERROR

	smb_error_t err;

	uint32_t status;

	smb_fqi_t *fqi;

	fqi = &sr->arg.dirop.fqi;

	if (smb_delete_check_path(sr, &wildcards) != 0)

	rc = smb_pathname_reduce(sr, sr->user_cr, fqi->path,

	    sr->tid_tree->t_snode, sr->tid_tree->t_snode,

	    &fqi->dir_snode, fqi->last_comp);

	if (rc == 0) {

		if (fqi->dir_snode->vp->v_type != VDIR) {

			smb_node_release(fqi->dir_snode);

			rc = ENOTDIR;

		}

	}

	if (rc != 0) {

		if (rc == ENOTDIR) {

			if (wildcards)

				status = NT_STATUS_OBJECT_NAME_NOT_FOUND;

			else

				status = NT_STATUS_OBJECT_PATH_NOT_FOUND;

			smbsr_error(sr, status, ERRDOS, ERROR_FILE_NOT_FOUND);

		} else {

			smbsr_errno(sr, rc);

	if ((fqi->dir_snode == sr->tid_tree->t_snode) &&

	    (strcmp(fqi->last_comp, "..") == 0)) {

		smb_node_release(fqi->dir_snode);

		smbsr_error(sr, NT_STATUS_OBJECT_PATH_SYNTAX_BAD,

		    ERRDOS, ERROR_BAD_PATHNAME);

		return (SDRC_ERROR);

	}

	rc = smb_fsop_access(sr, sr->user_cr, fqi->dir_snode,

	    FILE_LIST_DIRECTORY);

	if (rc != 0) {

		smb_node_release(fqi->dir_snode);

		smbsr_error(sr, NT_STATUS_ACCESS_DENIED,

		    ERRDOS, ERROR_ACCESS_DENIED);

		return (SDRC_ERROR);

	}

	if (wildcards)

		rc = smb_delete_multiple_files(sr, &err);

	else

		rc = smb_delete_single_file(sr, &err);

	if (rc != 0)

		smbsr_set_error(sr, &err);

	else

		rc = smbsr_encode_empty_result(sr);

	return (rc == 0 ? SDRC_SUCCESS : SDRC_ERROR);

}

/*

 * smb_delete_single_file

 *

 * Find the specified file and, if its attributes match the search

 * criteria, delete it.

 *

 * Returns 0 - success (file deleted)

 *        -1 - error, err is populated with error details

 */

static int

smb_delete_single_file(smb_request_t *sr, smb_error_t *err)

{

	smb_fqi_t *fqi;

	smb_attr_t ret_attr;

	fqi = &sr->arg.dirop.fqi;

	if (smb_fsop_lookup_name(sr, sr->user_cr, 0, sr->tid_tree->t_snode,

	    fqi->dir_snode, fqi->last_comp, &fqi->last_snode, &ret_attr) != 0) {

		smb_delete_error(err, NT_STATUS_OBJECT_NAME_NOT_FOUND,

		    ERRDOS, ERROR_FILE_NOT_FOUND);

		return (-1);

	}

	if (smb_delete_check_attr(sr, err) != 0) {

		smb_node_release(fqi->last_snode);

		return (-1);

	}

	if (smb_delete_remove_file(sr, err) != 0) {

		smb_node_release(fqi->last_snode);

		return (-1);

	}

	smb_node_release(fqi->last_snode);

	return (0);

}

/*

 * smb_delete_multiple_files

 *

 * For each matching file found by smb_delete_find_name:

 * 1. lookup file

 * 2. check the file's attributes

 *    - The search ends with an error if a readonly file

 *      (NT_STATUS_CANNOT_DELETE) is matched.

 *    - The search ends (but not an error) if a directory is

 *      matched and the request's search did not include

 *      directories.

 *    - Otherwise, if smb_delete_check_attr fails the file

 *      is skipped and the search continues (at step 1)

 * 3. delete the file

 *

 * Returns 0 - success

 *        -1 - error, err is populated with error details

 */

static int

smb_delete_multiple_files(smb_request_t *sr, smb_error_t *err)

{

	int rc, deleted = 0;

	uint32_t cookie = 0;

	smb_fqi_t *fqi;

	smb_attr_t ret_attr;

	fqi = &sr->arg.dirop.fqi;

	for (;;) {

		rc = smb_delete_find_fname(sr, &cookie);

		if (rc != 0)

			break;

		rc = smb_fsop_lookup_name(sr, sr->user_cr, 0,

		    sr->tid_tree->t_snode, fqi->dir_snode,

		    fqi->last_comp_od, &fqi->last_snode, &ret_attr);

		if (rc != 0)

			break;

		if (smb_delete_check_attr(sr, err) != 0) {

			smb_node_release(fqi->last_snode);

			if (err->status == NT_STATUS_CANNOT_DELETE) {

				return (-1);

			if ((err->status == NT_STATUS_FILE_IS_A_DIRECTORY) &&

			    (SMB_SEARCH_DIRECTORY(fqi->srch_attr) != 0))

				break;

			continue;

		if (smb_delete_remove_file(sr, err) == 0) {

			++deleted;

			smb_node_release(fqi->last_snode);

			continue;

		}

		if (err->status == NT_STATUS_OBJECT_NAME_NOT_FOUND) {

			smb_node_release(fqi->last_snode);

			continue;

		smb_node_release(fqi->last_snode);

		return (-1);

		smbsr_map_errno(rc, err);

		return (-1);

		smb_delete_error(err, NT_STATUS_NO_SUCH_FILE,

		    ERRDOS, ERROR_FILE_NOT_FOUND);

		return (-1);

	}

	return (0);

}

/*

 * smb_delete_find_fname

 *

 * Find next filename that matches search pattern (fqi->last_comp)

 * and save it in fqi->last_comp_od.

 *

 * Returns: 0 - success

 *          errno

 */

static int

smb_delete_find_fname(smb_request_t *sr, uint32_t *cookie)

{

	int rc, n_name;

	ino64_t fileid;

	smb_fqi_t *fqi;

	char name83[SMB_SHORTNAMELEN];

	char shortname[SMB_SHORTNAMELEN];

	boolean_t ignore_case;

	fqi = &sr->arg.dirop.fqi;

	ignore_case = SMB_TREE_IS_CASEINSENSITIVE(sr);

	for (;;) {

		n_name = sizeof (fqi->last_comp_od)  - 1;

		rc = smb_fsop_readdir(sr, sr->user_cr, fqi->dir_snode, cookie,

		    fqi->last_comp_od, &n_name, &fileid, NULL, NULL, NULL);

		if (rc != 0)

			return (rc);

		/* check for EOF */

		if (n_name == 0)

			return (ENOENT);

		fqi->last_comp_od[n_name] = '\0';

		if (smb_match_name(fileid, fqi->last_comp_od, shortname, name83,

		    fqi->last_comp, ignore_case))

			return (0);

	}

}

/*

 * smb_delete_check_attr

 *

 * Check file's dos atributes to ensure that

 * 1. the file is not a directory - NT_STATUS_FILE_IS_A_DIRECTORY

 * 2. the file is not readonly - NT_STATUS_CANNOT_DELETE

 * 3. the file's dos attributes comply with the specified search attributes

 *     If the file is either hidden or system and those attributes

 *     are not specified in the search attributes - NT_STATUS_NO_SUCH_FILE

 *

 * Returns: 0 - file's attributes pass all checks

 *         -1 - err populated with error details

 */

static int

smb_delete_check_attr(smb_request_t *sr, smb_error_t *err)

{

	smb_fqi_t *fqi;

	smb_node_t *node;

	uint16_t dosattr, sattr;

	fqi = &sr->arg.dirop.fqi;

	sattr = fqi->srch_attr;

	node = fqi->last_snode;

	dosattr = smb_node_get_dosattr(node);

	if (dosattr & FILE_ATTRIBUTE_DIRECTORY) {

		smb_delete_error(err, NT_STATUS_FILE_IS_A_DIRECTORY,

		    ERRDOS, ERROR_ACCESS_DENIED);

		return (-1);

	if (SMB_PATHFILE_IS_READONLY(sr, node)) {

		smb_delete_error(err, NT_STATUS_CANNOT_DELETE,

		    ERRDOS, ERROR_ACCESS_DENIED);

		return (-1);

	}

	if ((dosattr & FILE_ATTRIBUTE_HIDDEN) && !(SMB_SEARCH_HIDDEN(sattr))) {

		smb_delete_error(err, NT_STATUS_NO_SUCH_FILE,

		    ERRDOS, ERROR_FILE_NOT_FOUND);

		return (-1);

	}

	if ((dosattr & FILE_ATTRIBUTE_SYSTEM) && !(SMB_SEARCH_SYSTEM(sattr))) {

		smb_delete_error(err, NT_STATUS_NO_SUCH_FILE,

		    ERRDOS, ERROR_FILE_NOT_FOUND);

		return (-1);

	}

	return (0);

}

/*

 * smb_delete_remove_file

 *

 * For consistency with Windows 2000, the range check should be done

 * after checking for sharing violations.  Attempting to delete a

 * locked file will result in sharing violation, which is the same

 * thing that will happen if you try to delete a non-locked open file.

 *

 * Note that windows 2000 rejects lock requests on open files that

 * have been opened with metadata open modes.  The error is

 * STATUS_ACCESS_DENIED.

 *

 * NT does not always close a file immediately, which can cause the

 * share and access checking to fail (the node refcnt is greater

 * than one), and the file doesn't get deleted. Breaking the oplock

 * before share and access checking gives the client a chance to

 * close the file.

 *

 * Returns: 0 - success

 *         -1 - error, err populated with error details

 */

static int

smb_delete_remove_file(smb_request_t *sr, smb_error_t *err)

{

	int rc;

	uint32_t status;

	smb_fqi_t *fqi;

	smb_node_t *node;

	fqi = &sr->arg.dirop.fqi;

	node = fqi->last_snode;

	smb_oplock_break(node);

	smb_node_start_crit(node, RW_READER);

	status = smb_node_delete_check(node);

	if (status != NT_STATUS_SUCCESS) {

		smb_delete_error(err, NT_STATUS_SHARING_VIOLATION,

		    ERRDOS, ERROR_SHARING_VIOLATION);

		smb_node_end_crit(node);

		return (-1);

	}

	status = smb_range_check(sr, node, 0, UINT64_MAX, B_TRUE);

	if (status != NT_STATUS_SUCCESS) {

		smb_delete_error(err, NT_STATUS_ACCESS_DENIED,

		    ERRDOS, ERROR_ACCESS_DENIED);

		smb_node_end_crit(node);

		return (-1);

	}

	rc = smb_fsop_remove(sr, sr->user_cr, node->dir_snode,

	    node->od_name, 1);

	if (rc != 0) {

		if (rc == ENOENT)

			smb_delete_error(err, NT_STATUS_OBJECT_NAME_NOT_FOUND,

			    ERRDOS, ERROR_FILE_NOT_FOUND);

		else

			smbsr_map_errno(rc, err);

		smb_node_end_crit(node);

		return (-1);

	}

	smb_node_end_crit(node);

	return (0);

 * Perform initial validation on the pathname and last_comp.

 * wildcards in path:

 * Wildcards in the path (excluding the last_comp) should result

 * in NT_STATUS_OBJECT_NAME_INVALID.