}                                                                              
}                                                                                
                                                                                 
                                                                                 
                                                                                 
/****************************************************************************    
  function:      parse_args                                                      
  description:   parse the command line args.                                    
  arguments:                                                                     
    argc,argv    you know what these are.                                        
                                                                                 
  return value:  none.                                                           
  calls:         none.                                                           
  globals:       writes proxy_port, writes hostaddr.                             
 ****************************************************************************/   
                                                                                 
void parse_args (argc,argv)                                                      
int argc;                                                                        
char **argv;                                                                     
{                                                                                
  int i;                                                                         
  struct hostent *hostp;                                                         
  struct servent *servp;                                                         
  unsigned long inaddr;                                                          
  struct {                                                                       
    char proxy_port [16];                                                        
    char isolated_host [64];                                                     
    char service_name [32];                                                      
  } pargs;                                                                       
                                                                                 
                                                                                 
  if (argc < 4) {                                                                
    printf("usage:  %s <proxy-port> <host> <service-name|port-number>\r\n",      
           argv[0]);                                                             
    exit(1);                                                                     
  }                                                                              
                                                                                 
  strcpy(pargs.proxy_port,argv[1]);                                              
  strcpy(pargs.isolated_host,argv[2]);                                           
  strcpy(pargs.service_name,argv[3]);                                            
                                                                                 
  for (i = 0;  i < strlen(pargs.proxy_port);  i++)                               
    if (!isdigit(*(pargs.proxy_port + i)))                                       
      break;                                                                     
                                                                                 
  if (i == strlen(pargs.proxy_port))                                             
    proxy_port = htons(atoi(pargs.proxy_port));                                  
  else {                                                                         
    printf("%s: invalid proxy port\r\n",pargs.proxy_port);                       
    exit(0);                                                                     
  }                                                                              
                                                                                 
  bzero(&hostaddr,sizeof(hostaddr));                                             
  hostaddr.sin_family = AF_INET;                                                 
  if ((inaddr = inet_addr(pargs.isolated_host)) != INADDR_NONE)                  
    bcopy(&inaddr,&hostaddr.sin_addr,sizeof(inaddr));                            
  else if ((hostp = gethostbyname(pargs.isolated_host)) != NULL)                 
    bcopy(hostp->h_addr,&hostaddr.sin_addr,hostp->h_length);                     
  else {                                                                         
    printf("%s: unknown host\r\n",pargs.isolated_host);                          
    exit(1);                                                                     
  }                                                                              
                                                                                 
  if ((servp = getservbyname(pargs.service_name,TCP_PROTO)) != NULL)             
    hostaddr.sin_port = servp->s_port;                                           
  else if (atoi(pargs.service_name) > 0)                                         
    hostaddr.sin_port = htons(atoi(pargs.service_name));                         
  else {                                                                         
    printf("%s: invalid/unknown service name or port number\r\n",                
           pargs.service_name);                                                  
    exit(1);                                                                     
  }                                                                              
}                                                                                
                                                                                 
                                                                                 
                                                                                 
/****************************************************************************    
  function:      daemonize                                                       
  description:   detach the server process from the current context,             
                 creating a pristine, predictable environment in which it        
                 will execute.                                                   
  arguments:                                                                     
    servfd       file descriptor in use by server.                               
                                                                                 
  return value:  none.                                                           
  calls:         none.                                                           
  globals:       none.                                                           
 ****************************************************************************/   
                                                                                 
void daemonize (servfd)                                                          
int servfd;                                                                      
{                                                                                
  int childpid, fd, fdtablesize;                                                 
                                                                                 
  /* ignore terminal I/O, stop signals */                                        
  signal(SIGTTOU,SIG_IGN);                                                       
  signal(SIGTTIN,SIG_IGN);                                                       
  signal(SIGTSTP,SIG_IGN);                                                       
                                                                                 
  /* fork to put us in the background (whether or not the user                   
     specified '&' on the command line */                                        
                                                                                 
  if ((childpid = fork()) < 0) {                                                 
    fputs("failed to fork first child\r\n",stderr);                              
    exit(1);                                                                     
  }                                                                              
  else if (childpid > 0)                                                         
    exit(0);    /* terminate parent, continue in child */                        
                                                                                 
  /* dissociate from process group */                                            
  if (setpgrp(0,getpid()) < 0) {                                                 
    fputs("failed to become process group leader\r\n",stderr);                   
    exit(1);                                                                     
  }                                                                              
                                                                                 
  /* lose controlling terminal */                                                
  if ((fd = open("/dev/tty",O_RDWR)) >= 0) {                                     
    ioctl(fd,TIOCNOTTY,NULL);                                                    
    close(fd);                                                                   
  }                                                                              
                                                                                 
  /* close any open file descriptors */                                          
  for (fd = 0, fdtablesize = getdtablesize();  fd < fdtablesize;  fd++)          
    if (fd != servfd)                                                            
      close(fd);                                                                 
                                                                                 
  /* set working directory to / to allow filesystems to be unmounted */          
  chdir("/");                                                                    
                                                                                 
  /* clear the inherited umask */                                                
  umask(0);                                                                      
                                                                                 
  /* setup zombie prevention */