/*
 * This is sample code generated by rpcgen.
 * These are only templates and you can use them
 * as a guideline for developing your own functions.
 */

#include <stdio.h>
#include <stdlib.h>
#include <rpc/pmap_clnt.h>
#include <string.h>
#include <memory.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <pthread.h>

#include "vxi.h"

#define LOCK_TIMEOUT 1000
#define IO_TIMEOUT   1000

static u_short intr_server_port= 0;

typedef struct  {
    CLIENT       *clnt_core;
    CLIENT       *clnt_async;
    char         *device;
    Device_Link  lid;
    u_long       lock_timeout;
    u_long       io_timeout;
    bool_t       lock;
    u_short      abortPort;
    u_long       maxRecvSize;
    char         termChar;
    int          verbose;
} instr_dev_t;

typedef struct {
    u_int data_len;
    char *data_val;
} read_data_t;
  


int deviceAbort(instr_dev_t *dev)
{
    Device_Error *result;
    
    result= device_abort_1(&dev->lid, dev->clnt_async);
    if (result == (Device_Error *) NULL) {
	clnt_perror (dev->clnt_async, "call failed");
	return -1;
    }
    
    if(result->error != 0) {
	printf("device_abort ErrorCode= %d \n", result->error);
	return -1;
    }

    return 0;
}



int createLink(instr_dev_t *dev)
{
    Create_LinkResp  *result;
    Create_LinkParms  args;
    
    args.lockDevice  = dev->lock;
    args.lock_timeout= dev->lock_timeout;
    args.device      = dev->device;
    
    result= create_link_1(&args, dev->clnt_core);
    if (result == (Create_LinkResp *) NULL) {
	clnt_perror (dev->clnt_core, "call failed");
	return -1;
    }
    
    dev->lid= result->lid; 
    
    if(result->error != 0) {
	printf("create_link ErrorCode= %d \n", result->error);
	return -1;
    }
    else {
	if(dev->verbose) {
	    printf("create_link deviceLink= %u abortPort= %hu MaxRcvSize= %u\n",
		   result->lid,
		   result->abortPort, result->maxRecvSize);
	}
    }
    
    
    return 0;
}

int destroyLink(instr_dev_t *dev)
{
    Device_Error *result;
    
    result= destroy_link_1(&dev->lid, dev->clnt_core);
    if (result == (Device_Error *) NULL) {
	clnt_perror (dev->clnt_core, "call failed");
	return -1;
    }
    
    dev->lid= 0; 
    
    if(result->error != 0) {
	printf("destroy_link ErrorCode= %d \n", result->error);
	return -1;
    }

    return 0;
}

int DeviceLock(instr_dev_t *dev, Device_Flags flags) 
{

    Device_Error     *result;
    Device_LockParms args;
	
    args.lid         = dev->lid;
    args.flags       = flags;
    args.lock_timeout= dev->lock_timeout;
    
    result= device_lock_1(&args, dev->clnt_core);
    if (result == (Device_Error *) NULL) {
	clnt_perror (dev->clnt_core, "call failed");
	return -1;
    }
    
    if(result->error != 0) {
	printf("device_lock ErrorCode= %d \n", result->error);
	return -1;
    }

    return 0;
}


int DeviceUnlock(instr_dev_t *dev) 
{
	Device_Error  *result;
	
	result= device_unlock_1(&dev->lid, dev->clnt_core);
	if (result == (Device_Error *) NULL) {
	    clnt_perror (dev->clnt_core, "call failed");
	    return -1;
	}

	if(result->error != 0) {
	    printf("device_unlock ErrorCode= %d \n", result->error);
	    return -1;
	}

	return 0;
}


int deviceWrite(instr_dev_t *dev, Device_Flags flags, char *msg)
{
    Device_WriteResp  *result;
    Device_WriteParms  args;


    args.lid          = dev->lid;
    args.io_timeout   = dev->io_timeout;
    args.lock_timeout = dev->lock_timeout;
    args.flags        = flags;
    args.data.data_len= strlen(msg);
    args.data.data_val= msg;
    

    result= device_write_1(&args, dev->clnt_core);
    if (result == (Device_WriteResp *) NULL) {
	clnt_perror (dev->clnt_core, "call failed");
	return -1;
    }
    
    if(result->error != 0) {
	printf("device_write ErrorCode= %d \n", result->error);
	return -1;
    }
    else {
	if(dev->verbose) {
	    printf("device_write: size= %u\n", result->size);
	    
	}
    }

    return result->size;
}

read_data_t *deviceRead(instr_dev_t *dev, Device_Flags flags)
{
	Device_ReadResp  *result;
	Device_ReadParms args;
	int              i;

	args.lid         = dev->lid;
	args.requestSize = dev->maxRecvSize;
	args.io_timeout  = dev->io_timeout;
	args.lock_timeout= dev->lock_timeout;
	args.flags       = flags;
	args.termChar    = dev->termChar;

	result = device_read_1(&args, dev->clnt_core);
	if (result == (Device_ReadResp *) NULL) {
		clnt_perror (dev->clnt_core, "call failed");
		return NULL;
	}

	if(result->error != 0) {
	    printf("device_read ErrorCode= %d \n", result->error);
	    return NULL;
	}
	else {
	    if(dev->verbose) {
		printf("device_read: size= %u Data=[",
		       result->data.data_len);
		for(i=0;i<result->data.data_len;i++) {
		    if(isprint(result->data.data_val[i]))
			putchar(result->data.data_val[i]);
		}
		printf("]\n");
	    }
	}


	return (read_data_t *) &result->data;
}

unsigned char deviceReadStb(instr_dev_t *dev, Device_Flags flags)
{
    Device_ReadStbResp  *result;
    Device_GenericParms args;
    
    args.lid         = dev->lid;
    args.io_timeout  = dev->io_timeout;
    args.lock_timeout= dev->lock_timeout;
    args.flags       = flags;
    
    
    result= device_readstb_1(&args, dev->clnt_core);
    if (result == (Device_ReadStbResp *) NULL) {
	clnt_perror (dev->clnt_core, "call failed");
	return 0xff;
    }

    if(result->error != 0) {
	printf("device_readstb ErrorCode= %d \n", result->error);
	return 0xff;
    }

    return result->stb;
    
}

int deviceTrigger(instr_dev_t *dev, Device_Flags flags)
{

    Device_Error         *result;
    Device_GenericParms  args;
    
    args.lid         = dev->lid;
    args.io_timeout  = dev->io_timeout;
    args.lock_timeout= dev->lock_timeout;
    args.flags       = flags;

    result = device_trigger_1(&args, dev->clnt_core);
    if (result == (Device_Error *) NULL) {
	clnt_perror (dev->clnt_core, "call failed");
	return -1;
    }


    if(result->error != 0) {
	printf("device_trigger ErrorCode= %d \n", result->error);
	return -1;
    }

    return 0;
}

int deviceClear(instr_dev_t *dev, Device_Flags flags)
{

    Device_Error         *result;
    Device_GenericParms  args;

    args.lid         = dev->lid;
    args.io_timeout  = dev->io_timeout;
    args.lock_timeout= dev->lock_timeout;
    args.flags       = flags;

    result = device_clear_1(&args, dev->clnt_core);
	if (result == (Device_Error *) NULL) {
		clnt_perror (dev->clnt_core, "call failed");
		return -1;
	}

    if(result->error != 0) {
	printf("device_clear ErrorCode= %d \n", result->error);
	return -1;
    }

    return 0;
}



int deviceRemote(instr_dev_t *dev, Device_Flags flags)
{

    Device_Error         *result;
    Device_GenericParms  args;

    args.lid         = dev->lid;
    args.io_timeout  = dev->io_timeout;
    args.lock_timeout= dev->lock_timeout;
    args.flags       = flags;

    result = device_remote_1(&args, dev->clnt_core);
	if (result == (Device_Error *) NULL) {
		clnt_perror (dev->clnt_core, "call failed");
		return -1;
	}

    if(result->error != 0) {
	printf("device_remote ErrorCode= %d \n", result->error);
	return -1;
    }

    return 0;
}

int deviceLocal(instr_dev_t *dev, Device_Flags flags)
{

    Device_Error         *result;
    Device_GenericParms  args;

    args.lid         = dev->lid;
    args.io_timeout  = dev->io_timeout;
    args.lock_timeout= dev->lock_timeout;
    args.flags       = flags;

    result = device_local_1(&args, dev->clnt_core);
	if (result == (Device_Error *) NULL) {
		clnt_perror (dev->clnt_core, "call failed");
		return -1;
	}

    if(result->error != 0) {
	printf("device_local ErrorCode= %d \n", result->error);
	return -1;
    }

    return 0;
}


int createIntrChan(instr_dev_t *dev, u_long hostAddr, u_short hostPort,
		   Device_AddrFamily progFamily)
{

    Device_Error      *result;
    Device_RemoteFunc args;

    args.hostAddr  = hostAddr;
    args.hostPort  = hostPort;
    args.progNum   = DEVICE_INTR;
    args.progVers  = DEVICE_INTR_VERSION;
    args.progFamily= progFamily;

    result = create_intr_chan_1(&args, dev->clnt_core);
	if (result == (Device_Error *) NULL) {
		clnt_perror (dev->clnt_core, "call failed");
		return -1;
	}

    if(result->error != 0) {
	printf("create_intr_chan ErrorCode= %d \n", result->error);
	return -1;
    }

    return 0;
}


int destroyIntrChan(instr_dev_t *dev)
{

    Device_Error *result;

    result= destroy_intr_chan_1((void*) NULL, dev->clnt_core);

    if (result == (Device_Error *) NULL) {
	clnt_perror (dev->clnt_core, "call failed");
    }

    if(result->error != 0) {
	printf("destroy_intr_chan ErrorCode= %d \n", result->error);
	return -1;
    }

    return 0;
}

int deviceEnableSrq(instr_dev_t *dev, bool_t enable, u_int handle_len, void *handle_val)
{
	Device_Error          *result;
	Device_EnableSrqParms args;

	args.lid              = dev->lid;
	args.enable           = enable;
	args.handle.handle_len= handle_len;
	args.handle.handle_val= handle_val;

	result= device_enable_srq_1(&args, dev->clnt_core);
	if (result == (Device_Error *) NULL) {
		clnt_perror (dev->clnt_core, "call failed");
	}

    if(result->error != 0) {
	printf("device_enable_srq ErrorCode= %d \n", result->error);
	return -1;
    }

    return 0;
}

/*


	Device_DocmdResp  *result_12;
	Device_DocmdParms  device_docmd_1_arg;

	result_12 = device_docmd_1(&device_docmd_1_arg, clnt);
	if (result_12 == (Device_DocmdResp *) NULL) {
		clnt_perror (clnt, "call failed");
	}

*/

void *device_intr_srq_1_svc(Device_SrqParms *argp, struct svc_req *rqstp)
{
    static char * result;
    
    printf("device_intr_srq_1_svc\n");

    /*
     * insert server code here
     */
    
    return (void *) &result;
}

static void device_intr_1(struct svc_req *rqstp, register SVCXPRT *transp)
{
    union {
	Device_SrqParms device_intr_srq_1_arg;
    } argument;
    
    char *result;
    xdrproc_t _xdr_argument, _xdr_result;
    char *(*local)(char *, struct svc_req *);
    
    switch (rqstp->rq_proc) {
    case NULLPROC:
	(void) svc_sendreply (transp, (xdrproc_t) xdr_void, (char *)NULL);
	return;
	
    case device_intr_srq:
	_xdr_argument = (xdrproc_t) xdr_Device_SrqParms;
	_xdr_result = (xdrproc_t) xdr_void;
	local = (char *(*)(char *, struct svc_req *)) device_intr_srq_1_svc;
	break;
	
    default:
	svcerr_noproc (transp);
	return;
    }
    memset ((char *)&argument, 0, sizeof (argument));
    if (!svc_getargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
	svcerr_decode (transp);
	return;
    }
    result = (*local)((char *)&argument, rqstp);
    if (result != NULL && !svc_sendreply(transp, (xdrproc_t) _xdr_result, result)) {
	svcerr_systemerr (transp);
    }
    if (!svc_freeargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
	fprintf (stderr, "%s", "unable to free arguments");
	exit (1);
    }

    return;
}

void *intr_server(void *ptr)
{
    register    SVCXPRT *transp;
    instr_dev_t *dev= (instr_dev_t *) ptr;
	
    pmap_unset (DEVICE_INTR, DEVICE_INTR_VERSION);

    //transp = svctcp_create(RPC_ANYSOCK, 0, 0);
    transp = svcudp_create(RPC_ANYSOCK);
    if (transp == NULL) {
	fprintf (stderr, "%s", "cannot create tcp service.");
	return;
    }

    if (!svc_register(transp, DEVICE_INTR, DEVICE_INTR_VERSION, device_intr_1, IPPROTO_TCP)) {
	fprintf (stderr, "%s", "unable to register (DEVICE_INTR, DEVICE_INTR_VERSION, tcp).");
	return;
    }

    printf("port= %hu\n", transp->xp_port);

    intr_server_port= transp->xp_port;

    svc_run ();

}
//#define USE_INTR_SR
int main (int argc, char *argv[])
{
    char           *host;
    char           msg[1024];
    instr_dev_t    dev;
    read_data_t    *data;

    pthread_t      intr_server_thr;
    int            iret;

    char           host_name[256];
    char           device[100];
    struct hostent *host_ent;
    u_long         h_addr;
    int            i;

    if (argc < 4) {
	printf ("usage: %s server_host address message [r]\n", argv[0]);
	exit (1);
    }
    
    host = argv[1];
    

#ifdef USE_INTR_SR
    gethostname(host_name, sizeof(host_name));
    host_ent= gethostbyname(host_name);
    memcpy(&h_addr, host_ent->h_addr_list[0], 4);

    printf("Host name= %s address= %hhu.%hhu.%hhu.%hhu\n", host_name,
	   host_ent->h_addr_list[0][0],
	   host_ent->h_addr_list[0][1],
	   host_ent->h_addr_list[0][2],
	   host_ent->h_addr_list[0][3]);
#endif


#ifdef USE_INTR_SR
    iret = pthread_create( &intr_server_thr, NULL, intr_server, (void*) &dev);
#endif

    dev.clnt_core= clnt_create (host, DEVICE_CORE, DEVICE_CORE_VERSION, "tcp");
    if (dev.clnt_core == NULL) {
	printf("Core\n");
	clnt_pcreateerror (host);
	exit (1);
    }
    
    
    dev.clnt_async= clnt_create (host, DEVICE_ASYNC, DEVICE_ASYNC_VERSION, "tcp");
    if (dev.clnt_async == NULL) {
	printf("Async\n");
	clnt_pcreateerror (host);
	exit (1);
    }
    

    dev.verbose     = 0;
    dev.lock        = FALSE;
    dev.lock_timeout= 1000;
    dev.io_timeout  = 1000;
    dev.termChar    = 0x00;
    sprintf(device, "gpib%d,%d", 0, atoi(argv[2]));
    dev.device      = device;
    
    createLink(&dev);
    
    //    deviceAbort(&dev);
    //    deviceClear(&dev, 0x00);

#ifdef USE_INTR_SR

    while(intr_server_port == 0)
	sleep();

    createIntrChan(&dev, h_addr, intr_server_port, host_ent->h_addrtype);

    deviceEnableSrq(&dev, TRUE, sizeof(void*),(void*) &dev);
#endif


    sprintf(msg, "%s\n", argv[3]);
    deviceWrite(&dev, 0x00, msg);


    if(argc>4 && argv[4][0]== 'r') {

      data= deviceRead(&dev, 0x00);
      
      if(data) {	
	//printf("%d:", data->data_len);
	
	for(i=0;i<data->data_len;i++) {
	  if(isprint(data->data_val[i]))
	    printf("%c", data->data_val[i]);
	  //else
	  //printf("<%02x>", data->data_val[i]);
	}

	printf("\n");
      }
    }


#ifdef USE_INTR_SR
    deviceEnableSrq(&dev, FALSE, sizeof(void*),(void*) &dev);
    destroyIntrChan(&dev);
#endif

    destroyLink(&dev);



    clnt_destroy (dev.clnt_async);
    clnt_destroy (dev.clnt_core);

    exit (0);
}