/****************************************************************************
 *                   ^     +----- |  / ^     ^ |     | +-\                  *
 *                  / \    |      | /  |\   /| |     | |  \                 *
 *                 /   \   +---   |<   | \ / | |     | |  |                 *
 *                /-----\  |      | \  |  v  | |     | |  /                 *
 *               /       \ |      |  \ |     | +-----+ +-/                  *
 ****************************************************************************
 * AFKMud (c)1997-2002 Alsherok. Contributors: Samson, Dwip, Whir,          *
 * Cyberfox, Karangi, Rathian, Cam, Raine, and Tarl.                        *
 *                                                                          *
 * Original SMAUG 1.4a written by Thoric (Derek Snider) with Altrag,        *
 * Blodkai, Haus, Narn, Scryn, Swordbearer, Tricops, Gorog, Rennard,        *
 * Grishnakh, Fireblade, and Nivek.                                         *
 *                                                                          *
 * Original MERC 2.1 code by Hatchet, Furey, and Kahn.                      *
 *                                                                          *
 * Original DikuMUD code by: Hans Staerfeldt, Katja Nyboe, Tom Madsen,      *
 * Michael Seifert, and Sebastian Hammer.                                   *
 ****************************************************************************
 *                          DNS Resolver Module                             *
 ****************************************************************************/

#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <errno.h>
#include <ctype.h>
#include "mud.h"

DNS_DATA *first_cache;
DNS_DATA *last_cache;

void save_dns( void );

void prune_dns( void )
{
   DNS_DATA *cache, *cache_next;

   for( cache = first_cache; cache; cache = cache_next )
   {
	cache_next = cache->next;

	/* Stay in cache for 14 days */
	if( current_time - cache->time >= 1209600 || !str_cmp( cache->ip, "Unknown??" ) || !str_cmp( cache->name, "Unknown??" ) )
	{
	   STRFREE( cache->ip );
	   STRFREE( cache->name );
	   UNLINK( cache, first_cache, last_cache, next, prev );
	   DISPOSE( cache );
	}
   }
   save_dns();
   return;
}

void check_dns( void )
{
   if( current_time >= new_boot_time_t )
	prune_dns();
   return;
}

void add_dns( char *dhost, char *address )
{
   DNS_DATA *cache;

   CREATE( cache, DNS_DATA, 1 );
   cache->ip = STRALLOC( dhost );
   cache->name = STRALLOC( address );
   cache->time = current_time;
   LINK( cache, first_cache, last_cache, next, prev );

   save_dns();
   return;
}

char *in_dns_cache( char *ip )
{
   DNS_DATA *cache;
   static char dnsbuf[MSL];

   dnsbuf[0] = '\0';

   for( cache = first_cache; cache; cache = cache->next )
   {
	if( !str_cmp( ip, cache->ip ) )
	{
	   strcpy( dnsbuf, cache->name );
	   break;
	}
   }
   return dnsbuf;
}

#if defined(KEY)
#undef KEY
#endif

#define KEY( literal, field, value )					\
				if ( !str_cmp( word, literal ) )	\
				{					\
				      field = value;			\
				      fMatch = TRUE;			\
				      break;				\
				}

void fread_dns( DNS_DATA *cache, FILE *fp )
{
   char *word;
   bool fMatch;

   for ( ; ; )
   {
	word   = feof( fp ) ? "End" : fread_word( fp );
	fMatch = FALSE;

	switch ( UPPER(word[0]) )
	{
	   case '*':
	      fMatch = TRUE;
	      fread_to_eol( fp );
	   break;

	   case 'E':
	      if ( !str_cmp( word, "End" ) )
	      {
		   if( !cache->ip )
		      cache->ip = STRALLOC( "Unknown??" );
		   if( !cache->name )
			cache->name = STRALLOC( "Unknown??" );
		   return;
	      }
	   break;

	   case 'I':
	      KEY( "IP", cache->ip, fread_string( fp ) );
	   break;

	   case 'N':
	      KEY( "Name", cache->name, fread_string( fp ) );
	   break;

	   case 'T':
		KEY( "Time", cache->time, fread_number( fp ) );
	   break;
	}

	if( !fMatch )
	   bug( "fread_dns: no match: %s", word );
   }
}

void load_dns( void )
{
   char filename[256];
   DNS_DATA *cache;
   FILE *fp;
     
   first_cache = NULL;
   last_cache = NULL;

   sprintf( filename, "%s", DNS_FILE );

   if( ( fp = fopen( filename, "r" ) ) != NULL )
   {
	for ( ; ; )
	{
	   char letter;
	   char *word;

	   letter = fread_letter( fp );
	   if ( letter == '*' )
	   {
		fread_to_eol( fp );
		continue;
	   }

	   if ( letter != '#' )
	   {
		bug( "load_dns: # not found.", 0 );
		break;
	   }

	   word = fread_word( fp );
	   if ( !str_cmp( word, "CACHE" ) )
	   {
		CREATE( cache, DNS_DATA, 1 );
		fread_dns( cache, fp );
		LINK( cache, first_cache, last_cache, next, prev );
		continue;
	   }
	   else
            if ( !str_cmp( word, "END"	) )
	         break;
	   else
	   {
		bug( "load_dns: bad section: %s.", word );
		continue;
	   }
	}
	FCLOSE( fp );
   }
   prune_dns(); /* Clean out entries beyond 14 days */
   return;
}

void save_dns( void )
{
   DNS_DATA *cache;
   FILE *fp;
   char filename[256];

   sprintf( filename, "%s", DNS_FILE );

   if ( ( fp = fopen( filename, "w" ) ) == NULL )
   {
	bug( "save_dns: fopen", 0 );
	perror( filename );
   }
   else
   {
	for( cache = first_cache; cache; cache = cache->next )
      {
	   fprintf( fp, "#CACHE\n" );
	   fprintf( fp, "IP		%s~\n",	cache->ip );
	   fprintf( fp, "Name		%s~\n",	cache->name );
	   fprintf( fp, "Time		%ld\n",	cache->time );
	   fprintf( fp, "End\n\n" );
	}
	fprintf( fp, "#END\n" );
	FCLOSE(fp);
   }
   return;
}

/* DNS Resolver code by Trax of Forever's End */
/*
 * Almost the same as read_from_buffer...
 */
bool read_from_dns( int fd, char *buffer )
{
   static char inbuf[MAX_STRING_LENGTH*2];
   int iStart, i, j, k;

   /* Check for overflow. */
   iStart = strlen( inbuf );
   if ( iStart >= sizeof( inbuf ) - 10 )
   {
	bug( "DNS input overflow!!!", 0 );
	return FALSE;
   }

   /* Snarf input. */
   for ( ; ; )
   {
	int nRead;

	nRead = read( fd, inbuf + iStart, sizeof( inbuf ) - 10 - iStart );
	if ( nRead > 0 )
	{
	   iStart += nRead;
	   if ( inbuf[iStart-2] == '\n' || inbuf[iStart-2] == '\r' )
		break;
	}
	else if ( nRead == 0 )
	{
	   return FALSE;
	}
	else if ( errno == EWOULDBLOCK )
	   break;
	else
	{
	   perror( "Read_from_dns" );
	   return FALSE;
	}
   }

   inbuf[iStart] = '\0';

   /*
    * Look for at least one new line.
    */
   for( i = 0; inbuf[i] != '\n' && inbuf[i] != '\r'; i++ )
   {
	if( inbuf[i] == '\0' )
	   return FALSE;
   }

   /*
    * Canonical input processing.
    */
   for( i = 0, k = 0; inbuf[i] != '\n' && inbuf[i] != '\r'; i++ )
   {
	if ( inbuf[i] == '\b' && k > 0 )
	   --k;
	else if( isascii( inbuf[i] ) && isprint( inbuf[i] ) )
	   buffer[k++] = inbuf[i];
   }

   /*
    * Finish off the line.
    */
   if( k == 0 )
	buffer[k++] = ' ';
   buffer[k] = '\0';

   /*
    * Shift the input buffer.
    */
   while( inbuf[i] == '\n' || inbuf[i] == '\r' )
	i++;
   for ( j = 0; ( inbuf[j] = inbuf[i+j] ) != '\0'; j++ )
	;
    
   return TRUE;
}

/* DNS Resolver code by Trax of Forever's End */
/*
 * Process input that we got from resolve_dns.
 */
void process_dns( DESCRIPTOR_DATA *d )
{
   char address[MIL];
   int status;
    
   address[0] = '\0';
    
   if( !read_from_dns( d->ifd, address ) || address[0] == '\0' )
    	return;
    
   if ( address[0] != '\0' )
   {
	add_dns( d->host, address ); /* Add entry to DNS cache */
	STRFREE( d->host );
      d->host = STRALLOC( address );
	if( d->character )
	{
	   STRFREE( d->character->pcdata->lasthost );
	   d->character->pcdata->lasthost = STRALLOC( address );
	}
   }
    
   /* close descriptor and kill dns process */
   if( d->ifd != -1 )
   {
      close( d->ifd );
      d->ifd = -1;
   }

   /* 
    * we don't have to check here, 
    * cos the child is probably dead already. (but out of safety we do)
    * 
    * (later) I found this not to be true. The call to waitpid( ) is
    * necessary, because otherwise the child processes become zombie
    * and keep lingering around... The waitpid( ) removes them.
    */
   if( d->ipid != -1 )
   {
      waitpid( d->ipid, &status, 0 );
      d->ipid = -1;
   }
   return;
}

/* DNS Resolver hook. Code written by Trax of Forever's End */
void resolve_dns( DESCRIPTOR_DATA *d, long ip )
{
   int fds[2];
   pid_t pid;
    
   /* create pipe first */
   if( pipe( fds )!=0 )
   {
      perror( "resolve_dns: pipe: " );
      return;
   }
    
   if( dup2( fds[1], STDOUT_FILENO ) != STDOUT_FILENO )
   {
      perror( "resolve_dns: dup2(stdout): " );
      return;
   }
    
   if( ( pid = fork() ) > 0 )
   {
    	/* parent process */
    	d->ifd  = fds[0];
    	d->ipid = pid;
      close( fds[1] );
   }
   else if( pid == 0 )
   {
    	/* child process */
	char str_ip[64];
	int i;
        
    	d->ifd  = fds[0]; 
    	d->ipid = pid;

      for( i = 2; i < 255; ++i ) close(i);

	sprintf( str_ip, "%ld", ip );
    	execl( "../src/resolver", "AFKMud Resolver", str_ip, NULL );
    	/* Still here --> hmm. An error. */
    	bug( "resolve_dns: Exec failed; Closing child.", 0 );
    	d->ifd  = -1;
    	d->ipid = -1;    	
    	exit( 0 );
   }
   else 
   {
    	/* error */
    	perror( "resolve_dns: failed fork" );
    	close( fds[0] );
    	close( fds[1] );
   }
}

void do_cache( CHAR_DATA *ch, char *argument )
{
   DNS_DATA *cache;
   int ip = 0;

   send_to_pager( "&YCached DNS Information\n\r", ch );
   send_to_pager( "IP               | Address\n\r", ch );
   send_to_pager( "------------------------------------------------------------------------------\n\r", ch );
   for( cache = first_cache; cache; cache = cache->next )
   {
	pager_printf( ch, "&W%16.16s  &Y%s\n\r", cache->ip, cache->name );
	ip++;
   }
   pager_printf( ch, "\n\r&W%d IPs in the cache.\n\r", ip );
   return;
}