/* This program captures a number of interprocess communication functions
   in a number of simple interfaces
*/


#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<sys/time.h>
#include<fcntl.h>
#include <netinet/in.h>
#include <inttypes.h>

// utility function
int findmax_select(int A[], int size)
{
  int i, ax;
  ax = A[0];
  for(i=1;i<size;i++) { if (ax<A[i]) ax=A[i]; }
  return ax+1;
}


/* simple utilities to convert between int and void* */
void * iptovoidp(int *x)
{ 
  *x = htonl(*x);
  return (void *) x;
}

int voidptoi(void * p)
{ int x;
  x = *((int *) p);
  return ntohl(x);
}

/* read and write integer values to fd, converting to network byte ordering */
int readInt(int fd)
{
  int x;
  read(fd,&x,4);
  return ntohl(x);
}

void writeInt(int fd, int x)
{
  x = htonl(x);
  write(fd,&x,4);
}


/* read a line of text from a file descriptor, until \n encountered, then
   0-terminate the string.  Returns size of string, including 0 at end.
   the read string does NOT include the \n.
   Use as in 
     char buffer[64];
     size = fdreadline(fd,buffer);  
*/
int fdreadline(int fd, char *buffer)
{  int i = 0;  int j;  
   char c = ' ';
   buffer[0] = ' ';
   while (c != 10)
       {
	   j = read(fd,&c,1);
	   if (j==0) c = 10;  // force stopage of loop
	   buffer[i++] = c;
       } // end while
   buffer[i-1] = 0;   // zero-terminate the string;
   return i-1;
}  // fdreadline



/* the following function simplifies select.  It takes an array of
   file descriptors (and size of array) and waits until either one of
   the file descriptors becomes readable, or when timeout (in seconds)
   have expired.  The return value of the function is the first readable
   file descriptor, 0 if timed out, and -1 if error.  This function can
   also be used with a single-element array for a simple timeout operation.  
*/

int SelectRFD(int A[], int size, double timeout)
{  int limit, r, i; 
   fd_set readfds;
   struct timeval * tv;
   tv = NULL;
   if (size<1) return -1;
   if (timeout > 0.00001)
     {
       tv = (struct timeval*)malloc(sizeof(struct timeval));
       tv->tv_sec = (long) timeout;
       timeout = timeout - ((int)timeout); 
       tv->tv_usec = (long)(timeout * 1000000.0);
     }
   limit = findmax_select(A,size);
   FD_ZERO(&readfds);
   for(r=0;r<size;r++) FD_SET(A[r],&readfds);
   r = select(limit,&readfds,NULL,NULL,tv);
   if (tv) free(tv);
   if (r<1) return -1;
   for (i=0;i<size;i++)
       { if (FD_ISSET(A[i],&readfds)) { r = i; i=size; } }
   return A[r];
}


/* A simple Hoare CSP synchronization interface.
   A requesting (client) process initiates the communication by sending over
   a request for amount of data needed.  The server must call entry, which waits
   for such a request.
*/

void request(int pipe, int size, void *buffer)
{
  int i, j;  
  unsigned char c;
  writeInt(pipe,size);  // sends over amount of data requested
  read(pipe,buffer,size);  // read data into local buffer
}

// server serves data on request
void entry(int pipe, int size, void *buffer)
{ int i, j;
  unsigned char c;
  i = readInt(pipe);
  if (i==size) write(pipe,buffer,size);
}

// wait for a number of possible connections.
void selectEntry(int pipes[],int psize,int size,void *buffer)
{  int fd;
   fd = SelectRFD(pipes,psize,(double)0);
   if (fd>=0) entry(fd,size,buffer);
}