/*********************************************************/
/*  toksvc: a framework-native token broker service      */
/*  Copyright (C) 2020  SysDeer Technologies, LLC        */
/*  Released under GPLv2 and GPLv3; see COPYING.TOKSVC.  */
/*********************************************************/

#include <psxtypes/psxtypes.h>
#include <ntapi/ntapi.h>
#include <ntapi/nt_atomic.h>

#include <toksvc/toksvc.h>
#include "toksvc_daemon_impl.h"
#include "toksvc_driver_impl.h"

static int32_t toks_daemon_init_impl(
	struct toks_daemon_ctx *    dctx,
	const nt_guid *             svcguid,
	void *                      htty)
{
	int32_t				status;
	nt_daemon_params		dparams;
	wchar16_t *			port_name;
	nt_port_name_keys *		port_name_keys;
	void *				hsvclink;
	nt_sd_common_buffer		sd;

	/* daemon attributes */
	dctx->daemon_attr.type    = NT_PORT_TYPE_DAEMON;
	dctx->daemon_attr.subtype = NT_PORT_SUBTYPE_DEFAULT;

	/* port guid */
	ntapi->tt_guid_copy(
		&dctx->daemon_attr.guid,
		&(nt_guid)TOKS_PORT_GUID_DAEMON);

	/* port keys */
	if ((status = ntapi->tt_port_generate_keys(&dctx->daemon_attr.keys)))
		return status;

	/* port name */
	ntapi->tt_port_name_from_attr(
		&dctx->daemon_name,
		&dctx->daemon_attr);

	/* daemon sd */
	ntapi->acl_init_common_descriptor(
		&sd,0,0,0,0,
		NT_PORT_ALL_ACCESS | NT_SEC_STANDARD_RIGHTS_ALL,
		NT_PORT_CONNECT | NT_SEC_READ_CONTROL,
		NT_PORT_CONNECT | NT_SEC_READ_CONTROL,
		NT_PORT_ALL_ACCESS | NT_SEC_STANDARD_RIGHTS_ALL,
		NT_PORT_ALL_ACCESS | NT_SEC_STANDARD_RIGHTS_ALL,
		0);

	ntapi->tt_aligned_block_memlock(
		&sd,sizeof(sd));

	/* dparams */
	ntapi->tt_aligned_block_memset(
		&dparams,0,sizeof(dparams));

	port_name      = (wchar16_t *)&dctx->daemon_name;
	port_name_keys = (nt_port_name_keys *)&dctx->daemon_name.port_name_keys;

	dparams.port_keys	= &dctx->daemon_keys;
	dparams.port_name	= port_name;
	dparams.port_name_keys	= port_name_keys;
	dparams.port_sd		= &sd.sd;

	dparams.port_msg_size	= sizeof(nt_tty_port_msg);
	dparams.flags		= NT_DSR_INIT_DEFAULT;

	dparams.daemon_once_routine	= 0;
	dparams.daemon_loop_routine	= toks_daemon_loop;
	dparams.daemon_loop_context	= dctx;

	dparams.pport_daemon		= &dctx->hport_daemon;
	dparams.pport_internal_client	= &dctx->hport_internal_client;

	dparams.pevent_daemon_ready		= &dctx->hevent_daemon_ready;
	dparams.pevent_internal_client_ready	= &dctx->hevent_internal_client_ready;

	dparams.stack_size_commit		= 64 * 1024;
	dparams.stack_size_reserve		= 64 * 1024;

	if ((status = ntapi->dsr_init(&dparams)))
		return status;

	if ((status = ntapi->tt_create_dev_object_directory_entry(
			&hsvclink,
			NT_SYMBOLIC_LINK_ALL_ACCESS,
			toks_get_driver_hsvcdir(dctx->driver_ctx),
			dparams.hport_daemon,0,
			svcguid)))
		return status;

	toks_set_driver_hsvclink(
		dctx->driver_ctx,
		hsvclink);

	return (htty == 0)
		? NT_STATUS_SUCCESS
		: ntapi->tty_request_peer(
			htty,
			TOKS_DAEMON_TTYSIGNAL,
			0,&(nt_guid)TTY_PTS_GUID,
			&dctx->daemon_attr);
}

static int32_t toks_daemon_once = 0;

int32_t __stdcall toks_daemon_init(struct toks_daemon_ctx * dctx, const nt_guid * svcguid)
{
	int32_t			status;
	nt_timeout		timeout;
	nt_runtime_data *	rtdata;
	nt_filetime		pcnt;
	nt_guid			cliguid;
	uint32_t *		data;

	/* rtdata */
	if ((status = ntapi->tt_get_runtime_data(&rtdata,0)))
		return status;

	/* arbitrary client uuid */
	if (!svcguid) {
		toks_query_performance_counters(dctx->driver_ctx,&pcnt);

		svcguid = &cliguid;
		data    = &cliguid.data1;

		data[0] = ntapi->tt_buffer_crc32(
			(uint32_t)(uintptr_t)&cliguid,
			&pcnt,sizeof(pcnt));

		data[1] = ntapi->tt_buffer_crc32(
			(uint32_t)(uintptr_t)rtdata,
			rtdata,sizeof(*rtdata));

		data[2] = ntapi->tt_buffer_crc32(
			data[1],dctx,sizeof(*dctx));

		data[3] = ntapi->tt_buffer_crc32(
			data[2],dctx->driver_ctx,
			sizeof(*dctx->driver_ctx));
	}

	/* once */
	switch (at_locked_cas_32(&toks_daemon_once,0,1)) {
		case 0:
			if ((status = toks_daemon_init_impl(dctx,svcguid,rtdata->hsession))) {
				at_locked_add_32(&toks_daemon_once,2);
				return status;
			}

			at_locked_inc_32(&toks_daemon_once);
			return 0;

		case 1:
			timeout.quad = -10;

			for (; (at_locked_cas_32(&toks_daemon_once,0,1) == 1); )
				ntapi->zw_delay_execution(
					NT_SYNC_ALERTABLE,
					&timeout);

			return (toks_daemon_once == 2)
				? 0 : -1;

		case 2:
			return 0;

		case 3:
		default:
			return -1;
	}
}