path: root/source4/ntvfs/posix/pvfs_setfileinfo.c

/* 
   Unix SMB/CIFS implementation.

   POSIX NTVFS backend - setfileinfo

   Copyright (C) Andrew Tridgell 2004

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.
   
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
   
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#include "includes.h"
#include "vfs_posix.h"
#include "system/time.h"
#include "librpc/gen_ndr/xattr.h"


/*
  determine what access bits are needed for a call
*/
static uint32_t pvfs_setfileinfo_access(union smb_setfileinfo *info)
{
	uint32_t needed;

	switch (info->generic.level) {
	case RAW_SFILEINFO_EA_SET:
		needed = SEC_FILE_WRITE_EA;
		break;

	case RAW_SFILEINFO_DISPOSITION_INFO:
	case RAW_SFILEINFO_DISPOSITION_INFORMATION:
		needed = SEC_STD_DELETE;
		break;

	case RAW_SFILEINFO_END_OF_FILE_INFO:
		needed = SEC_FILE_WRITE_DATA;
		break;

	case RAW_SFILEINFO_POSITION_INFORMATION:
		needed = 0;
		break;

	case RAW_SFILEINFO_SEC_DESC:
		needed = 0;
		if (info->set_secdesc.in.secinfo_flags & (SECINFO_OWNER|SECINFO_GROUP)) {
			needed |= SEC_STD_WRITE_OWNER;
		}
		if (info->set_secdesc.in.secinfo_flags & SECINFO_DACL) {
			needed |= SEC_STD_WRITE_DAC;
		}
		if (info->set_secdesc.in.secinfo_flags & SECINFO_SACL) {
			needed |= SEC_FLAG_SYSTEM_SECURITY;
		}
		break;

	default:
		needed = SEC_FILE_WRITE_ATTRIBUTE;
		break;
	}

	return needed;
}

/*
  rename_information level
*/
static NTSTATUS pvfs_setfileinfo_rename(struct pvfs_state *pvfs, 
					struct ntvfs_request *req, 
					struct pvfs_filename *name,
					union smb_setfileinfo *info)
{
	NTSTATUS status;
	struct pvfs_filename *name2;
	char *new_name, *p;

	/* renames are only allowed within a directory */
	if (strchr_m(info->rename_information.in.new_name, '\\')) {
		return NT_STATUS_NOT_SUPPORTED;
	}

	if (name->dos.attrib & FILE_ATTRIBUTE_DIRECTORY) {
		/* don't allow this for now */
		return NT_STATUS_FILE_IS_A_DIRECTORY;
	}

	/* don't allow stream renames for now */
	if (name->stream_name) {
		return NT_STATUS_INVALID_PARAMETER;
	}

	/* w2k3 does not appear to allow relative rename */
	if (info->rename_information.in.root_fid != 0) {
		return NT_STATUS_INVALID_PARAMETER;
	}

	/* construct the fully qualified windows name for the new file name */
	new_name = talloc_strdup(req, name->original_name);
	if (new_name == NULL) {
		return NT_STATUS_NO_MEMORY;
	}
	p = strrchr_m(new_name, '\\');
	if (p == NULL) {
		return NT_STATUS_OBJECT_NAME_INVALID;
	}
	*p = 0;

	new_name = talloc_asprintf(req, "%s\\%s", new_name,
				   info->rename_information.in.new_name);
	if (new_name == NULL) {
		return NT_STATUS_NO_MEMORY;
	}

	/* resolve the new name */
	status = pvfs_resolve_name(pvfs, name, new_name, 0, &name2);
	if (!NT_STATUS_IS_OK(status)) {
		return status;
	}

	/* if the destination exists, then check the rename is allowed */
	if (name2->exists) {
		struct odb_lock *lck;

		if (strcmp(name2->full_name, name->full_name) == 0) {
			/* rename to same name is null-op */
			return NT_STATUS_OK;
		}

		if (!info->rename_information.in.overwrite) {
			return NT_STATUS_OBJECT_NAME_COLLISION;
		}

		status = pvfs_can_delete(pvfs, req, name2, &lck);
		if (NT_STATUS_EQUAL(status, NT_STATUS_SHARING_VIOLATION)) {
			return NT_STATUS_ACCESS_DENIED;
		}
		if (!NT_STATUS_IS_OK(status)) {
			return status;
		}
	}

	status = pvfs_access_check_parent(pvfs, req, name2, SEC_DIR_ADD_FILE);
	if (!NT_STATUS_IS_OK(status)) {
		return status;
	}

	status = pvfs_do_rename(pvfs, name, name2->full_name);
	if (NT_STATUS_IS_OK(status)) {
		name->full_name = talloc_steal(name, name2->full_name);
		name->original_name = talloc_steal(name, name2->original_name);
	}

	return NT_STATUS_OK;
}

/*
  add a single DOS EA
*/
NTSTATUS pvfs_setfileinfo_ea_set(struct pvfs_state *pvfs, 
				 struct pvfs_filename *name,
				 int fd, uint16_t num_eas,
				 struct ea_struct *eas)
{
	struct xattr_DosEAs *ealist;
	int i, j;
	NTSTATUS status;

	if (num_eas == 0) {
		return NT_STATUS_OK;
	}

	if (!(pvfs->flags & PVFS_FLAG_XATTR_ENABLE)) {
		return NT_STATUS_NOT_SUPPORTED;
	}

	ealist = talloc(name, struct xattr_DosEAs);

	/* load the current list */
	status = pvfs_doseas_load(pvfs, name, fd, ealist);
	if (!NT_STATUS_IS_OK(status)) {
		return status;
	}

	for (j=0;j<num_eas;j++) {
		struct ea_struct *ea = &eas[j];
		/* see if its already there */
		for (i=0;i<ealist->num_eas;i++) {
			if (strcasecmp_m(ealist->eas[i].name, ea->name.s) == 0) {
				ealist->eas[i].value = ea->value;
				break;
			}
		}

		if (i==ealist->num_eas) {
			/* add it */
			ealist->eas = talloc_realloc(ealist, ealist->eas, 
						       struct xattr_EA, 
						       ealist->num_eas+1);
			if (ealist->eas == NULL) {
				return NT_STATUS_NO_MEMORY;
			}
			ealist->eas[i].name = ea->name.s;
			ealist->eas[i].value = ea->value;
			ealist->num_eas++;
		}
	}
	
	/* pull out any null EAs */
	for (i=0;i<ealist->num_eas;i++) {
		if (ealist->eas[i].value.length == 0) {
			memmove(&ealist->eas[i],
				&ealist->eas[i+1],
				(ealist->num_eas-(i+1)) * sizeof(ealist->eas[i]));
			ealist->num_eas--;
			i--;
		}
	}

	status = pvfs_doseas_save(pvfs, name, fd, ealist);
	if (!NT_STATUS_IS_OK(status)) {
		return status;
	}

	notify_trigger(pvfs->notify_context, 
		       NOTIFY_ACTION_MODIFIED, 
		       FILE_NOTIFY_CHANGE_EA,
		       name->full_name);

	name->dos.ea_size = 4;
	for (i=0;i<ealist->num_eas;i++) {
		name->dos.ea_size += 4 + strlen(ealist->eas[i].name)+1 + 
			ealist->eas[i].value.length;
	}

	/* update the ea_size attrib */
	return pvfs_dosattrib_save(pvfs, name, fd);
}

/*
  set info on a open file
*/
NTSTATUS pvfs_setfileinfo(struct ntvfs_module_context *ntvfs,
			  struct ntvfs_request *req, 
			  union smb_setfileinfo *info)
{
	struct pvfs_state *pvfs = ntvfs->private_data;
	struct utimbuf unix_times;
	struct pvfs_file *f;
	struct pvfs_file_handle *h;
	struct pvfs_filename newstats;
	NTSTATUS status;
	uint32_t access_needed;
	uint32_t change_mask = 0;

	f = pvfs_find_fd(pvfs, req, info->generic.in.file.ntvfs);
	if (!f) {
		return NT_STATUS_INVALID_HANDLE;
	}

	h = f->handle;

	access_needed = pvfs_setfileinfo_access(info);
	if ((f->access_mask & access_needed) != access_needed) {
		return NT_STATUS_ACCESS_DENIED;
	}

	/* update the file information */
	status = pvfs_resolve_name_fd(pvfs, h->fd, h->name);
	if (!NT_STATUS_IS_OK(status)) {
		return status;
	}

	/* we take a copy of the current file stats, then update
	   newstats in each of the elements below. At the end we
	   compare, and make any changes needed */
	newstats = *h->name;

	switch (info->generic.level) {
	case RAW_SFILEINFO_SETATTR:
		if (!null_time(info->setattr.in.write_time)) {
			unix_to_nt_time(&newstats.dos.write_time, info->setattr.in.write_time);
		}
		if (info->setattr.in.attrib != FILE_ATTRIBUTE_NORMAL) {
			newstats.dos.attrib = info->setattr.in.attrib;
		}
  		break;

	case RAW_SFILEINFO_SETATTRE:
	case RAW_SFILEINFO_STANDARD:
		if (!null_time(info->setattre.in.create_time)) {
			unix_to_nt_time(&newstats.dos.create_time, info->setattre.in.create_time);
		}
		if (!null_time(info->setattre.in.access_time)) {
			unix_to_nt_time(&newstats.dos.access_time, info->setattre.in.access_time);
		}
		if (!null_time(info->setattre.in.write_time)) {
			unix_to_nt_time(&newstats.dos.write_time, info->setattre.in.write_time);
		}
  		break;

	case RAW_SFILEINFO_EA_SET:
		return pvfs_setfileinfo_ea_set(pvfs, h->name, h->fd, 
					       info->ea_set.in.num_eas,
					       info->ea_set.in.eas);

	case RAW_SFILEINFO_BASIC_INFO:
	case RAW_SFILEINFO_BASIC_INFORMATION:
		if (!null_nttime(info->basic_info.in.create_time)) {
			newstats.dos.create_time = info->basic_info.in.create_time;
		}
		if (!null_nttime(info->basic_info.in.access_time)) {
			newstats.dos.access_time = info->basic_info.in.access_time;
		}
		if (!null_nttime(info->basic_info.in.write_time)) {
			newstats.dos.write_time = info->basic_info.in.write_time;
			newstats.dos.flags |= XATTR_ATTRIB_FLAG_STICKY_WRITE_TIME;
			h->sticky_write_time = True;
		}
		if (!null_nttime(info->basic_info.in.change_time)) {
			newstats.dos.change_time = info->basic_info.in.change_time;
		}
		if (info->basic_info.in.attrib != 0) {
			newstats.dos.attrib = info->basic_info.in.attrib;
		}
  		break;

	case RAW_SFILEINFO_DISPOSITION_INFO:
	case RAW_SFILEINFO_DISPOSITION_INFORMATION:
		return pvfs_set_delete_on_close(pvfs, req, f, 
						info->disposition_info.in.delete_on_close);

	case RAW_SFILEINFO_ALLOCATION_INFO:
	case RAW_SFILEINFO_ALLOCATION_INFORMATION:
		newstats.dos.alloc_size = info->allocation_info.in.alloc_size;
		if (newstats.dos.alloc_size < newstats.st.st_size) {
			newstats.st.st_size = newstats.dos.alloc_size;
		}
		newstats.dos.alloc_size = pvfs_round_alloc_size(pvfs, 
								newstats.dos.alloc_size);
		break;

	case RAW_SFILEINFO_END_OF_FILE_INFO:
	case RAW_SFILEINFO_END_OF_FILE_INFORMATION:
		newstats.st.st_size = info->end_of_file_info.in.size;
		break;

	case RAW_SFILEINFO_POSITION_INFORMATION:
		h->position = info->position_information.in.position;
		break;

	case RAW_SFILEINFO_MODE_INFORMATION:
		/* this one is a puzzle */
		if (info->mode_information.in.mode != 0 &&
		    info->mode_information.in.mode != 2 &&
		    info->mode_information.in.mode != 4 &&
		    info->mode_information.in.mode != 6) {
			return NT_STATUS_INVALID_PARAMETER;
		}
		h->mode = info->mode_information.in.mode;
		break;

	case RAW_SFILEINFO_RENAME_INFORMATION:
		return pvfs_setfileinfo_rename(pvfs, req, h->name, 
					       info);

	case RAW_SFILEINFO_SEC_DESC:
		notify_trigger(pvfs->notify_context, 
			       NOTIFY_ACTION_MODIFIED, 
			       FILE_NOTIFY_CHANGE_SECURITY,
			       h->name->full_name);
		return pvfs_acl_set(pvfs, req, h->name, h->fd, f->access_mask, info);

	default:
		return NT_STATUS_INVALID_LEVEL;
	}

	/* possibly change the file size */
	if (newstats.st.st_size != h->name->st.st_size) {
		if (h->name->dos.attrib & FILE_ATTRIBUTE_DIRECTORY) {
			return NT_STATUS_FILE_IS_A_DIRECTORY;
		}
		if (h->name->stream_name) {
			status = pvfs_stream_truncate(pvfs, h->name, h->fd, newstats.st.st_size);
			if (!NT_STATUS_IS_OK(status)) {
				return status;
			}
			
			change_mask |= FILE_NOTIFY_CHANGE_STREAM_SIZE;
		} else {
			int ret;
			if (f->access_mask & 
			    (SEC_FILE_WRITE_DATA|SEC_FILE_APPEND_DATA)) {
				ret = ftruncate(h->fd, newstats.st.st_size);
			} else {
				ret = truncate(h->name->full_name, newstats.st.st_size);
			}
			if (ret == -1) {
				return pvfs_map_errno(pvfs, errno);
			}
			change_mask |= FILE_NOTIFY_CHANGE_SIZE | FILE_NOTIFY_CHANGE_ATTRIBUTES;
		}
	}

	/* possibly change the file timestamps */
	ZERO_STRUCT(unix_times);
	if (newstats.dos.create_time != h->name->dos.create_time) {
		change_mask |= FILE_NOTIFY_CHANGE_CREATION;
	}
	if (newstats.dos.access_time != h->name->dos.access_time) {
		unix_times.actime = nt_time_to_unix(newstats.dos.access_time);
		change_mask |= FILE_NOTIFY_CHANGE_LAST_ACCESS;
	}
	if (newstats.dos.write_time != h->name->dos.write_time) {
		unix_times.modtime = nt_time_to_unix(newstats.dos.write_time);
		change_mask |= FILE_NOTIFY_CHANGE_LAST_WRITE;
	}
	if (unix_times.actime != 0 || unix_times.modtime != 0) {
		if (utime(h->name->full_name, &unix_times) == -1) {
			return pvfs_map_errno(pvfs, errno);
		}
	}

	/* possibly change the attribute */
	if (newstats.dos.attrib != h->name->dos.attrib) {
		mode_t mode = pvfs_fileperms(pvfs, newstats.dos.attrib);
		if (!(h->name->dos.attrib & FILE_ATTRIBUTE_DIRECTORY)) {
			if (fchmod(h->fd, mode) == -1) {
				return pvfs_map_errno(pvfs, errno);
			}
		}
		change_mask |= FILE_NOTIFY_CHANGE_ATTRIBUTES;
	}

	*h->name = newstats;

	notify_trigger(pvfs->notify_context, 
		       NOTIFY_ACTION_MODIFIED, 
		       change_mask,
		       h->name->full_name);

	return pvfs_dosattrib_save(pvfs, h->name, h->fd);
}


/*
  set info on a pathname
*/
NTSTATUS pvfs_setpathinfo(struct ntvfs_module_context *ntvfs,
			  struct ntvfs_request *req, union smb_setfileinfo *info)
{
	struct pvfs_state *pvfs = ntvfs->private_data;
	struct pvfs_filename *name;
	struct pvfs_filename newstats;
	NTSTATUS status;
	struct utimbuf unix_times;
	uint32_t access_needed;
	uint32_t change_mask = 0;

	/* resolve the cifs name to a posix name */
	status = pvfs_resolve_name(pvfs, req, info->generic.in.file.path, 
				   PVFS_RESOLVE_STREAMS, &name);
	if (!NT_STATUS_IS_OK(status)) {
		return status;
	}

	if (!name->exists) {
		return NT_STATUS_OBJECT_NAME_NOT_FOUND;
	}

	access_needed = pvfs_setfileinfo_access(info);
	status = pvfs_access_check_simple(pvfs, req, name, access_needed);
	if (!NT_STATUS_IS_OK(status)) {
		return status;
	}

	/* we take a copy of the current file stats, then update
	   newstats in each of the elements below. At the end we
	   compare, and make any changes needed */
	newstats = *name;

	switch (info->generic.level) {
	case RAW_SFILEINFO_SETATTR:
		if (!null_time(info->setattr.in.write_time)) {
			unix_to_nt_time(&newstats.dos.write_time, info->setattr.in.write_time);
		}
		if (info->setattr.in.attrib == 0) {
			newstats.dos.attrib = FILE_ATTRIBUTE_NORMAL;
		} else if (info->setattr.in.attrib != FILE_ATTRIBUTE_NORMAL) {
			newstats.dos.attrib = info->setattr.in.attrib;
		}
  		break;

	case RAW_SFILEINFO_SETATTRE:
	case RAW_SFILEINFO_STANDARD:
		if (!null_time(info->setattre.in.create_time)) {
			unix_to_nt_time(&newstats.dos.create_time, info->setattre.in.create_time);
		}
		if (!null_time(info->setattre.in.access_time)) {
			unix_to_nt_time(&newstats.dos.access_time, info->setattre.in.access_time);
		}
		if (!null_time(info->setattre.in.write_time)) {
			unix_to_nt_time(&newstats.dos.write_time, info->setattre.in.write_time);
		}
  		break;

	case RAW_SFILEINFO_EA_SET:
		return pvfs_setfileinfo_ea_set(pvfs, name, -1, 
					       info->ea_set.in.num_eas,
					       info->ea_set.in.eas);

	case RAW_SFILEINFO_BASIC_INFO:
	case RAW_SFILEINFO_BASIC_INFORMATION:
		if (!null_nttime(info->basic_info.in.create_time)) {
			newstats.dos.create_time = info->basic_info.in.create_time;
		}
		if (!null_nttime(info->basic_info.in.access_time)) {
			newstats.dos.access_time = info->basic_info.in.access_time;
		}
		if (!null_nttime(info->basic_info.in.write_time)) {
			newstats.dos.write_time = info->basic_info.in.write_time;
		}
		if (!null_nttime(info->basic_info.in.change_time)) {
			newstats.dos.change_time = info->basic_info.in.change_time;
		}
		if (info->basic_info.in.attrib != 0) {
			newstats.dos.attrib = info->basic_info.in.attrib;
		}
  		break;

	case RAW_SFILEINFO_ALLOCATION_INFO:
	case RAW_SFILEINFO_ALLOCATION_INFORMATION:
		if (info->allocation_info.in.alloc_size > newstats.dos.alloc_size) {
			/* strange. Increasing the allocation size via setpathinfo 
			   should be silently ignored */
			break;
		}
		newstats.dos.alloc_size = info->allocation_info.in.alloc_size;
		if (newstats.dos.alloc_size < newstats.st.st_size) {
			newstats.st.st_size = newstats.dos.alloc_size;
		}
		newstats.dos.alloc_size = pvfs_round_alloc_size(pvfs, 
								newstats.dos.alloc_size);
		break;

	case RAW_SFILEINFO_END_OF_FILE_INFO:
	case RAW_SFILEINFO_END_OF_FILE_INFORMATION:
		newstats.st.st_size = info->end_of_file_info.in.size;
		break;

	case RAW_SFILEINFO_MODE_INFORMATION:
		if (info->mode_information.in.mode != 0 &&
		    info->mode_information.in.mode != 2 &&
		    info->mode_information.in.mode != 4 &&
		    info->mode_information.in.mode != 6) {
			return NT_STATUS_INVALID_PARAMETER;
		}
		return NT_STATUS_OK;

	case RAW_SFILEINFO_RENAME_INFORMATION:
		return pvfs_setfileinfo_rename(pvfs, req, name, 
					       info);

	case RAW_SFILEINFO_DISPOSITION_INFO:
	case RAW_SFILEINFO_DISPOSITION_INFORMATION:
	case RAW_SFILEINFO_POSITION_INFORMATION:
		return NT_STATUS_OK;

	default:
		return NT_STATUS_INVALID_LEVEL;
	}

	/* possibly change the file size */
	if (newstats.st.st_size != name->st.st_size) {
		if (name->stream_name) {
			status = pvfs_stream_truncate(pvfs, name, -1, newstats.st.st_size);
			if (!NT_STATUS_IS_OK(status)) {
				return status;
			}
		} else if (truncate(name->full_name, newstats.st.st_size) == -1) {
			return pvfs_map_errno(pvfs, errno);
		}
		change_mask |= FILE_NOTIFY_CHANGE_SIZE | FILE_NOTIFY_CHANGE_ATTRIBUTES;
	}

	/* possibly change the file timestamps */
	ZERO_STRUCT(unix_times);
	if (newstats.dos.create_time != name->dos.create_time) {
		change_mask |= FILE_NOTIFY_CHANGE_CREATION;
	}
	if (newstats.dos.access_time != name->dos.access_time) {
		unix_times.actime = nt_time_to_unix(newstats.dos.access_time);
		change_mask |= FILE_NOTIFY_CHANGE_LAST_ACCESS;
	}
	if (newstats.dos.write_time != name->dos.write_time) {
		unix_times.modtime = nt_time_to_unix(newstats.dos.write_time);
		change_mask |= FILE_NOTIFY_CHANGE_LAST_WRITE;
	}
	if (unix_times.actime != 0 || unix_times.modtime != 0) {
		if (utime(name->full_name, &unix_times) == -1) {
			return pvfs_map_errno(pvfs, errno);
		}
	}

	/* possibly change the attribute */
	newstats.dos.attrib |= (name->dos.attrib & FILE_ATTRIBUTE_DIRECTORY);
	if (newstats.dos.attrib != name->dos.attrib) {
		mode_t mode = pvfs_fileperms(pvfs, newstats.dos.attrib);
		if (chmod(name->full_name, mode) == -1) {
			return pvfs_map_errno(pvfs, errno);
		}
		change_mask |= FILE_NOTIFY_CHANGE_ATTRIBUTES;
	}

	*name = newstats;

	if (change_mask != 0) {
		notify_trigger(pvfs->notify_context, 
			       NOTIFY_ACTION_MODIFIED, 
			       change_mask,
			       name->full_name);
	}

	return pvfs_dosattrib_save(pvfs, name, -1);
}