#!/usr/bin/perl -w
#
# Utility to generate a zone file, add an entry to mail server configs
# and the entries for httpsd.conf and /etc/named.conf.

# sub generic_sort_config # ( $config_file, $begin_section_pattern, $end_section_pattern, $additional_section,
#				@order_tags );
# sub sort_sections_by_tags # ( $a, $b )
# sub get_input # ( $prompt_string, $valid_pattern );
# sub get_new_file # ( $prompt_string );
# sub get_existing_dir # ( $prompt_string );
# sub get_host_name # ( $prompt_string );
# sub courier_control
# sub add_http_vhost
# sub create_zone_file
# sub add_to_named_conf


use strict;


sub generic_sort_config
{
    my $build_section = "";
    my @sections;
    my $other_lines = "";
    my $bracket_count = 0;
    my $position = 0;
    my ( $config_file, $begin_section_pattern, $end_section_pattern, $additional_section,
	 @order_tags ) = @_;
    @GenericSortConfig::order_tags = @order_tags;

    if( ! open(CONF, $config_file) )
    {
	print "Error opening ${config_file}.\n";
	return 1;
    }

    my $conf_line = <CONF>;
    while( defined($conf_line) )
    {
	if ( $conf_line =~ m/(.*${begin_section_pattern})/ )
	{
	    $bracket_count++;
	    $build_section .= $1;
	    $conf_line = substr $conf_line, length $1, length $conf_line;
	    next;
	}

	if ( $conf_line =~ m/(.*${end_section_pattern})/ )
	{
	    if( $bracket_count == 1 )
	    {
		$build_section .= $1;
		$conf_line = substr $conf_line, length $1, length $conf_line;
		while( defined($conf_line) && $conf_line eq "\n" )
		{
		    $build_section .= "\n";
		    $conf_line = <CONF>;
		}

		splice(@sections, $#sections+1, 0, $build_section);
		$build_section = "";
	    }
	    elsif( $bracket_count > 1 )
	    {
		$build_section .= $1;
		$conf_line = substr $conf_line, length $1, length $conf_line;
	    }
	    $bracket_count--;
	    next;
	}

	if( $bracket_count > 0 )
	{
	    $build_section .= $conf_line;
	    $conf_line = "";
	}
	else
	{
	    $other_lines .= $conf_line;
	    $conf_line = "";
	}

	if( $conf_line eq "" )
	{
	    $conf_line = <CONF>;
	}
    }
    close(CONF);


    splice(@sections, $#sections+1, 0, $additional_section);

    @sections = sort sort_sections_by_tags @sections;

    if( ! open(CONF, ">${config_file}") )
    {
	print "\n\nError opening $config_file for writing.\n\n";
	return 1;
    }

    print CONF $other_lines;
    print CONF @sections;

    close(CONF);
}


sub sort_sections_by_tags # ( $a, $b )
{
    my $aval = -1;
    my $bval = -1;

    foreach $GenericSortConfig::tag (@GenericSortConfig::order_tags)
    {
	$aval = $GenericSortConfig::tag->[1] if( $aval == -1 && $a =~ m/$GenericSortConfig::tag->[0]/ );
	$bval = $GenericSortConfig::tag->[1] if( $bval == -1 && $b =~ m/$GenericSortConfig::tag->[0]/ );
    }

    return $aval cmp $bval if( $aval != $bval );
    return $a cmp $b;
}


sub get_input # ( $prompt_string, $valid_pattern )
{
    my ( $prompt, $pattern ) = @_;
    my ( $response );

    print "${prompt} ";
    $response = <STDIN>;
    chomp($response);
    return "" if($response !~ m/$pattern/);
    return $response;
}

sub get_new_file # ( $prompt_string )
{
    my ( $prompt ) = @_;
    my ( $response );

    print "${prompt} ";
    $response = <STDIN>;
    chomp($response);
    return "" if( -e $response);
    return $response;
}

sub get_existing_dir # ( $prompt_string )
{
    my ( $prompt ) = @_;
    my ( $response );

    print "${prompt} ";
    $response = <STDIN>;
    chomp($response);
    return "" if( ! -d $response);
    return $response;
}

sub get_host_name # ( $prompt_string )
{
    my ( $prompt ) = @_;
    my ( $response, $inetn, $host );

    print "${prompt} ";
    $response = <STDIN>;
    chomp($response);
    $inetn = gethostbyname($response);

    return "" if ( ! $inetn );

    my ($a, $b, $c, $d) = unpack('C4', $inetn);
    $host = "$a.$b.$c.$d";
    return $host;
}

sub courier_control
{
    my ( $chfile ) = @_;
    my ( @DOMAINS, @NEW );

    open(RCPT, "/etc/courier/${chfile}");
    @DOMAINS = <RCPT>;
    close(RCPT);
    @NEW = $main::domain."\n";
    splice(@DOMAINS, $#DOMAINS+1, 0, @NEW);

    @DOMAINS = sort @DOMAINS;

    if( ! open(RCPT, ">/etc/courier/${chfile}") )
    {
	print STDERR "Error writing to /etc/courier/${chfile}.\n";
	return 1;
    }
    print RCPT @DOMAINS;
    close(RCPT);
}

sub add_http_vhost
{
    return if( $main::http_location eq "");

    my $http_vhost =
"<VirtualHost 63.164.112.5:80>
	ServerName ${main::domain}
	ServerAlias ${main::domain} \*.${main::domain}
	DocumentRoot \"${main::http_location}/html\"
	<Directory \"${main::http_location}/html\">
	    Options Indexes Includes FollowSymLinks
	    AllowOverride None
	    Order allow,deny
	    Allow from all
	</Directory>
	ScriptAlias /cgi-bin/ \"${main::http_location}/cgi-bin/\"
	<Directory \"${main::http_location}/cgi-bin\">
	    AllowOverride None
	    Options ExecCGI
	    Order allow,deny
	    Allow from all
	</Directory>
</VirtualHost>

";

    my @otags = ( ["ServerName", 0] );
    generic_sort_config( "/etc/httpd/conf/vhosts",
			 "<VirtualHost", "</VirtualHost>", $http_vhost, @otags );
}

sub create_zone_file
{
    my $zone_file = "/var/named/db.${main::domain}";
    if( -e $zone_file)
    {
	print "${main::zone_file} already exists.  I will continue, but will not change that file!\n";
	return 1;
    }

    if( ! open(ZONE, ">${main::zone_file}") )
    {
	print "\n\nError writing zone file!!\n\n";
	return 1;
    }
    if( ! open(TEMPLATE, "/var/named/bin/template") )
    {
	print "\n\nCouldn't read template!!\n\n";
	return 1;
    }

    while (my $tline = <TEMPLATE>)
    {
	$tline =~ s/DOMAIN_NAME/$main::domain/g;
	print ZONE "$tline";
    }

    close(TEMPLATE);
    close(ZONE);
}

sub add_to_named_conf
{
    my $named_section;

    if( $main::type =~ m/master/i )
    {
#### sorta ugly
	$named_section = "zone \"${main::domain}\"{
	type master;
	file \"db.${main::domain}\";
};

";
###############
    }
    else # ( $type =~ m/slave/i )
    {
#### sorta ugly
	$named_section = "zone \"${main::domain}\"{
	type slave;
	file \"db.${main::domain}\";
	masters {
		${main::dns_master};
	};
};

";
###############
    }

    my @otags = ( ["type\\s*hint", 0],
		  ["type\\s*master", 1],
		  ["type\\s*slave",  2] );
    generic_sort_config( "/etc/named.conf",
			 "{", "};", $named_section, @otags );
}





###################################
##
## main:
##
###################################

$main::type = "";
$main::domain = "";
$main::dns_master = "";
$main::http_location = "";

while ( ($main::type = &get_input("Will this domain be a master or a slave?",
				  "master|slave")) eq "" )
{
    print "The correct answer to this question is either \"master\" or \"slave\", Dave! Please try again.\n";
}

while ( ($main::domain = &get_input("Enter new domain name:",
				    "^[-a-z0-9.]+\\....\$")) eq "" )
{
    print "That doesn't exactly look like a domain name to me... Try again.\n";
}

if($main::type =~ m/slave/i)
{
    while( ($main::dns_master = &get_host_name( "Enter IP address of this domain's master:" )) eq "" )
    {
	print "That is not a valid IP address, DAVE!  Please try again.\n";
    }
    &add_to_named_conf;
}
elsif($main::type =~ m/master/i)
{
    # It's ok to not specify anything at all...
    #while( ($location = &get_existing_dir( "Enter directory where the virtual domain will reside:" )) eq "" )
    #{
    #	print "please use an existing dir\n";
    #}
    #$http_location = &get_existing_dir( "Enter directory where the virtual domain will reside:" );
    $main::http_location = &get_input( "Enter directory where the virtual domain will reside:", "." );

    # If we are the master, then assume that we are going to host the mail and http servers
    &courier_control("esmtpacceptmailfor.dir/system");
    &courier_control("locals");
    &add_http_vhost;
    &create_zone_file;
    &add_to_named_conf;

    system("/usr/lib/courier/sbin/makeacceptmailfor");
    system("/etc/init.d/courier stop");
    system("/etc/init.d/courier start");
    system("/etc/init.d/named reload");
    print("Restart the web server when you are ready.\n");
}