/***********************************************************/

/*  ntux: native translation und extension                 */

/*  Copyright (C) 2016--2021  SysDeer Technologies, LLC    */

/*  Released under GPLv2 and GPLv3; see COPYING.NTUX.      */

/***********************************************************/

#include <psxabi/sys_sysapi.h>

#include <psxabi/sys_stat.h>

#include <psxabi/sys_path.h>

#include <psxabi/sys_errno.h>

#include <psxxfi/xfi_base.h>

#include <psxxfi/xfi_acl.h>

#include <psxxfi/xfi_fs.h>

#include <psxxfi/xfi_ofd.h>

#include <psxxfi/xfi_path.h>

#include <psxxfi/xfi_unicode.h>

#include <ntapi/nt_object.h>

#include <ntapi/nt_acl.h>

#include <ntapi/nt_file.h>

#include <ntux/ntux.h>

#include "ntux_driver_impl.h"

#include "ntux_nolibc_impl.h"

#include "ntux_errinfo_impl.h"

#include "nolibc/stdbool.h"

#define __SID_SYSTEM			{1,1,{{0,0,0,0,0,5}},{18}}

#define __SID_ADMINISTRATORS		{1,2,{{0,0,0,0,0,5}},{32,544}}

#define NTUX_OPT_MODE_NEUTRAL		(0)

#define NTUX_OPT_MODE_EQUAL		(1)

#define NTUX_OPT_MODE_PLUS		(2)

#define NTUX_OPT_MODE_MINUS		(3)

#define NTUX_BUF_SIZE_64K		(64*1024)

static const nt_sid    sid_system       = __SID_SYSTEM;

static const nt_sid_os sid_admins       = __SID_ADMINISTRATORS;

struct ntux_sd_buffer {

	nt_sd_common_buffer	sd;

	uint32_t		exbuf[512];

};

struct ntux_ace_any {

        nt_ace_header   header;

        uint32_t        mask;

        uint32_t        sid_start;

};

static int ntux_cmd_chmod_ret(int fd, struct __ofd * ofd, void * hasync, int ret)

{

	if (hasync)

		__xfi_close_handle(hasync);

	if (ofd)

		__xfi_ofd_ref_dec(ofd);

	if (fd >= 0)

		__sys_close(fd);

	return ret;

}

static nt_sid * ntux_cmd_chmod_sid_from_name(const char * name)

{

	if (!strcmp(name,"Administrators"))

		return (nt_sid *)&sid_admins;

	else if (!strcmp(name,"SYSTEM"))

		return (nt_sid *)&sid_system;

	else

		return 0;

}

int ntux_cmd_chmod(const struct ntux_driver_ctx * dctx, const char * dunit)

{

	intptr_t		ret;

	int32_t			status;

	int			fdout;

	int			fdcwd;

	int			finherit;

	int			optmode;

	const char *		strmode;

	const char *		chmode;

	const unsigned char *	unit;

	char *			ch;

	struct ntux_sd_buffer	sdbuf;

	struct ntux_sd_buffer	srcsd;

	struct ntux_sd_buffer	cntsd;

	nt_sd_common_buffer *	dstsd;

	nt_sd_common_meta	meta;

	nt_sid *		owner;

	nt_sid *		group;

	nt_acl *		dacl;

	struct ntux_ace_any *	srcace;

	struct ntux_ace_any *	dstace;

	uint32_t		access_owner;

	uint32_t		access_group;

	uint32_t		access_other;

	uint32_t		access_admin;

	uint32_t		ace_flags;

	uint32_t		sec_mask;

	size_t			size;

	size_t			addr;

	size_t			aceaddr;

	size_t			cntbufsize;

	char *			cntpath_utf8;

	wchar16_t *		cntpath_utf16;

	int			exacefilter;

	size_t			exacesize;

	int			exacecount;

	int			idx;

	int			fd      = -1;

	int			cntfd   = -1;

	struct __ofd *		ofd     = 0;

	struct __ofd *		cntofd  = 0;

	void *			cntbuf  = 0;

	void *			hasync  = 0;

	char			dummy   = 0;

	/* strmode */

	strmode   = dctx->cctx->strmode ? dctx->cctx->strmode : &dummy;

	optmode   = NTUX_OPT_MODE_NEUTRAL;

	finherit  = false;

	ace_flags = 0;

	for (chmode=strmode; *chmode; chmode++) {

		switch (*chmode) {

			case '=':

				optmode   = NTUX_OPT_MODE_EQUAL;

				finherit  = 0;

				ace_flags = 0;

				break;

			case '+':

				optmode = NTUX_OPT_MODE_PLUS;

				break;

			case '-':

				optmode = NTUX_OPT_MODE_MINUS;

				break;

			case 'p':

				switch (optmode) {

					case NTUX_OPT_MODE_EQUAL:

					case NTUX_OPT_MODE_PLUS:

						ace_flags = NT_ACE_CONTAINER_INHERIT | NT_ACE_OBJECT_INHERIT;

						break;

					case NTUX_OPT_MODE_MINUS:

						ace_flags = 0;

						break;

					default:

						return ntux_cmd_chmod_ret(

							0,0,0,

							NTUX_CUSTOM_ERROR(

								dctx,

								NTUX_ERR_FLEE_ERROR));

				}

				break;

			case 'P':

				switch (optmode) {

					case NTUX_OPT_MODE_EQUAL:

					case NTUX_OPT_MODE_PLUS:

						finherit = true;

						break;

					case NTUX_OPT_MODE_MINUS:

						finherit = false;

						break;

					default:

						return ntux_cmd_chmod_ret(

							0,0,0,

							NTUX_CUSTOM_ERROR(

								dctx,

								NTUX_ERR_FLEE_ERROR));

				}

				break;

			default:

				return ntux_cmd_chmod_ret(

					0,0,0,

					NTUX_CUSTOM_ERROR(

						dctx,

						NTUX_ERR_FLEE_ERROR));

		}

	}

	/* initial --owner and --group support: Administrators, SYSTEM */

	owner = 0;

	group = 0;

	if (dctx->cctx->owner)

		if (!(owner = ntux_cmd_chmod_sid_from_name(dctx->cctx->owner)))

			return ntux_cmd_chmod_ret(

				0,0,0,

				NTUX_CUSTOM_ERROR(

					dctx,

					NTUX_ERR_NOT_IMPLEMENTED));

	if (dctx->cctx->group)

		if (!(group = ntux_cmd_chmod_sid_from_name(dctx->cctx->group)))

			return ntux_cmd_chmod_ret(

				0,0,0,

				NTUX_CUSTOM_ERROR(

					dctx,

					NTUX_ERR_NOT_IMPLEMENTED));

	/* init */

	ntux_driver_set_ectx(

		dctx,0,dunit);

	unit = (const unsigned char *)dunit;

	/* fdctx */

	fdout = ntux_driver_fdout(dctx);

	fdcwd = ntux_driver_fdcwd(dctx);

	/* fd */

	if ((ret = __sys_openat(fdcwd,unit,0,0)) < 0)

		if (ntux_errno_set(dctx,ret))

			return ntux_cmd_chmod_ret(

				0,0,0,

				NTUX_SYSTEM_ERROR(dctx));

	fd = ret;

	/* ofd */

	if (!(ofd = __xfi_ofd_ref_inc(fd)))

		return ntux_cmd_chmod_ret(

			fd,0,0,

			NTUX_CUSTOM_ERROR(

				dctx,

				NTUX_ERR_FLOW_ERROR));

	/* hasync */

	sec_mask  = NT_SEC_READ_CONTROL;

	sec_mask |= NT_SEC_WRITE_DAC;

	sec_mask |= owner ? NT_SEC_WRITE_OWNER : 0;

	if ((status = __xfi_fs_open_async(

			&hasync,

			ofd->info.hfile,0,

			sec_mask,

			NT_FILE_SHARE_READ

				| NT_FILE_SHARE_WRITE

				| NT_FILE_SHARE_DELETE)))

		if (ntux_errno_set(dctx,EACCES))

			return ntux_cmd_chmod_ret(

				fd,ofd,0,

				NTUX_SYSTEM_ERROR(dctx));

	/* srcsd */

	if ((status = __xfi_query_security_object(

			hasync,

			NT_OWNER_SECURITY_INFORMATION

				| NT_GROUP_SECURITY_INFORMATION

				| NT_DACL_SECURITY_INFORMATION,

			&srcsd.sd.sd,sizeof(srcsd),&size)))

		if (ntux_errno_set(dctx,ENXIO))

			return ntux_cmd_chmod_ret(

				fd,ofd,hasync,

				NTUX_SYSTEM_ERROR(dctx));

	if ((status = __xfi_acl_init_common_descriptor_meta(

			&meta,&srcsd.sd.sd,

			NT_ACL_INIT_COMMON_DESCRIPTION_META_STRICT_MODE)))

		if (ntux_errno_set(dctx,EBADF))

			return ntux_cmd_chmod_ret(

				fd,ofd,hasync,

				NTUX_SYSTEM_ERROR(dctx));

	/* source permissions */

	access_owner  = meta.owner_ace  ? meta.owner_ace->mask  : 0;

	access_group  = meta.group_ace  ? meta.group_ace->mask  : 0;

	access_other  = meta.other_ace  ? meta.other_ace->mask  : 0;

	access_admin  = meta.admin_ace  ? meta.admin_ace->mask  : 0;

	/* initial --strmode support, retaining previous options as needed */

	if (!dctx->cctx->strmode) {

		ace_flags |= meta.owner_ace  ? meta.owner_ace->header.ace_flags : 0;

		ace_flags |= meta.group_ace  ? meta.group_ace->header.ace_flags : 0;

		ace_flags |= meta.other_ace  ? meta.other_ace->header.ace_flags : 0;

		ace_flags |= meta.admin_ace  ? meta.admin_ace->header.ace_flags : 0;

	}

	/* updated dacl */

	dstsd = &sdbuf.sd;

	__xfi_acl_init_common_descriptor(

		dstsd,

		owner ? owner : meta.owner,

		group ? group : meta.group,

		0,0,

		access_owner,access_group,access_other,

		access_admin,meta.system_acc,

		ace_flags);

	if ((dstsd->sd.offset_dacl < dstsd->sd.offset_owner)

			|| (dstsd->sd.offset_dacl < dstsd->sd.offset_group)

			|| (dstsd->sd.offset_dacl < dstsd->sd.offset_sacl))

		return ntux_cmd_chmod_ret(

			fd,0,0,

			NTUX_CUSTOM_ERROR(

				dctx,

				NTUX_ERR_FLOW_ERROR));

	/* inherited ace's */

	if (finherit) {

		dstsd->sd.control = NT_SE_SELF_RELATIVE

			| NT_SE_DACL_AUTO_INHERIT_REQ

			| NT_SE_DACL_AUTO_INHERITED

			| NT_SE_DACL_PRESENT;

		/* cntofd */

		cntbuf = 0; cntbufsize = NTUX_BUF_SIZE_64K;

		if (__xfi_allocate_virtual_memory(

				NT_CURRENT_PROCESS_HANDLE,

				&cntbuf,

				0,

				&cntbufsize,

				NT_MEM_COMMIT,

				NT_PAGE_READWRITE))

			return ntux_cmd_chmod_ret(

				fd,ofd,hasync,

				NTUX_SYSTEM_ERROR(dctx));

		if (__xfi_ofd_is_dir(ofd)) {

			cntpath_utf16 = (wchar16_t *)cntbuf;

			__xfi_path_conv_ofdat_utf16(

				ofd,

				(const wchar16_t[]){'.','.','/',0},

				PSX_PATH_SYNTAX_ANY,

				4*sizeof(wchar16_t),

				cntpath_utf16,

				PSX_PATH_SYNTAX_POSIX_STRICT,

				cntbufsize,

				0,0,PSX_PATH_CONV_RESOLVE_ELEMENT,

				&cntofd);

		} else {

			cntpath_utf8 = cntbuf;

			status = __xfi_path_conv_utf8(

				fdcwd,

				unit,

				PSX_PATH_SYNTAX_POSIX_STRICT,

				ntux_strlen((const char *)unit),

				cntpath_utf8,

				PSX_PATH_SYNTAX_POSIX_STRICT,

				cntbufsize,

				0,0,PSX_PATH_CONV_RESOLVE_ELEMENT,

				0);

			if (status) {

				__xfi_free_virtual_memory(

					NT_CURRENT_PROCESS_HANDLE,

					&cntbuf,

					&cntbufsize,

					NT_MEM_RELEASE);

				return ntux_cmd_chmod_ret(

					fd,ofd,hasync,

					NTUX_CUSTOM_ERROR(

						dctx,

						NTUX_ERR_FLOW_ERROR));

			}

			if ((cntpath_utf8[0] == '/') && cntpath_utf8[1]) {

				for (ch=cntpath_utf8; *ch; ch++)

					(void)0;

				/* guard against an internal error */

				if (ch[-1] != '/') {

					for (--ch; *ch != '/'; ch--)

						(void)0;

					*ch = 0;

					cntfd = __sys_openat(

						fdcwd,

						(const unsigned char *)cntpath_utf8,

						0,0);

					if (cntfd >= 0)

						if (!(cntofd = __xfi_ofd_ref_inc(cntfd)))

							__sys_close(cntfd);

				}

			}

		}

		__xfi_free_virtual_memory(

			NT_CURRENT_PROCESS_HANDLE,

			&cntbuf,

			&cntbufsize,

			NT_MEM_RELEASE);

		if (!cntofd)

			return ntux_cmd_chmod_ret(

				fd,ofd,hasync,

				NTUX_CUSTOM_ERROR(

					dctx,

					NTUX_ERR_FLOW_ERROR));

		status = __xfi_query_security_object(

			cntofd->info.hfile,

			NT_OWNER_SECURITY_INFORMATION

				| NT_GROUP_SECURITY_INFORMATION

				| NT_DACL_SECURITY_INFORMATION,

			&cntsd.sd.sd,sizeof(cntsd),&size);

		if (status) {

			__xfi_ofd_ref_dec(cntofd);

			__sys_close(cntfd);

			return ntux_cmd_chmod_ret(

				fd,ofd,hasync,

				NTUX_SYSTEM_ERROR(dctx));

		}

		/* exacefilter */

		exacefilter = __xfi_ofd_is_dir(ofd)

			? NT_ACE_CONTAINER_INHERIT

			: NT_ACE_OBJECT_INHERIT;

		/* exacecount, exacesize */

		if (cntsd.sd.sd.offset_dacl) {

			addr  = (size_t)&cntsd.sd.sd;

			addr += cntsd.sd.sd.offset_dacl;

			dacl  = (nt_acl *)addr;

			addr += sizeof(*dacl);

			exacecount = 0;

			exacesize  = 0;

			for (idx=0; idx<dacl->ace_count; idx++) {

				srcace = (struct ntux_ace_any *)addr;

				if (srcace->header.ace_flags & exacefilter) {

					exacecount++;

					exacesize += srcace->header.ace_size;

				}

				addr += srcace->header.ace_size;

			}

			/* dstsd::dacl */

			addr  = (size_t)dstsd;

			addr += dstsd->sd.offset_dacl;

			dacl  = (nt_acl *)addr;

			if (dstsd->sd.offset_dacl + dacl->acl_size + exacesize > sizeof(sdbuf)) {

				__xfi_ofd_ref_dec(cntofd);

				__sys_close(cntfd);

				return ntux_cmd_chmod_ret(

					fd,ofd,hasync,

					NTUX_BUFFER_ERROR(dctx));

			}

			dacl->acl_size  += exacesize;

			dacl->ace_count += exacecount;

			/* pointer to dstsd's next ace */

			aceaddr  = addr;

			aceaddr += sizeof(*dacl);

			for (idx=0; idx<dacl->ace_count; idx++) {

				dstace   = (struct ntux_ace_any *)aceaddr;

				aceaddr += dstace->header.ace_size;

			}

			dstace = (struct ntux_ace_any *)aceaddr;

			/* copy container's ace's according to filter */

			addr  = (size_t)&cntsd.sd.sd;

			addr += cntsd.sd.sd.offset_dacl;

			dacl  = (nt_acl *)addr;

			addr += sizeof(*dacl);

			for (idx=0; idx<dacl->ace_count; idx++) {

				srcace = (struct ntux_ace_any *)addr;

				if (srcace->header.ace_flags & exacefilter) {

					ntux_memcpy(dstace,srcace,srcace->header.ace_size);

					dstace->header.ace_flags = NT_ACE_INHERITED | ace_flags;

					aceaddr += srcace->header.ace_size;

					dstace   = (struct ntux_ace_any *)aceaddr;

				}

				addr += srcace->header.ace_size;

			}

		}

	}

	/* finalize */

	sec_mask  = NT_DACL_SECURITY_INFORMATION;

	sec_mask |= owner ? NT_OWNER_SECURITY_INFORMATION : 0;

	if ((status = __xfi_set_security_object(

			hasync,sec_mask,&dstsd->sd)))

		if (ntux_errno_set(dctx,EPERM))

			return ntux_cmd_chmod_ret(

				fd,ofd,hasync,

				NTUX_SYSTEM_ERROR(dctx));

	/* changes */

	(void)fdout;

	/* cntofd */

	if (cntofd) {

		__xfi_ofd_ref_dec(cntofd);

		__sys_close(cntfd);

	}

	/* all done */

	return ntux_cmd_chmod_ret(fd,ofd,hasync,0);

}