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

/*  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/nt_tty.h>

#include <toksvc/toksvc.h>

#include "toksvc_driver_impl.h"

#include "toksvc_daemon_impl.h"

#include "toksvc_log_impl.h"

#define  TOKS_OPCODE_STR(IDX) [TOKS_DAEMON_ ## IDX - TOKS_DAEMON_OPCODE_BASE]

static const char toks_error_str[]      = "#ERROR";

static const char toks_unknown_str[]    = "#UNKNOWN_OPCODE";

static const char toks_internal_msg[]   = "internal LPC message";

static const char toks_external_msg[]   = "external LPC message";

static const char * toks_opcode_str[]   = {

	TOKS_OPCODE_STR(CONNECT)        = "TOKS_DAEMON_CONNECT",

	TOKS_OPCODE_STR(DISCONNECT)     = "TOKS_DAEMON_DISCONNECT",

	TOKS_OPCODE_STR(TTYSIGNAL)      = "TOKS_DAEMON_TTYSIGNAL",

	TOKS_OPCODE_STR(IPCSIGNAL)      = "TOKS_DAEMON_IPCSIGNAL",

	TOKS_OPCODE_STR(SIGCHLD)        = "TOKS_DAEMON_SIGCHLD",

	TOKS_OPCODE_STR(THREADEXIT)     = "TOKS_DAEMON_THREADEXIT",

	TOKS_OPCODE_STR(CIDQUERY)       = "TOKS_DAEMON_CIDQUERY",

	TOKS_OPCODE_STR(ACQUIRE)        = "TOKS_DAEMON_ACQUIRE",

	TOKS_OPCODE_STR(RELEASE)        = "TOKS_DAEMON_RELEASE",

	TOKS_OPCODE_STR(CANCEL)         = "TOKS_DAEMON_CANCEL",

	TOKS_OPCODE_STR(ABORT)          = "TOKS_DAEMON_ABORT",

	TOKS_OPCODE_STR(IOCTL)          = "TOKS_DAEMON_IOCTL",

};

static const char * toks_lpc_msg_str[]  = {

	[NT_LPC_NEW_MESSAGE]            = "NT_LPC_NEW_MESSAGE",

	[NT_LPC_REQUEST]                = "NT_LPC_REQUEST",

	[NT_LPC_REPLY]                  = "NT_LPC_REPLY",

	[NT_LPC_DATAGRAM]               = "NT_LPC_DATAGRAM",

	[NT_LPC_LOST_REPLY]             = "NT_LPC_LOST_REPLY",

	[NT_LPC_PORT_CLOSED]            = "NT_LPC_PORT_CLOSED",

	[NT_LPC_CLIENT_DIED]            = "NT_LPC_CLIENT_DIED",

	[NT_LPC_EXCEPTION]              = "NT_LPC_EXCEPTION",

	[NT_LPC_DEBUG_EVENT]            = "NT_LPC_DEBUG_EVENT",

	[NT_LPC_ERROR_EVENT]            = "NT_LPC_ERROR_EVENT",

	[NT_LPC_CONNECTION_REQUEST]     = "NT_LPC_CONNECTION_REQUEST",

};

static const char * toks_alpc_msg_str[] = {

	[NT_ALPC_REQUEST ^ 0x2000]            = "NT_ALPC_REQUEST",

	[NT_ALPC_CONNECTION_REQUEST ^ 0x2000] = "NT_ALPC_CONNECTION_REQUEST",

};

static const char * toks_lpc_msg_type_desc(unsigned msgtype)

{

	if (msgtype <= NT_LPC_CONNECTION_REQUEST)

		return toks_lpc_msg_str[msgtype];

	else if (msgtype == NT_ALPC_REQUEST)

		return toks_alpc_msg_str[msgtype ^ 0x2000];

	else if (msgtype == NT_ALPC_CONNECTION_REQUEST)

		return toks_alpc_msg_str[msgtype ^ 0x2000];

	else

		return toks_error_str;

}

static const char * toks_lpc_msg_source_desc(uintptr_t syspid)

{

	return (syspid == pe_get_current_process_id())

		? toks_internal_msg

		: toks_external_msg;

}

static const char * toks_lpc_opcode_desc(struct toks_daemon_ctx * dctx)

{

	if ((dctx->opcode >= TOKS_DAEMON_OPCODE_BASE)

			&& (dctx->opcode < TOKS_DAEMON_OPCODE_CAP))

		return toks_opcode_str[dctx->opcode-TOKS_DAEMON_OPCODE_BASE];

	return toks_unknown_str;

}

static void toks_log_lpc_request_desc(

	struct toks_daemon_ctx * dctx,

	const nt_tty_port_msg *  msg,

	char *                   desc)

{

	char * ch = desc;

	ch += ntapi->sprintf(

		ch,

		" ::: REQUEST INFO ::: "

		"opcode=%s, "

		"opdata=%u (0x%08x)",

		toks_lpc_opcode_desc(dctx),

		msg->ttyinfo.opdata,

		msg->ttyinfo.opdata);

	if (dctx->opcode == TOKS_DAEMON_ACQUIRE)

		if (msg->syncinfo.ipcsvc.keys.reserved)

			ch += ntapi->sprintf(

				ch,

				" (tokpid=%d)",

				msg->syncinfo.ipcsvc.keys.reserved);

	if (msg->syncinfo.ipcsvc.keys.key[0])

		ch += ntapi->sprintf(

			ch,", refstr=``%s''",

			(const char *)msg->syncinfo.ipcsvc.keys.key);

}

static void toks_log_lpc_reply_desc(

	struct toks_daemon_ctx * dctx,

	const nt_tty_port_msg *  msg,

	char *                   desc)

{

	char *                ch;

	unsigned char *       uch;

	const unsigned int  * keys;

	ch = desc;

	ch += ntapi->sprintf(

		ch,

		" ::: REPLY INFO ::: "

		"status=0x%08x",

		msg->ttyinfo.status);

	switch (dctx->opcode) {

		case TOKS_DAEMON_ACQUIRE:

			keys = (msg->ttyinfo.status == NT_STATUS_SUCCESS)

				? msg->syncinfo.ipckeys : 0;

			break;

		case TOKS_DAEMON_RELEASE:

			keys = msg->syncinfo.ipckeys;

			break;

		default:

			keys = 0;

	}

	if (keys) {

		ch += ntapi->sprintf(ch,", token=[");

		uch = (unsigned char *)ch;

		uch[8]  = '-';

		uch[17] = '-';

		uch[26] = '-';

		uch[35] = '-';

		uch[44] = '-';

		ntapi->tt_uint32_to_hex_utf8(keys[0],&uch[0]);

		ntapi->tt_uint32_to_hex_utf8(keys[1],&uch[9]);

		ntapi->tt_uint32_to_hex_utf8(keys[2],&uch[18]);

		ntapi->tt_uint32_to_hex_utf8(keys[3],&uch[27]);

		ntapi->tt_uint32_to_hex_utf8(keys[4],&uch[36]);

		ntapi->tt_uint32_to_hex_utf8(keys[5],&uch[45]);

		ch += 6*8 + 5;

		*ch++ = ']';

		*ch   = 0;

	}

	if (dctx->opcode == TOKS_DAEMON_ACQUIRE) {

		if (msg->ttyinfo.status == NT_STATUS_SUCCESS) {

			(void)0;

		} else if (msg->ttyinfo.status == NT_STATUS_PENDING) {

			ch += ntapi->sprintf(ch," (pending, queued)");

		} else if (msg->ttyinfo.status == NT_STATUS_TIMEOUT) {

			if (!dctx->request.syncinfo.hevent)

				ch += ntapi->sprintf(ch," (timeout=0, not queued)");

			else

				ch += ntapi->sprintf(ch," (timeout, internal error)");

		} else {

			ch += ntapi->sprintf(ch," (error, not queued)");

		}

	}

}

void toks_log_lpc_request(

	struct toks_daemon_ctx * dctx,

	const nt_tty_port_msg *  msg)

{

	struct toks_driver_ctx * drvctx = dctx->driver_ctx;

	TOKS_LOG_LEVEL(drvctx,2);

	nt_cid cid;

	char   path[2048];

	char   desc[1024];

	cid.process_id = msg->header.client_id.process_id;

	cid.thread_id  = msg->header.client_id.thread_id;

	toks_log_get_arbitrary_process_name(

		&cid,path,sizeof(path));

	switch (msg->header.msg_type) {

		case NT_LPC_REQUEST:

			toks_log_lpc_request_desc(

				dctx,msg,desc);

			break;

		default:

			desc[0] = 0;

	}

	toks_log_header(

		drvctx,

		TOKS_LOG_ENTRY_SERVER_INFO,

		"%s from %s (syspid %d, systid %d), "

		"data_size=%u, msg_size=%u, "

		"msg_type=%u (%s), msg_id=%u%s\n",

		toks_lpc_msg_source_desc(msg->header.client_id.process_id),

		toks_log_basename(path),

		cid.process_id,

		cid.thread_id,

		msg->header.data_size,

		msg->header.msg_size,

		msg->header.msg_type,

		toks_lpc_msg_type_desc(msg->header.msg_type),

		msg->header.msg_id,

		desc);

	if (cid.process_id)

		toks_log_write(

			drvctx,

			TOKS_LOG_ENTRY_SUB_LEVEL_2,

			"%s.\n",path);

}

static void toks_log_lpc_reply_impl(

	struct toks_daemon_ctx * dctx,

	const nt_tty_port_msg *  msg)

{

	struct toks_driver_ctx * drvctx = dctx->driver_ctx;

	TOKS_LOG_LEVEL(drvctx,2);

	nt_cid cid;

	char   desc[1024];

	cid.process_id = msg->header.client_id.process_id;

	cid.thread_id  = msg->header.client_id.thread_id;

	switch (dctx->request.header.msg_type) {

		case NT_LPC_REQUEST:

			toks_log_lpc_reply_desc(

				dctx,msg,desc);

			break;

		default:

			desc[0] = 0;

	}

	toks_log_header(

		drvctx,

		TOKS_LOG_ENTRY_SERVER_INFO,

		"%s (syspid %d, systid %d), "

		"data_size=%u, msg_size=%u, "

		"msg_type=%u (%s), msg_id=%u%s\n",

		toks_lpc_msg_source_desc(msg->header.client_id.process_id),

		cid.process_id,

		cid.thread_id,

		msg->header.data_size,

		msg->header.msg_size,

		msg->header.msg_type,

		toks_lpc_msg_type_desc(msg->header.msg_type),

		msg->header.msg_id,

		desc);

}

void toks_log_lpc_reply(

	struct toks_daemon_ctx * dctx,

	const nt_tty_port_msg *  msg)

{

	struct toks_driver_ctx * drvctx = dctx->driver_ctx;

	int                      opdata = msg->ttyinfo.opdata;

	TOKS_LOG_LEVEL(drvctx,1);

	toks_log_lpc_reply_impl(dctx,msg);

	if (dctx->opcode == TOKS_DAEMON_IOCTL) {

		if (opdata == TOKS_IOCTL_SET_TOKEN_COUNT)

			toks_log_service_info(dctx);

	}

}