#!/usr/bin/perl
#------------------------------------------------------------------------------
# $Id$
# Get server connection setting XML
# Copyright (c) BAYBITS LLC. All rights reserved.
#------------------------------------------------------------------------------

use strict;
use utf8;
use CGI;
use TF::CommonUtils;
use URI::Escape;
use XML::DOM;
use TF::CommonUtils;
use TF::XMLUtils;
use Encode;

#
# global
#
my $BRAND         = $ENV{'TF_BRANDNAME'} || '';
my $LOCATION      = $ENV{'TF_LOCATION'} || '';
my $LANGPARAM     = TF::CommonUtils::getLangPriority();
my $CONF_ROOT     = $ENV{'TF_CONFIG_ROOT'} || '/usr/local/teamfile/www/conf/conf.d';

my $SERVERNAME    = $ENV{'SERVER_NAME'} || '';
my ($SCHEMA,$SERVERPORT,$dummy) = TF::CommonUtils::getCgiConnectInfo();

my $SETTINGS_DIR  = $CONF_ROOT . '/clientdata';
my $LOCATION_NAME = $LOCATION;
$LOCATION_NAME    =~ s/\///g;
my $TEMPLATE_TF   = $SETTINGS_DIR . '/teamfile_tfsv.tmpl';
my $TEMPLATE_SF   = $SETTINGS_DIR . '/smartfile_sfsv.tmpl';
my $MIME_TF       = 'application/tfsv-xml';
my $MIME_SF       = 'application/sfsv-xml';

my $MSGTABLE_ja  = {
					CGIError => "CGIエラーです",
					MissingFileName => "ファイル名が指定されておりません",
					MissingSchema => "アクセス元のスキーマ名が見つかりません",
					InvalidSchema => "アクセス元のスキーマ名が正しくありません",
					MissingHostinfo => "アクセス元のホスト情報が見つかりません",
					};

my $MSGTABLE_en  = {
					CGIError => "CGI error found.",
					MissingFileName => "The filename is missing.",
					MissingSchema => "The schema parameter is missing.",
					InvalidSchema => "The schema parameter is invalid.",
					MissingHostinfo => "The hostinfo parameter is missing.",
					};
my $MSGTABLE     = ($LANGPARAM eq 'ja') ? $MSGTABLE_ja : $MSGTABLE_en;

if (!$LOCATION) {
	TF::CommonUtils::showAccessDeny();
	die '';
}

main();

#
# main 
#
sub main {
	my $cgi = new CGI;
	if( ! $cgi ) {
		binmode(STDOUT, ":utf8");
		TF::CommonUtils::showErrorPage($MSGTABLE->{CGIError}, $LANGPARAM);
		print STDERR "CGI Object error";
		return;
	}

	if( $cgi->cgi_error ) {
		binmode(STDOUT, ":utf8");
		TF::CommonUtils::showErrorPage($MSGTABLE->{CGIError} . $cgi->cgi_error, $LANGPARAM);
		print STDERR "CGI Error (" . $cgi->cgi->error . ")";
		return;
	}

	my $enc_filename = $cgi->param('file') || '';
	if (!$enc_filename) {
		binmode(STDOUT, ":utf8");
		TF::CommonUtils::showErrorPage($MSGTABLE->{MissingFileName}, $LANGPARAM);
		return;
	}
	my $filename = TF::CommonUtils::decodeUTF8($enc_filename);
	$filename =~ s/\n//g;
	$filename =~ s/\r//g;
	$filename =~ s/\///g;
	my ($prefix, $ext) = split(/\./, $filename);

	# get request-SCHEMA and request-HOSTINFO
	my $reqSchema = $cgi->param('hidSchema');
	if (!$reqSchema) {
		binmode(STDOUT, ":utf8");
		TF::CommonUtils::showErrorPage($MSGTABLE->{MissingSchema}, $LANGPARAM);
		return;
	}
	my $USE_SSL = undef;
	if ($reqSchema eq 'https:' or $reqSchema eq 'https') {
		$USE_SSL = 'on';
	}
	elsif ($reqSchema eq 'http:' or $reqSchema eq 'http') {
		$USE_SSL = 'off';
	}
	else {
		binmode(STDOUT, ":utf8");
		TF::CommonUtils::showErrorPage($MSGTABLE->{InvalidSchema}, $LANGPARAM);
		return;
	}

	my $reqHostinfo = $cgi->param('hidHostinfo');
	if (!$reqHostinfo) {
		binmode(STDOUT, ":utf8");
		TF::CommonUtils::showErrorPage($MSGTABLE->{MissingHostinfo}, $LANGPARAM);
		return;
	}
	my ($reqHost, $reqPort) = split(/:/, $reqHostinfo);
	if ($reqHost) {
		$SERVERNAME = $reqHost;
	}
	if ($reqPort) {
		$SERVERPORT = $reqPort;
	}
	else {
		# insert default port number
		if ($USE_SSL eq 'on') {
			$SERVERPORT = 443;
		}
		elsif ($USE_SSL eq 'off') {
			$SERVERPORT = 80;
		}
	}

	# Check directive values (for downward compatibility)
	my $NOTIFYSERVER_NAME   = $ENV{'TF_NOTIFYSERVER_NAME'} || undef;
	my $NOTIFYSERVER_PORT   = $ENV{'TF_NOTIFYSERVER_PORT_ORIG'} || undef;
	my $NOTIFYSERVER_SCHEMA = $ENV{'TF_NOTIFYSERVER_SCHEMA_ORIG'} || undef;

	if ($NOTIFYSERVER_NAME) {
		$SERVERNAME = $NOTIFYSERVER_NAME;
	}
	if ($NOTIFYSERVER_PORT && $NOTIFYSERVER_PORT ne 'auto') {
		$SERVERPORT = $NOTIFYSERVER_PORT;
	}
	if ($NOTIFYSERVER_SCHEMA && $NOTIFYSERVER_SCHEMA ne 'auto') {
		if ($NOTIFYSERVER_SCHEMA eq 'https') {
			$USE_SSL = 'on';
		}
		elsif ($NOTIFYSERVER_SCHEMA eq 'http') {
			$USE_SSL = 'off';
		}
	}

	# Read template file
	my %tmplvals = readTeamplate($ext);

	my %retVals = ();
	$retVals{mimetype} = ($ext eq 'sfsv') ? $MIME_SF : $MIME_TF;

	# (1) FileName
	$retVals{filename} = $filename;

	# (2) DisplayName
	$retVals{Name} = ($tmplvals{Name}) ? $tmplvals{Name} : $LOCATION_NAME;

	# (3) HostName
	$retVals{HostName} = ($tmplvals{HostName}) ? $tmplvals{HostName} : $SERVERNAME;

	# (4) Port number
	$retVals{Port} = ($tmplvals{Port}) ? $tmplvals{Port} : $SERVERPORT;

	# (5) HTTP / HTTPS
	$retVals{UseSSL} = ($tmplvals{UseSSL}) ? ($tmplvals{UseSSL}) : (($USE_SSL eq 'on') ? 1 : 0);

	# (6) Location
	$retVals{URI} = $LOCATION . '/';

	# (7) Use agent
	$retVals{SubscribeWithAgent} = $tmplvals{SubscribeWithAgent};

	# (8) Ignore LOCK
	$retVals{OmitLockOperation} = $tmplvals{OmitLockOperation};

	# (9) Use compress
	$retVals{RequestDataCompression} = $tmplvals{RequestDataCompression};

	# (10) Proxy
	$retVals{ProxySettings} = $tmplvals{ProxySettings};

	# (11) Proxy Host
	$retVals{ProxyHost} = $tmplvals{ProxyHost};

	# (12) Proxy Port
	$retVals{ProxyPort} = $tmplvals{ProxyPort};

	# (13) Uri prefix
	$retVals{URIPrefix} = $tmplvals{URIPrefix};

	#
	# write to stream
	#
	writeData2Stream(\%retVals);
}

#
# Read template file
#
sub readTeamplate {
	my $ext = shift || '';

	if (!$ext) {
		return undef;
	}
	my %params = ();
	my $template = ($ext eq 'sfsv') ? $TEMPLATE_SF : $TEMPLATE_TF;

	if (-f $template) {
		my $xml = new XML::DOM::Parser;
		my $doc = $xml->parsefile($template);

		for my $elem ( $doc->getElementsByTagName("tfserversetting") ) {
			$params{Name}                   = TF::XMLUtils::getText($elem, "Name");
			$params{HostName}               = TF::XMLUtils::getText($elem, "HostName");
			$params{Port}                   = TF::XMLUtils::getText($elem, "Port");
			$params{UseSSL}                 = TF::XMLUtils::getText($elem, "UseSSL");
			$params{URI}                    = TF::XMLUtils::getText($elem, "URI");
			$params{SubscribeWithAgent}     = TF::XMLUtils::getText($elem, "SubscribeWithAgent") || '0';
			$params{OmitLockOperation}      = TF::XMLUtils::getText($elem, "OmitLockOperation")  || '0';
			$params{RequestDataCompression} = TF::XMLUtils::getText($elem, "RequestDataCompression") || '0';
			$params{ProxySettings}          = TF::XMLUtils::getText($elem, "ProxySettings") || '0';
			$params{ProxyHost}              = TF::XMLUtils::getText($elem, "ProxyHost") || '';
			$params{ProxyPort}              = TF::XMLUtils::getText($elem, "ProxyPort") || '0';
			$params{URIPrefix}              = TF::XMLUtils::getText($elem, "URIPrefix") || '';
		}
		$doc->dispose;
	}

	return %params;
}

#
# Write to stream
#
sub writeData2Stream {
	my $param_ref = shift || undef;

	if (!$param_ref) {
		return;
	}
	my %retVals = %{$param_ref};

	print <<"_EOF_";
Content-type: $retVals{mimetype}; charset=UTF-8\r
Content-Disposition:attachment; filename=$retVals{filename}\r

<?xml version="1.0" encoding="UTF-8" standalone="no" ?>\r
<tfserversetting>\r
  <Name>$retVals{Name}</Name>\r
  <HostName>$retVals{HostName}</HostName>\r
  <Port>$retVals{Port}</Port>\r
  <UseSSL>$retVals{UseSSL}</UseSSL>\r
  <URI>$retVals{URI}</URI>\r
  <SubscribeWithAgent>$retVals{SubscribeWithAgent}</SubscribeWithAgent>\r
  <OmitLockOperation>$retVals{OmitLockOperation}</OmitLockOperation>\r
  <RequestDataCompression>$retVals{RequestDataCompression}</RequestDataCompression>\r
  <ProxySettings>$retVals{ProxySettings}</ProxySettings>\r
  <ProxyHost>$retVals{ProxyHost}</ProxyHost>\r
  <ProxyPort>$retVals{ProxyPort}</ProxyPort>\r
  <URIPrefix>$retVals{URIPrefix}</URIPrefix>\r
</tfserversetting>\r
_EOF_

}

