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

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

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

static char toks_service_image[] = "/bin/toksvc";

static int32_t toks_spawn_child_exit_code(void * hprocess)
{
	nt_process_basic_information pbi;

	if (ntapi->zw_query_information_process(
			hprocess,
			NT_PROCESS_BASIC_INFORMATION,
			&pbi,sizeof(pbi),
			&(uint32_t){0}))
		return NT_STATUS_GENERIC_COMMAND_FAILED;

	return pbi.exit_status;
}

static int toks_spawn_impl(
	struct toks_driver_ctx *        dctx,
	struct toks_common_ctx *        cctx,
	int                             ntokens,
	int32_t                         ctrlpid,
	int32_t                         csyspid)
{
	int32_t				status;
	nt_spawn_process_params		sparams;
	nt_runtime_data			rtctx;
	nt_rtdata *			self;
	char *				img;
	void *				hroot;
	void *				hlog;
	const char *			logfile;
	char **				pearg;
	char *				eargv[10];
	char				tokbuf[32];
	char				pidbuf[32];

	/* init */
	self = toks_get_driver_rtdata(dctx);
	img  = toks_service_image;

	if (!(hroot = cctx->hroot) && cctx->sysroot)
		if ((status = toks_open_dir(&hroot,0,cctx->sysroot,false)))
			return status;

	if (hroot && (img[0] == '/'))
		img++;

	logfile = cctx->logfile;

	if (hroot && logfile && (logfile[0] == '/'))
		logfile++;

	if (logfile && (status = toks_open_log_file(&hlog,hroot,logfile,false)))
		return status;

	/* eargv */
	pearg    = eargv;
	*pearg++ = img;

	ntapi->sprintf(tokbuf,"%d",ntokens);
	*pearg++ = "-t";
	*pearg++ = tokbuf;

	if (ctrlpid) {
		ntapi->sprintf(pidbuf,"%d",ctrlpid);
		*pearg++ = "-p";
		*pearg++ = pidbuf;
	} else if (csyspid) {
		ntapi->sprintf(pidbuf,"%d",csyspid);
		*pearg++ = "-P";
		*pearg++ = pidbuf;
	}

	*pearg++ = 0;

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

	sparams.rtctx    = &rtctx;
	sparams.patharg  = img;
	sparams.argv     = eargv;
	sparams.envp     = self->envp;
	sparams.hroot    = hroot ? hroot : self->hroot;

	if ((status = toks_open_file(&sparams.himage,hroot,img,true)))
		return status;

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

	ntapi->tt_aligned_block_memcpy(
		(uintptr_t *)&rtctx.cid_parent,
		(uintptr_t *)&self->cid_self,
		sizeof(nt_cid));

	rtctx.hlog  = hlog;
	rtctx.hcwd  = self->hcwd;
	rtctx.hroot = sparams.hroot;
	rtctx.flags = self->flags | NT_RUNTIME_DATA_TTY_TOP_LEVEL;

	rtctx.dbg_level = 0;
	rtctx.log_level = self->log_level;

	rtctx.hstdin      = NT_INVALID_HANDLE_VALUE;
	rtctx.hstdout     = NT_INVALID_HANDLE_VALUE;
	rtctx.hstderr     = NT_INVALID_HANDLE_VALUE;

	rtctx.stdin_type  = NT_FILE_TYPE_UNKNOWN;
	rtctx.stdout_type = NT_FILE_TYPE_UNKNOWN;
	rtctx.stderr_type = NT_FILE_TYPE_UNKNOWN;

	/* hoppla */
	status = ntapi->tt_spawn_native_process(&sparams);

	if (sparams.himage)
		ntapi->zw_close(sparams.himage);

	if (status)
		return status;

	/* child ready? */
	if (!(sparams.eready.signal_state))
		status = toks_spawn_child_exit_code(sparams.hprocess);

	/* finalize */
	ntapi->zw_close(sparams.hprocess);
	ntapi->zw_close(sparams.hthread);

	/* all done */
	return status;
}

int32_t toks_service_start(
	struct toks_common_ctx *    cctx,
	int                         ntokens,
	int32_t                     ctrlpid,
	int32_t                     csyspid)
{
	int32_t                     status;
	struct toks_driver_ctx *    dctx;
	char *                      eargv[2];

	eargv[0] = "toksvc.driver";
	eargv[1] = 0;

	status = toks_get_driver_ctx(eargv,0,TOKS_DRIVER_VERSION,&dctx);

	if (status == NT_STATUS_SUCCESS) {
		status = toks_spawn_impl(dctx,cctx,ntokens,ctrlpid,csyspid);
		toks_free_driver_ctx(dctx);
	}

	return status;
}