/*
 * mini shell, pseudo terminal
 * refers to adb(android debug bridge)
 * author: clarkyy
 * date:   20160803
 * http://www.allwinnertech.com
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "mini_shell.h"

#ifndef TEMP_FAILURE_RETRY
#define TEMP_FAILURE_RETRY(exp) ({             \
	typeof (exp) _rc;                      \
	do {                                   \
		_rc = (exp);                   \
	} while (_rc == -1 && errno == EINTR); \
	_rc; })
#endif


#define MINI_SHELL_DEBUG_EN     0
#if MINI_SHELL_DEBUG_EN
char       g_dbg_buffer[1024];
#define D(format, ...) \
    sprintf(g_dbg_buffer, format, ##__VA_ARGS__); \
    mini_shell_stdout(g_dbg_buffer);
#else
#define D(format, ...)
#endif


typedef  pthread_t                 adb_thread_t;
typedef void*  (*adb_thread_func_t)( void*  arg );
typedef struct stinfo {
	void (*func)(int fd, void *cookie);
	int fd;
	void *cookie;
} stinfo;


static __inline__ void  close_on_exec(int  fd)
{
	fcntl( fd, F_SETFD, FD_CLOEXEC );
}

static int  unix_open(const char*  path, int options,...)
{
	if ((options & O_CREAT) == 0)
		return  TEMP_FAILURE_RETRY( open(path, options) );
	else {
		int      mode;
		va_list  args;
		va_start( args, options );
		mode = va_arg( args, int );
		va_end( args );
		return TEMP_FAILURE_RETRY( open( path, options, mode ) );
	}
}

int adb_open( const char*  pathname, int  options )
{
	int  fd = TEMP_FAILURE_RETRY( open( pathname, options ) );
	if (fd < 0)
		return -1;
	close_on_exec( fd );
	return fd;
}

int adb_read(int  fd, void*  buf, size_t  len)
{
    return TEMP_FAILURE_RETRY( read( fd, buf, len ) );
}

int adb_write(int  fd, const void*  buf, size_t  len)
{
	return TEMP_FAILURE_RETRY( write( fd, buf, len ) );
}

__inline__ int adb_close(int fd)
{
    return close(fd);
}

static void init_subproc_child()
{
	D("init_subproc_child\n");
	setsid();

	// Set OOM score adjustment to prevent killing
	int fd = adb_open("/proc/self/oom_score_adj", O_WRONLY | O_CLOEXEC);
	if (fd >= 0) {
		adb_write(fd, "0", 1);
		adb_close(fd);
	} else
		D("adb: unable to update oom_score_adj\n");
}

static void subproc_waiter_service(int fd, void *cookie)
{
	pid_t pid = (pid_t) (uintptr_t) cookie;

	D("entered. fd=%d of pid=%d\n", fd, pid);
	for (;;) {
		int status;
		pid_t p = waitpid(pid, &status, 0);
		if (p == pid) {
			D("fd=%d, post waitpid(pid=%d) status=%04x\n", fd, p, status);
			if (WIFSIGNALED(status)) {
				D("*** Killed by signal %d\n", WTERMSIG(status));
				break;
			} else if (!WIFEXITED(status)) {
				D("*** Didn't exit!!. status %d\n", status);
				break;
			} else if (WEXITSTATUS(status) >= 0) {
				D("*** Exit code %d\n", WEXITSTATUS(status));
				break;
			}
		}
	}
	D("shell exited fd=%d of pid=%d err=%d\n", fd, pid, errno);
	//if (SHELL_EXIT_NOTIFY_FD >=0) {
	//	int res;
	//	res = writex(SHELL_EXIT_NOTIFY_FD, &fd, sizeof(fd));
	//	D("notified shell exit via fd=%d for pid=%d res=%d errno=%d\n",
	//	SHELL_EXIT_NOTIFY_FD, pid, res, errno);
	//}
}

static int create_subproc_pty(const char *cmd, const char *arg0, const char *arg1, pid_t *pid)
{
	int ptm = 0, pts = 0;
		
	D("create_subproc_pty(cmd=%s, arg0=%s, arg1=%s)\n", cmd, arg0, arg1);

	ptm = unix_open("/dev/ptmx", O_RDWR | O_CLOEXEC); // | O_NOCTTY);
	if (ptm < 0) {
		D("[ cannot open /dev/ptmx - %s ]\n",strerror(errno));
		return -1;
	}
    D("%s: %d\n", __FUNCTION__, __LINE__);
	char devname[64];
	if (grantpt(ptm) || unlockpt(ptm) || ptsname_r(ptm, devname, sizeof(devname)) != 0) {
		D("[trouble with /dev/ptmx - %s ]\n", strerror(errno));
		adb_close(ptm);
		return -1;
	}
	D("devname: %s\n", devname);

	D("%s: %d\n", __FUNCTION__, __LINE__);

	*pid = fork();
	if (*pid < 0) {
		D("- fork failed: %s -\n", strerror(errno));
		adb_close(ptm);
		return -1;
	}

	D("%s: %d\n", __FUNCTION__, __LINE__);

	if (*pid == 0) {
		D("%s: %d\n", __FUNCTION__, __LINE__);
		init_subproc_child();

		D("%s: %d\n", __FUNCTION__, __LINE__);
		pts = unix_open(devname, O_RDWR | O_CLOEXEC);
		if (pts < 0) {
			adb_close(ptm);
			D("child failed to open pseudo-term slave: %s\n", devname);
			exit(-1);
		}

		D("%s: %d\n", __FUNCTION__, __LINE__);
		dup2(pts, STDIN_FILENO);
		dup2(pts, STDOUT_FILENO);
		dup2(pts, STDERR_FILENO);

		D("%s: %d\n", __FUNCTION__, __LINE__);
		adb_close(pts);
		adb_close(ptm);

		D("%s: %d\n", __FUNCTION__, __LINE__);
		execl(cmd, cmd, arg0, arg1, NULL);
		D("- exec '%s' failed: %s (%d) -\n",
			cmd, strerror(errno), errno);
		exit(-1);
	} else {
		return ptm;
	}
}

static void *service_bootstrap_func(void *x)
{
	stinfo *sti = x;
	D("%s: %d\n", __FUNCTION__, __LINE__);
	sti->func(sti->fd, sti->cookie);
	free(sti);
	return 0;
}

static int  adb_thread_create( adb_thread_t  *pthread, adb_thread_func_t  start, void*  arg )
{
	pthread_attr_t   attr;

	pthread_attr_init (&attr);
	pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);

	return pthread_create( pthread, &attr, start, arg );
}

#if 0
/*
 * compare current pts output to last pts output,
 * the real output saved in cur_output
 * returns length of cur_output, NOT includes '\0'
 */
static int calc_pts_output(const char *cur_output, const char *last_output)
{
	int cur_len = 0, last_len = 0;
	const char *cur_ptr = NULL, *last_ptr = NULL;
	
	if (cur_output && last_output) {
		cur_len = strlen(cur_output);
		last_len = strlen(last_output);
		
		if (cur_len > 0 && cur_len == last_len) {
			cur_ptr = cur_output + cur_len - 1;      // skip '\0'
			last_ptr = last_output + last_len - 1;   // skip '\0'
			while (cur_len-- > 0 && *cur_ptr-- == *last_ptr--);
			if (cur_len == 0) {
				cur_len = last_len;
			} else {
				cur_len++;
			}
		}
	}

	return cur_len;
}
#endif


// for pc, ADB_HOST = 1; for android, ADB_HOST = 0
#define ADB_HOST 1
#if ADB_HOST
#define SHELL_COMMAND "/bin/sh"
#else
#define SHELL_COMMAND "/system/bin/sh"
#endif
static int fd_log_file = -1;
static int fd_ptmx = -1;
static int stdin_copy = -1;
static int stdout_copy = -1;
static int stderr_copy = -1;
static char cmd_reply[1024] = { 0 };

int init_mini_shell(const char *log_file)
{
	stinfo *sti;
	adb_thread_t t;
	pid_t pid;

	//exit_mini_shell();

	stdin_copy = dup(STDIN_FILENO);
	stdout_copy = dup(STDOUT_FILENO);
	stderr_copy = dup(STDERR_FILENO);

	D("%s: %d %d %d\n", __FUNCTION__, stdin_copy, stdout_copy, stderr_copy);

	fd_ptmx = create_subproc_pty(SHELL_COMMAND, "-", NULL, &pid);
	if (fd_ptmx < 0) {
		D("cannot create subproc pty\n");
		return -1;
	}
	D("create_subprocess() ret_fd=%d pid=%d\n", fd_ptmx, pid);

	sti = malloc(sizeof(stinfo));
	if (sti == 0) {
		D("cannot allocate stinfo\n");
		return -1;
	}

	sti->func = subproc_waiter_service;
	sti->cookie = (void*)pid;
	sti->fd = fd_ptmx;

	if (adb_thread_create( &t, service_bootstrap_func, sti)) {
		free(sti);
		adb_close(fd_ptmx);
		D("cannot create service thread\n");
		return -1;
	}
	D("service thread started, fd=%d pid=%d\n", fd_ptmx, pid);

	if (log_file)
		fd_log_file = open(log_file, O_CREAT|O_APPEND|O_RDWR, 0777);
	adb_write(fd_log_file, "mini_shell init\n", strlen("mini_shell init\n")); 

	return 0;
}

void exit_mini_shell()
{
	D("%s: ready to exit\n", __FUNCTION__);
	if (fd_ptmx >= 0) {
		adb_write(fd_ptmx, "exit\n", strlen("exit\n"));
		usleep(500000);
		adb_close(fd_ptmx);
		fd_ptmx = -1;
	}

	if (fd_log_file >= 0) {
		adb_close(fd_log_file);
		fd_log_file = -1;
	}

	if (stdin_copy >= 0) {
		dup2(stdin_copy, STDIN_FILENO);
		stdin_copy = -1;
	}
	if (stdout_copy >= 0) {
		dup2(stdout_copy, STDOUT_FILENO);
		stdout_copy = -1;
	}
	if (stderr_copy >= 0) {
		dup2(stderr_copy, STDERR_FILENO);
		stderr_copy = -1;
	}
	D("%s: exits\n", __FUNCTION__);
}

int mini_shell_exec(const char *command, char *reply)
{
	if (fd_ptmx >= 0 && command) {
		adb_write(fd_ptmx, command, strlen(command));
		usleep(500000);  // wait for pts write

		memset(cmd_reply, 0, sizeof(cmd_reply));
		adb_read(fd_ptmx, cmd_reply, sizeof(cmd_reply));
		D("%s: %s\n", __FUNCTION__, cmd_reply);
		if (reply)
			strncpy(reply, cmd_reply, sizeof(cmd_reply));

		if (fd_log_file >= 0) {
			D("%s: %s\n", __FUNCTION__, reply);
			adb_write(fd_log_file, cmd_reply, sizeof(cmd_reply));
		}
		return 0;
	}

	return -1;
}

int mini_shell_stdin(char *inputs, int len)
{
	if (stdin_copy >= 0) {
		memset(inputs, 0, len);
		return adb_read(stdin_copy, inputs, len);
	}
	return -1;
}

int mini_shell_stdout(const char *outputs)
{
	if (stdout_copy >= 0)
		return adb_write(stdout_copy, outputs, strlen(outputs));
	printf(outputs);
	return -1;
}

int mini_shell_stderr(const char *error)
{
	if (stderr_copy >= 0)
		return adb_write(stderr_copy, error, strlen(error));
	printf(error);
	return -1;
}