/****************************************************************************    
  program:      proxyd                                                           
  module:       proxyd.c                                                         
  summary:      provides proxy tcp service for a host on an isolated network.    
                                                                                 
  programmer:   Carl Harris (ceharris@vt.edu)                                    
  date:         22 Feb 94                                                        
                                                                                 
  description:                                                                   
        This code implements a daemon process which listens for tcp connec-      
        tions on a specified port number.  When a connection is established,     
        a child is forked to handle the new client.  The child then estab-       
        lishes a tcp connection to a port on the isolated host.  The child       
        then falls into a loop in which it writes data to the isolated host      
        for the client and vice-versa.  Once a child has been forked, the        
        parent resumes listening for additional connections.                     
                                                                                 
        The name of the isolated host and the port to serve as proxy for,        
        as well as the port number the server listen on are specified as         
        command line arguments.                                                  
 ****************************************************************************/   
                                                                                 
                                                                                 
#include <stdio.h>                                                               
#include <ctype.h>                                                               
#include <errno.h>                                                               
#include <signal.h>                                                              
#include <sys/types.h>                                                           
#include <sys/socket.h>                                                          
#include <sys/file.h>                                                            
#include <sys/ioctl.h>                                                           
#include <sys/wait.h>                                                            
#include <netinet/in.h>                                                          
#include <netdb.h>                                                               
                                                                                 
                                                                                 
#define  TCP_PROTO      "tcp"                                                    
                                                                                 
int proxy_port;                 /* port to listen for proxy connections on */    
struct sockaddr_in hostaddr;    /* host addr assembled from gethostbyname() */   
                                                                                 
extern int errno;               /* defined by libc.a */                          
extern char *sys_errlist[];     /* defined by libc.a */                          
                                                                                 
                                                                                 
void parse_args (int argc, char **argv);                                         
void daemonize (int servfd);                                                     
void do_proxy (int usersockfd);                                                  
void reap_status (void);                                                         
void errorout (char *msg);                                                       
                                                                                 
                                                                                 
                                                                                 
/****************************************************************************    
  function:      main                                                            
  description:   Main level driver.  After daemonizing the process, a socket     
                 is opened to listen for connections on the proxy port,          
                 connections are accepted and children are spawned to handle     
                 each new connection.                                            
  arguments:                                                                     
    argc,argv    you know what those are.                                        
                                                                                 
  return value:  none.                                                           
  calls:         parse_args, do_proxy.                                           
  globals:       reads proxy_port.                                               
 ****************************************************************************/   
                                                                                 
main (argc,argv)                                                                 
int argc;                                                                        
char **argv;                                                                     
{                                                                                
  int clilen;                                                                    
  int childpid;                                                                  
  int sockfd, newsockfd;                                                         
  struct sockaddr_in servaddr, cliaddr;                                          
                                                                                 
  parse_args(argc,argv);                                                         
                                                                                 
  /* prepare an address struct to listen for connections */                      
  bzero((char *) &servaddr, sizeof(servaddr));                                   
  servaddr.sin_family = AF_INET;                                                 
  servaddr.sin_addr.s_addr = htonl(INADDR_ANY);                                  
  servaddr.sin_port = proxy_port;                                                
                                                                                 
  /* get a socket... */                                                          
  if ((sockfd = socket(AF_INET,SOCK_STREAM,0)) < 0) 
  {                            
    fputs("failed to create server socket\r\n",stderr);                          
    exit(1);                                                                     
  }                                                                              
                                                                                 
  /* ...and bind our address and port to it */                                   
  if (bind(sockfd,(struct sockaddr_in *) &servaddr,sizeof(servaddr)) < 0) {      
    fputs("faild to bind server socket to specified port\r\n",stderr);           
    exit(1);                                                                     
  }                                                                              
                                                                                 
  /* get ready to accept with at most 5 clients waiting to connect */            
  listen(sockfd,5);                                                              
                                                                                 
  /* turn ourselves into a daemon */                                             
  daemonize(sockfd);                                                             
                                                                                 
  /* fall into a loop to accept new connections and spawn children */            
  while (1) {                                                                    
                                                                                 
    /* accept the next connection */                                             
    clilen = sizeof(cliaddr);                                                    
    newsockfd = accept(sockfd, (struct sockaddr_in *) &cliaddr, &clilen);        
    if (newsockfd < 0 && errno == EINTR)                                         
      continue;    /* a signal might interrupt our accept() call */              
    else if (newsockfd < 0)                                                      
      /* something quite amiss -- kill the server */                             
      errorout("failed to accept connection");                                   
                                                                                 
    /* fork a child to handle this connection */                                 
    if ((childpid = fork()) == 0) {                                              
      close(sockfd);                                                             
      do_proxy(newsockfd);                                                       
      exit(0);                                                                   
    }                                                                            
                                                                                 
    /* if fork() failed, the connection is silently dropped -- oops! */          
                                                                                 
    close(newsockfd);                                                            
  }                                                                              
}