#define Version "0.50"
/*
  simple server ver.0.50
  last modified 3-May-1997 by Y.Takeuchi
  07-Dec-2000 Is spec. of recv(2) changed?
  05-Mar-2000 remedy for reference of non-listed hostname
  
  usage:
      -p  PortNumber
      -f  LogFile   : if you omit this option , log to stdout.
      -a  HostsFile : if you omit this , no host is denyed.
                      Maximum number of hosts is defined as HostsMAX below.
*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <netinet/in.h>
#include <time.h>
#include <signal.h>
#include <setjmp.h>
#include <unistd.h>

typedef unsigned char uchar;
char* timestr(void);
int secure(char*);
char* adrstr(struct sockaddr*);
int catch(void);
typedef void (*sighandler_t)(int);
int auth(int , char** , char* );

#define USAGE "usage: -p PortNumber [-f LogFile] [-a HostsFile] execfile\n"
jmp_buf env;
FILE* logf;
#define HostsMAX 30

/* ----------------------------------------------------------------
  
   MAIN

 ------------------------------------------------------------------ */
int main( int argc , char** argv )
{
  int fd ,so;
  int salen;
  struct sockaddr_in sa;
  int count = 0 , len , i , sum;
  char buf[256], cmd[256];
  FILE* pipe;
  int shut_by_client = 0;
  int PortNumber = -1;
  char* LogFile = NULL , * ExecFile = NULL , * HostsFile = NULL;
  int HostsInx = 0;
  char* Hosts[HostsMAX] , foreign[256];
  FILE*  hf;
  int c;
  extern char *optarg;
  extern int optind;
  char msg1[] = "Sorry, Your host is NOT authorized.\n.\n";

  /* --- option analysis --- */
  while((c=getopt(argc,argv,"p:f:a:")) !=EOF)
    switch(c) {
    case'p':
      PortNumber = atoi( optarg );
      break;
    case'f':
      LogFile = optarg;
      break;
    case'a':
      HostsFile = optarg;
      break;
    case'?':
    default:
      fprintf(stderr,USAGE);
      exit(2);
    }
  
  ExecFile = argv[optind];

  /* -- port option -- */
  if ( PortNumber <= 0 || ExecFile==NULL ) {
    fprintf(stderr,USAGE);
    exit(2);
  }

  /* -- logfile option -- */
  if (LogFile == NULL ) {
    LogFile = "stdout";
    logf = stdout;
  }
  else {
    logf = fopen(LogFile , "w" );
    if (logf == NULL ) {
      fprintf( stdout , "Can't open %s\n" , LogFile);
      exit(-1);
    }
  }

  /* -- hostsfile option -- */
  if (HostsFile != NULL) {
    hf = fopen(HostsFile , "r" );
    if (hf == NULL ) {
      fprintf( stdout , "Can't open %s\n" , HostsFile);
      exit(-1);
    }
    HostsInx = 0;
    while(1) {
      if (fgets( buf , 256 , hf) == NULL ) break;
      if (buf[strlen(buf)-1] == '\n') buf[strlen(buf)-1] = 0;
      Hosts[HostsInx++] = strdup(buf);
    }
  }

  /* -- server startup log --*/
  fprintf(logf , "Simple server Ver.%s\n" , Version);
  fprintf(logf , "Port:      %d\n", PortNumber );
  fprintf(logf , "Log file:  %s\n", LogFile );
  fprintf(logf , "Exec file: %s\n", ExecFile );
  if ( HostsFile != NULL ) {
    fprintf(logf , "permitted Hosts:\n" );
    for( i = 0 ; i<HostsInx ; i++ )
      fprintf(logf , "    %s\n", Hosts[i] );
  };

  fflush(logf);

  if ( access( ExecFile , R_OK | X_OK ) ) {
    fprintf( logf , "Can't read or execute %s\n" , ExecFile );
    fflush(logf);
    exit(-1);
  }

  signal( SIGPIPE , (sighandler_t)catch );

  sa.sin_family = AF_INET;
  sa.sin_port = htons( PortNumber );
  sa.sin_addr.s_addr = INADDR_ANY;

  buf[255]=0;

  salen = sizeof( sa );

  fd = socket( AF_INET , SOCK_STREAM , 0 );
  if ( fd == -1 ) {
    perror( NULL );
    exit( -1 );

  }

  if ( bind( fd, (struct sockaddr *)&sa, sizeof( sa ) ) == -1 ) 
    goto err;
  fprintf(logf , "%s Sever start.\n", timestr() );
  fflush(logf);

 listen:
  if( listen( fd , 5 ) == -1 ) goto err;
  fprintf(logf , "Waiting connetction...\n");
  fflush(logf);

  if ( (so = accept( fd, (struct sockaddr *)&sa , &salen )) == -1)
    goto err;
  shut_by_client = 0;
  strncpy(foreign , adrstr((struct sockaddr*)&sa) , 256);
  fprintf(logf , "%s [%s] Connection established.\n" ,
	  timestr() , foreign );
  fflush(logf);

  /* -- host authorization -- */
  if (HostsFile != NULL && !auth(HostsInx,Hosts,foreign)) {
    len = send( so , msg1 , strlen(msg1) , 0 );
    shutdown( so,2);
    close(so);
    fprintf(logf , "%s [%s] isn't authorized,Connection close.\n" ,
	    timestr() , foreign );
    fflush(logf);
    goto listen;
  }
  
  
  count++;

  for(i=0;;i++) {
    len = recv( so , buf, 256 , 0);
    if ( len == -1 ) goto QuitByClient;
    buf[len]=0;
    if (len==0 ) break;

    if (buf[0]=='.' ) goto QuitByClient;
    secure(buf);
    sprintf( cmd , "%s %s", ExecFile ,buf);
    pipe = popen(cmd , "r");
    sum = 0;

    fprintf(logf , "%s [%d:%d] %s " , timestr() ,count,i, buf );
    fflush(logf);

    while( fgets( buf , 255 , pipe )!= NULL ) {
      if (setjmp(env) ==  3 ) { shut_by_client = 1; break; }
      len = send( so , buf, strlen(buf) , 0 );
      sum+=len;
      if ( len == -1 ) break;
    }
    pclose(pipe);
    fprintf(logf , " : %d byte sent\n" , sum);
    fflush(logf);

    /* terminator */
    if ( shut_by_client ) break;
    buf[0]='.'; buf[1]='\n';
    len = send( so , buf, 2 , 0 );
  }

 QuitByClient:
  fprintf( logf , "%s Connection closed by client.\n", timestr() );
  fflush( logf);
  shutdown( so,2);
  close(so);
  goto listen;

 err:
  perror( NULL );  
  shutdown( fd,2);
  close( fd);
  return 0;
}

/* ----------------------------------------------------------------
  
   auth

 ------------------------------------------------------------------ */
int auth(int n , char** Array,char* str)
{
  int i;

  for( i = 0 ; i<n ; i++)
    if ( strcmp(Array[i] , str ) == 0 ) return 1;

  return 0;
}


/* ----------------------------------------------------------------
  
   secure

 ------------------------------------------------------------------ */
int secure(char* buf)
{
  int i;

  i=0;

  while( buf[i]!=0 ) {
    switch ((unsigned char)buf[i] ) {
    case '\n' :
    case '\r' :
      buf[i] = ' ';
      break;
    case '<' :
    case '>' :
    case '&' :
    case ';' :
    case '!' :
    case 0xff :
    case '|' :
    case '`' :
      fprintf( logf, "<secure code %c>\n" , buf[i] );
      fflush( logf);
      buf[i] = ' ';
      break;
    default : 
    }
    i++;
  }
}

/* ----------------------------------------------------------------
  
   timestr

 ------------------------------------------------------------------ */
char* timestr(void)
{
  static char tbuf[80];
  time_t clock;

  (void) time(&clock);

  strftime(tbuf , 80 , "%h %d %T", localtime(&clock));

  return tbuf;
}

/* ----------------------------------------------------------------
  
   adrstr

 ------------------------------------------------------------------ */
char* adrstr(struct sockaddr* sa)
{
  static char buf[80];
  unsigned long uaddr;
  struct hostent * hp;

  sprintf(buf , "%d.%d.%d.%d" , 
	  (uchar)sa->sa_data[2],(uchar)sa->sa_data[3],
	  (uchar)sa->sa_data[4],(uchar)sa->sa_data[5]);

  uaddr = inet_addr( buf );

  if ( uaddr != -1 ) {
    hp = gethostbyaddr(( char *) &uaddr ,4, AF_INET);
    if (hp != NULL) strcpy(buf , hp->h_name);
  }
  return buf;
}

/* ----------------------------------------------------------------
  
   catch

 ------------------------------------------------------------------ */
int catch(void)
{
  fprintf( logf , "%s Broken pipe... Server restart " , timestr());
  fflush(logf);
  signal( SIGPIPE , (sighandler_t)catch );
  longjmp(env,3);
  return( 0 );
}