public function ApacheVhostCreate($DomainName, $FarmID, $FarmRoleID, $DocumentRootDir, $EnableSSL, $SSLPrivateKey = null, $SSLCertificate = null)
{
$validator = new Validator();
if (!$validator->IsDomain($DomainName)) {
$err[] = _("Domain name is incorrect");
}
$DBFarm = DBFarm::LoadByID($FarmID);
if ($DBFarm->EnvID != $this->Environment->id) {
throw new Exception(sprintf("Farm #%s not found", $FarmID));
}
$DBFarmRole = DBFarmRole::LoadByID($FarmRoleID);
if ($DBFarm->ID != $DBFarmRole->FarmID) {
throw new Exception(sprintf("FarmRole #%s not found on Farm #%s", $FarmRoleID, $FarmID));
}
if (!$DocumentRootDir) {
throw new Exception(_("DocumentRootDir required"));
}
$options = serialize(array("document_root" => trim($DocumentRootDir), "logs_dir" => "/var/log", "server_admin" => $this->user->getEmail()));
$httpConfigTemplateSSL = @file_get_contents(dirname(__FILE__) . "/../../templates/services/apache/ssl.vhost.tpl");
$httpConfigTemplate = @file_get_contents(dirname(__FILE__) . "/../../templates/services/apache/nonssl.vhost.tpl");
$vHost = Scalr_Service_Apache_Vhost::init();
$vHost->envId = (int) $this->Environment->id;
$vHost->clientId = $this->user->getAccountId();
$vHost->domainName = $DomainName;
$vHost->isSslEnabled = $EnableSSL ? true : false;
$vHost->farmId = $FarmID;
$vHost->farmRoleId = $FarmRoleID;
$vHost->httpdConf = $httpConfigTemplate;
$vHost->templateOptions = $options;
//SSL stuff
if ($vHost->isSslEnabled) {
if ($SSLCertificate) {
$vHost->sslCert = base64_decode($SSLCertificate);
}
if ($SSLPrivateKey) {
$vHost->sslKey = base64_decode($SSLPrivateKey);
}
$vHost->httpdConfSsl = $httpConfigTemplateSSL;
} else {
$vHost->sslCert = "";
$vHost->sslKey = "";
$vHost->caCert = "";
$vHost->httpdConfSsl = "";
}
$vHost->save();
$servers = $DBFarm->GetServersByFilter(array('status' => array(SERVER_STATUS::INIT, SERVER_STATUS::RUNNING)));
foreach ($servers as $dBServer) {
if ($dBServer->GetFarmRoleObject()->GetRoleObject()->hasBehavior(ROLE_BEHAVIORS::NGINX) || $dBServer->GetFarmRoleObject()->GetRoleObject()->hasBehavior(ROLE_BEHAVIORS::APACHE)) {
$dBServer->SendMessage(new Scalr_Messaging_Msg_VhostReconfigure());
}
}
$response = $this->CreateInitialResponse();
$response->Result = 1;
return $response;
}
if ($registry_config->idn)
{
$allowed_utf8_chars = $registry_config->idn->xpath("//allowed-utf8-chars");
$disallowed_utf8_chars = $registry_config->idn->xpath("//disallowed-utf8-chars");
if ($allowed_utf8_chars[0] || $disallowed_utf8_chars[0])
{
$Validator = new Validator();
if (!$Validator->IsDomain("{$attr["name"]}.{$TLD}", null, null, (string)$allowed_utf8_chars[0], (string)$disallowed_utf8_chars[0]))
throw new Exception(_("Domain name contains non-supported characters"));
}
}
else
{
$Validator = new Validator();
if (!$Validator->IsDomain("{$attr["name"]}.{$TLD}"))
throw new Exception(_("Domain name contains non-supported characters"));
}
if ($attr["isTransfer"] == "false")
{
if ($Registry->DomainCanBeRegistered($Domain)->Result && !DBDomain::GetInstance()->ActiveDomainExists($Domain))
$res = "AVAIL";
else
$res = "NOT_AVAIL";
}
else
{
if ($Registry->DomainCanBeTransferred($Domain) && !DBDomain::GetInstance()->ActiveDomainExists($Domain))
$res = "AVAIL";
else
public function xSaveAction()
{
$validator = new Validator();
try {
if (!$validator->IsDomain($this->getParam('domainName'))) {
$err['domainName'] = _("Domain name is incorrect");
}
if (!$this->getParam('farmId')) {
$err['farmId'] = _("Farm required");
} else {
$dbFarm = DBFarm::LoadByID($this->getParam('farmId'));
$this->user->getPermissions()->validate($dbFarm);
}
if (!$this->getParam('farmRoleId')) {
$err['farmRoleId'] = _("Role required");
} else {
$dbFarmRole = DBFarmRole::LoadByID($this->getParam('farmRoleId'));
if ($dbFarmRole->FarmID != $dbFarm->ID) {
$err['farmRoleId'] = _("Role not found");
}
}
if (!$validator->IsEmail($this->getParam('serverAdmin'))) {
$err['serverAdmin'] = _("Server admin's email is incorrect or empty ");
}
if (!$this->getParam('documentRoot')) {
$err['documentRoot'] = _("Document root required");
}
if (!$this->getParam('logsDir')) {
$err['logsDir'] = _("Logs directory required");
}
if ($this->db->GetOne("SELECT id FROM apache_vhosts WHERE env_id=? AND `name` = ? AND id != ?", array($this->getEnvironmentId(), $this->getParam('domainName'), $this->getParam('vhostId')))) {
$err['domainName'] = "'{$this->getParam('domainName')}' virtualhost already exists";
}
} catch (Exception $e) {
$err[] = $e->getMessage();
}
if (count($err) == 0) {
$vHost = Scalr_Service_Apache_Vhost::init();
if ($this->getParam('vhostId')) {
$vHost->loadById($this->getParam('vhostId'));
$this->user->getPermissions()->validate($vHost);
} else {
$vHost->envId = $this->getEnvironmentId();
$vHost->clientId = $this->user->getAccountId();
}
$vHost->domainName = $this->getParam('domainName');
$vHost->isSslEnabled = $this->getParam('isSslEnabled') == 'on' ? true : false;
$vHost->farmId = $this->getParam('farmId');
$vHost->farmRoleId = $this->getParam('farmRoleId');
$vHost->httpdConf = $this->getParam("nonSslTemplate");
$vHost->templateOptions = serialize(array("document_root" => trim($this->getParam('documentRoot')), "logs_dir" => trim($this->getParam('logsDir')), "server_admin" => trim($this->getParam('serverAdmin')), "server_alias" => trim($this->getParam('serverAlias'))));
//SSL stuff
if ($vHost->isSslEnabled) {
if ($_FILES['certificate']['tmp_name']) {
$vHost->sslCert = file_get_contents($_FILES['certificate']['tmp_name']);
}
if ($_FILES['privateKey']['tmp_name']) {
$vHost->sslKey = file_get_contents($_FILES['privateKey']['tmp_name']);
}
if ($_FILES['certificateChain']['tmp_name']) {
$vHost->caCert = file_get_contents($_FILES['certificateChain']['tmp_name']);
}
$vHost->httpdConfSsl = $this->getParam("sslTemplate");
} else {
$vHost->sslCert = "";
$vHost->sslKey = "";
$vHost->caCert = "";
$vHost->httpdConfSsl = "";
}
$vHost->save();
$servers = $dbFarm->GetServersByFilter(array('status' => array(SERVER_STATUS::INIT, SERVER_STATUS::RUNNING)));
foreach ($servers as $dBServer) {
if ($dBServer->GetFarmRoleObject()->GetRoleObject()->hasBehavior(ROLE_BEHAVIORS::NGINX) || $dBServer->GetFarmRoleObject()->GetRoleObject()->hasBehavior(ROLE_BEHAVIORS::APACHE) && $dBServer->farmRoleId == $vHost->farmRoleId) {
$dBServer->SendMessage(new Scalr_Messaging_Msg_VhostReconfigure());
}
}
$this->response->success(_('Virtualhost successfully saved'));
} else {
$this->response->failure();
$this->response->data(array('errors' => $err));
}
}
function testValidation()
{
$Validator = new Validator();
// IsEmpty
$empty_var = 'sdfsdfsdfs';
$empty_var2 = 'sdfsdfs';
$result = $Validator->IsNotEmpty($empty_var) && $Validator->IsNotEmpty($empty_var2);
$this->assertTrue($result, "Validator->IsEmpty returned true on non empty var");
$empty_var = '';
$empty_var2 = 0;
$result = $Validator->IsNotEmpty($empty_var) && $Validator->IsNotEmpty($empty_var2);
$this->assertFalse($result, "Validator->IsEmpty returned false on empty var");
// IsNumeric
$number1 = 0;
$number2 = -1;
$number3 = 1.2;
$result = $Validator->IsNumeric($number1) && $Validator->IsNumeric($number2) && $Validator->IsNumeric($number3);
$this->assertTrue($result, "Validator->IsNumeric returned true on number var");
$number1 = "1,2";
$number2 = "abc";
$result = $Validator->IsNumeric($number1) && $Validator->IsNumeric($number2);
$this->assertFalse($result, "Validator->IsNumeric returned false on non-number var");
// IsAlpha
$alpha = "Alpha";
$result = $Validator->IsAlpha($alpha);
$this->assertTrue($result, "Validator->IsAlpha returned true");
$alpha = "22323";
$result = $Validator->IsAlpha($alpha);
$this->assertFalse($result, "Validator->IsAlpha returned false");
// IsAlphaNumeric
$alpha = "Alpha12";
$result = $Validator->IsAlphaNumeric($alpha);
$this->assertTrue($result, "Validator->IsAlphaNumeric returned true");
$alpha = "22323 sdfsd fsdf s";
$result = $Validator->IsAlphaNumeric($alpha);
$this->assertFalse($result, "Validator->IsAlphaNumeric returned false");
// IsEmail
$email = "*****@*****.**";
$result = $Validator->IsEmail($email);
$this->assertTrue($result, "Validator->IsEmail returned true");
$email = "asdasdsdfs";
$result = $Validator->IsEmail($email);
$this->assertFalse($result, "Validator->IsEmail returned false");
// IsURL
$url = "http://webta.net";
$url2 = "webta.net";
$url3 = "www.webta.net";
$url4 = "http://www.webta.net";
$result = $Validator->IsURL($url) && $Validator->IsURL($url2) && $Validator->IsURL($url3) && $Validator->IsURL($url4);
$this->assertTrue($result, "Validator->IsURL returned true");
$url = "asdasdsdfs";
$url2 = "asdasdsdfs-222.1-";
$url3 = "-webta.com";
$result = $Validator->IsURL($url) && $Validator->IsURL($url2) && $Validator->IsURL($url3);
$this->assertFalse($result, "Validator->IsURL returned false");
// IsIPAddress
$ip = "10.100.10.10";
$result = $Validator->IsIPAddress($ip);
$this->assertTrue($result, "Validator->IsIPAddress returned true");
$ip = "288.1221.11.11";
$result = $Validator->IsIPAddress($ip);
$this->assertFalse($result, "Validator->IsIPAddress returned false");
// IsExternalIPAddress
$result = $Validator->IsExternalIPAddress("111.120.11.1");
$this->assertTrue($result, "Validator->IsExternalIPAddress returned true for '111.120.11.1'");
$result = $Validator->IsExternalIPAddress("192.168.1.1");
$this->assertFalse($result, "Validator->IsExternalIPAddress returned false for '192.168.1.1'");
$result = $Validator->IsExternalIPAddress("172.16.10.100");
$this->assertFalse($result, "Validator->IsExternalIPAddress returned false for '172.16.10.100'");
$result = $Validator->IsExternalIPAddress("172.32.10.100");
$this->assertTrue($result, "Validator->IsExternalIPAddress returned true for '172.32.10.100'");
// IsDomain
$result = $Validator->IsDomain("webta.net");
$this->assertTrue($result, "Validator->IsDomain returned true for webta.net");
$result = $Validator->IsDomain("c1.webta.net");
$this->assertTrue($result, "Validator->IsDomain returned true for c1.webta.net");
$result = $Validator->IsDomain("webta@net") || $Validator->IsDomain("webtanet");
$this->assertFalse($result, "Validator->IsDomain returned false for weird zones");
// MatchesPattern
$string = "abs_111";
$pattern = "/^[A-Za-z]{3}_[0-9]{3}\$/";
$result = $Validator->MatchesPattern($string, $pattern);
$this->assertTrue($result, "Validator->MatchesPattern returned true");
$pattern = "/^[A-Za-z]_[0-9]\$/";
$result = $Validator->MatchesPattern($string, $pattern);
$this->assertFalse($result, "Validator->MatchesPattern returned false");
// AreEqual
$s1 = "abc123";
$s2 = "abc123";
$result = $Validator->AreEqual($s1, $s2);
$this->assertTrue($result, "Validator->AreEqual returned true");
$s2 = "sdfsdfasd";
$result = $Validator->AreEqual($s1, $s2);
$this->assertFalse($result, "Validator->AreEqual returned false");
}
if ($registry_config->idn)
{
$allowed_utf8_chars = $registry_config->idn->xpath("//allowed-utf8-chars");
$disallowed_utf8_chars = $registry_config->idn->xpath("//disallowed-utf8-chars");
if ($allowed_utf8_chars[0] || $disallowed_utf8_chars[0])
{
$Validator = new Validator();
if (!$Validator->IsDomain("{$post_domain}.{$post_TLD}", null, null, (string)$allowed_utf8_chars[0], (string)$disallowed_utf8_chars[0]))
throw new Exception(_("Domain name contains non-supported characters"));
}
}
else
{
$Validator = new Validator();
if (!$Validator->IsDomain("{$post_domain}.{$post_TLD}"))
throw new Exception(_("Domain name contains non-supported characters"));
}
// Create domain object
$Domain = $Registry->NewDomainInstance();
$Domain->Name = $post_domain;
try
{
// Be sure that it's free
$domain_avaiable = $Registry->DomainCanBeRegistered($Domain);
}
catch (Exception $e)
{
throw new Exception(_("Cannot check domain name availability. Make sure that you spelled domain name correctly"));
public function xSaveAction()
{
$this->request->defineParams(array('domainId' => array('type' => 'int'), 'domainName', 'domainType', 'domainFarm' => array('type' => 'int'), 'domainFarmRole' => array('type' => 'int'), 'soaRefresh' => array('type' => 'int'), 'soaExpire' => array('type' => 'int'), 'soaRetry' => array('type' => 'int'), 'records' => array('type' => 'json')));
$errors = array();
// validate farmId, farmRoleId
$farmId = 0;
$farmRoleId = 0;
if ($this->getParam('domainFarm')) {
$DBFarm = DBFarm::LoadByID($this->getParam('domainFarm'));
if (!$this->user->getPermissions()->check($DBFarm)) {
$errors['domainFarm'] = _('Farm not found');
} else {
$farmId = $DBFarm->ID;
if ($this->getParam('domainFarmRole')) {
$DBFarmRole = DBFarmRole::LoadByID($this->getParam('domainFarmRole'));
if ($DBFarmRole->FarmID != $DBFarm->ID) {
$errors['domainFarmRole'] = _('Role not found');
} else {
$farmRoleId = $DBFarmRole->ID;
}
}
}
}
// validate domain name
$domainName = '';
if (!$this->getParam('domainId')) {
if ($this->getParam('domainType') == 'own') {
$Validator = new Validator();
if (!$Validator->IsDomain($this->getParam('domainName'))) {
$errors['domainName'] = _("Invalid domain name");
} else {
$domainChunks = explode(".", $this->getParam('domainName'));
$chkDmn = '';
while (count($domainChunks) > 0) {
$chkDmn = trim(array_pop($domainChunks) . ".{$chkDmn}", ".");
$chkDomainId = $this->db->GetOne("SELECT id FROM dns_zones WHERE zone_name=? AND client_id != ?", array($chkDmn, $this->user->getAccountId()));
if ($chkDomainId) {
if ($chkDmn == $this->getParam('domainName')) {
$errors['domainName'] = sprintf(_("%s already exists on scalr nameservers"), $this->getParam('domainName'));
} else {
$chkDnsZone = DBDNSZone::loadById($chkDomainId);
$access = false;
foreach (explode(";", $chkDnsZone->allowedAccounts) as $email) {
if ($email == $this->user->getEmail()) {
$access = true;
}
}
if (!$access) {
$errors['domainName'] = sprintf(_("You cannot use %s domain name because top level domain %s does not belong to you"), $this->getParam('domainName'), $chkDmn);
}
}
}
}
//if (! $errors['domainName'])
$domainName = $this->getParam('domainName');
}
} else {
$domainName = Scalr::GenerateUID() . '.' . CONFIG::$DNS_TEST_DOMAIN_NAME;
}
// check in DB
$rez = $this->db->GetOne("SELECT id FROM dns_zones WHERE zone_name = ?", array($domainName));
if ($rez) {
$errors['domainName'] = 'Domain name already exist in database';
}
}
$records = array();
foreach ($this->getParam('records') as $key => $r) {
if (($r['name'] || $r['value']) && $r['issystem'] == 0) {
$r['name'] = str_replace("%hostname%", "{$domainName}", $r['name']);
$r['value'] = str_replace("%hostname%", "{$domainName}", $r['value']);
$records[$key] = $r;
}
}
$recordsValidation = Scalr_Net_Dns_Zone::validateRecords($records);
if ($recordsValidation !== true) {
$errors = array_merge($errors, $recordsValidation);
}
if (count($errors) == 0) {
if ($this->getParam('domainId')) {
$DBDNSZone = DBDNSZone::loadById($this->getParam('domainId'));
$this->user->getPermissions()->validate($DBDNSZone);
$DBDNSZone->soaRefresh = $this->getParam('soaRefresh');
$DBDNSZone->soaExpire = $this->getParam('soaExpire');
$DBDNSZone->soaRetry = $this->getParam('soaRetry');
$this->response->success("DNS zone successfully updated. It could take up to 5 minutes to update it on NS servers.");
} else {
$DBDNSZone = DBDNSZone::create($domainName, $this->getParam('soaRefresh'), $this->getParam('soaExpire'), str_replace('@', '.', $this->user->getEmail()), $this->getParam('soaRetry'));
$DBDNSZone->clientId = $this->user->getAccountId();
$DBDNSZone->envId = $this->getEnvironmentId();
$this->response->success("DNS zone successfully added to database. It could take up to 5 minutes to setup it on NS servers.");
}
if ($DBDNSZone->farmRoleId != $farmRoleId || $DBDNSZone->farmId != $farmId) {
$DBDNSZone->farmId = 0;
$DBDNSZone->updateSystemRecords();
}
$DBDNSZone->farmRoleId = $farmRoleId;
$DBDNSZone->farmId = $farmId;
$DBDNSZone->setRecords($records);
$DBDNSZone->save(true);
} else {
$this->response->failure();
$this->response->data(array('errors' => $errors));
}
}
@set_time_limit(999999);
if (Client::Load($_SESSION['userid'])->GetSettingValue('domain_preorder') != 1) {
CoreUtils::Redirect("index.php");
}
if ($_POST) {
$Validator = new Validator();
$lines = explode("\n", $post_domains);
$post_domainname = FQDN::Sanitize($post_domainname);
list($domain_name, $extension) = FQDN::Parse($post_domainname);
$expiredate = trim($post_dt);
// Validate date. Sucks.
if (!preg_match("/^[0-9]{4}-[0-9]{2}-[0-9]{2}\$/", $expiredate) || !strtotime($expiredate)) {
throw new ApplicationException(sprintf(_("Incorrect expiration date.")));
}
// Validate domain name
if (!$Validator->IsDomain($post_domainname)) {
throw new Exception(sprintf(_("Incorrect domain name: %s"), $post_domainname));
}
if (!$Registries[$extension]) {
try {
$Registry = RegistryModuleFactory::GetInstance()->GetRegistryByExtension($extension);
} catch (Exception $e) {
throw new ApplicationException($e->getMessage());
}
$Manifest = $Registry->GetManifest();
if ($Manifest->GetRegistryOptions()->ability->preregistration != 1) {
throw new ApplicationException(sprintf(_("Module %s does not support domain pre-registration."), $Registry->GetModuleName()));
}
}
$Domain = $Registry->NewDomainInstance();
$Domain->Name = $domain_name;
public function xImportStartAction()
{
$validator = new Validator();
if ($validator->IsDomain($this->getParam('remoteIp'))) {
$remoteIp = @gethostbyname($this->getParam('remoteIp'));
} else {
$remoteIp = $this->getParam('remoteIp');
}
if (!$validator->IsIPAddress($remoteIp, _("Server IP address"))) {
$err['remoteIp'] = 'Server IP address is incorrect';
}
if (!$validator->IsNotEmpty($this->getParam('roleName'))) {
$err['roleName'] = 'Role name cannot be empty';
}
if (strlen($this->getParam('roleName')) < 3) {
$err['roleName'] = _("Role name should be greater than 3 chars");
}
if (!preg_match("/^[A-Za-z0-9-]+\$/si", $this->getParam('roleName'))) {
$err['roleName'] = _("Role name is incorrect");
}
if ($this->db->GetOne("SELECT id FROM roles WHERE name=? AND (env_id = '0' OR env_id = ?)", array($this->getParam('roleName'), $this->getEnvironmentId()))) {
$err['roleName'] = 'Selected role name is already used. Please select another one.';
}
if ($this->getParam('add2farm')) {
}
// Find server in the database
$existingServer = $this->db->GetRow("SELECT * FROM servers WHERE remote_ip = ?", array($remoteIp));
if ($existingServer["client_id"] == $this->user->getAccountId()) {
$err['remoteIp'] = sprintf(_("Server %s is already in Scalr with a server_id: %s"), $remoteIp, $existingServer["server_id"]);
} else {
if ($existingServer) {
$err['remoteIp'] = sprintf(_("Server with selected IP address cannot be imported"));
}
}
if (count($err) == 0) {
$cryptoKey = Scalr::GenerateRandomKey(40);
$creInfo = new ServerCreateInfo($this->getParam('platform'), null, 0, 0);
$creInfo->clientId = $this->user->getAccountId();
$creInfo->envId = $this->getEnvironmentId();
$creInfo->farmId = (int) $this->getParam('farmId');
$creInfo->remoteIp = $remoteIp;
$creInfo->SetProperties(array(SERVER_PROPERTIES::SZR_IMPORTING_ROLE_NAME => $this->getParam('roleName'), SERVER_PROPERTIES::SZR_IMPORTING_BEHAVIOR => $this->getParam('behavior'), SERVER_PROPERTIES::SZR_KEY => $cryptoKey, SERVER_PROPERTIES::SZR_KEY_TYPE => SZR_KEY_TYPE::PERMANENT, SERVER_PROPERTIES::SZR_VESION => "0.7-1", SERVER_PROPERTIES::SZR_IMPORTING_OS_FAMILY => $this->getParam('os')));
if ($this->getParam('platform') == SERVER_PLATFORMS::EUCALYPTUS) {
$creInfo->SetProperties(array(EUCA_SERVER_PROPERTIES::REGION => $this->getParam('cloudLocation')));
}
if ($this->getParam('platform') == SERVER_PLATFORMS::RACKSPACE) {
$creInfo->SetProperties(array(RACKSPACE_SERVER_PROPERTIES::DATACENTER => $this->getParam('cloudLocation')));
}
if ($this->getParam('platform') == SERVER_PLATFORMS::OPENSTACK) {
$creInfo->SetProperties(array(OPENSTACK_SERVER_PROPERTIES::CLOUD_LOCATION => $this->getParam('cloudLocation')));
}
if ($this->getParam('platform') == SERVER_PLATFORMS::NIMBULA) {
$creInfo->SetProperties(array(NIMBULA_SERVER_PROPERTIES::CLOUD_LOCATION => 'nimbula-default'));
}
$dbServer = DBServer::Create($creInfo, true);
$this->response->data(array('serverId' => $dbServer->serverId));
} else {
$this->response->failure();
$this->response->data(array('errors' => $err));
}
}
public function DNSZoneCreate($DomainName, $FarmID = null, $FarmRoleID = null)
{
$DomainName = trim($DomainName);
$Validator = new Validator();
if (!$Validator->IsDomain($DomainName)) {
throw new Exception(_("Invalid domain name"));
}
$domain_chunks = explode(".", $DomainName);
$chk_dmn = '';
while (count($domain_chunks) > 0) {
$chk_dmn = trim(array_pop($domain_chunks) . ".{$chk_dmn}", ".");
if ($this->DB->GetOne("SELECT id FROM dns_zones WHERE zone_name=? AND client_id != ?", array($chk_dmn, $this->user->getAccountId()))) {
if ($chk_dmn == $DomainName) {
throw new Exception(sprintf(_("%s already exists on scalr nameservers"), $DomainName));
} else {
throw new Exception(sprintf(_("You cannot use %s domain name because top level domain %s does not belong to you"), $DomainName, $chk_dmn));
}
}
}
if ($FarmID) {
$DBFarm = DBFarm::LoadByID($FarmID);
if ($DBFarm->EnvID != $this->Environment->id) {
throw new Exception(sprintf("Farm #%s not found", $FarmID));
}
}
if ($FarmRoleID) {
$DBFarmRole = DBFarmRole::LoadByID($FarmRoleID);
if ($DBFarm->ID != $DBFarmRole->FarmID) {
throw new Exception(sprintf("FarmRole #%s not found on Farm #%s", $FarmRoleID, $FarmID));
}
}
$response = $this->CreateInitialResponse();
$DBDNSZone = DBDNSZone::create($DomainName, 14400, 86400, str_replace('@', '.', $this->user->getEmail()));
$DBDNSZone->farmRoleId = (int) $FarmRoleID;
$DBDNSZone->farmId = (int) $FarmID;
$DBDNSZone->clientId = $this->user->getAccountId();
$DBDNSZone->envId = $this->Environment->id;
$def_records = $this->DB->GetAll("SELECT * FROM default_records WHERE clientid=?", array($this->user->getAccountId()));
foreach ($def_records as $record) {
$record["name"] = str_replace("%hostname%", "{$DomainName}.", $record["name"]);
$record["value"] = str_replace("%hostname%", "{$DomainName}.", $record["value"]);
$records[] = $record;
}
$nss = $this->DB->GetAll("SELECT * FROM nameservers WHERE isbackup='0'");
foreach ($nss as $ns) {
$records[] = array("id" => "c" . rand(10000, 999999), "type" => "NS", "ttl" => 14400, "value" => "{$ns["host"]}.", "name" => "{$DomainName}.", "issystem" => 0);
}
$DBDNSZone->setRecords($records);
$DBDNSZone->save(true);
$response->Result = 1;
return $response;
}
if (empty($hostnames)) {
$errmsg = sprintf(_("No nameservers were entered"));
} else {
if (!$_SESSION['BU_TLD']) {
$errmsg = sprintf(_("No domain extension was selected"));
} else {
if (!$_SESSION['BU_DOMAINS']) {
$errmsg = sprintf(_("No domains were selected"));
} else {
// Create bulk update task abd put in into tasks queue
$Queue = TaskQueue::GetInstance();
try {
$nslist = array();
$Validator = new Validator();
foreach ($hostnames as $hostname) {
if ($Validator->IsDomain($hostname)) {
$nslist[] = new Nameserver($hostname);
} else {
throw new Exception(sprintf(_("%s is not a valid host"), $hostname));
}
}
// Construct task
$Task = new Task($_SESSION['userid'], new BulkUpdateNSJob($_SESSION['BU_TLD'], $nslist), $_SESSION['BU_DOMAINS']);
$Queue->Put($Task);
CoreUtils::Redirect("bulk_update_complete.php");
} catch (Exception $e) {
$errmsg = $e->getMessage();
$display['hostnames'] = join("\n", $hostnames);
}
}
}
private function Init()
{
if (!$this->prepared) {
$ErrList = new ErrorList();
if (!$this->Registry) {
$Factory = RegistryModuleFactory::GetInstance();
try {
$this->Registry = $Factory->GetRegistryByExtension($this->tld);
} catch (Exception $e) {
throw new RegisterDomainAction_Exception(sprintf(_("Cannot init registry module. Reason: %s"), $e->getMessage()));
}
}
$registry_config = $this->Registry->GetManifest()->GetSectionConfig();
$Validator = new Validator();
/**
* Validate period
*/
if ($this->period) {
self::ValidatePeriod($this->period, $this->Registry);
}
/*
* Validate additional domain information
*/
$extra_fields = null;
if (count($registry_config->domain->registration->extra_fields->field) > 0) {
$extra_fields = UI::GetRegExtraFieldsForSmarty($registry_config);
foreach ($extra_fields as $field) {
if ($field["isrequired"] == 1 && $field["type"] != "checkbox") {
if (!strlen($this->extra_data[$field['name']])) {
$ErrList->AddMessage(sprintf(_("%s required"), ucfirst($field["name"])));
}
}
}
}
// Break on errors
$this->ExceptionOnErrors($ErrList);
/**
* Validate DNS
*/
if (!$this->managed_dns_enabled) {
if (!$this->nameserver_list) {
foreach ($this->ns_list as $ns) {
$this->nameserver_list[] = new Nameserver($ns);
}
}
$nameserver_list = $this->nameserver_list;
if (count(array_unique($nameserver_list)) < count($nameserver_list)) {
$ErrList->AddMessage(_("Cannot use the same nameserver twice."));
} else {
foreach ($nameserver_list as $Nameserver) {
if (!$Validator->IsDomain($Nameserver->HostName)) {
$ErrList->AddMessage(sprintf(_("'%s' is not a valid host"), $Nameserver->HostName));
}
}
}
} else {
$this->nameserver_list = array(new Nameserver(CONFIG::$NS1), new Nameserver(CONFIG::$NS2));
}
$this->ExceptionOnErrors($ErrList);
/*
* Validate contacts
*/
if (!$this->contact_list) {
$DbContact = DBContact::GetInstance();
$this->contact_list = array();
foreach ($this->clid_list as $ctype => $clid) {
if (!$clid) {
continue;
}
try {
$Contact = $DbContact->LoadByCLID($clid);
$this->contact_list[$ctype] = $Contact;
} catch (Exception $e) {
$ErrList->AddMessage(sprintf(_("Cannot load %s contact. %s"), $ctype, $clid, $e->getMessage()));
}
}
// Break on errors
$this->ExceptionOnErrors($ErrList);
}
$this->ExceptionOnErrors(self::ValidateContactList($this->contact_list, $this->Registry));
$this->prepared = true;
}
}
}
if ($_POST) {
$Validator = new Validator();
$lines = explode("\n", $post_domains);
$err = array();
foreach ($lines as $k => $line) {
try {
$ErrorList = new ErrorList();
$chunks = explode(",", $line);
$domainname = trim($chunks[0]);
$expiredate = trim($chunks[1]);
if (!preg_match("/^[0-9]{4}-[0-9]{2}-[0-9]{2}\$/", $expiredate) || !strtotime($expiredate)) {
$ErrorList->AddMessage(sprintf(_("Incorrect expiration date (%s) for domain %s."), $expiredate, $domainname));
throw $ErrorList;
}
if (!$Validator->IsDomain($domainname)) {
$ErrorList->AddMessage(sprintf(_("Incorrect domain name %s"), $domainname));
throw $ErrorList;
}
$dmn_chunks = explode(".", $domainname);
$domain_name = array_shift($dmn_chunks);
$extension = implode(".", $dmn_chunks);
if (!$Registries[$extension]) {
try {
$Registries[$extension] = RegistryModuleFactory::GetInstance()->GetRegistryByExtension($extension);
} catch (Exception $e) {
$ErrorList->AddMessage(sprintf(_("Error while processing domain %s: %s"), $domainname, $e->getMessage()));
throw $ErrorList;
}
// F**k! Add a singleton here, you dick!
$Manifest = $Registries[$extension]->GetManifest();
// Transfer not available
// domain=>reason
$res_fail = array();
$Order = new Order($_SESSION['userid']);
// For each entered domain name check tranfer posibility
if (!$errmsg && $Registry) {
foreach ($domainnames as $domain_name) {
Log::Log("Process {$domain_name}", E_USER_NOTICE);
if ($Registry->GetManifest()->GetSectionConfig()->idn) {
$allowed_utf8_chars = $Registry->GetManifest()->GetSectionConfig()->idn->xpath("//allowed-utf8-chars");
$disallowed_utf8_chars = $Registry->GetManifest()->GetSectionConfig()->idn->xpath("//disallowed-utf8-chars");
$allowed_chars = (string) $allowed_utf8_chars[0];
$disallowed_chars = (string) $disallowed_utf8_chars[0];
}
$Validator = new Validator();
if (!$Validator->IsDomain("{$domain_name}.{$_SESSION["BT_TLD"]}", null, null, $allowed_chars, $disallowed_chars)) {
$res_fail[$domain_name] = _("Domain name contains non-supported characters");
} else {
$DbDomain = DBDomain::GetInstance();
// Inst domain object
$Domain = $Registry->NewDomainInstance();
$Domain->Name = $domain_name;
// Check that domain can be transferred
if ($DbDomain->ActiveDomainExists($Domain)) {
$res_fail[$domain_name] = _("Sorry, this domain can not be transferred");
}
// If no errors - start transfer process
if ($res_fail[$domain_name] === null) {
Log::Log("Update domain status to awaitingPayment", E_USER_NOTICE);
// Configure and save domain in Db
$Domain->UserID = $Order->UserID;
