function RuCenter_Domain_Register($Settings, $DomainName, $DomainZone, $Years, $Ns1Name, $Ns1IP, $Ns2Name, $Ns2IP, $Ns3Name, $Ns3IP, $Ns4Name, $Ns4IP, $IsPrivateWhoIs, $ContractID = '')
{
/****************************************************************************/
$__args_types = array('array', 'string', 'string', 'integer', 'string', 'string', 'string', 'string', 'string', 'string', 'string', 'string', 'boolean', 'string');
#-----------------------------------------------------------------------------
$__args__ = Func_Get_Args();
eval(FUNCTION_INIT);
/****************************************************************************/
$HTTP = array('Address' => $Settings['Address'], 'Port' => $Settings['Port'], 'Host' => $Settings['Address'], 'Protocol' => $Settings['Protocol'], 'Charset' => 'KOI8-R', 'IsLogging' => $Settings['Params']['IsLogging']);
#-----------------------------------------------------------------------------
$Domain = SPrintF('%s.%s', $DomainName, $DomainZone);
#-----------------------------------------------------------------------------
$ContractItem = Explode(':', $ContractID);
#-----------------------------------------------------------------------------
$ContractID = Current($ContractItem);
#-----------------------------------------------------------------------------
$Query = array();
#-----------------------------------------------------------------------------
$RequestID = UniqID('ID');
#-----------------------------------------------------------------------------
$Query[] = 'lang: ru';
$Query[] = 'request: order';
$Query[] = 'operation: create';
$Query[] = SPrintF('login: %s', $Settings['Login']);
$Query[] = SPrintF('password: %s', $Settings['Password']);
$Query[] = SPrintF('subject-contract: %s', $ContractID);
$Query[] = SPrintF('request-id: %s', $RequestID);
#-----------------------------------------------------------------------------
$Query[] = '';
#-----------------------------------------------------------------------------
$Query[] = '[order-item]';
$Query[] = 'check-ns: off';
#-----------------------------------------------------------------------------
switch ($DomainZone) {
case 'ru':
$Query[] = 'service: domain_ru';
$Query[] = 'template: client_ru';
break;
case 'su':
$Query[] = 'service: domain_su';
$Query[] = 'template: client_ru';
break;
case 'рф':
$Query[] = 'service: domain_rf';
$Query[] = 'template: domain_rf';
// Convert the domain
$IDNAConverter = new IDNAConvert();
$Domain = $IDNAConverter->encode($Domain);
break;
case 'msk.ru':
$Query[] = 'service: domain_msk_ru';
$Query[] = 'template: client_ru';
break;
case 'msk.su':
$Query[] = 'service: domain_msk_su';
$Query[] = 'template: client_ru';
break;
case 'spb.ru':
$Query[] = 'service: domain_spb_ru';
$Query[] = 'template: client_ru';
break;
case 'spb.su':
$Query[] = 'service: domain_spb_su';
$Query[] = 'template: client_ru';
break;
default:
#-------------------------------------------------------------------------
if (Count($ContractItem) < 2) {
#-----------------------------------------------------------------------
$Query = array();
#-----------------------------------------------------------------------
$RequestID = UniqID('ID');
#-----------------------------------------------------------------------
$Query[] = 'lang: ru';
$Query[] = 'request: contract';
$Query[] = 'operation: get';
$Query[] = SPrintF('login: %s', $Settings['Login']);
$Query[] = SPrintF('password: %s', $Settings['Password']);
$Query[] = SPrintF('subject-contract: %s', $ContractID);
$Query[] = SPrintF('request-id: %s', $RequestID);
#-----------------------------------------------------------------------
$Result = HTTP_Send('/dns/dealer', $HTTP, array(), array('SimpleRequest' => Implode("\n", $Query)));
if (Is_Error($Result)) {
return ERROR | @Trigger_Error('[RuCenter_Domain_Register]: не удалось выполнить запрос к серверу');
}
#-----------------------------------------------------------------------
if (Preg_Match('/HTTP\\/1.0\\s502/i', $Result['Heads'])) {
return false;
}
#-----------------------------------------------------------------------
$Result = Trim($Result['Body']);
#-----------------------------------------------------------------------
if (Preg_Match('/State:\\s([0-9]+)\\s/', $Result, $CodeID)) {
#---------------------------------------------------------------------
$CodeID = Next($CodeID);
#---------------------------------------------------------------------
switch ($CodeID) {
case '200':
#-----------------------------------------------------------------
if (Preg_Match_All('/([a-z\\-])+\\:(.+)/', $Result, $Matches)) {
#---------------------------------------------------------------
Debug(Print_R($Matches, 1));
#---------------------------------------------------------------
return new gException('NOT_SUPPORTED_YET', 'Пока не поддерживается');
}
#-----------------------------------------------------------------
break;
case '500':
return FALSE;
default:
return new gException('WRONG_ERROR', SPrintF('Неизвестный статус ошибки (%s)', $Result));
}
}
} else {
$NicHDL = Next($ContractItem);
}
#-------------------------------------------------------------------------
$Query[] = 'service: domain_rrp';
$Query[] = 'template: client_rrp';
$Query[] = SPrintF('period: %d', $Years);
$Query[] = SPrintF('admin-c: %s', $NicHDL);
$Query[] = SPrintF('bill-c: %s', $NicHDL);
$Query[] = SPrintF('tech-c: %s', $NicHDL);
$Query[] = 'lang-tag: RUS';
}
#-----------------------------------------------------------------------------
$Query[] = 'action: new';
$Query[] = SPrintF('domain: %s', $Domain);
$Query[] = SPrintF('private-person: %s', $IsPrivateWhoIs ? 'ON' : 'OFF');
#-----------------------------------------------------------------------------
if ($Ns1Name) {
$Query[] = $Ns1IP ? SPrintF('nserver: %s %s', $Ns1Name, $Ns1IP) : SPrintF('nserver: %s', $Ns1Name);
}
#-----------------------------------------------------------------------------
if ($Ns2Name) {
$Query[] = $Ns2IP ? SPrintF('nserver: %s %s', $Ns2Name, $Ns2IP) : SPrintF('nserver: %s', $Ns2Name);
}
#-----------------------------------------------------------------------------
if ($Ns3Name) {
$Query[] = $Ns3IP ? SPrintF('nserver: %s %s', $Ns3Name, $Ns3IP) : SPrintF('nserver: %s', $Ns3Name);
}
#-----------------------------------------------------------------------------
if ($Ns4Name) {
$Query[] = $Ns4IP ? SPrintF('nserver: %s %s', $Ns4Name, $Ns4IP) : SPrintF('nserver: %s', $Ns4Name);
}
#-----------------------------------------------------------------------------
$Query[] = 'type: CORPORATE';
#-----------------------------------------------------------------------------
$Result = HTTP_Send('/dns/dealer', $HTTP, array(), array('SimpleRequest' => Implode("\n", $Query)));
if (Is_Error($Result)) {
return ERROR | @Trigger_Error('[RuCenter_Domain_Register]: не удалось выполнить запрос к серверу');
}
#-----------------------------------------------------------------------------
if (Preg_Match('/HTTP\\/1.0\\s502/i', $Result['Heads'])) {
return false;
}
#-----------------------------------------------------------------------------
$Result = Trim($Result['Body']);
#-----------------------------------------------------------------------------
if (Preg_Match('/State:\\s([0-9]+)\\s/', $Result, $CodeID)) {
#---------------------------------------------------------------------------
$CodeID = Next($CodeID);
#---------------------------------------------------------------------------
switch ($CodeID) {
case '200':
#-----------------------------------------------------------------------
if (Preg_Match('/order_id:([0-9]+)/', $Result, $TicketID)) {
return array('TicketID' => Next($TicketID));
}
case '500':
return FALSE;
default:
return new gException('WRONG_ERROR', SPrintF('Неизвестный статус ошибки (%s)', $Result));
}
}
#-----------------------------------------------------------------------------
return new gException('WRONG_ANSWER', $Result);
}
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
$Row = $Scripts = $JsonOut = array();
#-------------------------------------------------------------------------------
foreach (array('Название домена', 'Статус', 'Цена в год', 'Сделать заказ') as $Text) {
$Row[] = new Tag('TD', array('class' => 'Head'), $Text);
}
#-------------------------------------------------------------------------------
$Rows = array($Row);
#-------------------------------------------------------------------------------
foreach (Array_Keys($Zones) as $Key) {
#-------------------------------------------------------------------------------
# проверяем, допустимо ли имя для доменной зоны (кириллица запрещена в .ru, латиница в .рф)
$IDNAConverter = new IDNAConvert();
#---------------------------------------------------------------------------
$Check = SPrintF('DomainName_%s', $IDNAConverter->encode($Zones[$Key]['Name']));
#---------------------------------------------------------------------------
if (!isset($Regulars[$Check])) {
$Check = 'DomainName';
}
#---------------------------------------------------------------------------
if (!Preg_Match($Regulars[$Check], $DomainName)) {
continue;
}
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
# если нам нужен только список на выходе - строим его в отдельный массив
if ($JSON) {
#-------------------------------------------------------------------------------
$Columns = array('`DomainSchemes`.`ID`', '`DomainSchemes`.`Name` as `Name`', '`DomainSchemes`.`IsActive` AS `IsActive`', '`Servers`.`Params` as `Params`');
#-------------------------------------------------------------------------------
$DomainScheme = DB_Select(array('DomainSchemes', 'Servers'), $Columns, array('UNIQ', 'Where' => SPrintF('`DomainSchemes`.`ServerID` = `Servers`.`ID` AND `DomainSchemes`.`ID` = %u', $DomainSchemeID)));
#-------------------------------------------------------------------------------
switch (ValueOf($DomainScheme)) {
case 'error':
return ERROR | @Trigger_Error(500);
case 'exception':
return new gException('DOMAIN_SCHEME_NOT_FOUND', 'Тарифный план не найден');
case 'array':
break;
default:
return ERROR | @Trigger_Error(101);
}
#-------------------------------------------------------------------------------
$IDNAConverter = new IDNAConvert();
#-------------------------------------------------------------------------------
$Key = SPrintF('DomainName_%s', $IDNAConverter->encode($DomainScheme['Name']));
#-------------------------------------------------------------------------------
if (!isset($Regulars[$Key])) {
$Key = 'DomainName';
}
#-------------------------------------------------------------------------------
if (!Preg_Match($Regulars[$Key], $DomainName)) {
return new gException('WRONG_DOMAIN_NAME', 'Неверное имя домена');
}
#-------------------------------------------------------------------------------
if (!$DomainScheme['IsActive']) {
return new gException('SCHEME_NOT_ACTIVE', 'Выбранный тарифный план заказа домена не активен');
}
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
foreach ($HostingOrders as $HostingOrder) {
#-------------------------------------------------------------------------------
$Boxes = $Users[$HostingOrder['Login']];
#-------------------------------------------------------------------------------
foreach ($Boxes as $Email => $Box) {
#-------------------------------------------------------------------------------
$Total = Next($Box);
if (!$Total) {
continue;
}
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
$Pieces = Explode('@', $Email);
#-------------------------------------------------------------------------------
$IDNAConverter = new IDNAConvert();
#-------------------------------------------------------------------------------
$Email = SPrintF('%s@%s', $Pieces[0], $IDNAConverter->encode($Pieces[1]));
#-------------------------------------------------------------------------------
if (!Preg_Match($Regulars['Email'], $Email)) {
continue;
}
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
$Used = Prev($Box);
#-------------------------------------------------------------------------------
$Usage = $Used / $Total * 100;
#-------------------------------------------------------------------------------
if ($Usage > $Settings['EmailBoxesNotifiesPercent']) {
#-------------------------------------------------------------------------------
$IsAdd = Comp_Load('www/Administrator/API/TaskEdit', array('UserID' => $HostingOrder['UserID'], 'TypeID' => 'Email', 'Params' => array($Email, 'Квота почтового ящика', TemplateReplace('Tasks.GC.EmailBoxesNotifies', array('Email' => $Email, 'Usage' => $Usage), FALSE), Implode("\n", $Heads))));
function WhoIs_Check($DomainName, $ZoneName, $IsAvalible = FALSE)
{
#-------------------------------------------------------------------------------
Debug(SPrintF('[system/libs/WhoIs]: run function WhoIs_Check, Domain = %s.%s', $DomainName, $ZoneName));
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
$CacheID = SPrintF('WhoIs-%s.%s', $DomainName, $ZoneName);
#-------------------------------------------------------------------------------
$Answer = CacheManager::get($CacheID);
#-------------------------------------------------------------------------------
if (!$Answer) {
#-------------------------------------------------------------------------------
# смотрим доменную зону, на предмет того использовать ли данные whois сервера, или юзать запросы к регистратору
$DomainZones = System_XML('config/DomainZones.xml');
if (Is_Error($DomainZones)) {
return ERROR | @Trigger_Error('[comp/www/API/WhoIs]: не удалось загрузить базу WhoIs серверов');
}
#-------------------------------------------------------------------------------
$IsSuppoted = FALSE;
#-------------------------------------------------------------------------------
foreach ($DomainZones as $Zone) {
#-------------------------------------------------------------------------------
if ($Zone['Name'] == $ZoneName) {
#-------------------------------------------------------------------------------
$IsSuppoted = TRUE;
#-------------------------------------------------------------------------------
break;
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
if (!$IsSuppoted || $Zone['IsUseRegistratorWhoIs']) {
#-------------------------------------------------------------------------------
if (!$IsSuppoted) {
Debug(SPrintF('[comp/www/API/WhoIs]: доменная зона не поддерживается'));
}
#-------------------------------------------------------------------------------
if ($IsSuppoted && $Zone['IsUseRegistratorWhoIs']) {
Debug(SPrintF('[comp/www/API/WhoIs]: принудительное использование WhoIs регистратора'));
}
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
# чекаем доменную зону
$Regulars = Regulars();
#-------------------------------------------------------------------------------
if (!Preg_Match($Regulars['DomainZone'], $ZoneName)) {
return ERROR | @Trigger_Error(SPrintF('[comp/www/API/WhoIs]: неверная доменная зона (%s)', $ZoneName));
}
#-------------------------------------------------------------------------------
# достаём список серверов на которых есть такой тариф
$Servers = DB_Select('DomainSchemes', array('ServerID'), array('Where' => SPrintF('`Name` = "%s"', $ZoneName)));
#-------------------------------------------------------------------------------
switch (ValueOf($Servers)) {
case 'error':
return ERROR | @Trigger_Error(500);
case 'exception':
return new gException('REGISTRATOR_SERVER_NOT_FOUND', 'Не найдены активные сервера регистраторов');
case 'array':
#-------------------------------------------------------------------------------
$Array = array();
#-------------------------------------------------------------------------------
foreach ($Servers as $Server) {
$Array[] = $Server['ServerID'];
}
#-------------------------------------------------------------------------------
break;
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
default:
return ERROR | @Trigger_Error(101);
}
#-------------------------------------------------------------------------------
# достаём список активных серверов регистраторов
$Servers = DB_Select('Servers', array('ID', 'Address', 'Params'), array('Where' => array(SPrintF('`ID` IN (%s)', Implode(',', $Array)), '`IsActive` = "yes"'), 'SortOn' => 'Address'));
#-------------------------------------------------------------------------------
switch (ValueOf($Servers)) {
case 'error':
return ERROR | @Trigger_Error(500);
case 'exception':
return new gException('REGISTRATOR_SERVER_NOT_FOUND', 'Не найдены активные сервера регистраторов');
case 'array':
break;
default:
return ERROR | @Trigger_Error(101);
}
#-------------------------------------------------------------------------------
# перебираем регистраторов
$UseServer = FALSE;
#-------------------------------------------------------------------------------
foreach ($Servers as $iServer) {
#-------------------------------------------------------------------------------
# если это не проверка доступности и в настройках сервера не стоит галка про получение WhoIs - пропускаем
if (!$IsAvalible) {
if (!$iServer['Params']['IsFetchWhoIs']) {
continue;
}
}
#-------------------------------------------------------------------------------
# достаём использованные запросы к регистратору, на данную минуту
$RatelimitID = SPrintF('ratelimit-%s-%s-00', $iServer['Address'], Date('H-i'));
#-------------------------------------------------------------------------------
$Ratelimit = CacheManager::get($RatelimitID);
#-------------------------------------------------------------------------------
# если из кэша что-то досталось и оно больше разрешённой частоты запросов - пропускаем цикл
if ($Ratelimit && $Ratelimit >= $iServer['Params']['RatelimitAPI']) {
#-------------------------------------------------------------------------------
Debug(SPrintF('[comp/www/API/WhoIs]: превышена частота запросов к серверу %s (разрешено %u, использовано %u)', $iServer['Address'], $iServer['Params']['RatelimitAPI'], $Ratelimit));
#-------------------------------------------------------------------------------
continue;
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
# сохраняем, на пару минут, в кэш новое число запросов к регистратору
CacheManager::add($RatelimitID, IntVal($Ratelimit) + 1, 120);
#-------------------------------------------------------------------------------
$UseServer = $iServer;
#-------------------------------------------------------------------------------
break;
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
# если не задан сервер - частота превышена для всех серверов
if (!$UseServer) {
return new gException('REGISTRATOR_SERVER_RATELIMIT', 'Превышена максимальная частота запросов к интерфейсу регистратора');
}
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
# выбираем сервер регистратора
if (Is_Error(System_Load('classes/DomainServer.class.php'))) {
return ERROR | @Trigger_Error(500);
}
#-------------------------------------------------------------------------------
$Server = new DomainServer();
#-------------------------------------------------------------------------------
$IsSelected = $Server->Select((int) $UseServer['ID']);
#-------------------------------------------------------------------------------
switch (ValueOf($IsSelected)) {
case 'error':
return ERROR | @Trigger_Error(500);
case 'exception':
return new gException('CANNOT_SELECT_REGISTRATOR', 'Не удалось выбрать регистратора');
case 'true':
break;
default:
return ERROR | @Trigger_Error(101);
}
#-------------------------------------------------------------------------------
# делаем запрос к API - функция в зависимости от $IsAvalible
if ($IsAvalible) {
#-------------------------------------------------------------------------------
$DomainCheck = $Server->DomainCheck($DomainName, $ZoneName);
#-------------------------------------------------------------------------------
switch (ValueOf($DomainCheck)) {
case 'error':
return ERROR | @Trigger_Error(500);
case 'exception':
return ERROR | @Trigger_Error(400);
case 'true':
return TRUE;
case 'false':
return array();
case 'array':
break;
default:
return ERROR | @Trigger_Error(101);
}
#-------------------------------------------------------------------------------
} else {
#-------------------------------------------------------------------------------
$DomainWhoIs = $Server->DomainWhoIs($DomainName, $ZoneName);
#-------------------------------------------------------------------------------
switch (ValueOf($DomainWhoIs)) {
case 'error':
return ERROR | @Trigger_Error(500);
case 'exception':
# a функции нет ... вылезаем на обычную проверку whois
break;
case 'true':
return TRUE;
case 'string':
#-------------------------------------------------------------------------------
CacheManager::add($CacheID, $DomainWhoIs, 1800);
#-------------------------------------------------------------------------------
break;
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
default:
return ERROR | @Trigger_Error(101);
}
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
$Config = Config();
#-------------------------------------------------------------------------------
$UseSystemApplication = $Config['Other']['Libs']['WhoIs']['UseSystemApplication'];
#-------------------------------------------------------------------------------
$Regulars = Regulars();
#-------------------------------------------------------------------------------
if (!Preg_Match($Regulars['DomainName'], $DomainName)) {
return new gException('WRONG_DOMAIN_NAME', 'Неверное доменное имя');
}
#-------------------------------------------------------------------------------
$DomainZones = System_XML('config/DomainZones.xml');
if (Is_Error($DomainZones)) {
return ERROR | @Trigger_Error('[WhoIs_Check]: не удалось загрузить базу WhoIs серверов');
}
#-------------------------------------------------------------------------------
$IsSuppoted = FALSE;
#-------------------------------------------------------------------------------
foreach ($DomainZones as $DomainZone) {
#-------------------------------------------------------------------------------
if ($DomainZone['Name'] == $ZoneName) {
#-------------------------------------------------------------------------------
$IsSuppoted = TRUE;
#-------------------------------------------------------------------------------
break;
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
if (!$IsSuppoted && !isset($DomainWhoIs)) {
return FALSE;
}
#-------------------------------------------------------------------------------
if (Mb_StrLen($DomainName) < ($MinChars = $DomainZone['MinChars'])) {
return new gException('WRONG_DOMAIN_NAME_LENGTH', SPrintF('Длина доменного имени должна быть не менее %u символа(ов)', $MinChars));
}
#-------------------------------------------------------------------------------
$Domain = SPrintF('%s.%s', $DomainName, $DomainZone['Name']);
#-------------------------------------------------------------------------------
$Answer = CacheManager::get($CacheID);
#-------------------------------------------------------------------------------
if (!$Answer) {
#-------------------------------------------------------------------------------
$IDNAConverter = new IDNAConvert();
#-------------------------------------------------------------------------------
if ($UseSystemApplication) {
#-------------------------------------------------------------------------------
$IsExec = Exec(SPrintF('whois %s', $IDNAConverter->encode($Domain)), $Answer);
#-------------------------------------------------------------------------------
$Answer = Implode("\n", $Answer);
#-------------------------------------------------------------------------------
} else {
#-------------------------------------------------------------------------------
$Socket = @FsockOpen($DomainZone['Server'], 43, $nError, $sError, 5);
#-------------------------------------------------------------------------------
if (!$Socket) {
return ERROR | @Trigger_Error('[WhoIs_Check]: ошибка соединения с сервером WhoIs');
}
#-------------------------------------------------------------------------------
if (!@Fputs($Socket, SPrintF("%s\r\n", $IDNAConverter->encode($Domain)))) {
return ERROR | @Trigger_Error('[WhoIs_Check]: ошибка работы с серверов WhoIs');
}
#-------------------------------------------------------------------------------
$Answer = '';
#-------------------------------------------------------------------------------
do {
#-------------------------------------------------------------------------------
$Line = @Fgets($Socket, 10);
#-------------------------------------------------------------------------------
$Answer .= $Line;
#-------------------------------------------------------------------------------
} while ($Line);
#-------------------------------------------------------------------------------
Fclose($Socket);
#-------------------------------------------------------------------------------
CacheManager::add($CacheID, $Answer, 1800);
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
Debug(SPrintF('[system/libs/WhoIs.php]: Answer = %s', print_r($Answer, true)));
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
if (Preg_Match(SPrintF('/%s/', $DomainZone['Available']), $Answer)) {
return TRUE;
}
#-------------------------------------------------------------------------------
if (Preg_Match(SPrintF('/%s/', $DomainZone['NotAvailable']), $Answer)) {
return new gException('DOMAIN_NOT_AVAILABLE', 'Доменное имя не доступно для регистрации');
}
#-------------------------------------------------------------------------------
$Result = array('Info' => Preg_Replace('/\\n\\s+\\n/sU', "\n", Preg_Replace('/\\%.+\\n/sU', '', $Answer)), 'ExpirationDate' => 0);
#-------------------------------------------------------------------------------
$ExpirationDate = $DomainZone['ExpirationDate'];
#-------------------------------------------------------------------------------
if ($ExpirationDate) {
#-------------------------------------------------------------------------------
if (Preg_Match(SPrintF('/%s/', $ExpirationDate), $Answer, $Mathes)) {
#-------------------------------------------------------------------------------
if (Count($Mathes) < 2) {
return ERROR | @Trigger_Error('[WhoIs_Check]: шаблон поиска даты окончания задан неверно');
}
#-------------------------------------------------------------------------------
$ExpirationDate = $Mathes[1];
#-------------------------------------------------------------------------------
$Months = array('jan', 'feb', 'mar', 'apr', 'may', 'jun', 'jul', 'aug', 'sep', 'oct', 'nov', 'dec');
#-------------------------------------------------------------------------------
if (Preg_Match('/^[0-9]{4}\\.[0-9]{2}\\.[0-9]{2}$/', $ExpirationDate)) {
#-------------------------------------------------------------------------------
$Date = Array_Combine(array('Year', 'Month', 'Day'), Explode('.', $ExpirationDate));
#-------------------------------------------------------------------------------
$ExpirationDate = MkTime(0, 0, 0, $Date['Month'], $Date['Day'], $Date['Year']);
#-------------------------------------------------------------------------------
} elseif (Preg_Match('/^[0-9]{4}\\-[0-9]{2}\\-[0-9]{2}$/', $ExpirationDate)) {
#-------------------------------------------------------------------------------
$Date = Array_Combine(array('Year', 'Month', 'Day'), Explode('-', $ExpirationDate));
#-------------------------------------------------------------------------------
$ExpirationDate = MkTime(0, 0, 0, $Date['Month'], $Date['Day'], $Date['Year']);
#-------------------------------------------------------------------------------
} elseif (Preg_Match('/^[0-9]{2}\\-[a-zA-Z]{3}\\-[0-9]{4}$/', $ExpirationDate)) {
#-------------------------------------------------------------------------------
$Date = Array_Combine(array('Day', 'Month', 'Year'), Explode('-', $ExpirationDate));
#-------------------------------------------------------------------------------
$Month = Array_Search(StrToLower($Date['Month']), $Months);
#-------------------------------------------------------------------------------
$ExpirationDate = MkTime(0, 0, 0, $Month + 1, $Date['Day'], $Date['Year']);
#-------------------------------------------------------------------------------
} elseif (Preg_Match('/^[0-9]{2}\\s[a-zA-Z]{2,10}\\s[0-9]{4}$/', $ExpirationDate)) {
#-------------------------------------------------------------------------------
$Months = array('january', 'february', 'march', 'april', 'may', 'june', 'july', 'august', 'september', 'octember', 'november', 'decemeber');
#-------------------------------------------------------------------------------
$Date = Array_Combine(array('Day', 'Month', 'Year'), Preg_Split('/\\s+/', $ExpirationDate));
#-------------------------------------------------------------------------------
$Month = Array_Search(StrToLower($Date['Month']), $Months);
#-------------------------------------------------------------------------------
$ExpirationDate = MkTime(0, 0, 0, $Month + 1, $Date['Day'], $Date['Year']);
#-------------------------------------------------------------------------------
} else {
#-------------------------------------------------------------------------------
$Date = Array_Combine(array('Week', 'Month', 'Day', 'Time', 'GMT', 'Year'), Preg_Split('/\\s+/', $ExpirationDate));
#-------------------------------------------------------------------------------
$Month = Array_Search(StrToLower($Date['Month']), $Months);
#-------------------------------------------------------------------------------
$ExpirationDate = MkTime(0, 0, 0, $Month + 1, $Date['Day'], $Date['Year']);
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
$Result['ExpirationDate'] = $ExpirationDate;
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
$NsName = $DomainZone['NsName'];
#-------------------------------------------------------------------------------
if ($NsName) {
#-------------------------------------------------------------------------------
if (Preg_Match_All(SPrintF('/%s/', $NsName), $Answer, $Mathes)) {
#-------------------------------------------------------------------------------
if (Count($Mathes) < 2) {
return ERROR | @Trigger_Error('[WhoIs_Check]: шаблон поиска именных серверов задан неверно');
}
#-------------------------------------------------------------------------------
$NsNames = $Mathes[1];
#-------------------------------------------------------------------------------
for ($i = 0; $i < Count($NsNames); $i++) {
#-------------------------------------------------------------------------------
$NsName = Trim(StrToLower($NsNames[$i]), '.');
#-------------------------------------------------------------------------------
$Result[SPrintF('Ns%uName', $i + 1)] = $NsName;
#-------------------------------------------------------------------------------
if ($NsName) {
#-------------------------------------------------------------------------------
if (Mb_SubStr($NsName, -Mb_StrLen($Domain)) == $Domain) {
#-------------------------------------------------------------------------------
$IP = GetHostByName($NsName);
#-------------------------------------------------------------------------------
if ($IP != $NsName) {
$Result[SPrintF('Ns%uIP', $i + 1)] = $IP;
}
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
$Registrar = $DomainZone['Registrar'];
#-------------------------------------------------------------------------------
if ($Registrar) {
#-------------------------------------------------------------------------------
if (Preg_Match(SPrintF('/%s/', $Registrar), $Answer, $Mathes)) {
#-------------------------------------------------------------------------------
if (Count($Mathes) < 2) {
return ERROR | @Trigger_Error('[WhoIs_Check]: шаблон поиска регистратора серверов задан неверно');
}
#-------------------------------------------------------------------------------
$Registrar = Next($Mathes);
#-------------------------------------------------------------------------------
$Result['Registrar'] = $Registrar;
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
return $Result;
#-------------------------------------------------------------------------------
}
