ansh/src/daemon2.c - diff

Return to daemon2.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / ansh / src

Diff for /ansh/src/daemon2.c between versions 1.1 and 1.1.1.1.2.3

version 1.1, 2011/10/04 22:37:46	version 1.1.1.1.2.3, 2011/10/13 11:01:37
Line 15 pktTx(sched_task_t *task)	Line 15 pktTx(sched_task_t *task)
{	{
struct tagProc *proc;	struct tagProc *proc;
int wlen;	int wlen;
	u_char *str;

FTRACE(3);	FTRACE(3);

Line 22 pktTx(sched_task_t *task)	Line 23 pktTx(sched_task_t *task)
if (!(proc = TASK_ARG(task)))	if (!(proc = TASK_ARG(task)))
return (void*) -1;	return (void*) -1;

if ((wlen = pktSend(TASK_FD(task), proc->proc_id, proc->proc_flg, proc->proc_buf_[FD2NET],	if (Crypted) {
	str = cryptBuffer(proc->proc_buf_[FD2NET], proc->proc_rlen_[FD2NET], Crypted);
	if (str) {
	memcpy(proc->proc_buf_[FD2NET], str, proc->proc_rlen_[FD2NET]);
	free(str);
	}
	}

	if ((wlen = pktSend(TASK_FD(task), proc->proc_flg, Crypted, proc->proc_buf_[FD2NET],
proc->proc_rlen_[FD2NET], &proc->proc_ea)) != ANSH_FLG_ERR) {	proc->proc_rlen_[FD2NET], &proc->proc_ea)) != ANSH_FLG_ERR) {
proc->proc_flg = ANSH_FLG_OK;	proc->proc_flg = ANSH_FLG_OK;
proc->proc_rlen_[FD2NET] = 0;	proc->proc_rlen_[FD2NET] = 0;
Line 35 pktTx(sched_task_t *task)	Line 44 pktTx(sched_task_t *task)
void *	void *
pktRx(sched_task_t *task)	pktRx(sched_task_t *task)
{	{
u_char *buf;	u_char buf, str;
struct ether_header eth;	struct ether_header eth;
int rlen, n = 0;	int rlen, n = 0;
struct tagProc *proc = NULL;	struct tagProc *proc = NULL;
Line 48 pktRx(sched_task_t *task)	Line 57 pktRx(sched_task_t *task)
if (!(buf = malloc(rlen)))	if (!(buf = malloc(rlen)))
goto end;	goto end;

if ((ret = pktRecv(TASK_FD(task), buf, &rlen, &eth)) == ANSH_FLG_ERR)	if ((ret = pktRecv(TASK_FD(task), &Crypted, buf, &rlen, &eth)) == ANSH_FLG_ERR)
goto end;	goto end;
VERB(5) LOG("Received %d bytes", rlen);	VERB(5) LOG("Received %d bytes", rlen);
	if (!(ret & ANSH_FLG_CPOUT))
	goto end;

/* packet is ok find active session */	/* packet is ok find active session */
SLIST_FOREACH(proc, &pH, proc_next)	SLIST_FOREACH(proc, &pH, proc_next)
Line 59 pktRx(sched_task_t *task)	Line 70 pktRx(sched_task_t *task)
break;	break;
}	}
/* not found in sessions, drop packet */	/* not found in sessions, drop packet */
if (n != ANSH_CODE)	if (n != ANSH_CODE) {
	proc = NULL;
goto end;	goto end;
	}

	if (Crypted) {
	str = cryptBuffer(buf, rlen, Crypted);
	if (str) {
	memcpy(buf, str, rlen);
	free(str);
	}
	}

switch (ret) {	switch (ret) {
case ANSH_FLG_EOF:	case ANSH_FLG_EOF:
case ANSH_FLG_CPOUT:	case ANSH_FLG_CPOUT:
break;	break;
case ANSH_FLG_WINZ:	case ANSH_FLG_WINZ:
b = (u_short*) buf;	b = (u_short*) buf;
ioChgWinPTY(proc->proc_pty, ntohs(buf[0]), ntohs(buf[1]), ntohs(buf[2]), ntohs(buf[3]));	ioChgWinPTY(proc->proc_pty, ntohs(b[0]), ntohs(b[1]), ntohs(b[2]), ntohs(b[3]));
/* if not started login, lets start & go! */	/* if not started login, lets start & go! */
if (!proc->proc_pid) {	if (!proc->proc_pid) {
memcpy(&proc->proc_ea.octet, &eth.ether_shost, ETHER_ADDR_LEN);	memcpy(&proc->proc_ea.octet, &eth.ether_shost, ETHER_ADDR_LEN);
Line 93 void *	Line 114 void *
fdTx(sched_task_t *task)	fdTx(sched_task_t *task)
{	{
struct tagProc *proc;	struct tagProc *proc;
	struct timeval tv = { 0 };
int wlen;	int wlen;

FTRACE(3);	FTRACE(3);
Line 102 fdTx(sched_task_t *task)	Line 124 fdTx(sched_task_t *task)
return (void*) -1;	return (void*) -1;

/* if != ANSH_FLG_CPOUT isnt received from client */	/* if != ANSH_FLG_CPOUT isnt received from client */
if (proc->proc_flg != ANSH_FLG_CPOUT)	if (proc->proc_flg != ANSH_FLG_CPOUT \|\| !proc->proc_pid)
return NULL;	return NULL;

if (waitpid(proc->proc_pid, &wlen, WNOHANG)) {	if (waitpid(proc->proc_pid, &wlen, WNOHANG)) {
schedCancelby(TASK_ROOT(task), NULL, CRITERIA_FD, (void*) TASK_FD(task), NULL);
ioFreePTY(TASK_FD(task), proc->proc_ttyname);	ioFreePTY(TASK_FD(task), proc->proc_ttyname);
	schedCancelby(TASK_ROOT(task), NULL, CRITERIA_FD, (void*) TASK_FD(task), NULL);

proc->proc_pid = 0;	proc->proc_pid = 0;
proc->proc_flg = ANSH_FLG_EOF;	proc->proc_flg = ANSH_FLG_EOF;
proc->proc_rlen_[FD2NET] = 0;	proc->proc_rlen_[FD2NET] = 0;

schedWrite(TASK_ROOT(task), pktTx, proc, proc->proc_sock);	schedCallOnce(TASK_ROOT(task), pktTx, proc, proc->proc_sock);
return NULL;	return NULL;
}	}

	/* if Timeout defined, disarm timer */
	if (Timeout)
	schedCancelby(TASK_ROOT(task), &TASK_ROOT(task)->root_timer, CRITERIA_CALL, TOfunc, NULL);

wlen = write(TASK_FD(task), proc->proc_buf_[NET2FD], proc->proc_rlen_[NET2FD]);	wlen = write(TASK_FD(task), proc->proc_buf_[NET2FD], proc->proc_rlen_[NET2FD]);
switch (wlen) {	switch (wlen) {
case -1:	case -1:
ERR("write2tty #%d - %s", errno, strerror(errno));	ERR("write2tty #%d - %s", errno, strerror(errno));
/* exit from shell and release tty */	/* exit from shell and release tty */
schedCancelby(TASK_ROOT(task), NULL, CRITERIA_FD, (void*) TASK_FD(task), NULL);
waitpid(proc->proc_pid, &wlen, 0);	waitpid(proc->proc_pid, &wlen, 0);
ioFreePTY(TASK_FD(task), proc->proc_ttyname);	ioFreePTY(TASK_FD(task), proc->proc_ttyname);
	schedCancelby(TASK_ROOT(task), NULL, CRITERIA_FD, (void*) TASK_FD(task), NULL);

proc->proc_pid = 0;	proc->proc_pid = 0;
proc->proc_flg = ANSH_FLG_EOF;	proc->proc_flg = ANSH_FLG_EOF;
proc->proc_rlen_[FD2NET] = 0;	proc->proc_rlen_[FD2NET] = 0;

schedWrite(TASK_ROOT(task), pktTx, proc, proc->proc_sock);	schedCallOnce(TASK_ROOT(task), pktTx, proc, proc->proc_sock);
return NULL;	return NULL;
default:	default:
proc->proc_flg = ANSH_FLG_OK;	proc->proc_flg = ANSH_FLG_OK;
Line 138 fdTx(sched_task_t *task)	Line 164 fdTx(sched_task_t *task)
}	}
VERB(3) LOG("Writed %d bytes - %s", wlen, proc->proc_buf_[NET2FD]);	VERB(3) LOG("Writed %d bytes - %s", wlen, proc->proc_buf_[NET2FD]);

	/* if Timeout defined, go arm timer */
	if (Timeout) {
	tv.tv_sec = Timeout;
	schedTimer(TASK_ROOT(task), TOfunc, proc, tv);
	}
return NULL;	return NULL;
}	}

Line 145 void *	Line 176 void *
fdRx(sched_task_t *task)	fdRx(sched_task_t *task)
{	{
struct tagProc *proc;	struct tagProc *proc;
	struct timeval tv = { 0 };
int rlen;	int rlen;

FTRACE(3);	FTRACE(3);
Line 152 fdRx(sched_task_t *task)	Line 184 fdRx(sched_task_t *task)
/* not found argument, drop data */	/* not found argument, drop data */
if (!(proc = TASK_ARG(task)))	if (!(proc = TASK_ARG(task)))
return (void*) -1;	return (void*) -1;
	if (!proc->proc_pid)
	return NULL;

if (waitpid(proc->proc_pid, &rlen, WNOHANG)) {	if (waitpid(proc->proc_pid, &rlen, WNOHANG)) {
schedCancelby(TASK_ROOT(task), NULL, CRITERIA_FD, (void*) TASK_FD(task), NULL);
ioFreePTY(TASK_FD(task), proc->proc_ttyname);	ioFreePTY(TASK_FD(task), proc->proc_ttyname);
	schedCancelby(TASK_ROOT(task), NULL, CRITERIA_FD, (void*) TASK_FD(task), NULL);

proc->proc_pid = 0;	proc->proc_pid = 0;
proc->proc_flg = ANSH_FLG_EOF;	proc->proc_flg = ANSH_FLG_EOF;
proc->proc_rlen_[FD2NET] = 0;	proc->proc_rlen_[FD2NET] = 0;

schedWrite(TASK_ROOT(task), pktTx, proc, proc->proc_sock);	schedCallOnce(TASK_ROOT(task), pktTx, proc, proc->proc_sock);
return NULL;	return NULL;
}	}

	/* if Timeout defined, disarm timer */
	if (Timeout)
	schedCancelby(TASK_ROOT(task), &TASK_ROOT(task)->root_timer, CRITERIA_CALL, TOfunc, NULL);

memset(proc->proc_buf_[FD2NET], 0, proc->proc_blen);	memset(proc->proc_buf_[FD2NET], 0, proc->proc_blen);
rlen = read(TASK_FD(task), proc->proc_buf_[FD2NET], proc->proc_blen);	rlen = read(TASK_FD(task), proc->proc_buf_[FD2NET],
	proc->proc_blen - ETHER_HDR_LEN + sizeof(struct ansh_hdr));
switch (rlen) {	switch (rlen) {
case -1:	case -1:
ERR("readtty #%d - %s", errno, strerror(errno));	ERR("readtty #%d - %s", errno, strerror(errno));
case 0:	case 0:
/* exit from shell and release tty */	/* exit from shell and release tty */
schedCancelby(TASK_ROOT(task), NULL, CRITERIA_FD, (void*) TASK_FD(task), NULL);
waitpid(proc->proc_pid, &rlen, 0);	waitpid(proc->proc_pid, &rlen, 0);
VERB(3) LOG("EOF process status %d", rlen);
ioFreePTY(TASK_FD(task), proc->proc_ttyname);	ioFreePTY(TASK_FD(task), proc->proc_ttyname);
	schedCancelby(TASK_ROOT(task), NULL, CRITERIA_FD, (void*) TASK_FD(task), NULL);
	VERB(3) LOG("EOF process status %d", rlen);

proc->proc_pid = 0;	proc->proc_pid = 0;
proc->proc_flg = ANSH_FLG_EOF;	proc->proc_flg = ANSH_FLG_EOF;
proc->proc_rlen_[FD2NET] = 0;	proc->proc_rlen_[FD2NET] = 0;

schedWrite(TASK_ROOT(task), pktTx, proc, proc->proc_sock);	schedCallOnce(TASK_ROOT(task), pktTx, proc, proc->proc_sock);
return NULL;	return NULL;
default:	default:
proc->proc_flg = ANSH_FLG_OK;	proc->proc_flg = ANSH_FLG_OK;
Line 189 fdRx(sched_task_t *task)	Line 228 fdRx(sched_task_t *task)
}	}
VERB(3) LOG("Readed %d bytes - %s", rlen, proc->proc_buf_[FD2NET]);	VERB(3) LOG("Readed %d bytes - %s", rlen, proc->proc_buf_[FD2NET]);

schedWrite(TASK_ROOT(task), pktTx, proc, proc->proc_sock);	schedCallOnce(TASK_ROOT(task), pktTx, proc, proc->proc_sock);
schedRead(TASK_ROOT(task), fdRx, proc, proc->proc_pty);	schedRead(TASK_ROOT(task), fdRx, proc, proc->proc_pty);

	/* if Timeout defined, go arm timer */
	if (Timeout) {
	tv.tv_sec = Timeout;
	schedTimer(TASK_ROOT(task), TOfunc, proc, tv);
	}
return NULL;	return NULL;
}	}

int	int
spawnLogin(sched_task_t task, struct tagProc proc)	spawnLogin(sched_task_t task, struct tagProc proc)
{	{
	int flg;
	struct timeval tv = { 0 };
	char str[STRSIZ] = { 0 };

FTRACE(3);	FTRACE(3);

assert(proc);	assert(proc);
Line 207 spawnLogin(sched_task_t task, struct tagProc proc)	Line 256 spawnLogin(sched_task_t task, struct tagProc proc)
ERR("ioForkPTY() #%d - %s", io_GetErrno(), io_GetError());	ERR("ioForkPTY() #%d - %s", io_GetErrno(), io_GetError());
return -1;	return -1;
case 0:	case 0:
execl("/usr/bin/login", "login", NULL);	printf("anshd ELWIX remote management system (%s)\n\n", proc->proc_ttyname);
// execl("/bin/echo", "echo", "MUUUUUUUUUUUUUUUUU", NULL);	strlcpy(str, "-hansh@", sizeof str);
	ether_ntoa_r(&proc->proc_ea, str + 7);

	execl("/usr/bin/login", "login", str, NULL);
/* never reached */	/* never reached */
return -1;	return -1;
default:	default:
VERB(3) LOG("Parent know child pid %d - ptyfd=%d", proc->proc_pid, proc->proc_pty);	flg = fcntl(proc->proc_pty, F_GETFL);
	fcntl(proc->proc_pty, F_SETFL, flg \| O_NONBLOCK);

	VERB(3) LOG("Parent know child pid %d", proc->proc_pid);
schedRead(TASK_ROOT(task), fdRx, proc, proc->proc_pty);	schedRead(TASK_ROOT(task), fdRx, proc, proc->proc_pty);

	/* if Timeout defined, go arm timer */
	if (Timeout) {
	tv.tv_sec = Timeout;
	schedTimer(TASK_ROOT(task), TOfunc, proc, tv);
	}
break;	break;
}	}

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>

Removed from v.1.1
changed lines
	Added in v.1.1.1.1.2.3