/*
 *  IPC.C
 *
 *  Handle IPC messages
 *
 *  NOTE:   Only an explicit disconnect command will drop DTR, or when
 *	    the serial.device is closed.
 */

static int dummy;

#ifdef NOTDEF

#include "dnet.h"
#include <local/ipc.h>

#define IPCMDS struct _IPCMDS

void do_online(), do_offline(), do_stat(), do_quit(), do_disconnect();
void do_state();
void do_recvon(), do_recvoff(), do_serialon(), do_serialoff();
void do_baud();
void do_getidle(), do_getconnect(), do_setidlealert(), do_setconnectalert();
void do_lessconnect(), do_resetconnect(), do_resetidle();

IPCMDS {
    short args;
    char *name;
    void (*func)();
};

IPCMDS IPCmds[] = {
    0, "online" , do_online,
    0, "offline", do_offline,
    0, "stat", do_stat,
    0, "quit", do_quit,
    0, "disconnect", do_disconnect,
    0, "state", do_state,
    0, "recvon", do_recvon,
    0, "recvoff", do_recvoff,
    0, "serialon", do_serialon,
    0, "serialoff", do_serialoff,
    1, "baud", do_baud,

    0, "getidle", do_getidle,
    0, "getconn", do_getconnect,
    2, "setidlealert", do_setidlealert,
    2, "setconnalert", do_setconnectalert,
    1, "lessconn", do_lessconnect,
    0, "resetconn", do_resetconnect,
    0, "resetidle", do_resetidle
};

handle_ipc()
{
    IPCMSG *msg;
    char *ptr;

    while (msg = GetMsg(IPCPort)) {
	long error = IF_ERROR;
	char **av = NULL;
	short ac = 0;
	short i;
	char *buf = NULL;
	long len = 0;

	if (ptr = (char *)msg->TBuf) {
	    short networknum = atoi(ptr);
	    if (networknum == NetworkNum) {
		while (*ptr++);
		ac = ParseCmd(ptr, &av, NULL, NULL, &error, NULL);
	    } else {
		error = IF_NOTFND;
	    }
	}
	for (i = 0; i < ac;) {
	    IPCMDS *cmds;

	    for (cmds = IPCmds; cmds != ARYEND(IPCmds); ++cmds) {
		if (strcmp(av[i], cmds->name) == 0)
		    break;
	    }
	    if (cmds == ARYEND(IPCmds)) {
		error = IF_ERROR;
		break;
	    }
	    if (i + cmds->args >= ac) {
		error = IF_ERROR;
		break;
	    }
	    error = 0;
	    (*cmds->func)(av + i, &buf, &len);
	    i += cmds->args + 1;
	}
	if (av)
	    FreeParseCmd(av);
	ReplyIPC(msg, buf, len, error);
    }
}

void
do_online()
{
    OnLine = 1;
}

void
do_offline()
{
    OnLine = 0;     /*	Take DNet off line  */
}

void
do_disconnect()
{
    OnLine = 0;     /*	Take DNet off line  */
    DropDTR();      /*  and (temp) drop DTR */
}

void
do_quit()
{
    Quit = 1;	    /*	Quit out of dnet    */
}

void
do_stat(av, pbuf, plen)
char **pbuf;
long *plen;
{
    char buf[256];
    char *ptr = buf;

    sprintf(ptr, "         Bytes  Packets   Errors\n");
    ptr += strlen(ptr);
    sprintf(ptr, "OUT:  %8ld %8ld %8ld\n", BytesOut, PacketsOut, PacketsResent);
    ptr += strlen(ptr);
    sprintf(ptr, "IN :  %8ld %8ld %8ld\n", BytesIn, PacketsIn, PacketsNakd);
    ptr += strlen(ptr);
    sprintf(ptr, "Garbage Bytes In: %ld\n", GarbageIn);
    ptr += strlen(ptr);
    if (ptr - buf > sizeof(buf))
	dneterror("do_stat: buffer overrun");
    AllocAppend(pbuf, plen, buf, strlen(buf)+1);
}

/*
 *  Return machine state (ascii)
 *
 *  s iiii:ii oooo:oo	    (s = 0/1 1=protrunning
 *			     i = idle time hrs:min
 *			     o = online time hrs:min
 */

void
do_state()
{

}

AllocAppend(pbuf, plen, buf, len)
char **pbuf;
long *plen;
char *buf;
long len;
{
    char *new;
    if (*pbuf) {
	new = malloc(*plen + len);
	BMov(*pbuf, new, *plen);
	free(*pbuf);
	*pbuf = new;
	new += *plen;
    } else {
	*pbuf = new = malloc(len);
    }
    BMov(buf, new, len);
    *plen += len;
}

void
do_recvon()
{
    NetRecvOn();
}

void
do_recvoff()
{
    NetRecvOff();
}

void
do_serialon()
{
    NetSerialOn();
}

void
do_serialoff()
{
    NetSerialOff();
}

void
do_baud(av)
char **av;
{
    long baud = atoi(av[1]);
    if (baud) {
	Baud = baud;
	SetBaudRate(baud);
    }
}

void
do_getidle(av, pbuf, plen)
char **av;
char **pbuf;
long *plen;
{
    char buf[32];
    sprintf(buf, "%ld", GetIdle());
    AllocAppend(pbuf, plen, buf, strlen(buf)+1);
}

void
do_getconnect(av, pbuf, plen)
char **av;
char **pbuf;
long *plen;
{
    char buf[32];
    sprintf(buf, "%ld", GetConnect());
    AllocAppend(pbuf, plen, buf, strlen(buf)+1);
}

void
do_setidlealert(av)
char **av;
{
    SetIdleAlert(atoi(av[1]), av[2]);
}

void
do_setconnectalert(av)
char **av;
{
    SetConnectAlert(atoi(av[1]), av[2]);
}

void
do_lessconnect(av)
char **av;
{
    LessConnect(atoi(av[1]));
}

void
do_resetconnect()
{
    ResetConnect();
}

void
do_resetidle()
{
    ResetIdle();
}

#endif