ss.c

speech signal process tools

/* Simple Socket Libary
   Written by Mat Watson and Hubert Bartels.  12/01/90
*/
/*
Copyright (c) 1990 Mat Watson and Hubert Bartels. All rights reserved. 

Permission to use, copy, and/or distribute for any purpose and 
without fee is hereby granted, provided that both the above copyright 
notice and this permission notice appear in all copies and derived works. 
Fees for distribution of this software or for derived sources may only 
be charged with the express written permission of the copyright holders. 
This software is provided ``as is'' without express or implied warranty.
*/

#include <esps/ss.h>

#ifdef M5600
#define OLD_BSD_FDSETS
#include <esps/ultrix_cpt.h>
#endif

static char *sccs_id = "%W% %G%	ERL";

/* #include "private_globals.h" */
/* #include <signal.h> */

int ss_server_flag;
int ss_client_flag;
int ss_init_flag=0;
SOCKARRAY ss_sockbuff;
int max_sd;  /* this variable is a private global */

#ifdef APOLLO_68K
int _SockFlsbuf();
void SockInit();
#endif

#ifndef DEC_ALPHA
char *malloc();
char *calloc();
#endif

SOCKET *AcceptSock( ssp )
SOCKET *ssp;               /* Server Socket Pointer */
{
  SOCKET *csp;             /* Client Socket Pointer */
  struct sockaddr *adrp;   /* Address Poiner        */
  int *adrlen;             /* Address Length        */
  int csd;                 /* Client Socket Descriptor */

  if( !(ss_sockbuff.n_sockets < MaxSockets) )
    return (SOCKET *) SS_NULL;

  /* Allocate space for the client's socket structure */
  csp = (SOCKET *)malloc( sizeof( SOCKET ));

  if( !csp )
    sserror("AcceptSock: malloc()",EXIT);

  csp->_rcnt = 0;
  csp->_rptr = SS_NULL;
  csp->_rbase = SS_NULL;
  csp->_wcnt = 0;
  csp->_wptr = SS_NULL;
  csp->_wbase = SS_NULL;
  csp->_flag = 0;

  adrp = (struct sockaddr *)0;
  adrlen = (int *)0;

  csd = accept( ssp->sd, adrp, adrlen );
  if( csd < 0 ) {
#ifdef Verbose_Errors
    sserror("AcceptSock: accept()",CONT);
#endif
    return SS_NULL;
  }

  /* Set the value of the maximum socket descriptor used so far */
  max_sd = csd >= max_sd ? csd : max_sd;
  
  csp->sd = csd;

  AddSock( csp, &ss_sockbuff );

  /* Return a pointer to the client socket */
  return csp;
}

void AddSock( sp, sap )
SOCKET *sp;
SOCKARRAY *sap;
{
  int n;
  n = sap->n_sockets;
  sap->n_sockets++;
  sap->spa[n] = sp;
  return;
}

SOCKET *ConnectSock( hostname, port_number )
char *hostname;
unsigned port_number;
{
  SOCKET *sp;
  struct hostent *hep;
  struct sockaddr *adrp;
  int adrlen;
  int result;

  SockInit( 'c' );

  sp = (SOCKET *) malloc( sizeof( SOCKET ) );

  if( !sp ) {
#ifdef Verbose_Errors
    sserror("ConnectSock: malloc()",CONT);
#endif
    return (SOCKET *) SS_NULL;
  }

  sp->_rcnt = 0;
  sp->_rptr = SS_NULL;
  sp->_rbase = SS_NULL;
  sp->_wcnt = 0;
  sp->_wptr = SS_NULL;
  sp->_wbase = SS_NULL;
  sp->_flag = 0;

  AddSock( sp, &ss_sockbuff );

  hep = gethostbyname( hostname );
  if( hep == (struct hostent *)0 ) {
#ifdef Verbose_Errors
    perror("ConnectSock: gethostbyname()");
#endif
    return (SOCKET *) SS_NULL;
  }

  bcopy( (char *)(hep->h_addr), (char *)&(sp->addr.sin_addr), hep->h_length );

  sp->addr.sin_family = AF_INET;
  sp->addr.sin_port = htons( (u_short)port_number );
  sp->sd = socket( AF_INET, SOCK_STREAM, 0 );
  if( sp->sd < 0 ) {
#ifdef Verbos_Errors
    sserror("ConnectSock: socket()",CONT);
#endif
    return (SOCKET *) SS_NULL;
  }

  adrp = (struct sockaddr *) &(sp->addr);
  adrlen = sizeof( sp->addr );

  result = connect( sp->sd, adrp, adrlen );
  if( result < 0 ) {
#ifdef Verbos_Errors
    sserror("ConnectSock: connect()",CONT);
#endif
    close(sp->sd);
    free((char *) sp );
    return (SOCKET *) SS_NULL;
  }
  max_sd = sp->sd >= max_sd ? sp->sd : max_sd ;
  return sp;
}

int IsExceptSet( sp )
SOCKET *sp;
{
  int result, i;
  SOCKARRAY * sap;
  sap = &ss_sockbuff;
  i = SockIndex( sp, sap );
  if( i == -1 )
    return -1;           /* Socket is not in ss_sockbuff */
  result = FD_ISSET( sap->spa[i]->sd, &(sap->exceptfds) );
  return result;
}

int IsReadSet( sp )
SOCKET *sp;
{
  int result, i;
  SOCKARRAY * sap;
  sap = &ss_sockbuff;
  i = SockIndex( sp, sap );
  if( i == -1 )
    return i;               /* Socket is not in the ss_sockbuff */
  result = FD_ISSET( sap->spa[i]->sd, &(sap->readfds) );
  return result;
}

int IsWriteSet( sp )
SOCKET *sp;
{
  int result, i;
  SOCKARRAY * sap;
  sap = &ss_sockbuff;
  i = SockIndex( sp, sap );
  if( i == -1 )
    return -1;    /* Socket is not in ss_sockbuff */
  result = FD_ISSET( sap->spa[i]->sd, &(sap->writefds) );
  return result;
}

void RemoveSock( sp )
SOCKET *sp;
{
  int i, n;
  SOCKARRAY *sap;
  sap = &ss_sockbuff;

  for( i = 0; i < sap->n_sockets; i++ ) 
    if( sp == sap->spa[i] ) break;

  n = i;

  for( i = n + 1; i < sap->n_sockets; i++ )
    sap->spa[i-1] = sap->spa[i];

  sap->spa[sap->n_sockets - 1] = SS_NULL;
  sap->n_sockets--;
  return;
}


SOCKET *ServerSock( port_number )
unsigned port_number;
{
  int sd;
  int optval;
  unsigned optlen;
  SOCKET *sp;
  int result;

  SockInit( 's' );

  sd = socket( AF_INET, SOCK_STREAM, 0 );
  if( sd < 0 ) {
/* sserror("ServerSock: socket()",EXIT); */
   return (SOCKET *) SS_NULL; 
  }
  
  optval = 1;  /* any nonzero value will cause the flag to be set */
  optlen = sizeof( int );
  result = setsockopt( sd, SOL_SOCKET, SO_REUSEADDR, (char *)&optval, optlen );
  if( result != 0 ) {
#ifdef Verbose_Errors
    sserror("ServerSock: setsockopt()",CONT);
#endif
    return (SOCKET *) SS_NULL;
  }

  sp = (SOCKET *)malloc( sizeof(SOCKET));
  if( !sp ) {
#ifdef Verbose_Errors
    sserror("ServerSock: mallock()",CONT);
#endif
    return (SOCKET *) SS_NULL;
  }
  
  sp->addr.sin_family = AF_INET;
  sp->addr.sin_addr.s_addr = INADDR_ANY;
  sp->addr.sin_port = htons( (u_short)port_number );

  result = bind( sd, (struct sockaddr *)&(sp->addr), sizeof(struct sockaddr));
  if( result !=0 ) {
#ifdef Verbose_Errors
    sserror("ServerSock: bind()",CONT);
#endif
    return (SOCKET *) SS_NULL;
  }

  max_sd = sd >= max_sd ? sd : max_sd;
  sp->sd = sd;
  sp->_rcnt = 0;
  sp->_rptr = SS_NULL;
  sp->_rbase = SS_NULL;
  sp->_wcnt = 0;
  sp->_wptr = SS_NULL;
  sp->_wbase = SS_NULL;
  sp->_flag = 0;
  
  result = listen( sd, 5 );
  if( result != 0 ) {
#ifdef Verbose_Errors
    sserror("ServerSock: listen()",CONT);
#endif
    return (SOCKET *) SS_NULL;
  }

  AddSock( sp, &ss_sockbuff );
  
  return sp;
}

void SockArrayInit( sap )
SOCKARRAY *sap;
{
  int i;
  sap->n_sockets = 0;
  for( i = 0; i < MaxSockets; i++ )
    sap->spa[i] = SS_NULL;
  return;
}

/*	fclose.c
	
	Hubert Bartels
	
	August 8, 1985
	
	fclose closes the file and frees the entry in the _iob block.

        Modified for sockets by Mat Watson 12/1/90

*/
int SockClose(sp)
SOCKET *sp;
{
	int result;

  RemoveSock( sp );

  result = SockFlush(sp);      /* Flush the buffer if needed */
  if( result < 0 ) {
#ifdef Verbose_Errors
    sserror("SockClose(): SockFlush failed",CONT);
#endif
    return SS_EOF;
  }
  result = close((int)sp->sd);		/* Close the file */
  if( result < 0 )
    sserror("SockClose: close() failed",EXIT);
  sp->sd = '\0';
  sp->_rcnt = 0;
  sp->_rptr = SS_NULL;
  if( (sp->_flag & SS_IONBF) == 0 ) 
    if(sp->_rbase)
      free((char *)sp->_rbase);
  sp->_rbase = SS_NULL;

  sp->_wcnt = 0;
  sp->_wptr = SS_NULL;
  if( (sp->_flag & SS_IONBF) == 0 ) 
    if(sp->_wbase)
      free((char *) sp->_wbase );
  sp->_wbase = SS_NULL;
  sp->_flag = 0;
  return 0; /* Success */
}

/* SockFilbuf.c
   Modified for sockets by Mat Watson 12/01/90
*/
/*	filbuf.c
	
	Hubert Bartels
	
	July 8, 1985
	
	filbuf is used to fill the buffer of files being read by the
	polyp. As such, it is part of the file system of the polyp.
*/
int _SockFilbuf(sp)
SOCKET *sp;
{
  static char smallbuf[NOFILE];  /* for unbuffered i/o */

  if( (sp->_flag & (SS_IOEOF | SS_IOERR)) != 0 )
    return(SS_EOF);

  while (sp->_rbase == SS_NULL) /* find buffer space */
    if(sp->_flag & SS_IONBF) /* unbuffered */
      sp->_rbase = &smallbuf[sp->sd];
    else if ((sp->_rbase = calloc(SS_BUFSIZ, 1)) == SS_NULL)
      sp->_flag |= SS_IONBF;	/* Cannot get unbuffered */
    else
      sp->_flag |= SS_IOMYBUF;	/* Got a big buffer */

  sp->_rptr = sp->_rbase;
  sp->_rcnt = read(sp->sd, sp->_rptr,