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

/*  ntux: native translation und extension                 */

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

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

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

#include <ntapi/nt_termios.h>

#include <psxabi/sys_sysapi.h>

#include <psxabi/sys_fcntl.h>

#include <psxabi/sys_errno.h>

#include <psxabi/sys_process.h>

#include <psxxfi/xfi_framework.h>

#include <ntux/ntux.h>

#include "ntux_driver_impl.h"

#include "ntux_nolibc_impl.h"

#include "ntux_errinfo_impl.h"

int ntux_cmd_bridge(const struct ntux_driver_ctx * dctx)

{

	int		ret;

	int		val;

	pid_t		pid;

	int		argc;

	const char **	argv;

	const char **	envp;

	unsigned char * program;

	unsigned char * logfile;

	ssize_t		rbytes;

	ssize_t		wbytes;

	char *		ch;

	char *		script;

	char *		interp;

	const char *	usrscript;

	char **		sargv;

	const char **	pargv;

	const char **	aargv;

	char		buf[2048];

	int		fdlog[2];

	int32_t		status;

	struct ntux_fd_ctx fdctx;

	/* init */

	ntux_driver_set_ectx(

		dctx,0,

		dctx->cctx->sargv[0]);

	if (ntux_get_driver_fdctx(dctx,&fdctx) < 0)

			if (ntux_errno_set(dctx,fdlog[1]))

				return NTUX_SYSTEM_ERROR(dctx);

	if (dctx->cctx->interp) {

		ret = __xfi_framework_get_int32_slot_value(

			PSX_RTDATA_UDAT32_ARGV1_IS_OPTARG,

			&val;;

		if (ret < 0)

			if (ntux_errno_set(dctx,fdlog[1]))

				return NTUX_CUSTOM_ERROR(

					dctx,

					NTUX_ERR_FLOW_ERROR);

		for (sargv=dctx->cctx->sargv; *sargv; sargv++)

			(void)0;

		argc = sargv - dctx->cctx->sargv;

		if (!(aargv = ntux_calloc(argc + 3,sizeof(char *))))

			if (ntux_errno_set(dctx,fdlog[1]))

				return NTUX_SYSTEM_ERROR(dctx);

		if (!(script = ntux_calloc(1,NTUX_MAX_PATH)))

			if (ntux_errno_set(dctx,fdlog[1]))

				return NTUX_SYSTEM_ERROR(dctx);

		if (!(interp = ntux_calloc(1,NTUX_MAX_PATH)))

			if (ntux_errno_set(dctx,fdlog[1]))

				return NTUX_SYSTEM_ERROR(dctx);

		usrscript = val ? dctx->cctx->sargv[2] : dctx->cctx->sargv[1];

		if (__sys_fs_npath(fdctx.fdcwd,usrscript,0,script,NTUX_MAX_PATH) < 0)

			if (ntux_errno_set(dctx,fdlog[1]))

				return NTUX_SYSTEM_ERROR(dctx);

		if (__sys_fs_npath(fdctx.fdcwd,dctx->cctx->interp,0,interp,NTUX_MAX_PATH) < 0)

			if (ntux_errno_set(dctx,fdlog[1]))

				return NTUX_SYSTEM_ERROR(dctx);

		if (val) {

			aargv[0] = interp;

			aargv[1] = dctx->cctx->sargv[1];

			aargv[2] = script;

			sargv    = &dctx->cctx->sargv[3];

			pargv    = &aargv[3];

		} else {

			aargv[0] = interp;

			aargv[1] = script;

			sargv    = &dctx->cctx->sargv[2];

			pargv    = &aargv[2];

		}

		for (; *sargv; )

			*pargv++ = *sargv++;

		argv    = aargv;

		program = (unsigned char *)interp;

	} else {

		argv    = (const char **)dctx->cctx->sargv;

		program = (unsigned char *)dctx->cctx->sargv[0];

	}

	envp    = (const char **)dctx->cctx->senvp;

	logfile = (unsigned char *)dctx->cctx->logfile;

	/* fdlog */

	if (logfile) {

		if ((fdlog[1] = __sys_openat(

				ntux_driver_fdcwd(dctx),

				logfile,O_CREAT|O_TRUNC|O_WRONLY,0)) < 0)

			if (ntux_errno_set(dctx,fdlog[1]))

				return NTUX_SYSTEM_ERROR(dctx);

	} else {

		if ((ret = __sys_pipe(fdlog)) < 0)

			if (ntux_errno_set(dctx,ret))

				return NTUX_SYSTEM_ERROR(dctx);

	}

	/* spawn */

	pid = __sys_vfork();

	/* failed? */

	if (pid < 0)

		if (ntux_errno_set(dctx,pid))

			return NTUX_SYSTEM_ERROR(dctx);

	/* child */

	if (pid == 0)

		if ((status = __sys_execve(program,argv,envp)))

			if (ntux_errno_set(dctx,status))

				if (NTUX_SYSTEM_ERROR(dctx))

					__sys_exit(0);

	/* parent */

	__sys_close(fdlog[1]);

	if (dctx->cctx->logfile) {

		__sys_wait4(

			pid,&status,

			0,0);

		return 0;

	}

	/* piped bridge output */

	rbytes = __sys_read(fdlog[0],buf,sizeof(buf));

	while (rbytes == -EINTR)

		rbytes = __sys_read(fdlog[0],buf,sizeof(buf));

	while (rbytes > 0) {

		for (ch=buf; rbytes; ch += wbytes) {

			wbytes = __sys_write(2,ch,rbytes);

			while (wbytes == -EINTR)

				wbytes = __sys_write(2,buf,rbytes);

			if (wbytes < 0) {

				__sys_close(fdlog[0]);

				ntux_errno_set(dctx,wbytes);

				return NTUX_SYSTEM_ERROR(dctx);

			}

			rbytes -= wbytes;

		}

		rbytes = __sys_read(fdlog[0],buf,sizeof(buf));

		while (rbytes == -EINTR)

			rbytes = __sys_read(fdlog[0],buf,sizeof(buf));

	}

	__sys_close(fdlog[0]);

	if (rbytes < 0)

		if (ntux_errno_set(dctx,rbytes))

			return NTUX_SYSTEM_ERROR(dctx);

	/* wait */

	struct ntux_driver_ctx_impl * ictx = ntux_get_driver_ictx(dctx);

	__sys_wait4(

		pid,

		&ictx->cctx.status,

		0,0);

	return 0;

}