/*************************************************************************
 *
 *  File: socket.c
 *
 *  These routines form a simple IPC mechanism to communicate between Verilog
 *  and C programs. This file is compiled in this directory with PLI defined
 *  for interfacing with the Verilog files and re-compiled in the 'src' 
 *  directory for interfacing with the C-based I/O test driver.
 *
 *
 */

#include <sys/types.h>
#include <sys/prctl.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <netdb.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#ifdef __sgi__
#include <bstring.h>
#else 
#include <netinet/in.h>	
#endif

#include "simipc.h"
#include "trace.h"

#ifdef PLI
#include "acc_user.h"
#include "vcsuser.h"

static s_setval_value value_s = { accIntVal };
static s_setval_delay delay_s = { { accRealTime, 0, 0, 0 }, accNoDelay };
#endif  /* PLI */


#ifndef PLI
#define	acc_initialize()
#define acc_configure(a, b)
#define acc_set_value(a, b, c)
#define	tf_putp(a,b)		return(b)
extern FILE *LogFp;
#else  /* !PLI */
unsigned long	Dflags = 0;
#ifndef __sgi__
FILE 		*LogFp;
#else
FILE 		*LogFp = stderr;
#endif
#endif  /* PLI */

char		IpcName[256];
static IpcPkt	pkt;

#ifndef __sgi__
    char *iosim_server=NULL;
    int iosim_port;
#endif

/*
 *  int IpcInit(char *name)
 */
#ifdef PLI
void
IpcInit(void)
{
	char	*name;
#else
int
IpcInit(char *name)
{
#endif

	acc_initialize();
	acc_configure(accDevelopmentVersion, "1.6");

#ifdef PLI
#ifndef __sgi__
	LogFp = stderr;
#endif
	if (tf_nump() != 1) {
		tf_error("illegal number of arguments: %d", tf_nump());
		tf_putp(0, -1);
	}
	name = (char *)tf_getcstringp(1);
#endif
	if ((name == NULL) || (strcmp(name, "NULL") == 0)) {
		sprintf(IpcName, DEFAULT_NAME_PATH, getenv("USER"));
	}
	else
		sprintf(IpcName, "/tmp/%s", name);

        fprintf(stderr, "IpcInit(iosim server): ipc_name=%s\n", IpcName)
		_TRACE(DALL, fprintf(LogFp, "IpcInit: ipc_name=%s\n", IpcName));
#ifndef __sgi__
        {    /* Setup Linux test environment */
             char *sport;
             iosim_server = getenv("IOSIM_SERVER");
             sport = getenv("IOSIM_PORT");
 
             if (iosim_server == NULL || sport == NULL) {
                 fprintf(stderr, "\n\nFatal error: please set environment variable: \n");
                 fprintf(stderr, "             IOSIM_SERVER and IOSIM_PORT\n\n\n");
                 tf_putp(0, -1);
                 exit(1);
             } 
             iosim_port = strtoul(sport, NULL, 0);
 
             fprintf(stderr, "IOSIM server=%s port=%d\n", iosim_server, iosim_port);
        }
#endif

	tf_putp(0, 0);

}  /* IpcInit */

int
IpcReceive(int fd, char *buf, int nbytes)
{    
	int nleft, nread;

	_TRACE(DREAD, fprintf(LogFp,
		"IpcReceive: fd=%d, buf=0x%08x, nbytes=%d\n", fd, buf, nbytes));

	bzero(buf, nbytes);
	nleft = nbytes;		
	while (nleft > 0) {
		nread = recv(fd, buf, nleft, 0);
		if (nread < 0) {
			_TRACE(DERROR, fprintf(LogFp,
				"IpcReceive: recv failed, errno=%d\n", errno));
			perror("recv failed: ");
			return(-1);
		}
#ifdef __sgi__
		if (nread == 0) {
			_TRACE(DERROR, fprintf(LogFp,
				"IpcReceive: nread == 0!\n"));
			break;
		}
#endif
		nleft -= nread;
		buf += nread;
	}


	_TRACE(DREAD, fprintf(LogFp, 
		"IpcReceive: return=%d, nbytes=%d, nleft=%d\n", nbytes - nleft,
		nbytes, nleft));

	return( (nleft > 0) ? -1 : 0);

}  /* IpcReceive */


int
IpcSend(int fd, char *buf, int nbytes)
{    
	int nleft, nwritten;
	int ret;

	_TRACE(DWRITE, fprintf(LogFp,"ipcWrite: fd=%d, buf=0x%08x, nbytes=%d\n",
		fd, buf, nbytes));

	nleft = nbytes;		
	while (nleft > 0) {
		nwritten = send(fd, buf, nleft, 0);
		if (nwritten <= 0) {
			_TRACE(DERROR, fprintf(LogFp,
				"IpcSend: send failed, errno=%d\n", errno));
			perror("send failed: ");
			return(-1);
		}
		nleft -= nwritten;
		buf += nwritten;
	}

	_TRACE(DWRITE, fprintf(LogFp, 
		"ipcWrite: return=%d, nbytes=%d, nleft=%d\n", nbytes - nleft,
		nbytes, nleft));

	return( (nleft > 0) ? -1 : 0);

}  /* IpcSend */


/*
 *  int IpcOpen(int type)
 */
#ifdef PLI
void
IpcOpen(void)
{
	int	type;
#else
int
IpcOpen(int type)
{
#endif

	int fd;
#ifdef __sgi__
	struct sockaddr_un addr;
#else 	
	struct sockaddr_in addr;
	int on;
#endif 

#ifdef PLI
	if (tf_nump() != 1) {
		tf_error("illegal number of arguments: %d", tf_nump());
		tf_putp(0, -1);
	}
	type = (int)tf_getp(1);
#endif

#ifdef __sgi__
	fd = socket(AF_UNIX, SOCK_STREAM, 0);
#else 
	fd = socket(AF_INET, SOCK_STREAM, 0);
#endif 
	if (fd < 0) {
		_TRACE(DERROR, fprintf(LogFp,
			"IpcOpen: socket failed, errno=%d\n", errno));
		perror("opening stream socket");
                tf_putp(0, -1);
	} 

	if (type == IPC_SERVER) {
#ifdef __sgi__
		/*
		 * Arrange to have ourselves die when parent dies
		 */
		 if (prctl(PR_TERMCHILD) == -1) {
			_TRACE(DERROR, fprintf(LogFp,
				"IpcOpen: prctl failed, errno=%d\n", errno));
			perror("prctl(PR_TERMCHILD)");
			tf_putp(0, -1);
		 }
#else
#endif
	
		/* 
	 	* Unlink UNIX socket streams path if exists 
	 	*/
		unlink(IpcName);
#ifndef __sgi__
        memset(&addr, 0, sizeof(addr));
        addr.sin_family = AF_INET;
        addr.sin_addr.s_addr = htonl(INADDR_ANY);
        addr.sin_port = htons(iosim_port);

	if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof on) < 0) {
            perror("SO_REUSEADDR stream socket");
            tf_putp(0, -1);
	}
        if (bind(fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
            _TRACE(DERROR, fprintf(LogFp,
                  "IpcOpen: bind failed, errno=%d\n", errno));
            perror("binding stream socket");
            tf_putp(0, -1);
			close(fd);
			fd = -1;
        }
#else
		strcpy(addr.sun_path, IpcName);
		addr.sun_family = AF_UNIX;

		/* Bind the name to the socket */
		if (bind(fd, (struct sockaddr *)&addr, 
			strlen(addr.sun_path) + sizeof(addr.sun_family)) < 0) {
			_TRACE(DERROR, fprintf(LogFp,
				"IpcOpen: bind failed, errno=%d\n", errno));
			perror("binding stream socket");
			tf_putp(0, -1);
		}
#endif

		/* Listen on the socket */
		if (listen(fd, 5) == -1) {
			_TRACE(DERROR, fprintf(LogFp,
				"IpcOpen: listen failed, errno=%d\n", errno));
			perror("listening on stream socket");
			tf_putp(0, -1);
		}
	}

	tf_putp(0, fd);

}  /* IpcOpen */


/*
 *  int IpcAccept(int fd)
 */
#ifdef PLI
void
IpcAccept(void)
{
	int fd;
#else
int
IpcAccept(int fd)
{
#endif
	int  newfd;
#ifdef __sgi__
	struct sockaddr_un from;
#else
	struct sockaddr_in from;
#endif
	int fromlen = sizeof (from);

#ifdef PLI
	if (tf_nump() != 1) {
		tf_error("illegal number of arguments: %d", tf_nump());
		tf_putp(0, -1);
	}
	fd = (int)tf_getp(1);
#endif

	newfd = accept(fd, (struct sockaddr *)&from, &fromlen);
	if (newfd < 0) {
		_TRACE(DERROR, fprintf(LogFp,
			"IpcAccept: accept failed, errno=%d\n", errno));
		/*
		perror("accepting stream socket");
		*/
                tf_putp(0, -1);
	} 
	else {
                tf_putp(0, newfd);
	}

}  /* IpcAccept */


/*
 *  int IpcConnect(int fd)
 */
#ifdef PLI
void
IpcConnect(void)
{
	int fd;
#else
int
IpcConnect(int fd)
{
#endif
#ifdef __sgi__
	struct sockaddr_un	addr;
#else
	struct sockaddr_in	addr;
#endif
	int			addrlen = sizeof (addr);

#ifdef PLI
	if (tf_nump() != 1) {
		tf_error("illegal number of arguments: %d", tf_nump());
		tf_putp(0, -1);
	}
	fd = (int)tf_getp(1);
#endif

#ifndef __sgi__
    memset(&addr, 0, sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = inet_addr(iosim_server);
    addr.sin_port = htons(iosim_port);
#else
    strcpy(addr.sun_path, IpcName);
	addr.sun_family = AF_UNIX;
#endif

	if (connect(fd, (struct sockaddr *)&addr, addrlen) < 0) {
		_TRACE(DERROR, fprintf(LogFp,
			"IpcConnect: connect failed, errno=%d\n", errno));
		/*
		perror("connecting stream socket");
		*/
        tf_putp(0, -1);
	} 
	else {
        tf_putp(0, 0);
	}

}  /* IpcConnect */


/*
 *  int IpcClose(int fd)
 */
#ifdef PLI
void
IpcClose(void)
{
	int fd;
#else
int
IpcClose(int fd)
{
#endif
#ifdef PLI
	if (tf_nump() != 1) {
		tf_error("illegal number of arguments: %d", tf_nump());
		tf_putp(0, -1);
	}
	fd = (int)tf_getp(1);
#endif

	close(fd);

	tf_putp(0, 0);

}  /* IpcClose */

#ifdef PLI
/* 
 * int IpcReceivePli(int fd, int *code, int *size, int *address,
 * 			int *data0, int *data1, int *data2, int *data3,
 * 			int *data4, int *data5, int *data6, int *data7)
 */

void
IpcReceivePli(void)
{
	int fd, i, combine_word, code;
	unsigned int buf[20];
	handle	hcode, hsize, haddr, hdata[8], hmsg;
	s_acc_vecval tmp;
	char *str;
  
    tf_putp(0, 0);	

	if (tf_nump() != 13) {
		tf_error("illegal number of arguments: %d", tf_nump());
		tf_putp(0, -1);
	}
	fd   = (int)tf_getp(1);

	hcode = acc_handle_tfarg(2);
	hsize = acc_handle_tfarg(3);
	haddr = acc_handle_tfarg(4);
    for (i=0; i<8; i++)
		hdata[i] = acc_handle_tfarg(5+i);
	hmsg = acc_handle_tfarg(13);

	if (IpcReceive(fd, (char *)buf, sizeof(IpcPkt)) < 0) {
		tf_error("IpcReceivePli: IpcReceive failed");
                tf_putp(0, -1);
	} 
	else {
		code = ntohl((int)buf[PKT_CODE_OFS]);
		value_s.value.integer = code;
        acc_set_value(hcode, &value_s, &delay_s);

        value_s.value.integer = ntohl((int)buf[PKT_SIZE_OFS]);
        acc_set_value(hsize, &value_s, &delay_s);

        value_s.value.integer = ntohl((int)buf[PKT_ADDR_OFS]);
        acc_set_value(haddr, &value_s, &delay_s);

		if (code != BD_REQ_DISPLAY_MSG) {
	        combine_word = (code & BCP_COMBINE_XZ)?BCP_COMBINE_WORD(code):0;

	        value_s.format = accVectorVal;
    	    for (i=0; i<combine_word; i++) {
        		tmp.aval = ntohl((int)buf[PKT_DATA_OFS+i]);      
				tmp.bval = ntohl((int)buf[PKT_DATA_OFS+8+i]);
				value_s.value.vector = &tmp;
				acc_set_value(hdata[i], &value_s, &delay_s);
       		}
			
        	value_s.format = accIntVal;
        	for (i=combine_word; i<8; i++) {
				value_s.value.integer =  ntohl((int)buf[PKT_DATA_OFS+i]);
				acc_set_value(hdata[i], &value_s, &delay_s);
        	}
	    } else {
        	value_s.format = accStringVal;
			str = (char *)(buf+PKT_DATA_OFS);
			value_s.value.str = str;
			acc_set_value(hmsg, &value_s, &delay_s);
        	value_s.format = accIntVal;
        }

		tf_putp(0, 0);
	}

}  /* IpcReceivePli */

/* 
 * int IpcSendPli(int fd, int code, int size, int address,
 * 			int data0, int data1, int data2, int data3,
 * 			int data4, int data5, int data6, int data7,
 * 			int xz0, int xz1, int xz2, int xz3,
 * 			int xz4, int xz5, int xz6, int xz7,
 */

void
IpcSendPli(void)
{

#define MSG_1 "\t\tdata:0x%08x, 0x%08x, 0x%08x, 0x%08x, \
0x%08x, 0x%08x, 0x%08x, 0x%08x\n"

	int	    fd, split_word, i, code;
	IpcPkt	pkt;
	int	    ret;
    handle  hdata[8];
	unsigned char    *buf;
    double  mm;
	s_acc_value v;
	s_acc_vecval tmp;

	if (tf_nump() != 12) {
		tf_error("illegal number of arguments: %d", tf_nump());
		tf_putp(0, -1);
	}

	bzero(&pkt, sizeof(IpcPkt));
	pkt.length = sizeof(IpcPkt);

	fd	    = (int)tf_getp(1);
    code    = (int)tf_getp(2);
	pkt.code    = htonl(BCP_DEL_SPLIT(code));
    pkt.size    = htonl((int)tf_getp(3));
    pkt.address = htonl((int)tf_getp(4));

    split_word = (code & BCP_SPLIT_XZ)?BCP_SPLIT_WORD(code):0;
	
	v.value.vector = &tmp;
	v.format = accVectorVal;
    for (i=0; i<split_word; i++) {
		hdata[i] = acc_handle_tfarg(5+i);
    	acc_fetch_value(hdata[i], "%%", &v);
		pkt.data[i] = htonl(v.value.vector->aval);
        pkt.data[i+8] = htonl(v.value.vector->bval);     
    }

    for (i=split_word; i<8; i++)
    	pkt.data[i] = htonl((int)tf_getp(5+i));

	_TRACE(DWRITE, fprintf(LogFp, "IpcSendPli: fd=%d, len=%d\n", 
		fd, pkt.length));
	_TRACE(DWRITE, fprintf(LogFp, 
		"IpcSendPli: pkt: code=%d, size=%d, addr=0x%08x\n", 
		pkt.code, pkt.size, pkt.address));
	_TRACE(DWRITE, fprintf(LogFp, MSG_1, 
		pkt.data[0], pkt.data[1], pkt.data[2], pkt.data[3],
		pkt.data[4], pkt.data[5], pkt.data[6], pkt.data[7]));

	ret = IpcSend(fd, (char *)&pkt, sizeof(IpcPkt));

	if (ret < 0)
		tf_error("IpcSendPli: IpcSend failed");

	tf_putp(0, ret);

}  /* IpcSendPli */

#endif  /* PLI */