PHP Validator::IsDomain方法代码示例

 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 = "test@test.com";
     $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 {
//.........这里部分代码省略.........

@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;
                }
                // Fuck! 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;