Subversion Repositories vapi

/* vapi.c -- Verification API Interface test side

   Copyright (C) 2001, Marko Mlinar, markom@opencores.org

This file is part of OpenRISC 1000 Architectural Simulator.

This program is free software; you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation; either version 2 of the License, or

(at your option) any later version.

This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with this program; if not, write to the Free Software

Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <sys/poll.h>

#include <sys/socket.h>

#include <netdb.h>

#include <netinet/in.h>

#include <netinet/tcp.h>

#include <sys/select.h>

#include <sys/time.h>

#include <unistd.h>

#include <signal.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <sys/ioctl.h>

#include <fcntl.h>

#include <errno.h>

#include "vapi.h"

int vapi_fd;

unsigned long first_id, last_id;

static int vapi_write_stream(int fd, void* buf, int len)

{

  int n;

  char* w_buf = (char*)buf;

  struct pollfd block;

  while(len) {

    if((n = write(fd,w_buf,len)) < 0) {

      switch(errno) {

      case EWOULDBLOCK: /* or EAGAIN */

        /* We've been called on a descriptor marked

           for nonblocking I/O. We better simulate

           blocking behavior. */

        block.fd = fd;

        block.events = POLLOUT;

        block.revents = 0;

        poll(&block,1,-1);

        continue;

      case EINTR:

        continue;

      case EPIPE:

        close(fd);

        vapi_fd = 0;

        return -1;

      default:

        return -1;

      }

    } else {

      len -= n;

      w_buf += n;

    }

  }

  return 0;

}

static int vapi_read_stream(int fd, void* buf, int len)

{

  int n;

  char* r_buf = (char*)buf;

  struct pollfd block;

  while(len) {

    if((n = read(fd,r_buf,len)) < 0) {

      switch(errno) {

      case EWOULDBLOCK: /* or EAGAIN */

        /* We've been called on a descriptor marked

           for nonblocking I/O. We better simulate

           blocking behavior. */

        block.fd = fd;

        block.events = POLLIN;

        block.revents = 0;

        poll(&block,1,-1);

        continue;

      case EINTR:

        continue;

      default:

        return -1;

      }

    } else if(n == 0) {

      close(fd);

      fd = 0;

      return -1;

    } else {

      len -= n;

      r_buf += n;

    }

  }

  return 0;

}

static int write_packet (unsigned long id, unsigned long data) {

  id = htonl (id);

  if (vapi_write_stream(vapi_fd, &id, sizeof (id)) < 0)

    return 1;

  data = htonl (data);

  if (vapi_write_stream(vapi_fd, &data, sizeof (data)) < 0)

    return 1;

  return 0;

}

static int read_packet (unsigned long *id, unsigned long *data) {

  if (vapi_read_stream(vapi_fd, id, sizeof (unsigned long)) < 0)

    return 1;

  *id = htonl (*id);

  if (vapi_read_stream(vapi_fd, data, sizeof (unsigned long)) < 0)

    return 1;

  *data = htonl (*data);

  return 0;

}

/* Added by CZ 24/05/01 */

static int connect_to_server(char* hostname,char* name)

{

  struct hostent *host;

  struct sockaddr_in sin;

  struct servent *service;

  struct protoent *protocol;

  int sock,flags;

  char sTemp[256],sTemp2[256];

  char* proto_name = "tcp";

  int port = 0;

  int on_off = 0; /* Turn off Nagel's algorithm on the socket */

  char *s;

  if(!(protocol = getprotobyname(proto_name))) {

    sprintf(sTemp,"Protocol \"%s\" not available.\n",

      proto_name);

    error(sTemp);

    return 0;

  }

  /* Convert name to an integer only if it is well formatted.

     Otherwise, assume that it is a service name. */

  port = strtol(name, &s, 10);

  if(*s)

    port = 0;

  if(!port) {

    if(!(service = getservbyname(name, protocol->p_name))) {

          sprintf(sTemp,"Unknown service \"%s\".\n",name);

          error(sTemp);

          return 0;

        }

    port = ntohs(service->s_port);

  }

  if(!(host = gethostbyname(hostname))) {

    sprintf(sTemp,"Unknown host \"%s\"\n",hostname);

    error(sTemp);

    return 0;

  }

  if((sock = socket(PF_INET, SOCK_STREAM, 0)) < 0) {

    sprintf(sTemp, "can't create socket errno = %d\n", errno);

    sprintf(sTemp2, "%s\n",strerror(errno));

    strcat(sTemp, sTemp2);

    error(sTemp);

    return 0;

  }

  if(fcntl(sock, F_GETFL, &flags) < 0) {

    sprintf(sTemp, "Unable to get flags for VAPI proxy socket %d", sock);

    error(sTemp);

    close(sock);

    return 0;

  }

  if(fcntl(sock,F_SETFL, flags & ~O_NONBLOCK) < 0) {

    sprintf(sTemp, "Unable to set flags for VAPI proxy socket %d to value 0x%08x", sock,flags | O_NONBLOCK);

    error(sTemp);

    close(sock);

    return 0;

  }

  memset(&sin,0,sizeof(sin));

  sin.sin_family = host->h_addrtype;

  memcpy(&sin.sin_addr, host->h_addr_list[0], host->h_length);

  sin.sin_port = htons(port);

  if((connect(sock, (struct sockaddr*)&sin, sizeof(sin)) < 0)

     && errno != EINPROGRESS) {

    sprintf(sTemp, "connect failed  errno = %d\n", errno);

    sprintf(sTemp2, "%s\n", strerror(errno));

    close(sock);

    strcat(sTemp, sTemp2);

    error(sTemp);

    return 0;

  }

  if(fcntl(sock,F_SETFL, flags | O_NONBLOCK) < 0) {

    sprintf(sTemp, "Unable to set flags for VAPI proxy socket %d to value 0x%08x", sock, flags | O_NONBLOCK);

    error(sTemp);

    close(sock);

    return 0;

  }

  if(setsockopt(sock,protocol->p_proto,TCP_NODELAY,&on_off,sizeof(int)) < 0) {

    sprintf(sTemp,"Unable to disable Nagel's algorithm for socket %d.\nsetsockopt", sock);

    error(sTemp);

    close(sock);

    return 0;

  }

  return sock;

}

/* Check if a vapi id is "good" */

static inline int good_id (unsigned long id)

{

  return ((id >= first_id) && (id <= last_id));

}

/* Initialize a new connection to the or1k board, and make sure we are

   really connected.  */

int

vapi_init (char *port_name, unsigned long id)

{

  first_id = id;

  last_id = id + num_vapi_ids - 1;

  /* CZ 24/05/01 - Check to see if we have specified a remote

     VAPI interface or a local one. It is remote if it follows

     the URL naming convention vapi://<hostname>:<port> */

  if(!strncmp(port_name,"vapi://",7)) {

    char *port;

    char hostname[256];

    port = strchr(&port_name[7], ':');

    if(port) {

          int len = port - port_name - 7;

          strncpy(hostname,&port_name[7],len);

          hostname[len] = '\0';

          port++;

        } else

      strcpy(hostname,&port_name[7]);

    /* Interface is remote */

    if(!(vapi_fd = connect_to_server(hostname,port))) {

          char sTemp[256];

          sprintf(sTemp,"Can not access VAPI Proxy Server at \"%s\"",

                  &port_name[5]);

          error(sTemp);

        }

    printf("Remote or1k testing using %s, id 0x%x\n", port_name, id);

    if (vapi_write_stream (vapi_fd, &id, sizeof (id)))

      return 1;

  } else

    return 1;

  return 0;

}

void

vapi_done ()  /* CZ */

{

  int flags = 0;

  struct linger linger;

  char sTemp[256];

  linger.l_onoff = 0;

  linger.l_linger = 0;

  /* First, make sure we're non blocking */

  if(fcntl(vapi_fd, F_GETFL,&flags) < 0) {

    sprintf(sTemp,"Unable to get flags for VAPI proxy socket %d", vapi_fd);

    error(sTemp);

  }

  if(fcntl(vapi_fd, F_SETFL, flags & ~O_NONBLOCK) < 0) {

    sprintf(sTemp,"Unable to set flags for VAPI proxy socket %d to value 0x%08x", vapi_fd, flags | O_NONBLOCK);

    error(sTemp);

  }

  /* Now, make sure we don't linger around */

  if(setsockopt(vapi_fd,SOL_SOCKET,SO_LINGER,&linger,sizeof(linger)) < 0) {

    sprintf(sTemp,"Unable to disable SO_LINGER for VAPI proxy socket %d.", vapi_fd);

    error(sTemp);

  }

  close(vapi_fd);

}

/* Writes an unsigned long to server */

void vapi_write(unsigned long data)

{

  vapi_write_with_id (0, data);

}

/* Writes an unsigned long to server with relative ID */

void vapi_write_with_id(unsigned long relative_id, unsigned long data)

{

  printf ("WRITE [%08x, %08x]\n", first_id + relative_id, data);

  if (write_packet (first_id + relative_id, data))

    perror ("write packet");

}

/* Reads an unsigned long from server */

unsigned long vapi_read()

{

  unsigned long relative_id, data;

  vapi_read_with_id (&relative_id, &data);

  return data;

}

/* Reads an unsigned long and vapi id from server */

void vapi_read_with_id(unsigned long *relative_id, unsigned long *data)

{

  unsigned long id;

  if(read_packet (&id, data)) {

    if(vapi_fd) {

      perror("vapi read");

      close(vapi_fd);

      vapi_fd = 0;

    }

    exit (2);

  }

  if (!good_id (id)) {

    if (last_id > first_id)

      fprintf (stderr, "ERROR: Invalid id %x, expected %x..%x", id, first_id, last_id);

    else

      fprintf (stderr, "ERROR: Invalid id %x, expected %x.", id, first_id);

    exit (1);

  }

  printf ("READ [%08x, %08x]\n", id, *data);

  *relative_id = id - first_id;

}

/* Polls the port if anything is available and if do_read is set something is read from port. */

int vapi_waiting ()

{

  struct pollfd fds[1];

  if(vapi_fd) {

    fds[0].fd = vapi_fd;

    fds[0].events = POLLIN;

    fds[0].revents = 0;

  } else

    return;

  while(1) {

    switch(poll(fds, 1, 0)) {

    case -1:

      if(errno == EINTR)

        continue;

      perror("poll");

      break;

    case 0: /* Nothing interesting going on */

      return 0;

    default:

      return 1;

    } /* End of switch statement */

  } /* End of while statement */

}

int main (int argc, char *argv[]) {

  unsigned long id, data;

  if (argc != 3) {

    printf ("Usage: %s URL ID\n", argv[0]);

    printf ("%s vapi://localhost:9998 0x12345678\n", argv[0]);

    return 2;

  }

  id = atol (argv[2]);

  if (sscanf (argv[2], "0x%x", &id)) {

    if (vapi_init(argv[1], id))

      return 1;

  } else {

    fprintf (stderr, "Invalid vapi_id\n", argv[2]);

    return 2;

  }

  if (vapi_main ()) {

    fprintf (stderr, "TEST FAILED.\n");

    return 1;

  }

  printf ("Test passed.\n");

  vapi_done();

  return 0;

}