/***********************************************************/
/*  ntux: native translation und extension                 */
/*  Copyright (C) 2016--2022  SysDeer Technologies, LLC    */
/*  Released under GPLv2 and GPLv3; see COPYING.NTUX.      */
/***********************************************************/
 
#include <psxabi/sys_sysapi.h>
#include <psxabi/sys_stat.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_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"
 
 
struct ntux_ace_any {
        nt_ace_header   header;
        uint32_t        mask;
        uint32_t        sid_start;
};
 
 
struct ntux_sid_any {
        unsigned char                   revision;
        unsigned char                   sub_authority_count;
        nt_sid_identifier_authority     identifier_authority;
        uint32_t                        sub_authority[];
};
 
 
static int ntux_cmd_aceit_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 int ntux_cmd_aceit_dump_acl(nt_acl * acl, const char * acldesc, int fdout)
{
	int                     idx;
	int                     saidx;
	size_t                  addr;
	struct ntux_sid_any *   sid;
	struct ntux_ace_any *   ace;
	char                    comma[2];
 
	ntux_dprintf(
		fdout,
		"  ::sd::%s = {\n"
		"    .revision = 0x%x,\n"
		"    .sbz_1st = 0x%x,\n"
		"    .acl_size = 0x%x,\n"
		"    .ace_count = 0x%x,\n"
		"    .sbz_2nd = 0x%x\n",
		acldesc,
		acl->acl_revision,
		acl->sbz_1st,
		acl->acl_size,
		acl->ace_count,
		acl->sbz_2nd);
 
	addr  = (size_t)acl;
	addr += sizeof(*acl);
 
	for (idx=0; idx<acl->ace_count; idx++) {
		ace = (struct ntux_ace_any *)addr;
 
		ntux_dprintf(
			fdout,
			"    ::sd::%s::ace[%d] = {\n"
			"      .ace_type = 0x%x,\n"
			"      .ace_flags = 0x%x,\n"
			"      .ace_size = 0x%x,\n"
			"      .mask = 0x%x,\n",
			acldesc,idx,
			ace->header.ace_type,
			ace->header.ace_flags,
			ace->header.ace_size,
			ace->mask);
 
		sid = (struct ntux_sid_any *)&ace->sid_start;
 
		ntux_dprintf(fdout,
		"      .sid = {\n"
		"        .revision = 0x%x,\n"
		"        .sub_authority_count = 0x%x,\n"
		"        .identifier_authority = {%u,%u,%u,%u,%u,%u}\n"
		"        .sub_authority = {",
		sid->revision,
		sid->sub_authority_count,
		sid->identifier_authority.value[0],
		sid->identifier_authority.value[1],
		sid->identifier_authority.value[2],
		sid->identifier_authority.value[3],
		sid->identifier_authority.value[4],
		sid->identifier_authority.value[5]);
 
		comma[0] = '\0';
		comma[1] = 0;
 
		for (saidx=0; saidx<sid->sub_authority_count; saidx++) {
			ntux_dprintf(fdout,"%s%u",comma,sid->sub_authority[saidx]);
			comma[0] = ',';
		}
 
		ntux_dprintf(fdout,"}\n");
		ntux_dprintf(fdout,"      }\n");
		ntux_dprintf(fdout,"    }\n");
 
		addr += ace->header.ace_size;
	}
 
	ntux_dprintf(fdout,"  }\n");
 
(void)saidx;
	return 0;
}
 
 
static int ntux_cmd_aceit_dump(const char * dunit, nt_sd * sd, int fdout)
{
	int             ret;
	size_t          addr;
	nt_acl *        sacl;
	nt_acl *        dacl;
 
	ntux_dprintf(
		fdout,
		"%s::sd = {\n"
		"  .revision = 0x%x,\n"
		"  .sbz_1st = 0x%x,\n"
		"  .control = 0x%x,\n"
		"  .offset_owner = 0x%x,\n"
		"  .offset_group = 0x%x,\n"
		"  .offset_sacl = 0x%x,\n"
		"  .offset_dacl = 0x%x\n",
		dunit,
		sd->revision,
		sd->sbz_1st,
		sd->control,
		sd->offset_owner,
		sd->offset_group,
		sd->offset_sacl,
		sd->offset_dacl);
 
	if (sd->offset_sacl) {
		addr  = (size_t)sd;
		addr += sd->offset_sacl;
		sacl  = (nt_acl *)addr;
 
		if ((ret = ntux_cmd_aceit_dump_acl(sacl,"sacl",fdout)))
			return ret;
	}
 
	if (sd->offset_dacl) {
		addr  = (size_t)sd;
		addr += sd->offset_dacl;
		dacl  = (nt_acl *)addr;
 
		if ((ret = ntux_cmd_aceit_dump_acl(dacl,"dacl",fdout)))
			return ret;
	}
 
	ntux_dprintf(fdout,"}\n");
 
	return 0;
}
 
 
int ntux_cmd_aceit(const struct ntux_driver_ctx * dctx, const char * dunit)
{
	intptr_t		ret;
	int32_t			status;
	int			fdout;
	int			fdcwd;
	const unsigned char *	unit;
	nt_sd *			srcsd;
	size_t			size;
	int			fd      = -1;
	struct __ofd *		ofd     = 0;
	void *			hasync  = 0;
	uint32_t		buf[0x300];
 
	/* 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_aceit_ret(
				0,0,0,
				NTUX_SYSTEM_ERROR(dctx));
 
	fd = ret;
 
	/* ofd */
	if (!(ofd = __xfi_ofd_ref_inc(fd)))
		return ntux_cmd_aceit_ret(
			fd,0,0,
			NTUX_CUSTOM_ERROR(
				dctx,
				NTUX_ERR_FLOW_ERROR));
 
	/* hasync */
	if ((status = __xfi_fs_open_async(
			&hasync,
			ofd->info.hfile,0,
			NT_SEC_READ_CONTROL,
			NT_FILE_SHARE_READ
				| NT_FILE_SHARE_WRITE
				| NT_FILE_SHARE_DELETE)))
		if (ntux_errno_set(dctx,EACCES))
			return ntux_cmd_aceit_ret(
				fd,ofd,0,
				NTUX_SYSTEM_ERROR(dctx));
 
	/* srcsd */
	srcsd = (nt_sd *)buf;
 
	if ((status = __xfi_query_security_object(
			hasync,
			NT_OWNER_SECURITY_INFORMATION
				| NT_GROUP_SECURITY_INFORMATION
				| NT_DACL_SECURITY_INFORMATION,
			srcsd,sizeof(buf),&size)))
		if (ntux_errno_set(dctx,ENXIO))
			return ntux_cmd_aceit_ret(
				fd,ofd,hasync,
				NTUX_SYSTEM_ERROR(dctx));
 
	/* dump */
	if (dctx->cctx->drvflags & NTUX_DRIVER_DUMP)
		if ((ntux_cmd_aceit_dump(dunit,srcsd,fdout)))
			return ntux_cmd_aceit_ret(
				fd,ofd,hasync,
				NTUX_SYSTEM_ERROR(dctx));
 
	/* all done */
	return ntux_cmd_aceit_ret(fd,ofd,hasync,0);
}