9861 lines
168 KiB
PHP
9861 lines
168 KiB
PHP
<?php
|
|
|
|
spl_autoload_register('Net_DNS2::autoload');
|
|
|
|
class Net_DNS2
|
|
{
|
|
|
|
const VERSION = '1.4.2';
|
|
|
|
const RESOLV_CONF = '/etc/resolv.conf';
|
|
|
|
public $use_resolv_options = false;
|
|
|
|
public $use_tcp = false;
|
|
|
|
public $dns_port = 53;
|
|
|
|
public $local_host = '';
|
|
public $local_port = 0;
|
|
|
|
public $timeout = 5;
|
|
|
|
public $ns_random = false;
|
|
|
|
public $domain = '';
|
|
|
|
public $search_list = array();
|
|
|
|
public $cache_type = 'none';
|
|
|
|
public $cache_file = '/tmp/net_dns2.cache';
|
|
|
|
public $cache_size = 50000;
|
|
|
|
public $cache_serializer = 'serialize';
|
|
|
|
public $strict_query_mode = false;
|
|
|
|
public $recurse = true;
|
|
|
|
public $dnssec = false;
|
|
|
|
public $dnssec_ad_flag = false;
|
|
|
|
public $dnssec_cd_flag = false;
|
|
|
|
public $dnssec_payload_size = 4000;
|
|
|
|
public $last_exception = null;
|
|
|
|
public $last_exception_list = array();
|
|
|
|
public $nameservers = array();
|
|
|
|
protected $sock = array('udp' => array(), 'tcp' => array());
|
|
|
|
protected $sockets_enabled = false;
|
|
|
|
protected $auth_signature = null;
|
|
|
|
protected $cache = null;
|
|
|
|
protected $use_cache = false;
|
|
|
|
public function __construct(array $options = null)
|
|
{
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
if ( (extension_loaded('sockets') == true) && (strtoupper(substr(PHP_OS, 0, 3)) !== 'WIN') ) {
|
|
|
|
$this->sockets_enabled = true;
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
if (!empty($options)) {
|
|
|
|
foreach ($options as $key => $value) {
|
|
|
|
if ($key == 'nameservers') {
|
|
|
|
$this->setServers($value);
|
|
} else {
|
|
|
|
$this->$key = $value;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
switch($this->cache_type) {
|
|
case 'shared':
|
|
if (extension_loaded('shmop')) {
|
|
|
|
$this->cache = new Net_DNS2_Cache_Shm;
|
|
$this->use_cache = true;
|
|
} else {
|
|
|
|
throw new Net_DNS2_Exception(
|
|
'shmop library is not available for cache',
|
|
Net_DNS2_Lookups::E_CACHE_SHM_UNAVAIL
|
|
);
|
|
}
|
|
break;
|
|
case 'file':
|
|
|
|
$this->cache = new Net_DNS2_Cache_File;
|
|
$this->use_cache = true;
|
|
|
|
break;
|
|
case 'none':
|
|
$this->use_cache = false;
|
|
break;
|
|
default:
|
|
|
|
throw new Net_DNS2_Exception(
|
|
'un-supported cache type: ' . $this->cache_type,
|
|
Net_DNS2_Lookups::E_CACHE_UNSUPPORTED
|
|
);
|
|
}
|
|
}
|
|
|
|
static public function autoload($name)
|
|
{
|
|
//
|
|
|
|
//
|
|
if (strncmp($name, 'Net_DNS2', 8) == 0) {
|
|
|
|
include str_replace('_', '/', $name) . '.php';
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
public function setServers($nameservers)
|
|
{
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
if (is_array($nameservers)) {
|
|
|
|
$this->nameservers = $nameservers;
|
|
|
|
} else {
|
|
|
|
//
|
|
|
|
//
|
|
$ns = array();
|
|
|
|
//
|
|
|
|
//
|
|
if (is_readable($nameservers) === true) {
|
|
|
|
$data = file_get_contents($nameservers);
|
|
if ($data === false) {
|
|
throw new Net_DNS2_Exception(
|
|
'failed to read contents of file: ' . $nameservers,
|
|
Net_DNS2_Lookups::E_NS_INVALID_FILE
|
|
);
|
|
}
|
|
|
|
$lines = explode("\n", $data);
|
|
|
|
foreach ($lines as $line) {
|
|
|
|
$line = trim($line);
|
|
|
|
//
|
|
|
|
//
|
|
if ( (strlen($line) == 0)
|
|
|| ($line[0] == '#')
|
|
|| ($line[0] == ';')
|
|
) {
|
|
continue;
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
if (strpos($line, ' ') === false) {
|
|
continue;
|
|
}
|
|
|
|
list($key, $value) = preg_split('/\s+/', $line, 2);
|
|
|
|
$key = trim(strtolower($key));
|
|
$value = trim(strtolower($value));
|
|
|
|
switch($key) {
|
|
case 'nameserver':
|
|
|
|
//
|
|
|
|
//
|
|
if ( (self::isIPv4($value) == true)
|
|
|| (self::isIPv6($value) == true)
|
|
) {
|
|
|
|
$ns[] = $value;
|
|
} else {
|
|
|
|
throw new Net_DNS2_Exception(
|
|
'invalid nameserver entry: ' . $value,
|
|
Net_DNS2_Lookups::E_NS_INVALID_ENTRY
|
|
);
|
|
}
|
|
break;
|
|
|
|
case 'domain':
|
|
$this->domain = $value;
|
|
break;
|
|
|
|
case 'search':
|
|
$this->search_list = preg_split('/\s+/', $value);
|
|
break;
|
|
|
|
case 'options':
|
|
$this->parseOptions($value);
|
|
break;
|
|
|
|
default:
|
|
;
|
|
}
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
if ( (strlen($this->domain) == 0)
|
|
&& (count($this->search_list) > 0)
|
|
) {
|
|
$this->domain = $this->search_list[0];
|
|
}
|
|
|
|
} else {
|
|
throw new Net_DNS2_Exception(
|
|
'resolver file file provided is not readable: ' . $nameservers,
|
|
Net_DNS2_Lookups::E_NS_INVALID_FILE
|
|
);
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
if (count($ns) > 0) {
|
|
$this->nameservers = $ns;
|
|
}
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
$this->nameservers = array_unique($this->nameservers);
|
|
|
|
//
|
|
|
|
//
|
|
$this->checkServers();
|
|
|
|
return true;
|
|
}
|
|
|
|
private function parseOptions($value)
|
|
{
|
|
//
|
|
|
|
//
|
|
if ( ($this->use_resolv_options == false) || (strlen($value) == 0) ) {
|
|
|
|
return true;
|
|
}
|
|
|
|
$options = preg_split('/\s+/', strtolower($value));
|
|
|
|
foreach ($options as $option) {
|
|
|
|
//
|
|
|
|
//
|
|
if ( (strncmp($option, 'timeout', 7) == 0) && (strpos($option, ':') !== false) ) {
|
|
|
|
list($key, $val) = explode(':', $option);
|
|
|
|
if ( ($val > 0) && ($val <= 30) ) {
|
|
|
|
$this->timeout = $val;
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
} else if (strncmp($option, 'rotate', 6) == 0) {
|
|
|
|
$this->ns_random = true;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
protected function checkServers($default = null)
|
|
{
|
|
if (empty($this->nameservers)) {
|
|
|
|
if (isset($default)) {
|
|
|
|
$this->setServers($default);
|
|
} else {
|
|
|
|
throw new Net_DNS2_Exception(
|
|
'empty name servers list; you must provide a list of name '.
|
|
'servers, or the path to a resolv.conf file.',
|
|
Net_DNS2_Lookups::E_NS_INVALID_ENTRY
|
|
);
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public function signTSIG(
|
|
$keyname, $signature = '', $algorithm = Net_DNS2_RR_TSIG::HMAC_MD5
|
|
) {
|
|
//
|
|
|
|
//
|
|
if ($keyname instanceof Net_DNS2_RR_TSIG) {
|
|
|
|
$this->auth_signature = $keyname;
|
|
|
|
} else {
|
|
|
|
//
|
|
|
|
//
|
|
$this->auth_signature = Net_DNS2_RR::fromString(
|
|
strtolower(trim($keyname)) .
|
|
' TSIG '. $signature
|
|
);
|
|
|
|
//
|
|
|
|
//
|
|
$this->auth_signature->algorithm = $algorithm;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public function signSIG0($filename)
|
|
{
|
|
//
|
|
|
|
//
|
|
if (extension_loaded('openssl') === false) {
|
|
|
|
throw new Net_DNS2_Exception(
|
|
'the OpenSSL extension is required to use SIG(0).',
|
|
Net_DNS2_Lookups::E_OPENSSL_UNAVAIL
|
|
);
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
if ($filename instanceof Net_DNS2_RR_SIG) {
|
|
|
|
$this->auth_signature = $filename;
|
|
|
|
} else {
|
|
|
|
//
|
|
|
|
//
|
|
$private = new Net_DNS2_PrivateKey($filename);
|
|
|
|
//
|
|
|
|
//
|
|
$this->auth_signature = new Net_DNS2_RR_SIG();
|
|
|
|
//
|
|
|
|
//
|
|
$this->auth_signature->name = $private->signname;
|
|
$this->auth_signature->ttl = 0;
|
|
$this->auth_signature->class = 'ANY';
|
|
|
|
//
|
|
|
|
//
|
|
$this->auth_signature->algorithm = $private->algorithm;
|
|
$this->auth_signature->keytag = $private->keytag;
|
|
$this->auth_signature->signname = $private->signname;
|
|
|
|
//
|
|
|
|
//
|
|
$this->auth_signature->typecovered = 'SIG0';
|
|
$this->auth_signature->labels = 0;
|
|
$this->auth_signature->origttl = 0;
|
|
|
|
//
|
|
|
|
//
|
|
$t = time();
|
|
|
|
$this->auth_signature->sigincep = gmdate('YmdHis', $t);
|
|
$this->auth_signature->sigexp = gmdate('YmdHis', $t + 500);
|
|
|
|
//
|
|
|
|
//
|
|
$this->auth_signature->private_key = $private;
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
switch($this->auth_signature->algorithm) {
|
|
case Net_DNS2_Lookups::DNSSEC_ALGORITHM_RSAMD5:
|
|
case Net_DNS2_Lookups::DNSSEC_ALGORITHM_RSASHA1:
|
|
case Net_DNS2_Lookups::DNSSEC_ALGORITHM_RSASHA256:
|
|
case Net_DNS2_Lookups::DNSSEC_ALGORITHM_RSASHA512:
|
|
case Net_DNS2_Lookups::DNSSEC_ALGORITHM_DSA:
|
|
break;
|
|
default:
|
|
throw new Net_DNS2_Exception(
|
|
'only asymmetric algorithms work with SIG(0)!',
|
|
Net_DNS2_Lookups::E_OPENSSL_INV_ALGO
|
|
);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public function cacheable($_type)
|
|
{
|
|
switch($_type) {
|
|
case 'AXFR':
|
|
case 'OPT':
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public static function expandUint32($_int)
|
|
{
|
|
if ( ($_int < 0) && (PHP_INT_MAX == 2147483647) ) {
|
|
return sprintf('%u', $_int);
|
|
} else {
|
|
return $_int;
|
|
}
|
|
}
|
|
|
|
public static function isIPv4($_address)
|
|
{
|
|
//
|
|
|
|
//
|
|
if (extension_loaded('filter') == true) {
|
|
|
|
if (filter_var($_address, FILTER_VALIDATE_IP, FILTER_FLAG_IPV4) == false) {
|
|
return false;
|
|
}
|
|
} else {
|
|
|
|
//
|
|
|
|
//
|
|
if (inet_pton($_address) === false) {
|
|
return false;
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
if (preg_match('/^[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}$/', $_address) == 0) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public static function isIPv6($_address)
|
|
{
|
|
//
|
|
|
|
//
|
|
if (extension_loaded('filter') == true) {
|
|
if (filter_var($_address, FILTER_VALIDATE_IP, FILTER_FLAG_IPV6) == false) {
|
|
return false;
|
|
}
|
|
} else {
|
|
|
|
//
|
|
|
|
//
|
|
if (inet_pton($_address) === false) {
|
|
return false;
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
if (preg_match('/^[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}$/', $_address) == 1) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public static function expandIPv6($_address)
|
|
{
|
|
if (strpos($_address, '::') !== false) {
|
|
|
|
$part = explode('::', $_address);
|
|
$part[0] = explode(':', $part[0]);
|
|
$part[1] = explode(':', $part[1]);
|
|
|
|
$missing = array();
|
|
|
|
$x = (8 - (count($part[0]) + count($part[1])));
|
|
for ($i = 0; $i < $x; $i++) {
|
|
|
|
array_push($missing, '0000');
|
|
}
|
|
|
|
$missing = array_merge($part[0], $missing);
|
|
$part = array_merge($missing, $part[1]);
|
|
|
|
} else {
|
|
|
|
$part = explode(':', $_address);
|
|
}
|
|
|
|
foreach ($part as &$p) {
|
|
while (strlen($p) < 4) {
|
|
$p = '0' . $p;
|
|
}
|
|
}
|
|
|
|
unset($p);
|
|
|
|
$result = implode(':', $part);
|
|
|
|
if (strlen($result) == 39) {
|
|
return $result;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
protected function sendPacket(Net_DNS2_Packet $request, $use_tcp)
|
|
{
|
|
//
|
|
|
|
//
|
|
$data = $request->get();
|
|
if (strlen($data) < Net_DNS2_Lookups::DNS_HEADER_SIZE) {
|
|
|
|
throw new Net_DNS2_Exception(
|
|
'invalid or empty packet for sending!',
|
|
Net_DNS2_Lookups::E_PACKET_INVALID,
|
|
null,
|
|
$request
|
|
);
|
|
}
|
|
|
|
reset($this->nameservers);
|
|
|
|
//
|
|
|
|
//
|
|
if ($this->ns_random == true) {
|
|
|
|
shuffle($this->nameservers);
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
$response = null;
|
|
$ns = '';
|
|
|
|
while (1) {
|
|
|
|
//
|
|
|
|
//
|
|
$ns = each($this->nameservers);
|
|
if ($ns === false) {
|
|
|
|
if (is_null($this->last_exception) == false) {
|
|
|
|
throw $this->last_exception;
|
|
} else {
|
|
|
|
throw new Net_DNS2_Exception(
|
|
'every name server provided has failed',
|
|
Net_DNS2_Lookups::E_NS_FAILED
|
|
);
|
|
}
|
|
}
|
|
|
|
$ns = $ns[1];
|
|
|
|
//
|
|
|
|
//
|
|
$max_udp_size = Net_DNS2_Lookups::DNS_MAX_UDP_SIZE;
|
|
if ($this->dnssec == true)
|
|
{
|
|
$max_udp_size = $this->dnssec_payload_size;
|
|
}
|
|
|
|
if ( ($use_tcp == true) || (strlen($data) > $max_udp_size) ) {
|
|
|
|
try
|
|
{
|
|
$response = $this->sendTCPRequest($ns, $data, ($request->question[0]->qtype == 'AXFR') ? true : false);
|
|
|
|
} catch(Net_DNS2_Exception $e) {
|
|
|
|
$this->last_exception = $e;
|
|
$this->last_exception_list[$ns] = $e;
|
|
|
|
continue;
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
} else {
|
|
|
|
try
|
|
{
|
|
$response = $this->sendUDPRequest($ns, $data);
|
|
|
|
//
|
|
|
|
//
|
|
if ($response->header->tc == 1) {
|
|
|
|
$response = $this->sendTCPRequest($ns, $data);
|
|
}
|
|
|
|
} catch(Net_DNS2_Exception $e) {
|
|
|
|
$this->last_exception = $e;
|
|
$this->last_exception_list[$ns] = $e;
|
|
|
|
continue;
|
|
}
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
if ($request->header->id != $response->header->id) {
|
|
|
|
$this->last_exception = new Net_DNS2_Exception(
|
|
|
|
'invalid header: the request and response id do not match.',
|
|
Net_DNS2_Lookups::E_HEADER_INVALID,
|
|
null,
|
|
$request,
|
|
$response
|
|
);
|
|
|
|
$this->last_exception_list[$ns] = $this->last_exception;
|
|
continue;
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
if ($response->header->qr != Net_DNS2_Lookups::QR_RESPONSE) {
|
|
|
|
$this->last_exception = new Net_DNS2_Exception(
|
|
|
|
'invalid header: the response provided is not a response packet.',
|
|
Net_DNS2_Lookups::E_HEADER_INVALID,
|
|
null,
|
|
$request,
|
|
$response
|
|
);
|
|
|
|
$this->last_exception_list[$ns] = $this->last_exception;
|
|
continue;
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
if ($response->header->rcode != Net_DNS2_Lookups::RCODE_NOERROR) {
|
|
|
|
$this->last_exception = new Net_DNS2_Exception(
|
|
|
|
'DNS request failed: ' .
|
|
Net_DNS2_Lookups::$result_code_messages[$response->header->rcode],
|
|
$response->header->rcode,
|
|
null,
|
|
$request,
|
|
$response
|
|
);
|
|
|
|
$this->last_exception_list[$ns] = $this->last_exception;
|
|
continue;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
return $response;
|
|
}
|
|
|
|
private function sendTCPRequest($_ns, $_data, $_axfr = false)
|
|
{
|
|
//
|
|
|
|
//
|
|
$start_time = microtime(true);
|
|
|
|
//
|
|
|
|
//
|
|
if ( (!isset($this->sock['tcp'][$_ns]))
|
|
|| (!($this->sock['tcp'][$_ns] instanceof Net_DNS2_Socket))
|
|
) {
|
|
|
|
//
|
|
|
|
//
|
|
if ($this->sockets_enabled === true) {
|
|
|
|
$this->sock['tcp'][$_ns] = new Net_DNS2_Socket_Sockets(
|
|
Net_DNS2_Socket::SOCK_STREAM, $_ns, $this->dns_port, $this->timeout
|
|
);
|
|
|
|
//
|
|
|
|
//
|
|
} else {
|
|
|
|
$this->sock['tcp'][$_ns] = new Net_DNS2_Socket_Streams(
|
|
Net_DNS2_Socket::SOCK_STREAM, $_ns, $this->dns_port, $this->timeout
|
|
);
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
if (strlen($this->local_host) > 0) {
|
|
|
|
$this->sock['tcp'][$_ns]->bindAddress(
|
|
$this->local_host, $this->local_port
|
|
);
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
if ($this->sock['tcp'][$_ns]->open() === false) {
|
|
|
|
throw new Net_DNS2_Exception(
|
|
$this->sock['tcp'][$_ns]->last_error, Net_DNS2_Lookups::E_NS_SOCKET_FAILED
|
|
);
|
|
}
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
if ($this->sock['tcp'][$_ns]->write($_data) === false) {
|
|
|
|
throw new Net_DNS2_Exception(
|
|
$this->sock['tcp'][$_ns]->last_error, Net_DNS2_Lookups::E_NS_SOCKET_FAILED
|
|
);
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
$size = 0;
|
|
$result = null;
|
|
$response = null;
|
|
|
|
//
|
|
|
|
//
|
|
if ($_axfr == true) {
|
|
|
|
$soa_count = 0;
|
|
|
|
while (1) {
|
|
|
|
//
|
|
|
|
//
|
|
$result = $this->sock['tcp'][$_ns]->read($size, ($this->dnssec == true) ? $this->dnssec_payload_size : Net_DNS2_Lookups::DNS_MAX_UDP_SIZE);
|
|
if ( ($result === false) || ($size < Net_DNS2_Lookups::DNS_HEADER_SIZE) ) {
|
|
|
|
throw new Net_DNS2_Exception(
|
|
$this->sock['tcp'][$_ns]->last_error, Net_DNS2_Lookups::E_NS_SOCKET_FAILED
|
|
);
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
$chunk = new Net_DNS2_Packet_Response($result, $size);
|
|
|
|
//
|
|
|
|
//
|
|
if (is_null($response) == true) {
|
|
|
|
$response = clone $chunk;
|
|
|
|
//
|
|
|
|
//
|
|
if ($response->header->rcode != Net_DNS2_Lookups::RCODE_NOERROR) {
|
|
break;
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
foreach ($response->answer as $index => $rr) {
|
|
|
|
//
|
|
|
|
//
|
|
if ($rr->type == 'SOA') {
|
|
$soa_count++;
|
|
}
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
if ($soa_count >= 2) {
|
|
break;
|
|
} else {
|
|
continue;
|
|
}
|
|
|
|
} else {
|
|
|
|
//
|
|
|
|
//
|
|
foreach ($chunk->answer as $index => $rr) {
|
|
|
|
//
|
|
|
|
//
|
|
if ($rr->type == 'SOA') {
|
|
$soa_count++;
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
$response->answer[] = $rr;
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
if ($soa_count >= 2) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
} else {
|
|
|
|
$result = $this->sock['tcp'][$_ns]->read($size, ($this->dnssec == true) ? $this->dnssec_payload_size : Net_DNS2_Lookups::DNS_MAX_UDP_SIZE);
|
|
if ( ($result === false) || ($size < Net_DNS2_Lookups::DNS_HEADER_SIZE) ) {
|
|
|
|
throw new Net_DNS2_Exception(
|
|
$this->sock['tcp'][$_ns]->last_error, Net_DNS2_Lookups::E_NS_SOCKET_FAILED
|
|
);
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
$response = new Net_DNS2_Packet_Response($result, $size);
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
$response->response_time = microtime(true) - $start_time;
|
|
|
|
//
|
|
|
|
//
|
|
$response->answer_from = $_ns;
|
|
$response->answer_socket_type = Net_DNS2_Socket::SOCK_STREAM;
|
|
|
|
//
|
|
|
|
//
|
|
return $response;
|
|
}
|
|
|
|
private function sendUDPRequest($_ns, $_data)
|
|
{
|
|
//
|
|
|
|
//
|
|
$start_time = microtime(true);
|
|
|
|
//
|
|
|
|
//
|
|
if ( (!isset($this->sock['udp'][$_ns]))
|
|
|| (!($this->sock['udp'][$_ns] instanceof Net_DNS2_Socket))
|
|
) {
|
|
|
|
//
|
|
|
|
//
|
|
if ($this->sockets_enabled === true) {
|
|
|
|
$this->sock['udp'][$_ns] = new Net_DNS2_Socket_Sockets(
|
|
Net_DNS2_Socket::SOCK_DGRAM, $_ns, $this->dns_port, $this->timeout
|
|
);
|
|
|
|
//
|
|
|
|
//
|
|
} else {
|
|
|
|
$this->sock['udp'][$_ns] = new Net_DNS2_Socket_Streams(
|
|
Net_DNS2_Socket::SOCK_DGRAM, $_ns, $this->dns_port, $this->timeout
|
|
);
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
if (strlen($this->local_host) > 0) {
|
|
|
|
$this->sock['udp'][$_ns]->bindAddress(
|
|
$this->local_host, $this->local_port
|
|
);
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
if ($this->sock['udp'][$_ns]->open() === false) {
|
|
|
|
throw new Net_DNS2_Exception(
|
|
$this->sock['udp'][$_ns]->last_error, Net_DNS2_Lookups::E_NS_SOCKET_FAILED
|
|
);
|
|
}
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
if ($this->sock['udp'][$_ns]->write($_data) === false) {
|
|
|
|
throw new Net_DNS2_Exception(
|
|
$this->sock['udp'][$_ns]->last_error, Net_DNS2_Lookups::E_NS_SOCKET_FAILED
|
|
);
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
$size = 0;
|
|
|
|
$result = $this->sock['udp'][$_ns]->read($size, ($this->dnssec == true) ? $this->dnssec_payload_size : Net_DNS2_Lookups::DNS_MAX_UDP_SIZE);
|
|
if (( $result === false) || ($size < Net_DNS2_Lookups::DNS_HEADER_SIZE)) {
|
|
|
|
throw new Net_DNS2_Exception(
|
|
$this->sock['udp'][$_ns]->last_error, Net_DNS2_Lookups::E_NS_SOCKET_FAILED
|
|
);
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
$response = new Net_DNS2_Packet_Response($result, $size);
|
|
|
|
//
|
|
|
|
//
|
|
$response->response_time = microtime(true) - $start_time;
|
|
|
|
//
|
|
|
|
//
|
|
$response->answer_from = $_ns;
|
|
$response->answer_socket_type = Net_DNS2_Socket::SOCK_DGRAM;
|
|
|
|
//
|
|
|
|
//
|
|
return $response;
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_BitMap
|
|
{
|
|
|
|
public static function bitMapToArray($data)
|
|
{
|
|
if (strlen($data) == 0) {
|
|
return null;
|
|
}
|
|
|
|
$output = array();
|
|
$offset = 0;
|
|
$length = strlen($data);
|
|
|
|
while ($offset < $length) {
|
|
|
|
//
|
|
|
|
//
|
|
$x = unpack('@' . $offset . '/Cwindow/Clength', $data);
|
|
$offset += 2;
|
|
|
|
//
|
|
|
|
//
|
|
$bitmap = unpack('C*', substr($data, $offset, $x['length']));
|
|
$offset += $x['length'];
|
|
|
|
//
|
|
|
|
//
|
|
$bitstr = '';
|
|
foreach ($bitmap as $r) {
|
|
|
|
$bitstr .= sprintf('%08b', $r);
|
|
}
|
|
|
|
$blen = strlen($bitstr);
|
|
for ($i=0; $i<$blen; $i++) {
|
|
|
|
if ($bitstr[$i] == '1') {
|
|
|
|
$type = $x['window'] * 256 + $i;
|
|
|
|
if (isset(Net_DNS2_Lookups::$rr_types_by_id[$type])) {
|
|
|
|
$output[] = Net_DNS2_Lookups::$rr_types_by_id[$type];
|
|
} else {
|
|
|
|
$output[] = 'TYPE' . $type;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return $output;
|
|
}
|
|
|
|
public static function arrayToBitMap(array $data)
|
|
{
|
|
if (count($data) == 0) {
|
|
return null;
|
|
}
|
|
|
|
$current_window = 0;
|
|
|
|
//
|
|
|
|
//
|
|
$max = 0;
|
|
$bm = array();
|
|
|
|
foreach ($data as $rr) {
|
|
|
|
$rr = strtoupper($rr);
|
|
|
|
//
|
|
|
|
//
|
|
$type = @Net_DNS2_Lookups::$rr_types_by_name[$rr];
|
|
if (isset($type)) {
|
|
|
|
//
|
|
|
|
//
|
|
if ( (isset(Net_DNS2_Lookups::$rr_qtypes_by_id[$type]))
|
|
|| (isset(Net_DNS2_Lookups::$rr_metatypes_by_id[$type]))
|
|
) {
|
|
continue;
|
|
}
|
|
|
|
} else {
|
|
|
|
//
|
|
|
|
//
|
|
list($name, $type) = explode('TYPE', $rr);
|
|
if (!isset($type)) {
|
|
|
|
continue;
|
|
}
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
$current_window = (int)($type / 256);
|
|
|
|
$val = $type - $current_window * 256.0;
|
|
if ($val > $max) {
|
|
$max = $val;
|
|
}
|
|
|
|
$bm[$current_window][$val] = 1;
|
|
$bm[$current_window]['length'] = ceil(($max + 1) / 8);
|
|
}
|
|
|
|
$output = '';
|
|
|
|
foreach ($bm as $window => $bitdata) {
|
|
|
|
$bitstr = '';
|
|
|
|
for ($i=0; $i<$bm[$window]['length'] * 8; $i++) {
|
|
if (isset($bm[$window][$i])) {
|
|
$bitstr .= '1';
|
|
} else {
|
|
$bitstr .= '0';
|
|
}
|
|
}
|
|
|
|
$output .= pack('CC', $window, $bm[$window]['length']);
|
|
$output .= pack('H*', self::bigBaseConvert($bitstr));
|
|
}
|
|
|
|
return $output;
|
|
}
|
|
|
|
public static function bigBaseConvert($number)
|
|
{
|
|
$result = '';
|
|
|
|
$bin = substr(chunk_split(strrev($number), 4, '-'), 0, -1);
|
|
$temp = preg_split('[-]', $bin, -1, PREG_SPLIT_DELIM_CAPTURE);
|
|
|
|
for ($i = count($temp)-1;$i >= 0;$i--) {
|
|
|
|
$result = $result . base_convert(strrev($temp[$i]), 2, 16);
|
|
}
|
|
|
|
return strtoupper($result);
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_Cache
|
|
{
|
|
|
|
protected $cache_file = '';
|
|
|
|
protected $cache_data = array();
|
|
|
|
protected $cache_size = 0;
|
|
|
|
protected $cache_serializer;
|
|
|
|
public function has($key)
|
|
{
|
|
return isset($this->cache_data[$key]);
|
|
}
|
|
|
|
public function get($key)
|
|
{
|
|
if (isset($this->cache_data[$key])) {
|
|
|
|
if ($this->cache_serializer == 'json') {
|
|
return json_decode($this->cache_data[$key]['object']);
|
|
} else {
|
|
return unserialize($this->cache_data[$key]['object']);
|
|
}
|
|
} else {
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public function put($key, $data)
|
|
{
|
|
$ttl = 86400 * 365;
|
|
|
|
//
|
|
|
|
//
|
|
$data->rdata = '';
|
|
$data->rdlength = 0;
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
foreach ($data->answer as $index => $rr) {
|
|
|
|
if ($rr->ttl < $ttl) {
|
|
$ttl = $rr->ttl;
|
|
}
|
|
|
|
$rr->rdata = '';
|
|
$rr->rdlength = 0;
|
|
}
|
|
foreach ($data->authority as $index => $rr) {
|
|
|
|
if ($rr->ttl < $ttl) {
|
|
$ttl = $rr->ttl;
|
|
}
|
|
|
|
$rr->rdata = '';
|
|
$rr->rdlength = 0;
|
|
}
|
|
foreach ($data->additional as $index => $rr) {
|
|
|
|
if ($rr->ttl < $ttl) {
|
|
$ttl = $rr->ttl;
|
|
}
|
|
|
|
$rr->rdata = '';
|
|
$rr->rdlength = 0;
|
|
}
|
|
|
|
$this->cache_data[$key] = array(
|
|
|
|
'cache_date' => time(),
|
|
'ttl' => $ttl
|
|
);
|
|
|
|
if ($this->cache_serializer == 'json') {
|
|
$this->cache_data[$key]['object'] = json_encode($data);
|
|
} else {
|
|
$this->cache_data[$key]['object'] = serialize($data);
|
|
}
|
|
}
|
|
|
|
protected function clean()
|
|
{
|
|
if (count($this->cache_data) > 0) {
|
|
|
|
//
|
|
|
|
//
|
|
$now = time();
|
|
|
|
foreach ($this->cache_data as $key => $data) {
|
|
|
|
$diff = $now - $data['cache_date'];
|
|
|
|
if ($data['ttl'] <= $diff) {
|
|
|
|
unset($this->cache_data[$key]);
|
|
} else {
|
|
|
|
$this->cache_data[$key]['ttl'] -= $diff;
|
|
$this->cache_data[$key]['cache_date'] = $now;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
protected function resize()
|
|
{
|
|
if (count($this->cache_data) > 0) {
|
|
|
|
//
|
|
|
|
//
|
|
if ($this->cache_serializer == 'json') {
|
|
$cache = json_encode($this->cache_data);
|
|
} else {
|
|
$cache = serialize($this->cache_data);
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
if (strlen($cache) > $this->cache_size) {
|
|
|
|
while (strlen($cache) > $this->cache_size) {
|
|
|
|
//
|
|
|
|
//
|
|
$smallest_ttl = time();
|
|
$smallest_key = null;
|
|
|
|
foreach ($this->cache_data as $key => $data) {
|
|
|
|
if ($data['ttl'] < $smallest_ttl) {
|
|
|
|
$smallest_ttl = $data['ttl'];
|
|
$smallest_key = $key;
|
|
}
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
unset($this->cache_data[$smallest_key]);
|
|
|
|
//
|
|
|
|
//
|
|
if ($this->cache_serializer == 'json') {
|
|
$cache = json_encode($this->cache_data);
|
|
} else {
|
|
$cache = serialize($this->cache_data);
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( ($cache == 'a:0:{}') || ($cache == '{}') ) {
|
|
return null;
|
|
} else {
|
|
return $cache;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
};
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_Exception extends Exception
|
|
{
|
|
private $_request;
|
|
private $_response;
|
|
|
|
public function __construct(
|
|
$message = '',
|
|
$code = 0,
|
|
$previous = null,
|
|
Net_DNS2_Packet_Request $request = null,
|
|
Net_DNS2_Packet_Response $response = null
|
|
) {
|
|
//
|
|
|
|
//
|
|
$this->_request = $request;
|
|
$this->_response = $response;
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
if (version_compare(PHP_VERSION, '5.3.0', '>=') == true) {
|
|
|
|
parent::__construct($message, $code, $previous);
|
|
} else {
|
|
|
|
parent::__construct($message, $code);
|
|
}
|
|
}
|
|
|
|
public function getRequest()
|
|
{
|
|
return $this->_request;
|
|
}
|
|
|
|
public function getResponse()
|
|
{
|
|
return $this->_response;
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_Header
|
|
{
|
|
public $id;
|
|
public $qr;
|
|
public $opcode;
|
|
public $aa;
|
|
public $tc;
|
|
public $rd;
|
|
public $ra;
|
|
public $z;
|
|
public $ad;
|
|
public $cd;
|
|
public $rcode;
|
|
public $qdcount;
|
|
public $ancount;
|
|
public $nscount;
|
|
public $arcount;
|
|
|
|
public function __construct(Net_DNS2_Packet &$packet = null)
|
|
{
|
|
if (!is_null($packet)) {
|
|
|
|
$this->set($packet);
|
|
} else {
|
|
|
|
$this->id = $this->nextPacketId();
|
|
$this->qr = Net_DNS2_Lookups::QR_QUERY;
|
|
$this->opcode = Net_DNS2_Lookups::OPCODE_QUERY;
|
|
$this->aa = 0;
|
|
$this->tc = 0;
|
|
$this->rd = 1;
|
|
$this->ra = 0;
|
|
$this->z = 0;
|
|
$this->ad = 0;
|
|
$this->cd = 0;
|
|
$this->rcode = Net_DNS2_Lookups::RCODE_NOERROR;
|
|
$this->qdcount = 1;
|
|
$this->ancount = 0;
|
|
$this->nscount = 0;
|
|
$this->arcount = 0;
|
|
}
|
|
}
|
|
|
|
public function nextPacketId()
|
|
{
|
|
if (++Net_DNS2_Lookups::$next_packet_id > 65535) {
|
|
|
|
Net_DNS2_Lookups::$next_packet_id = 1;
|
|
}
|
|
|
|
return Net_DNS2_Lookups::$next_packet_id;
|
|
}
|
|
|
|
public function __toString()
|
|
{
|
|
$output = ";;\n;; Header:\n";
|
|
|
|
$output .= ";;\t id = " . $this->id . "\n";
|
|
$output .= ";;\t qr = " . $this->qr . "\n";
|
|
$output .= ";;\t opcode = " . $this->opcode . "\n";
|
|
$output .= ";;\t aa = " . $this->aa . "\n";
|
|
$output .= ";;\t tc = " . $this->tc . "\n";
|
|
$output .= ";;\t rd = " . $this->rd . "\n";
|
|
$output .= ";;\t ra = " . $this->ra . "\n";
|
|
$output .= ";;\t z = " . $this->z . "\n";
|
|
$output .= ";;\t ad = " . $this->ad . "\n";
|
|
$output .= ";;\t cd = " . $this->cd . "\n";
|
|
$output .= ";;\t rcode = " . $this->rcode . "\n";
|
|
$output .= ";;\t qdcount = " . $this->qdcount . "\n";
|
|
$output .= ";;\t ancount = " . $this->ancount . "\n";
|
|
$output .= ";;\t nscount = " . $this->nscount . "\n";
|
|
$output .= ";;\t arcount = " . $this->arcount . "\n";
|
|
|
|
return $output;
|
|
}
|
|
|
|
public function set(Net_DNS2_Packet &$packet)
|
|
{
|
|
//
|
|
|
|
//
|
|
if ($packet->rdlength < Net_DNS2_Lookups::DNS_HEADER_SIZE) {
|
|
|
|
throw new Net_DNS2_Exception(
|
|
'invalid header data provided; to small',
|
|
Net_DNS2_Lookups::E_HEADER_INVALID
|
|
);
|
|
}
|
|
|
|
$offset = 0;
|
|
|
|
//
|
|
|
|
//
|
|
$this->id = ord($packet->rdata[$offset]) << 8 |
|
|
ord($packet->rdata[++$offset]);
|
|
|
|
++$offset;
|
|
$this->qr = (ord($packet->rdata[$offset]) >> 7) & 0x1;
|
|
$this->opcode = (ord($packet->rdata[$offset]) >> 3) & 0xf;
|
|
$this->aa = (ord($packet->rdata[$offset]) >> 2) & 0x1;
|
|
$this->tc = (ord($packet->rdata[$offset]) >> 1) & 0x1;
|
|
$this->rd = ord($packet->rdata[$offset]) & 0x1;
|
|
|
|
++$offset;
|
|
$this->ra = (ord($packet->rdata[$offset]) >> 7) & 0x1;
|
|
$this->z = (ord($packet->rdata[$offset]) >> 6) & 0x1;
|
|
$this->ad = (ord($packet->rdata[$offset]) >> 5) & 0x1;
|
|
$this->cd = (ord($packet->rdata[$offset]) >> 4) & 0x1;
|
|
$this->rcode = ord($packet->rdata[$offset]) & 0xf;
|
|
|
|
$this->qdcount = ord($packet->rdata[++$offset]) << 8 |
|
|
ord($packet->rdata[++$offset]);
|
|
$this->ancount = ord($packet->rdata[++$offset]) << 8 |
|
|
ord($packet->rdata[++$offset]);
|
|
$this->nscount = ord($packet->rdata[++$offset]) << 8 |
|
|
ord($packet->rdata[++$offset]);
|
|
$this->arcount = ord($packet->rdata[++$offset]) << 8 |
|
|
ord($packet->rdata[++$offset]);
|
|
|
|
//
|
|
|
|
//
|
|
$packet->offset += Net_DNS2_Lookups::DNS_HEADER_SIZE;
|
|
|
|
return true;
|
|
}
|
|
|
|
public function get(Net_DNS2_Packet &$packet)
|
|
{
|
|
$data = pack('n', $this->id) .
|
|
chr(
|
|
($this->qr << 7) | ($this->opcode << 3) |
|
|
($this->aa << 2) | ($this->tc << 1) | ($this->rd)
|
|
) .
|
|
chr(
|
|
($this->ra << 7) | ($this->ad << 5) | ($this->cd << 4) | $this->rcode
|
|
) .
|
|
chr($this->qdcount << 8) . chr($this->qdcount) .
|
|
chr($this->ancount << 8) . chr($this->ancount) .
|
|
chr($this->nscount << 8) . chr($this->nscount) .
|
|
chr($this->arcount << 8) . chr($this->arcount);
|
|
|
|
$packet->offset += Net_DNS2_Lookups::DNS_HEADER_SIZE;
|
|
|
|
return $data;
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
//
|
|
|
|
//
|
|
Net_DNS2_Lookups::$next_packet_id = mt_rand(0, 65535);
|
|
|
|
//
|
|
|
|
//
|
|
Net_DNS2_Lookups::$rr_types_by_id = array_flip(Net_DNS2_Lookups::$rr_types_by_name);
|
|
Net_DNS2_Lookups::$classes_by_id = array_flip(Net_DNS2_Lookups::$classes_by_name);
|
|
Net_DNS2_Lookups::$rr_types_class_to_id = array_flip(Net_DNS2_Lookups::$rr_types_id_to_class);
|
|
Net_DNS2_Lookups::$algorithm_name_to_id = array_flip(Net_DNS2_Lookups::$algorithm_id_to_name);
|
|
Net_DNS2_Lookups::$digest_name_to_id = array_flip(Net_DNS2_Lookups::$digest_id_to_name);
|
|
Net_DNS2_Lookups::$rr_qtypes_by_id = array_flip(Net_DNS2_Lookups::$rr_qtypes_by_name);
|
|
Net_DNS2_Lookups::$rr_metatypes_by_id = array_flip(Net_DNS2_Lookups::$rr_metatypes_by_name);
|
|
Net_DNS2_Lookups::$protocol_by_id = array_flip(Net_DNS2_Lookups::$protocol_by_name);
|
|
|
|
class Net_DNS2_Lookups
|
|
{
|
|
|
|
const DNS_HEADER_SIZE = 12;
|
|
|
|
const DNS_MAX_UDP_SIZE = 512;
|
|
|
|
const QR_QUERY = 0;
|
|
const QR_RESPONSE = 1;
|
|
|
|
const OPCODE_QUERY = 0;
|
|
const OPCODE_IQUERY = 1;
|
|
const OPCODE_STATUS = 2;
|
|
const OPCODE_NOTIFY = 4;
|
|
const OPCODE_UPDATE = 5;
|
|
|
|
const RR_CLASS_IN = 1;
|
|
const RR_CLASS_CH = 3;
|
|
const RR_CLASS_HS = 4;
|
|
const RR_CLASS_NONE = 254;
|
|
const RR_CLASS_ANY = 255;
|
|
|
|
const RCODE_NOERROR = 0;
|
|
const RCODE_FORMERR = 1;
|
|
const RCODE_SERVFAIL = 2;
|
|
const RCODE_NXDOMAIN = 3;
|
|
const RCODE_NOTIMP = 4;
|
|
const RCODE_REFUSED = 5;
|
|
const RCODE_YXDOMAIN = 6;
|
|
const RCODE_YXRRSET = 7;
|
|
const RCODE_NXRRSET = 8;
|
|
const RCODE_NOTAUTH = 9;
|
|
const RCODE_NOTZONE = 10;
|
|
|
|
const RCODE_BADSIG = 16;
|
|
const RCODE_BADKEY = 17;
|
|
const RCODE_BADTIME = 18;
|
|
const RCODE_BADMODE = 19;
|
|
const RCODE_BADNAME = 20;
|
|
const RCODE_BADALG = 21;
|
|
const RCODE_BADTRUNC = 22;
|
|
|
|
const E_NONE = 0;
|
|
const E_DNS_FORMERR = self::RCODE_FORMERR;
|
|
const E_DNS_SERVFAIL = self::RCODE_SERVFAIL;
|
|
const E_DNS_NXDOMAIN = self::RCODE_NXDOMAIN;
|
|
const E_DNS_NOTIMP = self::RCODE_NOTIMP;
|
|
const E_DNS_REFUSED = self::RCODE_REFUSED;
|
|
const E_DNS_YXDOMAIN = self::RCODE_YXDOMAIN;
|
|
const E_DNS_YXRRSET = self::RCODE_YXRRSET;
|
|
const E_DNS_NXRRSET = self::RCODE_NXRRSET;
|
|
const E_DNS_NOTAUTH = self::RCODE_NOTAUTH;
|
|
const E_DNS_NOTZONE = self::RCODE_NOTZONE;
|
|
|
|
const E_DNS_BADSIG = self::RCODE_BADSIG;
|
|
const E_DNS_BADKEY = self::RCODE_BADKEY;
|
|
const E_DNS_BADTIME = self::RCODE_BADTIME;
|
|
const E_DNS_BADMODE = self::RCODE_BADMODE;
|
|
const E_DNS_BADNAME = self::RCODE_BADNAME;
|
|
const E_DNS_BADALG = self::RCODE_BADALG;
|
|
const E_DNS_BADTRUNC = self::RCODE_BADTRUNC;
|
|
|
|
const E_NS_INVALID_FILE = 200;
|
|
const E_NS_INVALID_ENTRY = 201;
|
|
const E_NS_FAILED = 202;
|
|
const E_NS_SOCKET_FAILED = 203;
|
|
|
|
const E_PACKET_INVALID = 300;
|
|
const E_PARSE_ERROR = 301;
|
|
const E_HEADER_INVALID = 302;
|
|
const E_QUESTION_INVALID = 303;
|
|
const E_RR_INVALID = 304;
|
|
|
|
const E_OPENSSL_ERROR = 400;
|
|
const E_OPENSSL_UNAVAIL = 401;
|
|
const E_OPENSSL_INV_PKEY = 402;
|
|
const E_OPENSSL_INV_ALGO = 403;
|
|
|
|
const E_CACHE_UNSUPPORTED = 500;
|
|
const E_CACHE_SHM_FILE = 501;
|
|
const E_CACHE_SHM_UNAVAIL = 502;
|
|
|
|
const DNSSEC_ALGORITHM_RES = 0;
|
|
const DNSSEC_ALGORITHM_RSAMD5 = 1;
|
|
const DNSSEC_ALGORITHM_DH = 2;
|
|
const DNSSEC_ALGORITHM_DSA = 3;
|
|
const DNSSEC_ALGORITHM_ECC = 4;
|
|
const DNSSEC_ALGORITHM_RSASHA1 = 5;
|
|
const DNSSEC_ALGORITHM_DSANSEC3SHA1 = 6;
|
|
const DSNSEC_ALGORITHM_RSASHA1NSEC3SHA1 = 7;
|
|
const DNSSEC_ALGORITHM_RSASHA256 = 8;
|
|
const DNSSEC_ALGORITHM_RSASHA512 = 10;
|
|
const DNSSEC_ALGORITHM_ECCGOST = 12;
|
|
const DNSSEC_ALGORITHM_INDIRECT = 252;
|
|
const DNSSEC_ALGORITHM_PRIVATEDNS = 253;
|
|
const DNSSEC_ALGORITHM_PRIVATEOID = 254;
|
|
|
|
const DNSSEC_DIGEST_RES = 0;
|
|
const DNSSEC_DIGEST_SHA1 = 1;
|
|
|
|
public static $next_packet_id;
|
|
|
|
public static $rr_types_by_id = array();
|
|
public static $rr_types_by_name = array(
|
|
|
|
'SIG0' => 0,
|
|
'A' => 1,
|
|
'NS' => 2,
|
|
'MD' => 3,
|
|
'MF' => 4,
|
|
'CNAME' => 5,
|
|
'SOA' => 6,
|
|
'MB' => 7,
|
|
'MG' => 8,
|
|
'MR' => 9,
|
|
'NULL' => 10,
|
|
'WKS' => 11,
|
|
'PTR' => 12,
|
|
'HINFO' => 13,
|
|
'MINFO' => 14,
|
|
'MX' => 15,
|
|
'TXT' => 16,
|
|
'RP' => 17,
|
|
'AFSDB' => 18,
|
|
'X25' => 19,
|
|
'ISDN' => 20,
|
|
'RT' => 21,
|
|
'NSAP' => 22,
|
|
'NSAP_PTR' => 23,
|
|
'SIG' => 24,
|
|
'KEY' => 25,
|
|
'PX' => 26,
|
|
'GPOS' => 27,
|
|
'AAAA' => 28,
|
|
'LOC' => 29,
|
|
'NXT' => 30,
|
|
'EID' => 31,
|
|
'NIMLOC' => 32,
|
|
'SRV' => 33,
|
|
'ATMA' => 34,
|
|
'NAPTR' => 35,
|
|
'KX' => 36,
|
|
'CERT' => 37,
|
|
'A6' => 38,
|
|
'DNAME' => 39,
|
|
'SINK' => 40,
|
|
'OPT' => 41,
|
|
'APL' => 42,
|
|
'DS' => 43,
|
|
'SSHFP' => 44,
|
|
'IPSECKEY' => 45,
|
|
'RRSIG' => 46,
|
|
'NSEC' => 47,
|
|
'DNSKEY' => 48,
|
|
'DHCID' => 49,
|
|
'NSEC3' => 50,
|
|
'NSEC3PARAM' => 51,
|
|
'TLSA' => 52,
|
|
|
|
'HIP' => 55,
|
|
'NINFO' => 56,
|
|
'RKEY' => 57,
|
|
'TALINK' => 58, //
|
|
'CDS' => 59,
|
|
'CDNSKEY' => 60,
|
|
'OPENPGPKEY' => 61,
|
|
'CSYNC' => 62,
|
|
|
|
'SPF' => 99,
|
|
'UINFO' => 100,
|
|
'UID' => 101,
|
|
'GID' => 102,
|
|
'UNSPEC' => 103,
|
|
'NID' => 104,
|
|
'L32' => 105,
|
|
'L64' => 106,
|
|
'LP' => 107,
|
|
'EUI48' => 108,
|
|
'EUI64' => 109,
|
|
|
|
'TKEY' => 249,
|
|
'TSIG' => 250,
|
|
'IXFR' => 251,
|
|
'AXFR' => 252,
|
|
'MAILB' => 253,
|
|
'MAILA' => 254,
|
|
'ANY' => 255,
|
|
'URI' => 256,
|
|
'CAA' => 257,
|
|
|
|
'TA' => 32768,
|
|
'DLV' => 32769
|
|
);
|
|
|
|
public static $rr_qtypes_by_id = array();
|
|
public static $rr_qtypes_by_name = array(
|
|
|
|
'IXFR' => 251,
|
|
'AXFR' => 252,
|
|
'MAILB' => 253,
|
|
'MAILA' => 254,
|
|
'ANY' => 255
|
|
);
|
|
|
|
public static $rr_metatypes_by_id = array();
|
|
public static $rr_metatypes_by_name = array(
|
|
|
|
'OPT' => 41,
|
|
'TKEY' => 249,
|
|
'TSIG' => 250
|
|
);
|
|
|
|
public static $rr_types_class_to_id = array();
|
|
public static $rr_types_id_to_class = array(
|
|
|
|
1 => 'Net_DNS2_RR_A',
|
|
2 => 'Net_DNS2_RR_NS',
|
|
5 => 'Net_DNS2_RR_CNAME',
|
|
6 => 'Net_DNS2_RR_SOA',
|
|
11 => 'Net_DNS2_RR_WKS',
|
|
12 => 'Net_DNS2_RR_PTR',
|
|
13 => 'Net_DNS2_RR_HINFO',
|
|
15 => 'Net_DNS2_RR_MX',
|
|
16 => 'Net_DNS2_RR_TXT',
|
|
17 => 'Net_DNS2_RR_RP',
|
|
18 => 'Net_DNS2_RR_AFSDB',
|
|
19 => 'Net_DNS2_RR_X25',
|
|
20 => 'Net_DNS2_RR_ISDN',
|
|
21 => 'Net_DNS2_RR_RT',
|
|
22 => 'Net_DNS2_RR_NSAP',
|
|
24 => 'Net_DNS2_RR_SIG',
|
|
25 => 'Net_DNS2_RR_KEY',
|
|
26 => 'Net_DNS2_RR_PX',
|
|
28 => 'Net_DNS2_RR_AAAA',
|
|
29 => 'Net_DNS2_RR_LOC',
|
|
31 => 'Net_DNS2_RR_EID',
|
|
32 => 'Net_DNS2_RR_NIMLOC',
|
|
33 => 'Net_DNS2_RR_SRV',
|
|
34 => 'Net_DNS2_RR_ATMA',
|
|
35 => 'Net_DNS2_RR_NAPTR',
|
|
36 => 'Net_DNS2_RR_KX',
|
|
37 => 'Net_DNS2_RR_CERT',
|
|
39 => 'Net_DNS2_RR_DNAME',
|
|
41 => 'Net_DNS2_RR_OPT',
|
|
42 => 'Net_DNS2_RR_APL',
|
|
43 => 'Net_DNS2_RR_DS',
|
|
44 => 'Net_DNS2_RR_SSHFP',
|
|
45 => 'Net_DNS2_RR_IPSECKEY',
|
|
46 => 'Net_DNS2_RR_RRSIG',
|
|
47 => 'Net_DNS2_RR_NSEC',
|
|
48 => 'Net_DNS2_RR_DNSKEY',
|
|
49 => 'Net_DNS2_RR_DHCID',
|
|
50 => 'Net_DNS2_RR_NSEC3',
|
|
51 => 'Net_DNS2_RR_NSEC3PARAM',
|
|
52 => 'Net_DNS2_RR_TLSA',
|
|
55 => 'Net_DNS2_RR_HIP',
|
|
58 => 'Net_DNS2_RR_TALINK',
|
|
59 => 'Net_DNS2_RR_CDS',
|
|
60 => 'Net_DNS2_RR_CDNSKEY',
|
|
61 => 'Net_DNS2_RR_OPENPGPKEY',
|
|
62 => 'Net_DNS2_RR_CSYNC',
|
|
99 => 'Net_DNS2_RR_SPF',
|
|
104 => 'Net_DNS2_RR_NID',
|
|
105 => 'Net_DNS2_RR_L32',
|
|
106 => 'Net_DNS2_RR_L64',
|
|
107 => 'Net_DNS2_RR_LP',
|
|
108 => 'Net_DNS2_RR_EUI48',
|
|
109 => 'Net_DNS2_RR_EUI64',
|
|
|
|
249 => 'Net_DNS2_RR_TKEY',
|
|
250 => 'Net_DNS2_RR_TSIG',
|
|
|
|
255 => 'Net_DNS2_RR_ANY',
|
|
256 => 'Net_DNS2_RR_URI',
|
|
257 => 'Net_DNS2_RR_CAA',
|
|
32768 => 'Net_DNS2_RR_TA',
|
|
32769 => 'Net_DNS2_RR_DLV'
|
|
);
|
|
|
|
public static $classes_by_id = array();
|
|
public static $classes_by_name = array(
|
|
|
|
'IN' => self::RR_CLASS_IN,
|
|
'CH' => self::RR_CLASS_CH,
|
|
'HS' => self::RR_CLASS_HS,
|
|
'NONE' => self::RR_CLASS_NONE,
|
|
'ANY' => self::RR_CLASS_ANY
|
|
);
|
|
|
|
public static $result_code_messages = array(
|
|
|
|
self::RCODE_NOERROR => 'The request completed successfully.',
|
|
self::RCODE_FORMERR => 'The name server was unable to interpret the query.',
|
|
self::RCODE_SERVFAIL => 'The name server was unable to process this query due to a problem with the name server.',
|
|
self::RCODE_NXDOMAIN => 'The domain name referenced in the query does not exist.',
|
|
self::RCODE_NOTIMP => 'The name server does not support the requested kind of query.',
|
|
self::RCODE_REFUSED => 'The name server refuses to perform the specified operation for policy reasons.',
|
|
self::RCODE_YXDOMAIN => 'Name Exists when it should not.',
|
|
self::RCODE_YXRRSET => 'RR Set Exists when it should not.',
|
|
self::RCODE_NXRRSET => 'RR Set that should exist does not.',
|
|
self::RCODE_NOTAUTH => 'Server Not Authoritative for zone.',
|
|
self::RCODE_NOTZONE => 'Name not contained in zone.',
|
|
|
|
self::RCODE_BADSIG => 'TSIG Signature Failure.',
|
|
self::RCODE_BADKEY => 'Key not recognized.',
|
|
self::RCODE_BADTIME => 'Signature out of time window.',
|
|
self::RCODE_BADMODE => 'Bad TKEY Mode.',
|
|
self::RCODE_BADNAME => 'Duplicate key name.',
|
|
self::RCODE_BADALG => 'Algorithm not supported.',
|
|
self::RCODE_BADTRUNC => 'Bad truncation.'
|
|
);
|
|
|
|
public static $algorithm_name_to_id = array();
|
|
public static $algorithm_id_to_name = array(
|
|
|
|
self::DNSSEC_ALGORITHM_RES => 'RES',
|
|
self::DNSSEC_ALGORITHM_RSAMD5 => 'RSAMD5',
|
|
self::DNSSEC_ALGORITHM_DH => 'DH',
|
|
self::DNSSEC_ALGORITHM_DSA => 'DSA',
|
|
self::DNSSEC_ALGORITHM_ECC => 'ECC',
|
|
self::DNSSEC_ALGORITHM_RSASHA1 => 'RSASHA1',
|
|
self::DNSSEC_ALGORITHM_DSANSEC3SHA1 => 'DSA-NSEC3-SHA1',
|
|
self::DSNSEC_ALGORITHM_RSASHA1NSEC3SHA1 => 'RSASHA1-NSEC3-SHA1',
|
|
self::DNSSEC_ALGORITHM_RSASHA256 => 'RSASHA256',
|
|
self::DNSSEC_ALGORITHM_RSASHA512 => 'RSASHA512',
|
|
self::DNSSEC_ALGORITHM_ECCGOST => 'ECC-GOST',
|
|
self::DNSSEC_ALGORITHM_INDIRECT => 'INDIRECT',
|
|
self::DNSSEC_ALGORITHM_PRIVATEDNS => 'PRIVATEDNS',
|
|
self::DNSSEC_ALGORITHM_PRIVATEOID => 'PRIVATEOID'
|
|
);
|
|
|
|
public static $digest_name_to_id = array();
|
|
public static $digest_id_to_name = array(
|
|
|
|
self::DNSSEC_DIGEST_RES => 'RES',
|
|
self::DNSSEC_DIGEST_SHA1 => 'SHA-1'
|
|
);
|
|
|
|
public static $protocol_by_id = array();
|
|
public static $protocol_by_name = array(
|
|
|
|
'ICMP' => 1,
|
|
'IGMP' => 2,
|
|
'GGP' => 3,
|
|
'ST' => 5,
|
|
'TCP' => 6,
|
|
'UCL' => 7,
|
|
'EGP' => 8,
|
|
'IGP' => 9,
|
|
'BBN-RCC-MON' => 10,
|
|
'NVP-II' => 11,
|
|
'PUP' => 12,
|
|
'ARGUS' => 13,
|
|
'EMCON' => 14,
|
|
'XNET' => 15,
|
|
'CHAOS' => 16,
|
|
'UDP' => 17,
|
|
'MUX' => 18,
|
|
'DCN-MEAS' => 19,
|
|
'HMP' => 20,
|
|
'PRM' => 21,
|
|
'XNS-IDP' => 22,
|
|
'TRUNK-1' => 23,
|
|
'TRUNK-2' => 24,
|
|
'LEAF-1' => 25,
|
|
'LEAF-2' => 26,
|
|
'RDP' => 27,
|
|
'IRTP' => 28,
|
|
'ISO-TP4' => 29,
|
|
'NETBLT' => 30,
|
|
'MFE-NSP' => 31,
|
|
'MERIT-INP' => 32,
|
|
'SEP' => 33,
|
|
|
|
'CFTP' => 62,
|
|
|
|
'SAT-EXPAK' => 64,
|
|
'MIT-SUBNET' => 65,
|
|
'RVD' => 66,
|
|
'IPPC' => 67,
|
|
|
|
'SAT-MON' => 69,
|
|
|
|
'IPCV' => 71,
|
|
|
|
'BR-SAT-MON' => 76,
|
|
|
|
'WB-MON' => 78,
|
|
'WB-EXPAK' => 79
|
|
|
|
);
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_Packet
|
|
{
|
|
|
|
public $rdata;
|
|
public $rdlength;
|
|
|
|
public $offset = 0;
|
|
|
|
public $header;
|
|
|
|
public $question = array();
|
|
|
|
public $answer = array();
|
|
|
|
public $authority = array();
|
|
|
|
public $additional = array();
|
|
|
|
private $_compressed = array();
|
|
|
|
public function __toString()
|
|
{
|
|
$output = $this->header->__toString();
|
|
|
|
foreach ($this->question as $x) {
|
|
|
|
$output .= $x->__toString() . "\n";
|
|
}
|
|
foreach ($this->answer as $x) {
|
|
|
|
$output .= $x->__toString() . "\n";
|
|
}
|
|
foreach ($this->authority as $x) {
|
|
|
|
$output .= $x->__toString() . "\n";
|
|
}
|
|
foreach ($this->additional as $x) {
|
|
|
|
$output .= $x->__toString() . "\n";
|
|
}
|
|
|
|
return $output;
|
|
}
|
|
|
|
public function get()
|
|
{
|
|
$data = $this->header->get($this);
|
|
|
|
foreach ($this->question as $x) {
|
|
|
|
$data .= $x->get($this);
|
|
}
|
|
foreach ($this->answer as $x) {
|
|
|
|
$data .= $x->get($this);
|
|
}
|
|
foreach ($this->authority as $x) {
|
|
|
|
$data .= $x->get($this);
|
|
}
|
|
foreach ($this->additional as $x) {
|
|
|
|
$data .= $x->get($this);
|
|
}
|
|
|
|
return $data;
|
|
}
|
|
|
|
public function compress($name, &$offset)
|
|
{
|
|
$names = explode('.', $name);
|
|
$compname = '';
|
|
|
|
while (!empty($names)) {
|
|
|
|
$dname = join('.', $names);
|
|
|
|
if (isset($this->_compressed[$dname])) {
|
|
|
|
$compname .= pack('n', 0xc000 | $this->_compressed[$dname]);
|
|
$offset += 2;
|
|
|
|
break;
|
|
}
|
|
|
|
$this->_compressed[$dname] = $offset;
|
|
$first = array_shift($names);
|
|
|
|
$length = strlen($first);
|
|
if ($length <= 0) {
|
|
continue;
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
if ($length > 63) {
|
|
|
|
$length = 63;
|
|
$first = substr($first, 0, $length);
|
|
}
|
|
|
|
$compname .= pack('Ca*', $length, $first);
|
|
$offset += $length + 1;
|
|
}
|
|
|
|
if (empty($names)) {
|
|
|
|
$compname .= pack('C', 0);
|
|
$offset++;
|
|
}
|
|
|
|
return $compname;
|
|
}
|
|
|
|
public static function pack($name)
|
|
{
|
|
$offset = 0;
|
|
$names = explode('.', $name);
|
|
$compname = '';
|
|
|
|
while (!empty($names)) {
|
|
|
|
$first = array_shift($names);
|
|
$length = strlen($first);
|
|
|
|
$compname .= pack('Ca*', $length, $first);
|
|
$offset += $length + 1;
|
|
}
|
|
|
|
$compname .= "\0";
|
|
$offset++;
|
|
|
|
return $compname;
|
|
}
|
|
|
|
public static function expand(Net_DNS2_Packet &$packet, &$offset)
|
|
{
|
|
$name = '';
|
|
|
|
while (1) {
|
|
if ($packet->rdlength < ($offset + 1)) {
|
|
return null;
|
|
}
|
|
|
|
$xlen = ord($packet->rdata[$offset]);
|
|
if ($xlen == 0) {
|
|
|
|
++$offset;
|
|
break;
|
|
|
|
} else if (($xlen & 0xc0) == 0xc0) {
|
|
if ($packet->rdlength < ($offset + 2)) {
|
|
|
|
return null;
|
|
}
|
|
|
|
$ptr = ord($packet->rdata[$offset]) << 8 |
|
|
ord($packet->rdata[$offset+1]);
|
|
$ptr = $ptr & 0x3fff;
|
|
|
|
$name2 = Net_DNS2_Packet::expand($packet, $ptr);
|
|
if (is_null($name2)) {
|
|
|
|
return null;
|
|
}
|
|
|
|
$name .= $name2;
|
|
$offset += 2;
|
|
|
|
break;
|
|
} else {
|
|
++$offset;
|
|
|
|
if ($packet->rdlength < ($offset + $xlen)) {
|
|
|
|
return null;
|
|
}
|
|
|
|
$elem = '';
|
|
$elem = substr($packet->rdata, $offset, $xlen);
|
|
$name .= $elem . '.';
|
|
$offset += $xlen;
|
|
}
|
|
}
|
|
|
|
return trim($name, '.');
|
|
}
|
|
|
|
public static function label(Net_DNS2_Packet &$packet, &$offset)
|
|
{
|
|
$name = '';
|
|
|
|
if ($packet->rdlength < ($offset + 1)) {
|
|
|
|
return null;
|
|
}
|
|
|
|
$xlen = ord($packet->rdata[$offset]);
|
|
++$offset;
|
|
|
|
if (($xlen + $offset) > $packet->rdlength) {
|
|
|
|
$name = substr($packet->rdata, $offset);
|
|
$offset = $packet->rdlength;
|
|
} else {
|
|
|
|
$name = substr($packet->rdata, $offset, $xlen);
|
|
$offset += $xlen;
|
|
}
|
|
|
|
return $name;
|
|
}
|
|
|
|
public function copy(Net_DNS2_Packet $packet)
|
|
{
|
|
$this->header = $packet->header;
|
|
$this->question = $packet->question;
|
|
$this->answer = $packet->answer;
|
|
$this->authority = $packet->authority;
|
|
$this->additional = $packet->additional;
|
|
|
|
return true;
|
|
}
|
|
|
|
public function reset()
|
|
{
|
|
$this->header->id = $this->header->nextPacketId();
|
|
$this->rdata = '';
|
|
$this->rdlength = 0;
|
|
$this->offset = 0;
|
|
$this->answer = array();
|
|
$this->authority = array();
|
|
$this->additional = array();
|
|
$this->_compressed = array();
|
|
|
|
return true;
|
|
}
|
|
|
|
public static function formatIPv6($address)
|
|
{
|
|
return Net_DNS2::expandIPv6($address);
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_PrivateKey
|
|
{
|
|
|
|
public $filename;
|
|
|
|
public $keytag;
|
|
|
|
public $signname;
|
|
|
|
public $algorithm;
|
|
|
|
public $key_format;
|
|
|
|
public $instance;
|
|
|
|
private $_modulus;
|
|
|
|
private $_public_exponent;
|
|
|
|
private $_private_exponent;
|
|
|
|
private $_prime1;
|
|
|
|
private $_prime2;
|
|
|
|
private $_exponent1;
|
|
|
|
private $_exponent2;
|
|
|
|
private $_coefficient;
|
|
|
|
public $prime;
|
|
|
|
public $subprime;
|
|
|
|
public $base;
|
|
|
|
public $private_value;
|
|
|
|
public $public_value;
|
|
|
|
public function __construct($file = null)
|
|
{
|
|
if (isset($file)) {
|
|
$this->parseFile($file);
|
|
}
|
|
}
|
|
|
|
public function parseFile($file)
|
|
{
|
|
//
|
|
|
|
//
|
|
if (extension_loaded('openssl') === false) {
|
|
|
|
throw new Net_DNS2_Exception(
|
|
'the OpenSSL extension is required to use parse private key.',
|
|
Net_DNS2_Lookups::E_OPENSSL_UNAVAIL
|
|
);
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
if (is_readable($file) == false) {
|
|
|
|
throw new Net_DNS2_Exception(
|
|
'invalid private key file: ' . $file,
|
|
Net_DNS2_Lookups::E_OPENSSL_INV_PKEY
|
|
);
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
$keyname = basename($file);
|
|
if (strlen($keyname) == 0) {
|
|
|
|
throw new Net_DNS2_Exception(
|
|
'failed to get basename() for: ' . $file,
|
|
Net_DNS2_Lookups::E_OPENSSL_INV_PKEY
|
|
);
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
if (preg_match("/K(.*)\.\+(\d{3})\+(\d*)\.private/", $keyname, $matches)) {
|
|
|
|
$this->signname = $matches[1];
|
|
$this->algorithm = intval($matches[2]);
|
|
$this->keytag = intval($matches[3]);
|
|
|
|
} else {
|
|
|
|
throw new Net_DNS2_Exception(
|
|
'file ' . $keyname . ' does not look like a private key file!',
|
|
Net_DNS2_Lookups::E_OPENSSL_INV_PKEY
|
|
);
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
$data = file($file, FILE_IGNORE_NEW_LINES|FILE_SKIP_EMPTY_LINES);
|
|
if (count($data) == 0) {
|
|
|
|
throw new Net_DNS2_Exception(
|
|
'file ' . $keyname . ' is empty!',
|
|
Net_DNS2_Lookups::E_OPENSSL_INV_PKEY
|
|
);
|
|
}
|
|
|
|
foreach ($data as $line) {
|
|
|
|
list($key, $value) = explode(':', $line);
|
|
|
|
$key = trim($key);
|
|
$value = trim($value);
|
|
|
|
switch(strtolower($key)) {
|
|
|
|
case 'private-key-format':
|
|
$this->_key_format = $value;
|
|
break;
|
|
|
|
case 'algorithm':
|
|
if ($this->algorithm != $value) {
|
|
throw new Net_DNS2_Exception(
|
|
'Algorithm mis-match! filename is ' . $this->algorithm .
|
|
', contents say ' . $value,
|
|
Net_DNS2_Lookups::E_OPENSSL_INV_ALGO
|
|
);
|
|
}
|
|
break;
|
|
|
|
//
|
|
|
|
//
|
|
case 'modulus':
|
|
$this->_modulus = $value;
|
|
break;
|
|
|
|
case 'publicexponent':
|
|
$this->_public_exponent = $value;
|
|
break;
|
|
|
|
case 'privateexponent':
|
|
$this->_private_exponent = $value;
|
|
break;
|
|
|
|
case 'prime1':
|
|
$this->_prime1 = $value;
|
|
break;
|
|
|
|
case 'prime2':
|
|
$this->_prime2 = $value;
|
|
break;
|
|
|
|
case 'exponent1':
|
|
$this->_exponent1 = $value;
|
|
break;
|
|
|
|
case 'exponent2':
|
|
$this->_exponent2 = $value;
|
|
break;
|
|
|
|
case 'coefficient':
|
|
$this->_coefficient = $value;
|
|
break;
|
|
|
|
//
|
|
|
|
//
|
|
case 'prime(p)':
|
|
$this->prime = $value;
|
|
break;
|
|
|
|
case 'subprime(q)':
|
|
$this->subprime = $value;
|
|
break;
|
|
|
|
case 'base(g)':
|
|
$this->base = $value;
|
|
break;
|
|
|
|
case 'private_value(x)':
|
|
$this->private_value = $value;
|
|
break;
|
|
|
|
case 'public_value(y)':
|
|
$this->public_value = $value;
|
|
break;
|
|
|
|
default:
|
|
throw new Net_DNS2_Exception(
|
|
'unknown private key data: ' . $key . ': ' . $value,
|
|
Net_DNS2_Lookups::E_OPENSSL_INV_PKEY
|
|
);
|
|
}
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
$args = array();
|
|
|
|
switch($this->algorithm) {
|
|
|
|
//
|
|
|
|
//
|
|
case Net_DNS2_Lookups::DNSSEC_ALGORITHM_RSAMD5:
|
|
case Net_DNS2_Lookups::DNSSEC_ALGORITHM_RSASHA1:
|
|
case Net_DNS2_Lookups::DNSSEC_ALGORITHM_RSASHA256:
|
|
case Net_DNS2_Lookups::DNSSEC_ALGORITHM_RSASHA512:
|
|
|
|
$args = array(
|
|
|
|
'rsa' => array(
|
|
|
|
'n' => base64_decode($this->_modulus),
|
|
'e' => base64_decode($this->_public_exponent),
|
|
'd' => base64_decode($this->_private_exponent),
|
|
'p' => base64_decode($this->_prime1),
|
|
'q' => base64_decode($this->_prime2),
|
|
'dmp1' => base64_decode($this->_exponent1),
|
|
'dmq1' => base64_decode($this->_exponent2),
|
|
'iqmp' => base64_decode($this->_coefficient)
|
|
)
|
|
);
|
|
|
|
break;
|
|
|
|
//
|
|
|
|
//
|
|
case Net_DNS2_Lookups::DNSSEC_ALGORITHM_DSA:
|
|
|
|
$args = array(
|
|
|
|
'dsa' => array(
|
|
|
|
'p' => base64_decode($this->prime),
|
|
'q' => base64_decode($this->subprime),
|
|
'g' => base64_decode($this->base),
|
|
'priv_key' => base64_decode($this->private_value),
|
|
'pub_key' => base64_decode($this->public_value)
|
|
)
|
|
);
|
|
|
|
break;
|
|
|
|
default:
|
|
throw new Net_DNS2_Exception(
|
|
'we only currently support RSAMD5 and RSASHA1 encryption.',
|
|
Net_DNS2_Lookups::E_OPENSSL_INV_PKEY
|
|
);
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
$this->instance = openssl_pkey_new($args);
|
|
if ($this->instance === false) {
|
|
throw new Net_DNS2_Exception(
|
|
openssl_error_string(),
|
|
Net_DNS2_Lookups::E_OPENSSL_ERROR
|
|
);
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
$this->filename = $file;
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_Question
|
|
{
|
|
|
|
public $qname;
|
|
|
|
public $qtype;
|
|
|
|
public $qclass;
|
|
|
|
public function __construct(Net_DNS2_Packet &$packet = null)
|
|
{
|
|
if (!is_null($packet)) {
|
|
|
|
$this->set($packet);
|
|
} else {
|
|
|
|
$this->qname = '';
|
|
$this->qtype = 'A';
|
|
$this->qclass = 'IN';
|
|
}
|
|
}
|
|
|
|
public function __toString()
|
|
{
|
|
return ";;\n;; Question:\n;;\t " . $this->qname . '. ' .
|
|
$this->qtype . ' ' . $this->qclass . "\n";
|
|
}
|
|
|
|
public function set(Net_DNS2_Packet &$packet)
|
|
{
|
|
//
|
|
|
|
//
|
|
$this->qname = $packet->expand($packet, $packet->offset);
|
|
if ($packet->rdlength < ($packet->offset + 4)) {
|
|
|
|
throw new Net_DNS2_Exception(
|
|
'invalid question section: to small',
|
|
Net_DNS2_Lookups::E_QUESTION_INVALID
|
|
);
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
$type = ord($packet->rdata[$packet->offset++]) << 8 |
|
|
ord($packet->rdata[$packet->offset++]);
|
|
$class = ord($packet->rdata[$packet->offset++]) << 8 |
|
|
ord($packet->rdata[$packet->offset++]);
|
|
|
|
//
|
|
|
|
//
|
|
$type_name = Net_DNS2_Lookups::$rr_types_by_id[$type];
|
|
$class_name = Net_DNS2_Lookups::$classes_by_id[$class];
|
|
|
|
if ( (!isset($type_name)) || (!isset($class_name)) ) {
|
|
|
|
throw new Net_DNS2_Exception(
|
|
'invalid question section: invalid type (' . $type .
|
|
') or class (' . $class . ') specified.',
|
|
Net_DNS2_Lookups::E_QUESTION_INVALID
|
|
);
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
$this->qtype = $type_name;
|
|
$this->qclass = $class_name;
|
|
|
|
return true;
|
|
}
|
|
|
|
public function get(Net_DNS2_Packet &$packet)
|
|
{
|
|
//
|
|
|
|
//
|
|
$type = Net_DNS2_Lookups::$rr_types_by_name[$this->qtype];
|
|
$class = Net_DNS2_Lookups::$classes_by_name[$this->qclass];
|
|
|
|
if ( (!isset($type)) || (!isset($class)) ) {
|
|
|
|
throw new Net_DNS2_Exception(
|
|
'invalid question section: invalid type (' . $this->qtype .
|
|
') or class (' . $this->qclass . ') specified.',
|
|
Net_DNS2_Lookups::E_QUESTION_INVALID
|
|
);
|
|
}
|
|
|
|
$data = $packet->compress($this->qname, $packet->offset);
|
|
|
|
$data .= chr($type << 8) . chr($type) . chr($class << 8) . chr($class);
|
|
$packet->offset += 4;
|
|
|
|
return $data;
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_Resolver extends Net_DNS2
|
|
{
|
|
|
|
public function __construct(array $options = null)
|
|
{
|
|
parent::__construct($options);
|
|
}
|
|
|
|
public function query($name, $type = 'A', $class = 'IN')
|
|
{
|
|
//
|
|
|
|
//
|
|
$this->checkServers(Net_DNS2::RESOLV_CONF);
|
|
|
|
//
|
|
|
|
//
|
|
if ($type == 'IXFR') {
|
|
|
|
$type = 'AXFR';
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
if ( (strpos($name, '.') === false) && ($type != 'PTR') ) {
|
|
|
|
$name .= '.' . strtolower($this->domain);
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
$packet = new Net_DNS2_Packet_Request($name, $type, $class);
|
|
|
|
//
|
|
|
|
//
|
|
if ( ($this->auth_signature instanceof Net_DNS2_RR_TSIG)
|
|
|| ($this->auth_signature instanceof Net_DNS2_RR_SIG)
|
|
) {
|
|
$packet->additional[] = $this->auth_signature;
|
|
$packet->header->arcount = count($packet->additional);
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
if ($this->dnssec == true) {
|
|
|
|
//
|
|
|
|
//
|
|
$opt = new Net_DNS2_RR_OPT();
|
|
|
|
//
|
|
|
|
//
|
|
$opt->do = 1;
|
|
$opt->class = $this->dnssec_payload_size;
|
|
|
|
//
|
|
|
|
//
|
|
$packet->additional[] = $opt;
|
|
$packet->header->arcount = count($packet->additional);
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
if ($this->dnssec_ad_flag == true) {
|
|
|
|
$packet->header->ad = 1;
|
|
}
|
|
if ($this->dnssec_cd_flag == true) {
|
|
|
|
$packet->header->cd = 1;
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
$packet_hash = '';
|
|
|
|
if ( ($this->use_cache == true) && ($this->cacheable($type) == true) ) {
|
|
|
|
//
|
|
|
|
//
|
|
$this->cache->open(
|
|
$this->cache_file, $this->cache_size, $this->cache_serializer
|
|
);
|
|
|
|
//
|
|
|
|
//
|
|
$packet_hash = md5(
|
|
$packet->question[0]->qname . '|' . $packet->question[0]->qtype
|
|
);
|
|
|
|
if ($this->cache->has($packet_hash)) {
|
|
|
|
return $this->cache->get($packet_hash);
|
|
}
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
if ($this->recurse == false) {
|
|
$packet->header->rd = 0;
|
|
} else {
|
|
$packet->header->rd = 1;
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
$response = $this->sendPacket(
|
|
$packet, ($type == 'AXFR') ? true : $this->use_tcp
|
|
);
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
if ( ($this->strict_query_mode == true)
|
|
&& ($response->header->ancount > 0)
|
|
) {
|
|
|
|
$found = false;
|
|
|
|
//
|
|
|
|
//
|
|
foreach ($response->answer as $index => $object) {
|
|
|
|
if ( (strcasecmp($object->name, $name) == 0)
|
|
&& ($object->type == $type)
|
|
&& ($object->class == $class)
|
|
) {
|
|
$found = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
if ($found == false) {
|
|
|
|
$response->answer = array();
|
|
$response->header->ancount = 0;
|
|
}
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
if ( ($this->use_cache == true) && ($this->cacheable($type) == true) ) {
|
|
|
|
$this->cache->put($packet_hash, $response);
|
|
}
|
|
|
|
return $response;
|
|
}
|
|
|
|
public function iquery(Net_DNS2_RR $rr)
|
|
{
|
|
//
|
|
|
|
//
|
|
$this->checkServers(Net_DNS2::RESOLV_CONF);
|
|
|
|
//
|
|
|
|
//
|
|
$packet = new Net_DNS2_Packet_Request($rr->name, 'A', 'IN');
|
|
|
|
//
|
|
|
|
//
|
|
$packet->question = array();
|
|
$packet->header->qdcount = 0;
|
|
|
|
//
|
|
|
|
//
|
|
$packet->header->opcode = Net_DNS2_Lookups::OPCODE_IQUERY;
|
|
|
|
//
|
|
|
|
//
|
|
$packet->answer[] = $rr;
|
|
$packet->header->ancount = 1;
|
|
|
|
//
|
|
|
|
//
|
|
if ( ($this->auth_signature instanceof Net_DNS2_RR_TSIG)
|
|
|| ($this->auth_signature instanceof Net_DNS2_RR_SIG)
|
|
) {
|
|
$packet->additional[] = $this->auth_signature;
|
|
$packet->header->arcount = count($packet->additional);
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
return $this->sendPacket($packet, $this->use_tcp);
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
abstract class Net_DNS2_RR
|
|
{
|
|
|
|
public $name;
|
|
|
|
public $type;
|
|
|
|
public $class;
|
|
|
|
public $ttl;
|
|
|
|
public $rdlength;
|
|
|
|
public $rdata;
|
|
|
|
abstract protected function rrToString();
|
|
|
|
abstract protected function rrFromString(array $rdata);
|
|
|
|
abstract protected function rrSet(Net_DNS2_Packet &$packet);
|
|
|
|
abstract protected function rrGet(Net_DNS2_Packet &$packet);
|
|
|
|
public function __construct(Net_DNS2_Packet &$packet = null, array $rr = null)
|
|
{
|
|
if ( (!is_null($packet)) && (!is_null($rr)) ) {
|
|
|
|
if ($this->set($packet, $rr) == false) {
|
|
|
|
throw new Net_DNS2_Exception(
|
|
'failed to generate resource record',
|
|
Net_DNS2_Lookups::E_RR_INVALID
|
|
);
|
|
}
|
|
} else {
|
|
|
|
$class = Net_DNS2_Lookups::$rr_types_class_to_id[get_class($this)];
|
|
if (isset($class)) {
|
|
|
|
$this->type = Net_DNS2_Lookups::$rr_types_by_id[$class];
|
|
}
|
|
|
|
$this->class = 'IN';
|
|
$this->ttl = 86400;
|
|
}
|
|
}
|
|
|
|
public function __toString()
|
|
{
|
|
return $this->name . '. ' . $this->ttl . ' ' . $this->class .
|
|
' ' . $this->type . ' ' . $this->rrToString();
|
|
}
|
|
|
|
protected function formatString($string)
|
|
{
|
|
return '"' . str_replace('"', '\"', trim($string, '"')) . '"';
|
|
}
|
|
|
|
protected function buildString(array $chunks)
|
|
{
|
|
$data = array();
|
|
$c = 0;
|
|
$in = false;
|
|
|
|
foreach ($chunks as $r) {
|
|
|
|
$r = trim($r);
|
|
if (strlen($r) == 0) {
|
|
continue;
|
|
}
|
|
|
|
if ( ($r[0] == '"')
|
|
&& ($r[strlen($r) - 1] == '"')
|
|
&& ($r[strlen($r) - 2] != '\\')
|
|
) {
|
|
|
|
$data[$c] = $r;
|
|
++$c;
|
|
$in = false;
|
|
|
|
} else if ($r[0] == '"') {
|
|
|
|
$data[$c] = $r;
|
|
$in = true;
|
|
|
|
} else if ( ($r[strlen($r) - 1] == '"')
|
|
&& ($r[strlen($r) - 2] != '\\')
|
|
) {
|
|
|
|
$data[$c] .= ' ' . $r;
|
|
++$c;
|
|
$in = false;
|
|
|
|
} else {
|
|
|
|
if ($in == true) {
|
|
$data[$c] .= ' ' . $r;
|
|
} else {
|
|
$data[$c++] = $r;
|
|
}
|
|
}
|
|
}
|
|
|
|
foreach ($data as $index => $string) {
|
|
|
|
$data[$index] = str_replace('\"', '"', trim($string, '"'));
|
|
}
|
|
|
|
return $data;
|
|
}
|
|
|
|
public function set(Net_DNS2_Packet &$packet, array $rr)
|
|
{
|
|
$this->name = $rr['name'];
|
|
$this->type = Net_DNS2_Lookups::$rr_types_by_id[$rr['type']];
|
|
|
|
//
|
|
|
|
//
|
|
if ($this->type == 'OPT') {
|
|
$this->class = $rr['class'];
|
|
} else {
|
|
$this->class = Net_DNS2_Lookups::$classes_by_id[$rr['class']];
|
|
}
|
|
|
|
$this->ttl = $rr['ttl'];
|
|
$this->rdlength = $rr['rdlength'];
|
|
$this->rdata = substr($packet->rdata, $packet->offset, $rr['rdlength']);
|
|
|
|
return $this->rrSet($packet);
|
|
}
|
|
|
|
public function get(Net_DNS2_Packet &$packet)
|
|
{
|
|
$data = '';
|
|
$rdata = '';
|
|
|
|
//
|
|
|
|
//
|
|
$data = $packet->compress($this->name, $packet->offset);
|
|
|
|
//
|
|
|
|
//
|
|
if ($this->type == 'OPT') {
|
|
|
|
//
|
|
|
|
//
|
|
$this->preBuild();
|
|
|
|
//
|
|
|
|
//
|
|
$data .= pack(
|
|
'nnN',
|
|
Net_DNS2_Lookups::$rr_types_by_name[$this->type],
|
|
$this->class,
|
|
$this->ttl
|
|
);
|
|
} else {
|
|
|
|
$data .= pack(
|
|
'nnN',
|
|
Net_DNS2_Lookups::$rr_types_by_name[$this->type],
|
|
Net_DNS2_Lookups::$classes_by_name[$this->class],
|
|
$this->ttl
|
|
);
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
$packet->offset += 10;
|
|
|
|
//
|
|
|
|
//
|
|
if ($this->rdlength != -1) {
|
|
|
|
$rdata = $this->rrGet($packet);
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
$data .= pack('n', strlen($rdata)) . $rdata;
|
|
|
|
return $data;
|
|
}
|
|
|
|
public static function parse(Net_DNS2_Packet &$packet)
|
|
{
|
|
$object = array();
|
|
|
|
//
|
|
|
|
//
|
|
$object['name'] = $packet->expand($packet, $packet->offset);
|
|
if (is_null($object['name'])) {
|
|
|
|
throw new Net_DNS2_Exception(
|
|
'failed to parse resource record: failed to expand name.',
|
|
Net_DNS2_Lookups::E_PARSE_ERROR
|
|
);
|
|
}
|
|
if ($packet->rdlength < ($packet->offset + 10)) {
|
|
|
|
throw new Net_DNS2_Exception(
|
|
'failed to parse resource record: packet too small.',
|
|
Net_DNS2_Lookups::E_PARSE_ERROR
|
|
);
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
$object['type'] = ord($packet->rdata[$packet->offset++]) << 8 |
|
|
ord($packet->rdata[$packet->offset++]);
|
|
$object['class'] = ord($packet->rdata[$packet->offset++]) << 8 |
|
|
ord($packet->rdata[$packet->offset++]);
|
|
|
|
$object['ttl'] = ord($packet->rdata[$packet->offset++]) << 24 |
|
|
ord($packet->rdata[$packet->offset++]) << 16 |
|
|
ord($packet->rdata[$packet->offset++]) << 8 |
|
|
ord($packet->rdata[$packet->offset++]);
|
|
|
|
$object['rdlength'] = ord($packet->rdata[$packet->offset++]) << 8 |
|
|
ord($packet->rdata[$packet->offset++]);
|
|
|
|
if ($packet->rdlength < ($packet->offset + $object['rdlength'])) {
|
|
return null;
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
$o = null;
|
|
$class = Net_DNS2_Lookups::$rr_types_id_to_class[$object['type']];
|
|
|
|
if (isset($class)) {
|
|
|
|
$o = new $class($packet, $object);
|
|
if ($o) {
|
|
|
|
$packet->offset += $object['rdlength'];
|
|
}
|
|
} else {
|
|
|
|
throw new Net_DNS2_Exception(
|
|
'un-implemented resource record type: ' . $object['type'],
|
|
Net_DNS2_Lookups::E_RR_INVALID
|
|
);
|
|
}
|
|
|
|
return $o;
|
|
}
|
|
|
|
public function cleanString($data)
|
|
{
|
|
return strtolower(rtrim($data, '.'));
|
|
}
|
|
|
|
public static function fromString($line)
|
|
{
|
|
if (strlen($line) == 0) {
|
|
throw new Net_DNS2_Exception(
|
|
'empty config line provided.',
|
|
Net_DNS2_Lookups::E_PARSE_ERROR
|
|
);
|
|
}
|
|
|
|
$name = '';
|
|
$type = '';
|
|
$class = 'IN';
|
|
$ttl = 86400;
|
|
|
|
//
|
|
|
|
//
|
|
$values = preg_split('/[\s]+/', $line);
|
|
if (count($values) < 3) {
|
|
|
|
throw new Net_DNS2_Exception(
|
|
'failed to parse config: minimum of name, type and rdata required.',
|
|
Net_DNS2_Lookups::E_PARSE_ERROR
|
|
);
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
$name = trim(strtolower(array_shift($values)), '.');
|
|
|
|
//
|
|
|
|
//
|
|
foreach ($values as $value) {
|
|
|
|
switch($value) {
|
|
case is_numeric($value):
|
|
|
|
$ttl = array_shift($values);
|
|
break;
|
|
|
|
//
|
|
|
|
//
|
|
case ($value === 0):
|
|
$ttl = array_shift($values);
|
|
break;
|
|
|
|
case isset(Net_DNS2_Lookups::$classes_by_name[strtoupper($value)]):
|
|
|
|
$class = strtoupper(array_shift($values));
|
|
break;
|
|
|
|
case isset(Net_DNS2_Lookups::$rr_types_by_name[strtoupper($value)]):
|
|
|
|
$type = strtoupper(array_shift($values));
|
|
break 2;
|
|
break;
|
|
default:
|
|
|
|
throw new Net_DNS2_Exception(
|
|
'invalid config line provided: unknown file: ' . $value,
|
|
Net_DNS2_Lookups::E_PARSE_ERROR
|
|
);
|
|
}
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
$o = null;
|
|
$class_name = Net_DNS2_Lookups::$rr_types_id_to_class[
|
|
Net_DNS2_Lookups::$rr_types_by_name[$type]
|
|
];
|
|
|
|
if (isset($class_name)) {
|
|
|
|
$o = new $class_name;
|
|
if (!is_null($o)) {
|
|
|
|
//
|
|
|
|
//
|
|
$o->name = $name;
|
|
$o->class = $class;
|
|
$o->ttl = $ttl;
|
|
|
|
//
|
|
|
|
//
|
|
if ($o->rrFromString($values) === false) {
|
|
|
|
throw new Net_DNS2_Exception(
|
|
'failed to parse rdata for config: ' . $line,
|
|
Net_DNS2_Lookups::E_PARSE_ERROR
|
|
);
|
|
}
|
|
|
|
} else {
|
|
|
|
throw new Net_DNS2_Exception(
|
|
'failed to create new RR record for type: ' . $type,
|
|
Net_DNS2_Lookups::E_RR_INVALID
|
|
);
|
|
}
|
|
|
|
} else {
|
|
|
|
throw new Net_DNS2_Exception(
|
|
'un-implemented resource record type: '. $type,
|
|
Net_DNS2_Lookups::E_RR_INVALID
|
|
);
|
|
}
|
|
|
|
return $o;
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
if (defined('SOCK_STREAM') == false) {
|
|
define('SOCK_STREAM', 1);
|
|
}
|
|
if (defined('SOCK_DGRAM') == false) {
|
|
define('SOCK_DGRAM', 2);
|
|
}
|
|
|
|
abstract class Net_DNS2_Socket
|
|
{
|
|
protected $sock;
|
|
protected $type;
|
|
protected $host;
|
|
protected $port;
|
|
protected $timeout;
|
|
|
|
protected $local_host;
|
|
protected $local_port;
|
|
|
|
public $last_error;
|
|
|
|
const SOCK_STREAM = SOCK_STREAM;
|
|
const SOCK_DGRAM = SOCK_DGRAM;
|
|
|
|
public function __construct($type, $host, $port, $timeout)
|
|
{
|
|
$this->type = $type;
|
|
$this->host = $host;
|
|
$this->port = $port;
|
|
$this->timeout = $timeout;
|
|
}
|
|
|
|
public function __destruct()
|
|
{
|
|
$this->close();
|
|
}
|
|
|
|
public function bindAddress($address, $port = 0)
|
|
{
|
|
$this->local_host = $address;
|
|
$this->local_port = $port;
|
|
|
|
return true;
|
|
}
|
|
|
|
abstract public function open();
|
|
|
|
abstract public function close();
|
|
|
|
abstract public function write($data);
|
|
|
|
abstract public function read(&$size, $max_size);
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_Updater extends Net_DNS2
|
|
{
|
|
|
|
private $_packet;
|
|
|
|
public function __construct($zone, array $options = null)
|
|
{
|
|
parent::__construct($options);
|
|
|
|
//
|
|
|
|
//
|
|
$this->_packet = new Net_DNS2_Packet_Request(
|
|
strtolower(trim($zone, " \n\r\t.")), 'SOA', 'IN'
|
|
);
|
|
|
|
//
|
|
|
|
//
|
|
$this->_packet->header->opcode = Net_DNS2_Lookups::OPCODE_UPDATE;
|
|
}
|
|
|
|
private function _checkName($name)
|
|
{
|
|
if (!preg_match('/' . $this->_packet->question[0]->qname . '$/', $name)) {
|
|
|
|
throw new Net_DNS2_Exception(
|
|
'name provided (' . $name . ') does not match zone name (' .
|
|
$this->_packet->question[0]->qname . ')',
|
|
Net_DNS2_Lookups::E_PACKET_INVALID
|
|
);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public function signature($keyname, $signature)
|
|
{
|
|
return $this->signTSIG($keyname, $signature);
|
|
}
|
|
|
|
public function add(Net_DNS2_RR $rr)
|
|
{
|
|
$this->_checkName($rr->name);
|
|
|
|
//
|
|
|
|
//
|
|
if (!in_array($rr, $this->_packet->authority)) {
|
|
$this->_packet->authority[] = $rr;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public function delete(Net_DNS2_RR $rr)
|
|
{
|
|
$this->_checkName($rr->name);
|
|
|
|
$rr->ttl = 0;
|
|
$rr->class = 'NONE';
|
|
|
|
//
|
|
|
|
//
|
|
if (!in_array($rr, $this->_packet->authority)) {
|
|
$this->_packet->authority[] = $rr;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public function deleteAny($name, $type)
|
|
{
|
|
$this->_checkName($name);
|
|
|
|
$class = Net_DNS2_Lookups::$rr_types_id_to_class[
|
|
Net_DNS2_Lookups::$rr_types_by_name[$type]
|
|
];
|
|
if (!isset($class)) {
|
|
|
|
throw new Net_DNS2_Exception(
|
|
'unknown or un-supported resource record type: ' . $type,
|
|
Net_DNS2_Lookups::E_RR_INVALID
|
|
);
|
|
}
|
|
|
|
$rr = new $class;
|
|
|
|
$rr->name = $name;
|
|
$rr->ttl = 0;
|
|
$rr->class = 'ANY';
|
|
$rr->rdlength = -1;
|
|
$rr->rdata = '';
|
|
|
|
//
|
|
|
|
//
|
|
if (!in_array($rr, $this->_packet->authority)) {
|
|
$this->_packet->authority[] = $rr;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public function deleteAll($name)
|
|
{
|
|
$this->_checkName($name);
|
|
|
|
//
|
|
|
|
//
|
|
$rr = new Net_DNS2_RR_ANY;
|
|
|
|
$rr->name = $name;
|
|
$rr->ttl = 0;
|
|
$rr->type = 'ANY';
|
|
$rr->class = 'ANY';
|
|
$rr->rdlength = -1;
|
|
$rr->rdata = '';
|
|
|
|
//
|
|
|
|
//
|
|
if (!in_array($rr, $this->_packet->authority)) {
|
|
$this->_packet->authority[] = $rr;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public function checkExists($name, $type)
|
|
{
|
|
$this->_checkName($name);
|
|
|
|
$class = Net_DNS2_Lookups::$rr_types_id_to_class[
|
|
Net_DNS2_Lookups::$rr_types_by_name[$type]
|
|
];
|
|
if (!isset($class)) {
|
|
|
|
throw new Net_DNS2_Exception(
|
|
'unknown or un-supported resource record type: ' . $type,
|
|
Net_DNS2_Lookups::E_RR_INVALID
|
|
);
|
|
}
|
|
|
|
$rr = new $class;
|
|
|
|
$rr->name = $name;
|
|
$rr->ttl = 0;
|
|
$rr->class = 'ANY';
|
|
$rr->rdlength = -1;
|
|
$rr->rdata = '';
|
|
|
|
//
|
|
|
|
//
|
|
if (!in_array($rr, $this->_packet->answer)) {
|
|
$this->_packet->answer[] = $rr;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public function checkValueExists(Net_DNS2_RR $rr)
|
|
{
|
|
$this->_checkName($rr->name);
|
|
|
|
$rr->ttl = 0;
|
|
|
|
//
|
|
|
|
//
|
|
if (!in_array($rr, $this->_packet->answer)) {
|
|
$this->_packet->answer[] = $rr;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public function checkNotExists($name, $type)
|
|
{
|
|
$this->_checkName($name);
|
|
|
|
$class = Net_DNS2_Lookups::$rr_types_id_to_class[
|
|
Net_DNS2_Lookups::$rr_types_by_name[$type]
|
|
];
|
|
if (!isset($class)) {
|
|
|
|
throw new Net_DNS2_Exception(
|
|
'unknown or un-supported resource record type: ' . $type,
|
|
Net_DNS2_Lookups::E_RR_INVALID
|
|
);
|
|
}
|
|
|
|
$rr = new $class;
|
|
|
|
$rr->name = $name;
|
|
$rr->ttl = 0;
|
|
$rr->class = 'NONE';
|
|
$rr->rdlength = -1;
|
|
$rr->rdata = '';
|
|
|
|
//
|
|
|
|
//
|
|
if (!in_array($rr, $this->_packet->answer)) {
|
|
$this->_packet->answer[] = $rr;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public function checkNameInUse($name)
|
|
{
|
|
$this->_checkName($name);
|
|
|
|
//
|
|
|
|
//
|
|
$rr = new Net_DNS2_RR_ANY;
|
|
|
|
$rr->name = $name;
|
|
$rr->ttl = 0;
|
|
$rr->type = 'ANY';
|
|
$rr->class = 'ANY';
|
|
$rr->rdlength = -1;
|
|
$rr->rdata = '';
|
|
|
|
//
|
|
|
|
//
|
|
if (!in_array($rr, $this->_packet->answer)) {
|
|
$this->_packet->answer[] = $rr;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public function checkNameNotInUse($name)
|
|
{
|
|
$this->_checkName($name);
|
|
|
|
//
|
|
|
|
//
|
|
$rr = new Net_DNS2_RR_ANY;
|
|
|
|
$rr->name = $name;
|
|
$rr->ttl = 0;
|
|
$rr->type = 'ANY';
|
|
$rr->class = 'NONE';
|
|
$rr->rdlength = -1;
|
|
$rr->rdata = '';
|
|
|
|
//
|
|
|
|
//
|
|
if (!in_array($rr, $this->_packet->answer)) {
|
|
$this->_packet->answer[] = $rr;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public function packet()
|
|
{
|
|
//
|
|
|
|
//
|
|
$p = $this->_packet;
|
|
|
|
//
|
|
|
|
//
|
|
if ( ($this->auth_signature instanceof Net_DNS2_RR_TSIG)
|
|
|| ($this->auth_signature instanceof Net_DNS2_RR_SIG)
|
|
) {
|
|
$p->additional[] = $this->auth_signature;
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
$p->header->qdcount = count($p->question);
|
|
$p->header->ancount = count($p->answer);
|
|
$p->header->nscount = count($p->authority);
|
|
$p->header->arcount = count($p->additional);
|
|
|
|
return $p;
|
|
}
|
|
|
|
public function update(&$response = null)
|
|
{
|
|
//
|
|
|
|
//
|
|
$this->checkServers(Net_DNS2::RESOLV_CONF);
|
|
|
|
//
|
|
|
|
//
|
|
if ( ($this->auth_signature instanceof Net_DNS2_RR_TSIG)
|
|
|| ($this->auth_signature instanceof Net_DNS2_RR_SIG)
|
|
) {
|
|
$this->_packet->additional[] = $this->auth_signature;
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
$this->_packet->header->qdcount = count($this->_packet->question);
|
|
$this->_packet->header->ancount = count($this->_packet->answer);
|
|
$this->_packet->header->nscount = count($this->_packet->authority);
|
|
$this->_packet->header->arcount = count($this->_packet->additional);
|
|
|
|
//
|
|
|
|
//
|
|
if ( ($this->_packet->header->qdcount == 0)
|
|
|| ($this->_packet->header->nscount == 0)
|
|
) {
|
|
throw new Net_DNS2_Exception(
|
|
'empty headers- nothing to send!',
|
|
Net_DNS2_Lookups::E_PACKET_INVALID
|
|
);
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
$response = $this->sendPacket($this->_packet, $this->use_tcp);
|
|
|
|
//
|
|
|
|
//
|
|
$this->_packet->reset();
|
|
|
|
//
|
|
|
|
//
|
|
return true;
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_Cache_File extends Net_DNS2_Cache
|
|
{
|
|
|
|
public function open($cache_file, $size, $serializer)
|
|
{
|
|
$this->cache_size = $size;
|
|
$this->cache_file = $cache_file;
|
|
$this->cache_serializer = $serializer;
|
|
|
|
//
|
|
|
|
//
|
|
if ( (file_exists($this->cache_file) == true)
|
|
&& (filesize($this->cache_file) > 0)
|
|
) {
|
|
|
|
//
|
|
|
|
//
|
|
$fp = @fopen($this->cache_file, 'r');
|
|
if ($fp !== false) {
|
|
|
|
//
|
|
|
|
//
|
|
flock($fp, LOCK_EX);
|
|
|
|
//
|
|
|
|
//
|
|
$data = fread($fp, filesize($this->cache_file));
|
|
|
|
$decoded = null;
|
|
|
|
if ($this->cache_serializer == 'json') {
|
|
|
|
$decoded = json_decode($data, true);
|
|
} else {
|
|
|
|
$decoded = unserialize($data);
|
|
}
|
|
|
|
if (is_array($decoded) == true) {
|
|
|
|
$this->cache_data = $decoded;
|
|
} else {
|
|
|
|
$this->cache_data = array();
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
flock($fp, LOCK_UN);
|
|
|
|
//
|
|
|
|
//
|
|
fclose($fp);
|
|
|
|
//
|
|
|
|
//
|
|
$this->clean();
|
|
}
|
|
}
|
|
}
|
|
|
|
public function __destruct()
|
|
{
|
|
//
|
|
|
|
//
|
|
if (strlen($this->cache_file) == 0) {
|
|
return;
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
$fp = fopen($this->cache_file, 'a+');
|
|
if ($fp !== false) {
|
|
|
|
//
|
|
|
|
//
|
|
flock($fp, LOCK_EX);
|
|
|
|
//
|
|
|
|
//
|
|
fseek($fp, 0, SEEK_SET);
|
|
|
|
//
|
|
|
|
//
|
|
$data = @fread($fp, filesize($this->cache_file));
|
|
if ( ($data !== false) && (strlen($data) > 0) ) {
|
|
|
|
//
|
|
|
|
//
|
|
$c = $this->cache_data;
|
|
|
|
$decoded = null;
|
|
|
|
if ($this->cache_serializer == 'json') {
|
|
|
|
$decoded = json_decode($data, true);
|
|
} else {
|
|
|
|
$decoded = unserialize($data);
|
|
}
|
|
|
|
if (is_array($decoded) == true) {
|
|
|
|
$this->cache_data = array_merge($c, $decoded);
|
|
}
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
ftruncate($fp, 0);
|
|
|
|
//
|
|
|
|
//
|
|
$this->clean();
|
|
|
|
//
|
|
|
|
//
|
|
$data = $this->resize();
|
|
if (!is_null($data)) {
|
|
|
|
//
|
|
|
|
//
|
|
fwrite($fp, $data);
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
flock($fp, LOCK_UN);
|
|
|
|
//
|
|
|
|
//
|
|
fclose($fp);
|
|
}
|
|
}
|
|
};
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_Cache_Shm extends Net_DNS2_Cache
|
|
{
|
|
|
|
private $_cache_id = false;
|
|
|
|
private $_cache_file_tok = -1;
|
|
|
|
public function open($cache_file, $size, $serializer)
|
|
{
|
|
$this->cache_size = $size;
|
|
$this->cache_file = $cache_file;
|
|
$this->cache_serializer = $serializer;
|
|
|
|
//
|
|
|
|
//
|
|
if (!file_exists($cache_file)) {
|
|
|
|
if (file_put_contents($cache_file, '') === false) {
|
|
|
|
throw new Net_DNS2_Exception(
|
|
'failed to create empty SHM file: ' . $cache_file,
|
|
Net_DNS2_Lookups::E_CACHE_SHM_FILE
|
|
);
|
|
}
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
$this->_cache_file_tok = ftok($cache_file, 't');
|
|
if ($this->_cache_file_tok == -1) {
|
|
|
|
throw new Net_DNS2_Exception(
|
|
'failed on ftok() file: ' . $this->_cache_file_tok,
|
|
Net_DNS2_Lookups::E_CACHE_SHM_FILE
|
|
);
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
$this->_cache_id = @shmop_open($this->_cache_file_tok, 'w', 0, 0);
|
|
if ($this->_cache_id !== false) {
|
|
|
|
//
|
|
|
|
//
|
|
$allocated = shmop_size($this->_cache_id);
|
|
if ($allocated > 0) {
|
|
|
|
//
|
|
|
|
//
|
|
$data = trim(shmop_read($this->_cache_id, 0, $allocated));
|
|
if ( ($data !== false) && (strlen($data) > 0) ) {
|
|
|
|
//
|
|
|
|
//
|
|
$decoded = null;
|
|
|
|
if ($this->cache_serializer == 'json') {
|
|
|
|
$decoded = json_decode($data, true);
|
|
} else {
|
|
|
|
$decoded = unserialize($data);
|
|
}
|
|
|
|
if (is_array($decoded) == true) {
|
|
|
|
$this->cache_data = $decoded;
|
|
} else {
|
|
|
|
$this->cache_data = array();
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
$this->clean();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public function __destruct()
|
|
{
|
|
//
|
|
|
|
//
|
|
if (strlen($this->cache_file) == 0) {
|
|
return;
|
|
}
|
|
|
|
$fp = fopen($this->cache_file, 'r');
|
|
if ($fp !== false) {
|
|
|
|
//
|
|
|
|
//
|
|
flock($fp, LOCK_EX);
|
|
|
|
//
|
|
|
|
//
|
|
if ($this->_cache_id === false) {
|
|
|
|
//
|
|
|
|
//
|
|
$this->_cache_id = @shmop_open(
|
|
$this->_cache_file_tok, 'w', 0, 0
|
|
);
|
|
if ($this->_cache_id === false) {
|
|
|
|
//
|
|
|
|
//
|
|
$this->_cache_id = @shmop_open(
|
|
$this->_cache_file_tok, 'c', 0, $this->cache_size
|
|
);
|
|
}
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
$allocated = shmop_size($this->_cache_id);
|
|
|
|
//
|
|
|
|
//
|
|
$data = trim(shmop_read($this->_cache_id, 0, $allocated));
|
|
|
|
//
|
|
|
|
//
|
|
if ( ($data !== false) && (strlen($data) > 0) ) {
|
|
|
|
//
|
|
|
|
//
|
|
$c = $this->cache_data;
|
|
|
|
$decoded = null;
|
|
|
|
if ($this->cache_serializer == 'json') {
|
|
|
|
$decoded = json_decode($data, true);
|
|
} else {
|
|
|
|
$decoded = unserialize($data);
|
|
}
|
|
|
|
if (is_array($decoded) == true) {
|
|
|
|
$this->cache_data = array_merge($c, $decoded);
|
|
}
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
shmop_delete($this->_cache_id);
|
|
|
|
//
|
|
|
|
//
|
|
$this->clean();
|
|
|
|
//
|
|
|
|
//
|
|
$data = $this->resize();
|
|
if (!is_null($data)) {
|
|
|
|
//
|
|
|
|
//
|
|
$this->_cache_id = @shmop_open(
|
|
$this->_cache_file_tok, 'c', 0644, $this->cache_size
|
|
);
|
|
if ($this->_cache_id === false) {
|
|
return;
|
|
}
|
|
|
|
$o = shmop_write($this->_cache_id, $data, 0);
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
shmop_close($this->_cache_id);
|
|
|
|
//
|
|
|
|
//
|
|
flock($fp, LOCK_UN);
|
|
|
|
//
|
|
|
|
//
|
|
fclose($fp);
|
|
}
|
|
}
|
|
};
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_Packet_Request extends Net_DNS2_Packet
|
|
{
|
|
|
|
public function __construct($name, $type = null, $class = null)
|
|
{
|
|
$this->set($name, $type, $class);
|
|
}
|
|
|
|
public function set($name, $type = 'A', $class = 'IN')
|
|
{
|
|
//
|
|
|
|
//
|
|
$this->header = new Net_DNS2_Header;
|
|
|
|
//
|
|
|
|
//
|
|
$q = new Net_DNS2_Question();
|
|
|
|
//
|
|
|
|
//
|
|
if ($name != '.') {
|
|
$name = trim(strtolower($name), " \t\n\r\0\x0B.");
|
|
}
|
|
|
|
$type = strtoupper(trim($type));
|
|
$class = strtoupper(trim($class));
|
|
|
|
//
|
|
|
|
//
|
|
if (empty($name)) {
|
|
|
|
throw new Net_DNS2_Exception(
|
|
'empty query string provided',
|
|
Net_DNS2_Lookups::E_PACKET_INVALID
|
|
);
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
if ($type == '*') {
|
|
|
|
$type = 'ANY';
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
if ( (!isset(Net_DNS2_Lookups::$rr_types_by_name[$type]))
|
|
|| (!isset(Net_DNS2_Lookups::$classes_by_name[$class]))
|
|
) {
|
|
throw new Net_DNS2_Exception(
|
|
'invalid type (' . $type . ') or class (' . $class . ') specified.',
|
|
Net_DNS2_Lookups::E_PACKET_INVALID
|
|
);
|
|
}
|
|
|
|
if ($type == 'PTR') {
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
if (Net_DNS2::isIPv4($name) == true) {
|
|
|
|
//
|
|
|
|
//
|
|
$name = implode('.', array_reverse(explode('.', $name)));
|
|
$name .= '.in-addr.arpa';
|
|
|
|
} else if (Net_DNS2::isIPv6($name) == true) {
|
|
|
|
//
|
|
|
|
//
|
|
$e = Net_DNS2::expandIPv6($name);
|
|
if ($e !== false) {
|
|
|
|
$name = implode(
|
|
'.', array_reverse(str_split(str_replace(':', '', $e)))
|
|
);
|
|
|
|
$name .= '.ip6.arpa';
|
|
|
|
} else {
|
|
|
|
throw new Net_DNS2_Exception(
|
|
'unsupported PTR value: ' . $name,
|
|
Net_DNS2_Lookups::E_PACKET_INVALID
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
$q->qname = $name;
|
|
$q->qtype = $type;
|
|
$q->qclass = $class;
|
|
|
|
$this->question[] = $q;
|
|
|
|
//
|
|
|
|
//
|
|
$this->answer = array();
|
|
$this->authority = array();
|
|
$this->additional = array();
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_Packet_Response extends Net_DNS2_Packet
|
|
{
|
|
|
|
public $answer_from;
|
|
|
|
public $answer_socket_type;
|
|
|
|
public $response_time = 0;
|
|
|
|
public function __construct($data, $size)
|
|
{
|
|
$this->set($data, $size);
|
|
}
|
|
|
|
public function set($data, $size)
|
|
{
|
|
//
|
|
|
|
//
|
|
$this->rdata = $data;
|
|
$this->rdlength = $size;
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
$this->header = new Net_DNS2_Header($this);
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
if ($this->header->tc == 1) {
|
|
|
|
return false;
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
for ($x = 0; $x < $this->header->qdcount; ++$x) {
|
|
|
|
$this->question[$x] = new Net_DNS2_Question($this);
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
for ($x = 0; $x < $this->header->ancount; ++$x) {
|
|
|
|
$o = Net_DNS2_RR::parse($this);
|
|
if (!is_null($o)) {
|
|
|
|
$this->answer[] = $o;
|
|
}
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
for ($x = 0; $x < $this->header->nscount; ++$x) {
|
|
|
|
$o = Net_DNS2_RR::parse($this);
|
|
if (!is_null($o)) {
|
|
|
|
$this->authority[] = $o;
|
|
}
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
for ($x = 0; $x < $this->header->arcount; ++$x) {
|
|
|
|
$o = Net_DNS2_RR::parse($this);
|
|
if (!is_null($o)) {
|
|
|
|
$this->additional[] = $o;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_RR_A extends Net_DNS2_RR
|
|
{
|
|
|
|
public $address;
|
|
|
|
protected function rrToString()
|
|
{
|
|
return $this->address;
|
|
}
|
|
|
|
protected function rrFromString(array $rdata)
|
|
{
|
|
$value = array_shift($rdata);
|
|
|
|
if (Net_DNS2::isIPv4($value) == true) {
|
|
|
|
$this->address = $value;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected function rrSet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if ($this->rdlength > 0) {
|
|
|
|
$this->address = inet_ntop($this->rdata);
|
|
if ($this->address !== false) {
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected function rrGet(Net_DNS2_Packet &$packet)
|
|
{
|
|
$packet->offset += 4;
|
|
return inet_pton($this->address);
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_RR_AAAA extends Net_DNS2_RR
|
|
{
|
|
|
|
public $address;
|
|
|
|
protected function rrToString()
|
|
{
|
|
return $this->address;
|
|
}
|
|
|
|
protected function rrFromString(array $rdata)
|
|
{
|
|
//
|
|
|
|
//
|
|
$value = array_shift($rdata);
|
|
if (Net_DNS2::isIPv6($value) == true) {
|
|
|
|
$this->address = $value;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected function rrSet(Net_DNS2_Packet &$packet)
|
|
{
|
|
//
|
|
|
|
//
|
|
if ($this->rdlength == 16) {
|
|
|
|
//
|
|
|
|
//
|
|
$x = unpack('n8', $this->rdata);
|
|
if (count($x) == 8) {
|
|
|
|
$this->address = vsprintf('%x:%x:%x:%x:%x:%x:%x:%x', $x);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected function rrGet(Net_DNS2_Packet &$packet)
|
|
{
|
|
$packet->offset += 16;
|
|
return inet_pton($this->address);
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_RR_AFSDB extends Net_DNS2_RR
|
|
{
|
|
|
|
public $subtype;
|
|
|
|
public $hostname;
|
|
|
|
protected function rrToString()
|
|
{
|
|
return $this->subtype . ' ' . $this->cleanString($this->hostname) . '.';
|
|
}
|
|
|
|
protected function rrFromString(array $rdata)
|
|
{
|
|
$this->subtype = array_shift($rdata);
|
|
$this->hostname = $this->cleanString(array_shift($rdata));
|
|
|
|
return true;
|
|
}
|
|
|
|
protected function rrSet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if ($this->rdlength > 0) {
|
|
|
|
//
|
|
|
|
//
|
|
$x = unpack('nsubtype', $this->rdata);
|
|
|
|
$this->subtype = $x['subtype'];
|
|
$offset = $packet->offset + 2;
|
|
|
|
$this->hostname = Net_DNS2_Packet::expand($packet, $offset);
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected function rrGet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if (strlen($this->hostname) > 0) {
|
|
|
|
$data = pack('n', $this->subtype);
|
|
$packet->offset += 2;
|
|
|
|
$data .= $packet->compress($this->hostname, $packet->offset);
|
|
|
|
return $data;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_RR_ANY extends Net_DNS2_RR
|
|
{
|
|
|
|
protected function rrToString()
|
|
{
|
|
return '';
|
|
}
|
|
|
|
protected function rrFromString(array $rdata)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
protected function rrSet(Net_DNS2_Packet &$packet)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
protected function rrGet(Net_DNS2_Packet &$packet)
|
|
{
|
|
return '';
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_RR_APL extends Net_DNS2_RR
|
|
{
|
|
|
|
public $apl_items = array();
|
|
|
|
protected function rrToString()
|
|
{
|
|
$out = '';
|
|
|
|
foreach ($this->apl_items as $item) {
|
|
|
|
if ($item['n'] == 1) {
|
|
|
|
$out .= '!';
|
|
}
|
|
|
|
$out .= $item['address_family'] . ':' .
|
|
$item['afd_part'] . '/' . $item['prefix'] . ' ';
|
|
}
|
|
|
|
return trim($out);
|
|
}
|
|
|
|
protected function rrFromString(array $rdata)
|
|
{
|
|
foreach ($rdata as $item) {
|
|
|
|
if (preg_match('/^(!?)([1|2])\:([^\/]*)\/([0-9]{1,3})$/', $item, $m)) {
|
|
|
|
$i = array(
|
|
|
|
'address_family' => $m[2],
|
|
'prefix' => $m[4],
|
|
'n' => ($m[1] == '!') ? 1 : 0,
|
|
'afd_part' => strtolower($m[3])
|
|
);
|
|
|
|
$address = $this->_trimZeros(
|
|
$i['address_family'], $i['afd_part']
|
|
);
|
|
|
|
$i['afd_length'] = count(explode('.', $address));
|
|
|
|
$this->apl_items[] = $i;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
protected function rrSet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if ($this->rdlength > 0) {
|
|
|
|
$offset = 0;
|
|
|
|
while ($offset < $this->rdlength) {
|
|
|
|
//
|
|
|
|
//
|
|
$x = unpack(
|
|
'naddress_family/Cprefix/Cextra', substr($this->rdata, $offset)
|
|
);
|
|
|
|
$item = array(
|
|
|
|
'address_family' => $x['address_family'],
|
|
'prefix' => $x['prefix'],
|
|
'n' => ($x['extra'] >> 7) & 0x1,
|
|
'afd_length' => $x['extra'] & 0xf
|
|
);
|
|
|
|
switch($item['address_family']) {
|
|
|
|
case 1:
|
|
$r = unpack(
|
|
'C*', substr($this->rdata, $offset + 4, $item['afd_length'])
|
|
);
|
|
if (count($r) < 4) {
|
|
|
|
for ($c=count($r)+1; $c<4+1; $c++) {
|
|
|
|
$r[$c] = 0;
|
|
}
|
|
}
|
|
|
|
$item['afd_part'] = implode('.', $r);
|
|
|
|
break;
|
|
case 2:
|
|
$r = unpack(
|
|
'C*', substr($this->rdata, $offset + 4, $item['afd_length'])
|
|
);
|
|
if (count($r) < 8) {
|
|
|
|
for ($c=count($r)+1; $c<8+1; $c++) {
|
|
|
|
$r[$c] = 0;
|
|
}
|
|
}
|
|
|
|
$item['afd_part'] = sprintf(
|
|
'%x:%x:%x:%x:%x:%x:%x:%x',
|
|
$r[1], $r[2], $r[3], $r[4], $r[5], $r[6], $r[7], $r[8]
|
|
);
|
|
|
|
break;
|
|
default:
|
|
return false;
|
|
}
|
|
|
|
$this->apl_items[] = $item;
|
|
|
|
$offset += 4 + $item['afd_length'];
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected function rrGet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if (count($this->apl_items) > 0) {
|
|
|
|
$data = '';
|
|
|
|
foreach ($this->apl_items as $item) {
|
|
|
|
//
|
|
|
|
//
|
|
$data .= pack(
|
|
'nCC',
|
|
$item['address_family'],
|
|
$item['prefix'],
|
|
($item['n'] << 7) | $item['afd_length']
|
|
);
|
|
|
|
switch($item['address_family']) {
|
|
case 1:
|
|
$address = explode(
|
|
'.',
|
|
$this->_trimZeros($item['address_family'], $item['afd_part'])
|
|
);
|
|
|
|
foreach ($address as $b) {
|
|
$data .= chr($b);
|
|
}
|
|
break;
|
|
case 2:
|
|
$address = explode(
|
|
':',
|
|
$this->_trimZeros($item['address_family'], $item['afd_part'])
|
|
);
|
|
|
|
foreach ($address as $b) {
|
|
$data .= pack('H', $b);
|
|
}
|
|
break;
|
|
default:
|
|
return null;
|
|
}
|
|
}
|
|
|
|
$packet->offset += strlen($data);
|
|
|
|
return $data;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private function _trimZeros($family, $address)
|
|
{
|
|
$a = array();
|
|
|
|
switch($family) {
|
|
case 1:
|
|
$a = array_reverse(explode('.', $address));
|
|
break;
|
|
case 2:
|
|
$a = array_reverse(explode(':', $address));
|
|
break;
|
|
default:
|
|
return '';
|
|
}
|
|
|
|
foreach ($a as $value) {
|
|
|
|
if ($value === '0') {
|
|
|
|
array_shift($a);
|
|
}
|
|
}
|
|
|
|
$out = '';
|
|
|
|
switch($family) {
|
|
case 1:
|
|
$out = implode('.', array_reverse($a));
|
|
break;
|
|
case 2:
|
|
$out = implode(':', array_reverse($a));
|
|
break;
|
|
default:
|
|
return '';
|
|
}
|
|
|
|
return $out;
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_RR_ATMA extends Net_DNS2_RR
|
|
{
|
|
|
|
public $format;
|
|
|
|
public $address;
|
|
|
|
protected function rrToString()
|
|
{
|
|
return $this->address;
|
|
}
|
|
|
|
protected function rrFromString(array $rdata)
|
|
{
|
|
$value = array_shift($rdata);
|
|
|
|
if (ctype_xdigit($value) == true) {
|
|
|
|
$this->format = 0;
|
|
$this->address = $value;
|
|
|
|
} else if (is_numeric($value) == true) {
|
|
|
|
$this->format = 1;
|
|
$this->address = $value;
|
|
|
|
} else {
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
protected function rrSet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if ($this->rdlength > 0) {
|
|
|
|
//
|
|
|
|
//
|
|
$x = unpack('Cformat/N*address', $this->rdata);
|
|
|
|
$this->format = $x['format'];
|
|
|
|
if ($this->format == 0) {
|
|
|
|
$a = unpack('@1/H*address', $this->rdata);
|
|
|
|
$this->address = $a['address'];
|
|
|
|
} else if ($this->format == 1) {
|
|
|
|
$this->address = substr($this->rdata, 1, $this->rdlength - 1);
|
|
|
|
} else {
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected function rrGet(Net_DNS2_Packet &$packet)
|
|
{
|
|
$data = chr($this->format);
|
|
|
|
if ($this->format == 0) {
|
|
|
|
$data .= pack('H*', $this->address);
|
|
|
|
} else if ($this->format == 1) {
|
|
|
|
$data .= $this->address;
|
|
|
|
} else {
|
|
|
|
return null;
|
|
}
|
|
|
|
$packet->offset += strlen($data);
|
|
|
|
return $data;
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_RR_CAA extends Net_DNS2_RR
|
|
{
|
|
|
|
public $flags;
|
|
|
|
public $tag;
|
|
|
|
public $value;
|
|
|
|
protected function rrToString()
|
|
{
|
|
return $this->flags . ' ' . $this->tag . ' "' .
|
|
trim($this->cleanString($this->value), '"') . '"';
|
|
}
|
|
|
|
protected function rrFromString(array $rdata)
|
|
{
|
|
$this->flags = array_shift($rdata);
|
|
$this->tag = array_shift($rdata);
|
|
|
|
$this->value = trim($this->cleanString(implode($rdata, ' ')), '"');
|
|
|
|
return true;
|
|
}
|
|
|
|
protected function rrSet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if ($this->rdlength > 0) {
|
|
|
|
//
|
|
|
|
//
|
|
$x = unpack('Cflags/Ctag_length', $this->rdata);
|
|
|
|
$this->flags = $x['flags'];
|
|
$offset = 2;
|
|
|
|
$this->tag = substr($this->rdata, $offset, $x['tag_length']);
|
|
$offset += $x['tag_length'];
|
|
|
|
$this->value = substr($this->rdata, $offset);
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected function rrGet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if (strlen($this->value) > 0) {
|
|
|
|
$data = chr($this->flags);
|
|
$data .= chr(strlen($this->tag)) . $this->tag . $this->value;
|
|
|
|
$packet->offset += strlen($data);
|
|
|
|
return $data;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_RR_CDNSKEY extends Net_DNS2_RR_DNSKEY
|
|
{
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_RR_CDS extends Net_DNS2_RR_DS
|
|
{
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_RR_CERT extends Net_DNS2_RR
|
|
{
|
|
|
|
const CERT_FORMAT_RES = 0;
|
|
const CERT_FORMAT_PKIX = 1;
|
|
const CERT_FORMAT_SPKI = 2;
|
|
const CERT_FORMAT_PGP = 3;
|
|
const CERT_FORMAT_IPKIX = 4;
|
|
const CERT_FORMAT_ISPKI = 5;
|
|
const CERT_FORMAT_IPGP = 6;
|
|
const CERT_FORMAT_ACPKIX = 7;
|
|
const CERT_FORMAT_IACPKIX = 8;
|
|
const CERT_FORMAT_URI = 253;
|
|
const CERT_FORMAT_OID = 254;
|
|
|
|
public $cert_format_name_to_id = array();
|
|
public $cert_format_id_to_name = array(
|
|
|
|
self::CERT_FORMAT_RES => 'Reserved',
|
|
self::CERT_FORMAT_PKIX => 'PKIX',
|
|
self::CERT_FORMAT_SPKI => 'SPKI',
|
|
self::CERT_FORMAT_PGP => 'PGP',
|
|
self::CERT_FORMAT_IPKIX => 'IPKIX',
|
|
self::CERT_FORMAT_ISPKI => 'ISPKI',
|
|
self::CERT_FORMAT_IPGP => 'IPGP',
|
|
self::CERT_FORMAT_ACPKIX => 'ACPKIX',
|
|
self::CERT_FORMAT_IACPKIX => 'IACPKIX',
|
|
self::CERT_FORMAT_URI => 'URI',
|
|
self::CERT_FORMAT_OID => 'OID'
|
|
);
|
|
|
|
public $format;
|
|
|
|
public $keytag;
|
|
|
|
public $algorithm;
|
|
|
|
public $certificate;
|
|
|
|
public function __construct(Net_DNS2_Packet &$packet = null, array $rr = null)
|
|
{
|
|
parent::__construct($packet, $rr);
|
|
|
|
//
|
|
|
|
//
|
|
$this->cert_format_name_to_id = array_flip($this->cert_format_id_to_name);
|
|
}
|
|
|
|
protected function rrToString()
|
|
{
|
|
return $this->format . ' ' . $this->keytag . ' ' . $this->algorithm .
|
|
' ' . base64_encode($this->certificate);
|
|
}
|
|
|
|
protected function rrFromString(array $rdata)
|
|
{
|
|
//
|
|
|
|
//
|
|
$this->format = array_shift($rdata);
|
|
if (!is_numeric($this->format)) {
|
|
|
|
$mnemonic = strtoupper(trim($this->format));
|
|
if (!isset($this->cert_format_name_to_id[$mnemonic])) {
|
|
|
|
return false;
|
|
}
|
|
|
|
$this->format = $this->cert_format_name_to_id[$mnemonic];
|
|
} else {
|
|
|
|
if (!isset($this->cert_format_id_to_name[$this->format])) {
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|
|
$this->keytag = array_shift($rdata);
|
|
|
|
//
|
|
|
|
//
|
|
$this->algorithm = array_shift($rdata);
|
|
if (!is_numeric($this->algorithm)) {
|
|
|
|
$mnemonic = strtoupper(trim($this->algorithm));
|
|
if (!isset(Net_DNS2_Lookups::$algorithm_name_to_id[$mnemonic])) {
|
|
|
|
return false;
|
|
}
|
|
|
|
$this->algorithm = Net_DNS2_Lookups::$algorithm_name_to_id[
|
|
$mnemonic
|
|
];
|
|
} else {
|
|
|
|
if (!isset(Net_DNS2_Lookups::$algorithm_id_to_name[$this->algorithm])) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
$this->certificate = base64_decode(implode(' ', $rdata));
|
|
|
|
return true;
|
|
}
|
|
|
|
protected function rrSet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if ($this->rdlength > 0) {
|
|
|
|
//
|
|
|
|
//
|
|
$x = unpack('nformat/nkeytag/Calgorithm', $this->rdata);
|
|
|
|
$this->format = $x['format'];
|
|
$this->keytag = $x['keytag'];
|
|
$this->algorithm = $x['algorithm'];
|
|
|
|
//
|
|
|
|
//
|
|
$this->certificate = substr($this->rdata, 5, $this->rdlength - 5);
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected function rrGet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if (strlen($this->certificate) > 0) {
|
|
|
|
$data = pack('nnC', $this->format, $this->keytag, $this->algorithm) .
|
|
$this->certificate;
|
|
|
|
$packet->offset += strlen($data);
|
|
|
|
return $data;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_RR_CNAME extends Net_DNS2_RR
|
|
{
|
|
|
|
public $cname;
|
|
|
|
protected function rrToString()
|
|
{
|
|
return $this->cleanString($this->cname) . '.';
|
|
}
|
|
|
|
protected function rrFromString(array $rdata)
|
|
{
|
|
$this->cname = $this->cleanString(array_shift($rdata));
|
|
return true;
|
|
}
|
|
|
|
protected function rrSet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if ($this->rdlength > 0) {
|
|
|
|
$offset = $packet->offset;
|
|
$this->cname = Net_DNS2_Packet::expand($packet, $offset);
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected function rrGet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if (strlen($this->cname) > 0) {
|
|
|
|
return $packet->compress($this->cname, $packet->offset);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_RR_CSYNC extends Net_DNS2_RR
|
|
{
|
|
|
|
public $serial;
|
|
|
|
public $flags;
|
|
|
|
public $type_bit_maps = array();
|
|
|
|
protected function rrToString()
|
|
{
|
|
$out = $this->serial . ' ' . $this->flags;
|
|
|
|
//
|
|
|
|
//
|
|
foreach ($this->type_bit_maps as $rr) {
|
|
|
|
$out .= ' ' . strtoupper($rr);
|
|
}
|
|
|
|
return $out;
|
|
}
|
|
|
|
protected function rrFromString(array $rdata)
|
|
{
|
|
$this->serial = array_shift($rdata);
|
|
$this->flags = array_shift($rdata);
|
|
|
|
$this->type_bit_maps = $rdata;
|
|
|
|
return true;
|
|
}
|
|
|
|
protected function rrSet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if ($this->rdlength > 0) {
|
|
|
|
//
|
|
|
|
//
|
|
$x = unpack('@' . $packet->offset . '/Nserial/nflags', $packet->rdata);
|
|
|
|
$this->serial = Net_DNS2::expandUint32($x['serial']);
|
|
$this->flags = $x['flags'];
|
|
|
|
//
|
|
|
|
//
|
|
$this->type_bit_maps = Net_DNS2_BitMap::bitMapToArray(
|
|
substr($this->rdata, 6)
|
|
);
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected function rrGet(Net_DNS2_Packet &$packet)
|
|
{
|
|
//
|
|
|
|
//
|
|
$data = pack('Nn', $this->serial, $this->flags);
|
|
|
|
//
|
|
|
|
//
|
|
$data .= Net_DNS2_BitMap::arrayToBitMap($this->type_bit_maps);
|
|
|
|
//
|
|
|
|
//
|
|
$packet->offset += strlen($data);
|
|
|
|
return $data;
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_RR_DHCID extends Net_DNS2_RR
|
|
{
|
|
|
|
public $id_type;
|
|
|
|
public $digest_type;
|
|
|
|
public $digest;
|
|
|
|
protected function rrToString()
|
|
{
|
|
$out = pack('nC', $this->id_type, $this->digest_type);
|
|
$out .= base64_decode($this->digest);
|
|
|
|
return base64_encode($out);
|
|
}
|
|
|
|
protected function rrFromString(array $rdata)
|
|
{
|
|
$data = base64_decode(array_shift($rdata));
|
|
if (strlen($data) > 0) {
|
|
|
|
//
|
|
|
|
//
|
|
$x = unpack('nid_type/Cdigest_type', $data);
|
|
|
|
$this->id_type = $x['id_type'];
|
|
$this->digest_type = $x['digest_type'];
|
|
|
|
//
|
|
|
|
//
|
|
$this->digest = base64_encode(substr($data, 3, strlen($data) - 3));
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected function rrSet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if ($this->rdlength > 0) {
|
|
|
|
//
|
|
|
|
//
|
|
$x = unpack('nid_type/Cdigest_type', $this->rdata);
|
|
|
|
$this->id_type = $x['id_type'];
|
|
$this->digest_type = $x['digest_type'];
|
|
|
|
//
|
|
|
|
//
|
|
$this->digest = base64_encode(
|
|
substr($this->rdata, 3, $this->rdlength - 3)
|
|
);
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected function rrGet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if (strlen($this->digest) > 0) {
|
|
|
|
$data = pack('nC', $this->id_type, $this->digest_type) .
|
|
base64_decode($this->digest);
|
|
|
|
$packet->offset += strlen($data);
|
|
|
|
return $data;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_RR_DLV extends Net_DNS2_RR_DS
|
|
{
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_RR_DNAME extends Net_DNS2_RR
|
|
{
|
|
|
|
public $dname;
|
|
|
|
protected function rrToString()
|
|
{
|
|
return $this->cleanString($this->dname) . '.';
|
|
}
|
|
|
|
protected function rrFromString(array $rdata)
|
|
{
|
|
$this->dname = $this->cleanString(array_shift($rdata));
|
|
return true;
|
|
}
|
|
|
|
protected function rrSet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if ($this->rdlength > 0) {
|
|
|
|
$offset = $packet->offset;
|
|
$this->dname = Net_DNS2_Packet::expand($packet, $offset);
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected function rrGet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if (strlen($this->dname) > 0) {
|
|
|
|
return $packet->compress($this->dname, $packet->offset);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_RR_DNSKEY extends Net_DNS2_RR
|
|
{
|
|
|
|
public $flags;
|
|
|
|
public $protocol;
|
|
|
|
public $algorithm;
|
|
|
|
public $key;
|
|
|
|
protected function rrToString()
|
|
{
|
|
return $this->flags . ' ' . $this->protocol . ' ' .
|
|
$this->algorithm . ' ' . $this->key;
|
|
}
|
|
|
|
protected function rrFromString(array $rdata)
|
|
{
|
|
$this->flags = array_shift($rdata);
|
|
$this->protocol = array_shift($rdata);
|
|
$this->algorithm = array_shift($rdata);
|
|
$this->key = implode(' ', $rdata);
|
|
|
|
return true;
|
|
}
|
|
|
|
protected function rrSet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if ($this->rdlength > 0) {
|
|
|
|
//
|
|
|
|
//
|
|
$x = unpack('nflags/Cprotocol/Calgorithm', $this->rdata);
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
$this->flags = $x['flags'];
|
|
$this->protocol = $x['protocol'];
|
|
$this->algorithm = $x['algorithm'];
|
|
|
|
$this->key = base64_encode(substr($this->rdata, 4));
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected function rrGet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if (strlen($this->key) > 0) {
|
|
|
|
$data = pack('nCC', $this->flags, $this->protocol, $this->algorithm);
|
|
$data .= base64_decode($this->key);
|
|
|
|
$packet->offset += strlen($data);
|
|
|
|
return $data;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_RR_DS extends Net_DNS2_RR
|
|
{
|
|
|
|
public $keytag;
|
|
|
|
public $algorithm;
|
|
|
|
public $digesttype;
|
|
|
|
public $digest;
|
|
|
|
protected function rrToString()
|
|
{
|
|
return $this->keytag . ' ' . $this->algorithm . ' ' .
|
|
$this->digesttype . ' ' . $this->digest;
|
|
}
|
|
|
|
protected function rrFromString(array $rdata)
|
|
{
|
|
$this->keytag = array_shift($rdata);
|
|
$this->algorithm = array_shift($rdata);
|
|
$this->digesttype = array_shift($rdata);
|
|
$this->digest = implode('', $rdata);
|
|
|
|
return true;
|
|
}
|
|
|
|
protected function rrSet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if ($this->rdlength > 0) {
|
|
|
|
//
|
|
|
|
//
|
|
$x = unpack('nkeytag/Calgorithm/Cdigesttype', $this->rdata);
|
|
|
|
$this->keytag = $x['keytag'];
|
|
$this->algorithm = $x['algorithm'];
|
|
$this->digesttype = $x['digesttype'];
|
|
|
|
//
|
|
|
|
//
|
|
$digest_size = 0;
|
|
if ($this->digesttype == 1) {
|
|
|
|
$digest_size = 20;
|
|
|
|
} else if ($this->digesttype == 2) {
|
|
|
|
$digest_size = 32;
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
$x = unpack('H*', substr($this->rdata, 4, $digest_size));
|
|
$this->digest = $x[1];
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected function rrGet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if (strlen($this->digest) > 0) {
|
|
|
|
$data = pack(
|
|
'nCCH*',
|
|
$this->keytag, $this->algorithm, $this->digesttype, $this->digest
|
|
);
|
|
|
|
$packet->offset += strlen($data);
|
|
|
|
return $data;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_RR_EID extends Net_DNS2_RR
|
|
{
|
|
|
|
protected function rrToString()
|
|
{
|
|
return '';
|
|
}
|
|
|
|
protected function rrFromString(array $rdata)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
protected function rrSet(Net_DNS2_Packet &$packet)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
protected function rrGet(Net_DNS2_Packet &$packet)
|
|
{
|
|
return $this->rdata;
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_RR_EUI48 extends Net_DNS2_RR
|
|
{
|
|
|
|
public $address;
|
|
|
|
protected function rrToString()
|
|
{
|
|
return $this->address;
|
|
}
|
|
|
|
protected function rrFromString(array $rdata)
|
|
{
|
|
$value = array_shift($rdata);
|
|
|
|
//
|
|
|
|
//
|
|
$a = explode('-', $value);
|
|
if (count($a) != 6) {
|
|
|
|
return false;
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
foreach ($a as $i) {
|
|
if (ctype_xdigit($i) == false) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
$this->address = strtolower($value);
|
|
|
|
return true;
|
|
}
|
|
|
|
protected function rrSet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if ($this->rdlength > 0) {
|
|
|
|
$x = unpack('C6', $this->rdata);
|
|
if (count($x) == 6) {
|
|
|
|
$this->address = vsprintf('%02x-%02x-%02x-%02x-%02x-%02x', $x);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected function rrGet(Net_DNS2_Packet &$packet)
|
|
{
|
|
$data = '';
|
|
|
|
$a = explode('-', $this->address);
|
|
foreach ($a as $b) {
|
|
|
|
$data .= chr(hexdec($b));
|
|
}
|
|
|
|
$packet->offset += 6;
|
|
return $data;
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_RR_EUI64 extends Net_DNS2_RR
|
|
{
|
|
|
|
public $address;
|
|
|
|
protected function rrToString()
|
|
{
|
|
return $this->address;
|
|
}
|
|
|
|
protected function rrFromString(array $rdata)
|
|
{
|
|
$value = array_shift($rdata);
|
|
|
|
//
|
|
|
|
//
|
|
$a = explode('-', $value);
|
|
if (count($a) != 8) {
|
|
|
|
return false;
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
foreach ($a as $i) {
|
|
if (ctype_xdigit($i) == false) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
$this->address = strtolower($value);
|
|
|
|
return true;
|
|
}
|
|
|
|
protected function rrSet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if ($this->rdlength > 0) {
|
|
|
|
$x = unpack('C8', $this->rdata);
|
|
if (count($x) == 8) {
|
|
|
|
$this->address = vsprintf(
|
|
'%02x-%02x-%02x-%02x-%02x-%02x-%02x-%02x', $x
|
|
);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected function rrGet(Net_DNS2_Packet &$packet)
|
|
{
|
|
$data = '';
|
|
|
|
$a = explode('-', $this->address);
|
|
foreach ($a as $b) {
|
|
|
|
$data .= chr(hexdec($b));
|
|
}
|
|
|
|
$packet->offset += 8;
|
|
return $data;
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_RR_HINFO extends Net_DNS2_RR
|
|
{
|
|
|
|
public $cpu;
|
|
|
|
public $os;
|
|
|
|
protected function rrToString()
|
|
{
|
|
return $this->formatString($this->cpu) . ' ' .
|
|
$this->formatString($this->os);
|
|
}
|
|
|
|
protected function rrFromString(array $rdata)
|
|
{
|
|
$data = $this->buildString($rdata);
|
|
if (count($data) == 2) {
|
|
|
|
$this->cpu = $data[0];
|
|
$this->os = $data[1];
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected function rrSet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if ($this->rdlength > 0) {
|
|
|
|
$offset = $packet->offset;
|
|
|
|
$this->cpu = trim(Net_DNS2_Packet::label($packet, $offset), '"');
|
|
$this->os = trim(Net_DNS2_Packet::label($packet, $offset), '"');
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected function rrGet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if (strlen($this->cpu) > 0) {
|
|
|
|
$data = chr(strlen($this->cpu)) . $this->cpu;
|
|
$data .= chr(strlen($this->os)) . $this->os;
|
|
|
|
$packet->offset += strlen($data);
|
|
|
|
return $data;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_RR_HIP extends Net_DNS2_RR
|
|
{
|
|
|
|
public $hit_length;
|
|
|
|
public $pk_algorithm;
|
|
|
|
public $pk_length;
|
|
|
|
public $hit;
|
|
|
|
public $public_key;
|
|
|
|
public $rendezvous_servers = array();
|
|
|
|
protected function rrToString()
|
|
{
|
|
$out = $this->pk_algorithm . ' ' .
|
|
$this->hit . ' ' . $this->public_key . ' ';
|
|
|
|
foreach ($this->rendezvous_servers as $index => $server) {
|
|
|
|
$out .= $server . '. ';
|
|
}
|
|
|
|
return trim($out);
|
|
}
|
|
|
|
protected function rrFromString(array $rdata)
|
|
{
|
|
$this->pk_algorithm = array_shift($rdata);
|
|
$this->hit = strtoupper(array_shift($rdata));
|
|
$this->public_key = array_shift($rdata);
|
|
|
|
//
|
|
|
|
//
|
|
if (count($rdata) > 0) {
|
|
|
|
$this->rendezvous_servers = preg_replace('/\.$/', '', $rdata);
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
$this->hit_length = strlen(pack('H*', $this->hit));
|
|
$this->pk_length = strlen(base64_decode($this->public_key));
|
|
|
|
return true;
|
|
}
|
|
|
|
protected function rrSet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if ($this->rdlength > 0) {
|
|
|
|
//
|
|
|
|
//
|
|
$x = unpack('Chit_length/Cpk_algorithm/npk_length', $this->rdata);
|
|
|
|
$this->hit_length = $x['hit_length'];
|
|
$this->pk_algorithm = $x['pk_algorithm'];
|
|
$this->pk_length = $x['pk_length'];
|
|
|
|
$offset = 4;
|
|
|
|
//
|
|
|
|
//
|
|
$hit = unpack('H*', substr($this->rdata, $offset, $this->hit_length));
|
|
|
|
$this->hit = strtoupper($hit[1]);
|
|
$offset += $this->hit_length;
|
|
|
|
//
|
|
|
|
//
|
|
$this->public_key = base64_encode(
|
|
substr($this->rdata, $offset, $this->pk_length)
|
|
);
|
|
$offset += $this->pk_length;
|
|
|
|
//
|
|
|
|
//
|
|
$offset = $packet->offset + $offset;
|
|
|
|
while ( ($offset - $packet->offset) < $this->rdlength) {
|
|
|
|
$this->rendezvous_servers[] = Net_DNS2_Packet::expand(
|
|
$packet, $offset
|
|
);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected function rrGet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if ( (strlen($this->hit) > 0) && (strlen($this->public_key) > 0) ) {
|
|
|
|
//
|
|
|
|
//
|
|
$data = pack(
|
|
'CCnH*',
|
|
$this->hit_length,
|
|
$this->pk_algorithm,
|
|
$this->pk_length,
|
|
$this->hit
|
|
);
|
|
|
|
//
|
|
|
|
//
|
|
$data .= base64_decode($this->public_key);
|
|
|
|
//
|
|
|
|
//
|
|
$packet->offset += strlen($data);
|
|
|
|
//
|
|
|
|
//
|
|
foreach ($this->rendezvous_servers as $index => $server) {
|
|
|
|
$data .= $packet->compress($server, $packet->offset);
|
|
}
|
|
|
|
return $data;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_RR_IPSECKEY extends Net_DNS2_RR
|
|
{
|
|
const GATEWAY_TYPE_NONE = 0;
|
|
const GATEWAY_TYPE_IPV4 = 1;
|
|
const GATEWAY_TYPE_IPV6 = 2;
|
|
const GATEWAY_TYPE_DOMAIN = 3;
|
|
|
|
const ALGORITHM_NONE = 0;
|
|
const ALGORITHM_DSA = 1;
|
|
const ALGORITHM_RSA = 2;
|
|
|
|
public $precedence;
|
|
|
|
public $gateway_type;
|
|
|
|
public $algorithm;
|
|
|
|
public $gateway;
|
|
|
|
public $key;
|
|
|
|
protected function rrToString()
|
|
{
|
|
$out = $this->precedence . ' ' . $this->gateway_type . ' ' .
|
|
$this->algorithm . ' ';
|
|
|
|
switch($this->gateway_type) {
|
|
case self::GATEWAY_TYPE_NONE:
|
|
$out .= '. ';
|
|
break;
|
|
|
|
case self::GATEWAY_TYPE_IPV4:
|
|
case self::GATEWAY_TYPE_IPV6:
|
|
$out .= $this->gateway . ' ';
|
|
break;
|
|
|
|
case self::GATEWAY_TYPE_DOMAIN:
|
|
$out .= $this->gateway . '. ';
|
|
break;
|
|
}
|
|
|
|
$out .= $this->key;
|
|
return $out;
|
|
}
|
|
|
|
protected function rrFromString(array $rdata)
|
|
{
|
|
//
|
|
|
|
//
|
|
$precedence = array_shift($rdata);
|
|
$gateway_type = array_shift($rdata);
|
|
$algorithm = array_shift($rdata);
|
|
$gateway = strtolower(trim(array_shift($rdata)));
|
|
$key = array_shift($rdata);
|
|
|
|
//
|
|
|
|
//
|
|
switch($gateway_type) {
|
|
case self::GATEWAY_TYPE_NONE:
|
|
$gateway = '';
|
|
break;
|
|
|
|
case self::GATEWAY_TYPE_IPV4:
|
|
if (Net_DNS2::isIPv4($gateway) == false) {
|
|
return false;
|
|
}
|
|
break;
|
|
|
|
case self::GATEWAY_TYPE_IPV6:
|
|
if (Net_DNS2::isIPv6($gateway) == false) {
|
|
return false;
|
|
}
|
|
break;
|
|
|
|
case self::GATEWAY_TYPE_DOMAIN:
|
|
;
|
|
break;
|
|
|
|
default:
|
|
return false;
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
switch($algorithm) {
|
|
case self::ALGORITHM_NONE:
|
|
$key = '';
|
|
break;
|
|
|
|
case self::ALGORITHM_DSA:
|
|
case self::ALGORITHM_RSA:
|
|
;
|
|
break;
|
|
|
|
default:
|
|
return false;
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
$this->precedence = $precedence;
|
|
$this->gateway_type = $gateway_type;
|
|
$this->algorithm = $algorithm;
|
|
$this->gateway = $gateway;
|
|
$this->key = $key;
|
|
|
|
return true;
|
|
}
|
|
|
|
protected function rrSet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if ($this->rdlength > 0) {
|
|
|
|
//
|
|
|
|
//
|
|
$x = unpack('Cprecedence/Cgateway_type/Calgorithm', $this->rdata);
|
|
|
|
$this->precedence = $x['precedence'];
|
|
$this->gateway_type = $x['gateway_type'];
|
|
$this->algorithm = $x['algorithm'];
|
|
|
|
$offset = 3;
|
|
|
|
//
|
|
|
|
//
|
|
switch($this->gateway_type) {
|
|
case self::GATEWAY_TYPE_NONE:
|
|
$this->gateway = '';
|
|
break;
|
|
|
|
case self::GATEWAY_TYPE_IPV4:
|
|
$this->gateway = inet_ntop(substr($this->rdata, $offset, 4));
|
|
$offset += 4;
|
|
break;
|
|
|
|
case self::GATEWAY_TYPE_IPV6:
|
|
$ip = unpack('n8', substr($this->rdata, $offset, 16));
|
|
if (count($ip) == 8) {
|
|
|
|
$this->gateway = vsprintf('%x:%x:%x:%x:%x:%x:%x:%x', $ip);
|
|
$offset += 16;
|
|
} else {
|
|
|
|
return false;
|
|
}
|
|
break;
|
|
|
|
case self::GATEWAY_TYPE_DOMAIN:
|
|
|
|
$doffset = $offset + $packet->offset;
|
|
$this->gateway = Net_DNS2_Packet::expand($packet, $doffset);
|
|
$offset = ($doffset - $packet->offset);
|
|
break;
|
|
|
|
default:
|
|
return false;
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
switch($this->algorithm) {
|
|
case self::ALGORITHM_NONE:
|
|
$this->key = '';
|
|
break;
|
|
|
|
case self::ALGORITHM_DSA:
|
|
case self::ALGORITHM_RSA:
|
|
$this->key = base64_encode(substr($this->rdata, $offset));
|
|
break;
|
|
|
|
default:
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected function rrGet(Net_DNS2_Packet &$packet)
|
|
{
|
|
//
|
|
|
|
//
|
|
$data = pack(
|
|
'CCC', $this->precedence, $this->gateway_type, $this->algorithm
|
|
);
|
|
|
|
//
|
|
|
|
//
|
|
switch($this->gateway_type) {
|
|
case self::GATEWAY_TYPE_NONE:
|
|
;
|
|
break;
|
|
|
|
case self::GATEWAY_TYPE_IPV4:
|
|
case self::GATEWAY_TYPE_IPV6:
|
|
$data .= inet_pton($this->gateway);
|
|
break;
|
|
|
|
case self::GATEWAY_TYPE_DOMAIN:
|
|
$data .= chr(strlen($this->gateway)) . $this->gateway;
|
|
break;
|
|
|
|
default:
|
|
return null;
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
switch($this->algorithm) {
|
|
case self::ALGORITHM_NONE:
|
|
;
|
|
break;
|
|
|
|
case self::ALGORITHM_DSA:
|
|
case self::ALGORITHM_RSA:
|
|
$data .= base64_decode($this->key);
|
|
break;
|
|
|
|
default:
|
|
return null;
|
|
}
|
|
|
|
$packet->offset += strlen($data);
|
|
|
|
return $data;
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_RR_ISDN extends Net_DNS2_RR
|
|
{
|
|
|
|
public $isdnaddress;
|
|
|
|
public $sa;
|
|
|
|
protected function rrToString()
|
|
{
|
|
return $this->formatString($this->isdnaddress) . ' ' .
|
|
$this->formatString($this->sa);
|
|
}
|
|
|
|
protected function rrFromString(array $rdata)
|
|
{
|
|
$data = $this->buildString($rdata);
|
|
if (count($data) >= 1) {
|
|
|
|
$this->isdnaddress = $data[0];
|
|
if (isset($data[1])) {
|
|
|
|
$this->sa = $data[1];
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected function rrSet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if ($this->rdlength > 0) {
|
|
|
|
$this->isdnaddress = Net_DNS2_Packet::label($packet, $packet->offset);
|
|
|
|
//
|
|
|
|
//
|
|
if ( (strlen($this->isdnaddress) + 1) < $this->rdlength) {
|
|
|
|
$this->sa = Net_DNS2_Packet::label($packet, $packet->offset);
|
|
} else {
|
|
|
|
$this->sa = '';
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected function rrGet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if (strlen($this->isdnaddress) > 0) {
|
|
|
|
$data = chr(strlen($this->isdnaddress)) . $this->isdnaddress;
|
|
if (!empty($this->sa)) {
|
|
|
|
$data .= chr(strlen($this->sa));
|
|
$data .= $this->sa;
|
|
}
|
|
|
|
$packet->offset += strlen($data);
|
|
|
|
return $data;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_RR_KEY extends Net_DNS2_RR_DNSKEY
|
|
{
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_RR_KX extends Net_DNS2_RR
|
|
{
|
|
|
|
public $preference;
|
|
|
|
public $exchange;
|
|
|
|
protected function rrToString()
|
|
{
|
|
return $this->preference . ' ' . $this->cleanString($this->exchange) . '.';
|
|
}
|
|
|
|
protected function rrFromString(array $rdata)
|
|
{
|
|
$this->preference = array_shift($rdata);
|
|
$this->exchange = $this->cleanString(array_shift($rdata));
|
|
|
|
return true;
|
|
}
|
|
|
|
protected function rrSet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if ($this->rdlength > 0) {
|
|
|
|
//
|
|
|
|
//
|
|
$x = unpack('npreference', $this->rdata);
|
|
$this->preference = $x['preference'];
|
|
|
|
//
|
|
|
|
//
|
|
$offset = $packet->offset + 2;
|
|
$this->exchange = Net_DNS2_Packet::label($packet, $offset);
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected function rrGet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if (strlen($this->exchange) > 0) {
|
|
|
|
$data = pack('nC', $this->preference, strlen($this->exchange)) .
|
|
$this->exchange;
|
|
|
|
$packet->offset += strlen($data);
|
|
|
|
return $data;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_RR_L32 extends Net_DNS2_RR
|
|
{
|
|
|
|
public $preference;
|
|
|
|
public $locator32;
|
|
|
|
protected function rrToString()
|
|
{
|
|
return $this->preference . ' ' . $this->locator32;
|
|
}
|
|
|
|
protected function rrFromString(array $rdata)
|
|
{
|
|
$this->preference = array_shift($rdata);
|
|
$this->locator32 = array_shift($rdata);
|
|
|
|
return true;
|
|
}
|
|
|
|
protected function rrSet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if ($this->rdlength > 0) {
|
|
|
|
//
|
|
|
|
//
|
|
$x = unpack('npreference/C4locator', $this->rdata);
|
|
|
|
$this->preference = $x['preference'];
|
|
|
|
//
|
|
|
|
//
|
|
$this->locator32 = $x['locator1'] . '.' . $x['locator2'] . '.' .
|
|
$x['locator3'] . '.' . $x['locator4'];
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected function rrGet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if (strlen($this->locator32) > 0) {
|
|
|
|
//
|
|
|
|
//
|
|
$n = explode('.', $this->locator32);
|
|
|
|
//
|
|
|
|
//
|
|
return pack('nC4', $this->preference, $n[0], $n[1], $n[2], $n[3]);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_RR_L64 extends Net_DNS2_RR
|
|
{
|
|
|
|
public $preference;
|
|
|
|
public $locator64;
|
|
|
|
protected function rrToString()
|
|
{
|
|
return $this->preference . ' ' . $this->locator64;
|
|
}
|
|
|
|
protected function rrFromString(array $rdata)
|
|
{
|
|
$this->preference = array_shift($rdata);
|
|
$this->locator64 = array_shift($rdata);
|
|
|
|
return true;
|
|
}
|
|
|
|
protected function rrSet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if ($this->rdlength > 0) {
|
|
|
|
//
|
|
|
|
//
|
|
$x = unpack('npreference/n4locator', $this->rdata);
|
|
|
|
$this->preference = $x['preference'];
|
|
|
|
//
|
|
|
|
//
|
|
$this->locator64 = dechex($x['locator1']) . ':' .
|
|
dechex($x['locator2']) . ':' .
|
|
dechex($x['locator3']) . ':' .
|
|
dechex($x['locator4']);
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected function rrGet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if (strlen($this->locator64) > 0) {
|
|
|
|
//
|
|
|
|
//
|
|
$n = explode(':', $this->locator64);
|
|
|
|
//
|
|
|
|
//
|
|
return pack(
|
|
'n5', $this->preference, hexdec($n[0]), hexdec($n[1]),
|
|
hexdec($n[2]), hexdec($n[3])
|
|
);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_RR_LOC extends Net_DNS2_RR
|
|
{
|
|
|
|
public $version;
|
|
|
|
public $size;
|
|
|
|
public $horiz_pre;
|
|
|
|
public $vert_pre;
|
|
|
|
public $latitude;
|
|
|
|
public $longitude;
|
|
|
|
public $altitude;
|
|
|
|
private $_powerOfTen = array(1, 10, 100, 1000, 10000, 100000,
|
|
1000000,10000000,100000000,1000000000);
|
|
|
|
const CONV_SEC = 1000;
|
|
const CONV_MIN = 60000;
|
|
const CONV_DEG = 3600000;
|
|
|
|
const REFERENCE_ALT = 10000000;
|
|
const REFERENCE_LATLON = 2147483648;
|
|
|
|
protected function rrToString()
|
|
{
|
|
if ($this->version == 0) {
|
|
|
|
return $this->_d2Dms($this->latitude, 'LAT') . ' ' .
|
|
$this->_d2Dms($this->longitude, 'LNG') . ' ' .
|
|
sprintf('%.2fm', $this->altitude) . ' ' .
|
|
sprintf('%.2fm', $this->size) . ' ' .
|
|
sprintf('%.2fm', $this->horiz_pre) . ' ' .
|
|
sprintf('%.2fm', $this->vert_pre);
|
|
}
|
|
|
|
return '';
|
|
}
|
|
|
|
protected function rrFromString(array $rdata)
|
|
{
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
$res = preg_match(
|
|
'/^(\d+) \s+((\d+) \s+)?(([\d.]+) \s+)?(N|S) \s+(\d+) ' .
|
|
'\s+((\d+) \s+)?(([\d.]+) \s+)?(E|W) \s+(-?[\d.]+) m?(\s+ ' .
|
|
'([\d.]+) m?)?(\s+ ([\d.]+) m?)?(\s+ ([\d.]+) m?)?/ix',
|
|
implode(' ', $rdata), $x
|
|
);
|
|
|
|
if ($res) {
|
|
|
|
//
|
|
|
|
//
|
|
$latdeg = $x[1];
|
|
$latmin = (isset($x[3])) ? $x[3] : 0;
|
|
$latsec = (isset($x[5])) ? $x[5] : 0;
|
|
$lathem = strtoupper($x[6]);
|
|
|
|
$this->latitude = $this->_dms2d($latdeg, $latmin, $latsec, $lathem);
|
|
|
|
//
|
|
|
|
//
|
|
$londeg = $x[7];
|
|
$lonmin = (isset($x[9])) ? $x[9] : 0;
|
|
$lonsec = (isset($x[11])) ? $x[11] : 0;
|
|
$lonhem = strtoupper($x[12]);
|
|
|
|
$this->longitude = $this->_dms2d($londeg, $lonmin, $lonsec, $lonhem);
|
|
|
|
//
|
|
|
|
//
|
|
$version = 0;
|
|
|
|
$this->size = (isset($x[15])) ? $x[15] : 1;
|
|
$this->horiz_pre = ((isset($x[17])) ? $x[17] : 10000);
|
|
$this->vert_pre = ((isset($x[19])) ? $x[19] : 10);
|
|
$this->altitude = $x[13];
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected function rrSet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if ($this->rdlength > 0) {
|
|
|
|
//
|
|
|
|
//
|
|
$x = unpack(
|
|
'Cver/Csize/Choriz_pre/Cvert_pre/Nlatitude/Nlongitude/Naltitude',
|
|
$this->rdata
|
|
);
|
|
|
|
//
|
|
|
|
//
|
|
$this->version = $x['ver'];
|
|
if ($this->version == 0) {
|
|
|
|
$this->size = $this->_precsizeNtoA($x['size']);
|
|
$this->horiz_pre = $this->_precsizeNtoA($x['horiz_pre']);
|
|
$this->vert_pre = $this->_precsizeNtoA($x['vert_pre']);
|
|
|
|
//
|
|
|
|
//
|
|
if ($x['latitude'] < 0) {
|
|
|
|
$this->latitude = ($x['latitude'] +
|
|
self::REFERENCE_LATLON) / self::CONV_DEG;
|
|
} else {
|
|
|
|
$this->latitude = ($x['latitude'] -
|
|
self::REFERENCE_LATLON) / self::CONV_DEG;
|
|
}
|
|
|
|
if ($x['longitude'] < 0) {
|
|
|
|
$this->longitude = ($x['longitude'] +
|
|
self::REFERENCE_LATLON) / self::CONV_DEG;
|
|
} else {
|
|
|
|
$this->longitude = ($x['longitude'] -
|
|
self::REFERENCE_LATLON) / self::CONV_DEG;
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
$this->altitude = ($x['altitude'] - self::REFERENCE_ALT) / 100;
|
|
|
|
return true;
|
|
|
|
} else {
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected function rrGet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if ($this->version == 0) {
|
|
|
|
$lat = 0;
|
|
$lng = 0;
|
|
|
|
if ($this->latitude < 0) {
|
|
|
|
$lat = ($this->latitude * self::CONV_DEG) - self::REFERENCE_LATLON;
|
|
} else {
|
|
|
|
$lat = ($this->latitude * self::CONV_DEG) + self::REFERENCE_LATLON;
|
|
}
|
|
|
|
if ($this->longitude < 0) {
|
|
|
|
$lng = ($this->longitude * self::CONV_DEG) - self::REFERENCE_LATLON;
|
|
} else {
|
|
|
|
$lng = ($this->longitude * self::CONV_DEG) + self::REFERENCE_LATLON;
|
|
}
|
|
|
|
$packet->offset += 16;
|
|
|
|
return pack(
|
|
'CCCCNNN',
|
|
$this->version,
|
|
$this->_precsizeAtoN($this->size),
|
|
$this->_precsizeAtoN($this->horiz_pre),
|
|
$this->_precsizeAtoN($this->vert_pre),
|
|
$lat, $lng,
|
|
($this->altitude * 100) + self::REFERENCE_ALT
|
|
);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private function _precsizeNtoA($prec)
|
|
{
|
|
$mantissa = (($prec >> 4) & 0x0f) % 10;
|
|
$exponent = (($prec >> 0) & 0x0f) % 10;
|
|
|
|
return $mantissa * $this->_powerOfTen[$exponent];
|
|
}
|
|
|
|
private function _precsizeAtoN($prec)
|
|
{
|
|
$exponent = 0;
|
|
while ($prec >= 10) {
|
|
|
|
$prec /= 10;
|
|
++$exponent;
|
|
}
|
|
|
|
return ($prec << 4) | ($exponent & 0x0f);
|
|
}
|
|
|
|
private function _dms2d($deg, $min, $sec, $hem)
|
|
{
|
|
$deg = $deg - 0;
|
|
$min = $min - 0;
|
|
|
|
$sign = ($hem == 'W' || $hem == 'S') ? -1 : 1;
|
|
return ((($sec/60+$min)/60)+$deg) * $sign;
|
|
}
|
|
|
|
private function _d2Dms($data, $latlng)
|
|
{
|
|
$deg = 0;
|
|
$min = 0;
|
|
$sec = 0;
|
|
$msec = 0;
|
|
$hem = '';
|
|
|
|
if ($latlng == 'LAT') {
|
|
$hem = ($data > 0) ? 'N' : 'S';
|
|
} else {
|
|
$hem = ($data > 0) ? 'E' : 'W';
|
|
}
|
|
|
|
$data = abs($data);
|
|
|
|
$deg = (int)$data;
|
|
$min = (int)(($data - $deg) * 60);
|
|
$sec = (int)(((($data - $deg) * 60) - $min) * 60);
|
|
$msec = round((((((($data - $deg) * 60) - $min) * 60) - $sec) * 1000));
|
|
|
|
return sprintf('%d %02d %02d.%03d %s', $deg, $min, $sec, round($msec), $hem);
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_RR_LP extends Net_DNS2_RR
|
|
{
|
|
|
|
public $preference;
|
|
|
|
public $fqdn;
|
|
|
|
protected function rrToString()
|
|
{
|
|
return $this->preference . ' ' . $this->fqdn . '.';
|
|
}
|
|
|
|
protected function rrFromString(array $rdata)
|
|
{
|
|
$this->preference = array_shift($rdata);
|
|
$this->fqdn = trim(array_shift($rdata), '.');
|
|
|
|
return true;
|
|
}
|
|
|
|
protected function rrSet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if ($this->rdlength > 0) {
|
|
|
|
//
|
|
|
|
//
|
|
$x = unpack('npreference', $this->rdata);
|
|
$this->preference = $x['preference'];
|
|
$offset = $packet->offset + 2;
|
|
|
|
//
|
|
|
|
//
|
|
$this->fqdn = Net_DNS2_Packet::expand($packet, $offset);
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected function rrGet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if (strlen($this->fqdn) > 0) {
|
|
|
|
$data = pack('n', $this->preference);
|
|
$packet->offset += 2;
|
|
|
|
$data .= $packet->compress($this->fqdn, $packet->offset);
|
|
return $data;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_RR_MX extends Net_DNS2_RR
|
|
{
|
|
|
|
public $preference;
|
|
|
|
public $exchange;
|
|
|
|
protected function rrToString()
|
|
{
|
|
return $this->preference . ' ' . $this->cleanString($this->exchange) . '.';
|
|
}
|
|
|
|
protected function rrFromString(array $rdata)
|
|
{
|
|
$this->preference = array_shift($rdata);
|
|
$this->exchange = $this->cleanString(array_shift($rdata));
|
|
|
|
return true;
|
|
}
|
|
|
|
protected function rrSet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if ($this->rdlength > 0) {
|
|
|
|
//
|
|
|
|
//
|
|
$x = unpack('npreference', $this->rdata);
|
|
$this->preference = $x['preference'];
|
|
|
|
//
|
|
|
|
//
|
|
$offset = $packet->offset + 2;
|
|
$this->exchange = Net_DNS2_Packet::expand($packet, $offset);
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected function rrGet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if (strlen($this->exchange) > 0) {
|
|
|
|
$data = pack('n', $this->preference);
|
|
$packet->offset += 2;
|
|
|
|
$data .= $packet->compress($this->exchange, $packet->offset);
|
|
return $data;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_RR_NAPTR extends Net_DNS2_RR
|
|
{
|
|
|
|
public $order;
|
|
|
|
public $preference;
|
|
|
|
public $flags;
|
|
|
|
public $services;
|
|
|
|
public $regexp;
|
|
|
|
public $replacement;
|
|
|
|
protected function rrToString()
|
|
{
|
|
return $this->order . ' ' . $this->preference . ' ' .
|
|
$this->formatString($this->flags) . ' ' .
|
|
$this->formatString($this->services) . ' ' .
|
|
$this->formatString($this->regexp) . ' ' .
|
|
$this->cleanString($this->replacement) . '.';
|
|
}
|
|
|
|
protected function rrFromString(array $rdata)
|
|
{
|
|
$this->order = array_shift($rdata);
|
|
$this->preference = array_shift($rdata);
|
|
|
|
$data = $this->buildString($rdata);
|
|
if (count($data) == 4) {
|
|
|
|
$this->flags = $data[0];
|
|
$this->services = $data[1];
|
|
$this->regexp = $data[2];
|
|
$this->replacement = $this->cleanString($data[3]);
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected function rrSet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if ($this->rdlength > 0) {
|
|
|
|
//
|
|
|
|
//
|
|
$x = unpack('norder/npreference', $this->rdata);
|
|
|
|
$this->order = $x['order'];
|
|
$this->preference = $x['preference'];
|
|
|
|
$offset = $packet->offset + 4;
|
|
|
|
$this->flags = Net_DNS2_Packet::label($packet, $offset);
|
|
$this->services = Net_DNS2_Packet::label($packet, $offset);
|
|
$this->regexp = Net_DNS2_Packet::label($packet, $offset);
|
|
|
|
$this->replacement = Net_DNS2_Packet::expand($packet, $offset);
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected function rrGet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if ( (isset($this->order)) && (strlen($this->services) > 0) ) {
|
|
|
|
$data = pack('nn', $this->order, $this->preference);
|
|
|
|
$data .= chr(strlen($this->flags)) . $this->flags;
|
|
$data .= chr(strlen($this->services)) . $this->services;
|
|
$data .= chr(strlen($this->regexp)) . $this->regexp;
|
|
|
|
$packet->offset += strlen($data);
|
|
|
|
$data .= $packet->compress($this->replacement, $packet->offset);
|
|
|
|
return $data;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_RR_NID extends Net_DNS2_RR
|
|
{
|
|
|
|
public $preference;
|
|
|
|
public $nodeid;
|
|
|
|
protected function rrToString()
|
|
{
|
|
return $this->preference . ' ' . $this->nodeid;
|
|
}
|
|
|
|
protected function rrFromString(array $rdata)
|
|
{
|
|
$this->preference = array_shift($rdata);
|
|
$this->nodeid = array_shift($rdata);
|
|
|
|
return true;
|
|
}
|
|
|
|
protected function rrSet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if ($this->rdlength > 0) {
|
|
|
|
//
|
|
|
|
//
|
|
$x = unpack('npreference/n4nodeid', $this->rdata);
|
|
|
|
$this->preference = $x['preference'];
|
|
|
|
//
|
|
|
|
//
|
|
$this->nodeid = dechex($x['nodeid1']) . ':' .
|
|
dechex($x['nodeid2']) . ':' .
|
|
dechex($x['nodeid3']) . ':' .
|
|
dechex($x['nodeid4']);
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected function rrGet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if (strlen($this->nodeid) > 0) {
|
|
|
|
//
|
|
|
|
//
|
|
$n = explode(':', $this->nodeid);
|
|
|
|
//
|
|
|
|
//
|
|
return pack(
|
|
'n5', $this->preference, hexdec($n[0]), hexdec($n[1]),
|
|
hexdec($n[2]), hexdec($n[3])
|
|
);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_RR_NIMLOCK extends Net_DNS2_RR
|
|
{
|
|
|
|
protected function rrToString()
|
|
{
|
|
return '';
|
|
}
|
|
|
|
protected function rrFromString(array $rdata)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
protected function rrSet(Net_DNS2_Packet &$packet)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
protected function rrGet(Net_DNS2_Packet &$packet)
|
|
{
|
|
return $this->rdata;
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_RR_NS extends Net_DNS2_RR
|
|
{
|
|
|
|
public $nsdname;
|
|
|
|
protected function rrToString()
|
|
{
|
|
return $this->cleanString($this->nsdname) . '.';
|
|
}
|
|
|
|
protected function rrFromString(array $rdata)
|
|
{
|
|
$this->nsdname = $this->cleanString(array_shift($rdata));
|
|
return true;
|
|
}
|
|
|
|
protected function rrSet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if ($this->rdlength > 0) {
|
|
|
|
$offset = $packet->offset;
|
|
$this->nsdname = Net_DNS2_Packet::expand($packet, $offset);
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected function rrGet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if (strlen($this->nsdname) > 0) {
|
|
|
|
return $packet->compress($this->nsdname, $packet->offset);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_RR_NSAP extends Net_DNS2_RR
|
|
{
|
|
public $afi;
|
|
public $idi;
|
|
public $dfi;
|
|
public $aa;
|
|
public $rsvd;
|
|
public $rd;
|
|
public $area;
|
|
public $id;
|
|
public $sel;
|
|
|
|
protected function rrToString()
|
|
{
|
|
return $this->cleanString($this->afi) . '.' .
|
|
$this->cleanString($this->idi) . '.' .
|
|
$this->cleanString($this->dfi) . '.' .
|
|
$this->cleanString($this->aa) . '.' .
|
|
$this->cleanString($this->rsvd) . '.' .
|
|
$this->cleanString($this->rd) . '.' .
|
|
$this->cleanString($this->area) . '.' .
|
|
$this->cleanString($this->id) . '.' .
|
|
$this->sel;
|
|
}
|
|
|
|
protected function rrFromString(array $rdata)
|
|
{
|
|
$data = strtolower(trim(array_shift($rdata)));
|
|
|
|
//
|
|
|
|
//
|
|
$data = str_replace(array('.', '0x'), '', $data);
|
|
|
|
//
|
|
|
|
//
|
|
$x = unpack('A2afi/A4idi/A2dfi/A6aa/A4rsvd/A4rd/A4area/A12id/A2sel', $data);
|
|
|
|
//
|
|
|
|
//
|
|
if ($x['afi'] == 47) {
|
|
|
|
$this->afi = '0x' . $x['afi'];
|
|
$this->idi = $x['idi'];
|
|
$this->dfi = $x['dfi'];
|
|
$this->aa = $x['aa'];
|
|
$this->rsvd = $x['rsvd'];
|
|
$this->rd = $x['rd'];
|
|
$this->area = $x['area'];
|
|
$this->id = $x['id'];
|
|
$this->sel = $x['sel'];
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected function rrSet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if ($this->rdlength == 20) {
|
|
|
|
//
|
|
|
|
//
|
|
$this->afi = dechex(ord($this->rdata[0]));
|
|
|
|
//
|
|
|
|
//
|
|
if ($this->afi == 47) {
|
|
|
|
//
|
|
|
|
//
|
|
$x = unpack(
|
|
'Cafi/nidi/Cdfi/C3aa/nrsvd/nrd/narea/Nidh/nidl/Csel',
|
|
$this->rdata
|
|
);
|
|
|
|
$this->afi = sprintf('0x%02x', $x['afi']);
|
|
$this->idi = sprintf('%04x', $x['idi']);
|
|
$this->dfi = sprintf('%02x', $x['dfi']);
|
|
$this->aa = sprintf(
|
|
'%06x', $x['aa1'] << 16 | $x['aa2'] << 8 | $x['aa3']
|
|
);
|
|
$this->rsvd = sprintf('%04x', $x['rsvd']);
|
|
$this->rd = sprintf('%04x', $x['rd']);
|
|
$this->area = sprintf('%04x', $x['area']);
|
|
$this->id = sprintf('%08x', $x['idh']) .
|
|
sprintf('%04x', $x['idl']);
|
|
$this->sel = sprintf('%02x', $x['sel']);
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected function rrGet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if ($this->afi == 0x47) {
|
|
|
|
//
|
|
|
|
//
|
|
$aa = unpack('A2x/A2y/A2z', $this->aa);
|
|
|
|
//
|
|
|
|
//
|
|
$id = unpack('A8a/A4b', $this->id);
|
|
|
|
//
|
|
$data = pack(
|
|
'CnCCCCnnnNnC',
|
|
hexdec($this->afi),
|
|
hexdec($this->idi),
|
|
hexdec($this->dfi),
|
|
hexdec($aa['x']),
|
|
hexdec($aa['y']),
|
|
hexdec($aa['z']),
|
|
hexdec($this->rsvd),
|
|
hexdec($this->rd),
|
|
hexdec($this->area),
|
|
hexdec($id['a']),
|
|
hexdec($id['b']),
|
|
hexdec($this->sel)
|
|
);
|
|
|
|
if (strlen($data) == 20) {
|
|
|
|
$packet->offset += 20;
|
|
return $data;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_RR_NSEC extends Net_DNS2_RR
|
|
{
|
|
|
|
public $next_domain_name;
|
|
|
|
public $type_bit_maps = array();
|
|
|
|
protected function rrToString()
|
|
{
|
|
$data = $this->cleanString($this->next_domain_name) . '.';
|
|
|
|
foreach ($this->type_bit_maps as $rr) {
|
|
|
|
$data .= ' ' . $rr;
|
|
}
|
|
|
|
return $data;
|
|
}
|
|
|
|
protected function rrFromString(array $rdata)
|
|
{
|
|
$this->next_domain_name = $this->cleanString(array_shift($rdata));
|
|
$this->type_bit_maps = $rdata;
|
|
|
|
return true;
|
|
}
|
|
|
|
protected function rrSet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if ($this->rdlength > 0) {
|
|
|
|
//
|
|
|
|
//
|
|
$offset = $packet->offset;
|
|
$this->next_domain_name = Net_DNS2_Packet::expand($packet, $offset);
|
|
|
|
//
|
|
|
|
//
|
|
$this->type_bit_maps = Net_DNS2_BitMap::bitMapToArray(
|
|
substr($this->rdata, $offset - $packet->offset)
|
|
);
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected function rrGet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if (strlen($this->next_domain_name) > 0) {
|
|
|
|
$data = $packet->compress($this->next_domain_name, $packet->offset);
|
|
$bitmap = Net_DNS2_BitMap::arrayToBitMap($this->type_bit_maps);
|
|
|
|
$packet->offset += strlen($bitmap);
|
|
|
|
return $data . $bitmap;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_RR_NSEC3 extends Net_DNS2_RR
|
|
{
|
|
|
|
public $algorithm;
|
|
|
|
public $flags;
|
|
|
|
public $iterations;
|
|
|
|
public $salt_length;
|
|
|
|
public $salt;
|
|
|
|
public $hash_length;
|
|
|
|
public $hashed_owner_name;
|
|
|
|
public $type_bit_maps = array();
|
|
|
|
protected function rrToString()
|
|
{
|
|
$out = $this->algorithm . ' ' . $this->flags . ' ' . $this->iterations . ' ';
|
|
|
|
//
|
|
|
|
//
|
|
if ($this->salt_length > 0) {
|
|
|
|
$out .= $this->salt;
|
|
} else {
|
|
|
|
$out .= '-';
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
$out .= ' ' . $this->hashed_owner_name;
|
|
|
|
//
|
|
|
|
//
|
|
foreach ($this->type_bit_maps as $rr) {
|
|
|
|
$out .= ' ' . strtoupper($rr);
|
|
}
|
|
|
|
return $out;
|
|
}
|
|
|
|
protected function rrFromString(array $rdata)
|
|
{
|
|
$this->algorithm = array_shift($rdata);
|
|
$this->flags = array_shift($rdata);
|
|
$this->iterations = array_shift($rdata);
|
|
|
|
//
|
|
|
|
//
|
|
$salt = array_shift($rdata);
|
|
if ($salt == '-') {
|
|
|
|
$this->salt_length = 0;
|
|
$this->salt = '';
|
|
} else {
|
|
|
|
$this->salt_length = strlen(pack('H*', $salt));
|
|
$this->salt = strtoupper($salt);
|
|
}
|
|
|
|
$this->hashed_owner_name = array_shift($rdata);
|
|
$this->hash_length = strlen(base64_decode($this->hashed_owner_name));
|
|
|
|
$this->type_bit_maps = $rdata;
|
|
|
|
return true;
|
|
}
|
|
|
|
protected function rrSet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if ($this->rdlength > 0) {
|
|
|
|
//
|
|
|
|
//
|
|
$x = unpack('Calgorithm/Cflags/niterations/Csalt_length', $this->rdata);
|
|
|
|
$this->algorithm = $x['algorithm'];
|
|
$this->flags = $x['flags'];
|
|
$this->iterations = $x['iterations'];
|
|
$this->salt_length = $x['salt_length'];
|
|
|
|
$offset = 5;
|
|
|
|
if ($this->salt_length > 0) {
|
|
|
|
$x = unpack('H*', substr($this->rdata, $offset, $this->salt_length));
|
|
$this->salt = strtoupper($x[1]);
|
|
$offset += $this->salt_length;
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
$x = unpack('@' . $offset . '/Chash_length', $this->rdata);
|
|
$offset++;
|
|
|
|
//
|
|
|
|
//
|
|
$this->hash_length = $x['hash_length'];
|
|
if ($this->hash_length > 0) {
|
|
|
|
$this->hashed_owner_name = base64_encode(
|
|
substr($this->rdata, $offset, $this->hash_length)
|
|
);
|
|
$offset += $this->hash_length;
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
$this->type_bit_maps = Net_DNS2_BitMap::bitMapToArray(
|
|
substr($this->rdata, $offset)
|
|
);
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected function rrGet(Net_DNS2_Packet &$packet)
|
|
{
|
|
//
|
|
|
|
//
|
|
$salt = pack('H*', $this->salt);
|
|
$this->salt_length = strlen($salt);
|
|
|
|
//
|
|
|
|
//
|
|
$data = pack(
|
|
'CCnC',
|
|
$this->algorithm, $this->flags, $this->iterations, $this->salt_length
|
|
);
|
|
$data .= $salt;
|
|
|
|
//
|
|
|
|
//
|
|
$data .= chr($this->hash_length);
|
|
if ($this->hash_length > 0) {
|
|
|
|
$data .= base64_decode($this->hashed_owner_name);
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
$data .= Net_DNS2_BitMap::arrayToBitMap($this->type_bit_maps);
|
|
|
|
$packet->offset += strlen($data);
|
|
|
|
return $data;
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_RR_NSEC3PARAM extends Net_DNS2_RR
|
|
{
|
|
|
|
public $algorithm;
|
|
|
|
public $flags;
|
|
|
|
public $iterations;
|
|
|
|
public $salt_length;
|
|
|
|
public $salt;
|
|
|
|
protected function rrToString()
|
|
{
|
|
$out = $this->algorithm . ' ' . $this->flags . ' ' . $this->iterations . ' ';
|
|
|
|
//
|
|
|
|
//
|
|
if ($this->salt_length > 0) {
|
|
|
|
$out .= $this->salt;
|
|
} else {
|
|
|
|
$out .= '-';
|
|
}
|
|
|
|
return $out;
|
|
}
|
|
|
|
protected function rrFromString(array $rdata)
|
|
{
|
|
$this->algorithm = array_shift($rdata);
|
|
$this->flags = array_shift($rdata);
|
|
$this->iterations = array_shift($rdata);
|
|
|
|
$salt = array_shift($rdata);
|
|
if ($salt == '-') {
|
|
|
|
$this->salt_length = 0;
|
|
$this->salt = '';
|
|
} else {
|
|
|
|
$this->salt_length = strlen(pack('H*', $salt));
|
|
$this->salt = strtoupper($salt);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
protected function rrSet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if ($this->rdlength > 0) {
|
|
|
|
$x = unpack('Calgorithm/Cflags/niterations/Csalt_length', $this->rdata);
|
|
|
|
$this->algorithm = $x['algorithm'];
|
|
$this->flags = $x['flags'];
|
|
$this->iterations = $x['iterations'];
|
|
$this->salt_length = $x['salt_length'];
|
|
|
|
if ($this->salt_length > 0) {
|
|
|
|
$x = unpack('H*', substr($this->rdata, 5, $this->salt_length));
|
|
$this->salt = strtoupper($x[1]);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected function rrGet(Net_DNS2_Packet &$packet)
|
|
{
|
|
$salt = pack('H*', $this->salt);
|
|
$this->salt_length = strlen($salt);
|
|
|
|
$data = pack(
|
|
'CCnC',
|
|
$this->algorithm, $this->flags, $this->iterations, $this->salt_length
|
|
) . $salt;
|
|
|
|
$packet->offset += strlen($data);
|
|
|
|
return $data;
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_RR_OPENPGPKEY extends Net_DNS2_RR
|
|
{
|
|
|
|
public $key;
|
|
|
|
protected function rrToString()
|
|
{
|
|
return $this->key;
|
|
}
|
|
|
|
protected function rrFromString(array $rdata)
|
|
{
|
|
$this->key = array_shift($rdata);
|
|
|
|
return true;
|
|
}
|
|
|
|
protected function rrSet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if ($this->rdlength > 0) {
|
|
|
|
$this->key = base64_encode($this->rdata);
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected function rrGet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if (strlen($this->key) > 0) {
|
|
|
|
$data = base64_decode($this->key);
|
|
|
|
$packet->offset += strlen($data);
|
|
|
|
return $data;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_RR_OPT extends Net_DNS2_RR
|
|
{
|
|
|
|
public $option_code;
|
|
|
|
public $option_length;
|
|
|
|
public $option_data;
|
|
|
|
public $extended_rcode;
|
|
|
|
public $version;
|
|
|
|
public $do;
|
|
|
|
public $z;
|
|
|
|
public function __construct(Net_DNS2_Packet &$packet = null, array $rr = null)
|
|
{
|
|
//
|
|
|
|
//
|
|
$this->type = 'OPT';
|
|
$this->rdlength = 0;
|
|
|
|
$this->option_length = 0;
|
|
$this->extended_rcode = 0;
|
|
$this->version = 0;
|
|
$this->do = 0;
|
|
$this->z = 0;
|
|
|
|
//
|
|
|
|
//
|
|
if ( (!is_null($packet)) && (!is_null($rr)) ) {
|
|
|
|
parent::__construct($packet, $rr);
|
|
}
|
|
}
|
|
|
|
protected function rrToString()
|
|
{
|
|
return $this->option_code . ' ' . $this->option_data;
|
|
}
|
|
|
|
protected function rrFromString(array $rdata)
|
|
{
|
|
$this->option_code = array_shift($rdata);
|
|
$this->option_data = array_shift($rdata);
|
|
$this->option_length = strlen($this->option_data);
|
|
|
|
$x = unpack('Cextended/Cversion/Cdo/Cz', pack('N', $this->ttl));
|
|
|
|
$this->extended_rcode = $x['extended'];
|
|
$this->version = $x['version'];
|
|
$this->do = ($x['do'] >> 7);
|
|
$this->z = $x['z'];
|
|
|
|
return true;
|
|
}
|
|
|
|
protected function rrSet(Net_DNS2_Packet &$packet)
|
|
{
|
|
//
|
|
|
|
//
|
|
$x = unpack('Cextended/Cversion/Cdo/Cz', pack('N', $this->ttl));
|
|
|
|
$this->extended_rcode = $x['extended'];
|
|
$this->version = $x['version'];
|
|
$this->do = ($x['do'] >> 7);
|
|
$this->z = $x['z'];
|
|
|
|
//
|
|
|
|
//
|
|
if ($this->rdlength > 0) {
|
|
|
|
//
|
|
|
|
//
|
|
$x = unpack('noption_code/noption_length', $this->rdata);
|
|
|
|
$this->option_code = $x['option_code'];
|
|
$this->option_length = $x['option_length'];
|
|
|
|
//
|
|
|
|
//
|
|
$this->option_data = substr($this->rdata, 4);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
protected function preBuild()
|
|
{
|
|
//
|
|
|
|
//
|
|
$ttl = unpack(
|
|
'N',
|
|
pack('CCCC', $this->extended_rcode, $this->version, ($this->do << 7), 0)
|
|
);
|
|
|
|
$this->ttl = $ttl[1];
|
|
|
|
return;
|
|
}
|
|
|
|
protected function rrGet(Net_DNS2_Packet &$packet)
|
|
{
|
|
//
|
|
|
|
//
|
|
if ($this->option_code) {
|
|
|
|
$data = pack('nn', $this->option_code, $this->option_length) .
|
|
$this->option_data;
|
|
|
|
$packet->offset += strlen($data);
|
|
|
|
return $data;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_RR_PTR extends Net_DNS2_RR
|
|
{
|
|
|
|
public $ptrdname;
|
|
|
|
protected function rrToString()
|
|
{
|
|
return rtrim($this->ptrdname, '.') . '.';
|
|
}
|
|
|
|
protected function rrFromString(array $rdata)
|
|
{
|
|
$this->ptrdname = rtrim(implode(' ', $rdata), '.');
|
|
return true;
|
|
}
|
|
|
|
protected function rrSet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if ($this->rdlength > 0) {
|
|
|
|
$offset = $packet->offset;
|
|
$this->ptrdname = Net_DNS2_Packet::expand($packet, $offset);
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected function rrGet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if (strlen($this->ptrdname) > 0) {
|
|
|
|
return $packet->compress($this->ptrdname, $packet->offset);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_RR_PX extends Net_DNS2_RR
|
|
{
|
|
|
|
public $preference;
|
|
|
|
public $map822;
|
|
|
|
public $mapx400;
|
|
|
|
protected function rrToString()
|
|
{
|
|
return $this->preference . ' ' . $this->cleanString($this->map822) . '. ' .
|
|
$this->cleanString($this->mapx400) . '.';
|
|
}
|
|
|
|
protected function rrFromString(array $rdata)
|
|
{
|
|
$this->preference = $rdata[0];
|
|
$this->map822 = $this->cleanString($rdata[1]);
|
|
$this->mapx400 = $this->cleanString($rdata[2]);
|
|
|
|
return true;
|
|
}
|
|
|
|
protected function rrSet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if ($this->rdlength > 0) {
|
|
|
|
//
|
|
|
|
//
|
|
$x = unpack('npreference', $this->rdata);
|
|
$this->preference = $x['preference'];
|
|
|
|
$offset = $packet->offset + 2;
|
|
|
|
$this->map822 = Net_DNS2_Packet::expand($packet, $offset);
|
|
$this->mapx400 = Net_DNS2_Packet::expand($packet, $offset);
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected function rrGet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if (strlen($this->map822) > 0) {
|
|
|
|
$data = pack('n', $this->preference);
|
|
$packet->offset += 2;
|
|
|
|
$data .= $packet->compress($this->map822, $packet->offset);
|
|
$data .= $packet->compress($this->mapx400, $packet->offset);
|
|
|
|
return $data;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_RR_RP extends Net_DNS2_RR
|
|
{
|
|
|
|
public $mboxdname;
|
|
|
|
public $txtdname;
|
|
|
|
protected function rrToString()
|
|
{
|
|
return $this->cleanString($this->mboxdname) . '. ' .
|
|
$this->cleanString($this->txtdname) . '.';
|
|
}
|
|
|
|
protected function rrFromString(array $rdata)
|
|
{
|
|
$this->mboxdname = $this->cleanString($rdata[0]);
|
|
$this->txtdname = $this->cleanString($rdata[1]);
|
|
|
|
return true;
|
|
}
|
|
|
|
protected function rrSet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if ($this->rdlength > 0) {
|
|
|
|
$offset = $packet->offset;
|
|
|
|
$this->mboxdname = Net_DNS2_Packet::expand($packet, $offset);
|
|
$this->txtdname = Net_DNS2_Packet::expand($packet, $offset);
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected function rrGet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if (strlen($this->mboxdname) > 0) {
|
|
|
|
return $packet->compress($this->mboxdname, $packet->offset) .
|
|
$packet->compress($this->txtdname, $packet->offset);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_RR_RRSIG extends Net_DNS2_RR
|
|
{
|
|
|
|
public $typecovered;
|
|
|
|
public $algorithm;
|
|
|
|
public $labels;
|
|
|
|
public $origttl;
|
|
|
|
public $sigexp;
|
|
|
|
public $sigincep;
|
|
|
|
public $keytag;
|
|
|
|
public $signname;
|
|
|
|
public $signature;
|
|
|
|
protected function rrToString()
|
|
{
|
|
return $this->typecovered . ' ' . $this->algorithm . ' ' .
|
|
$this->labels . ' ' . $this->origttl . ' ' .
|
|
$this->sigexp . ' ' . $this->sigincep . ' ' .
|
|
$this->keytag . ' ' . $this->cleanString($this->signname) . '. ' .
|
|
$this->signature;
|
|
}
|
|
|
|
protected function rrFromString(array $rdata)
|
|
{
|
|
$this->typecovered = strtoupper(array_shift($rdata));
|
|
$this->algorithm = array_shift($rdata);
|
|
$this->labels = array_shift($rdata);
|
|
$this->origttl = array_shift($rdata);
|
|
$this->sigexp = array_shift($rdata);
|
|
$this->sigincep = array_shift($rdata);
|
|
$this->keytag = array_shift($rdata);
|
|
$this->signname = $this->cleanString(array_shift($rdata));
|
|
|
|
foreach ($rdata as $line) {
|
|
|
|
$this->signature .= $line;
|
|
}
|
|
|
|
$this->signature = trim($this->signature);
|
|
|
|
return true;
|
|
}
|
|
|
|
protected function rrSet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if ($this->rdlength > 0) {
|
|
|
|
//
|
|
|
|
//
|
|
$x = unpack(
|
|
'ntc/Calgorithm/Clabels/Norigttl/Nsigexp/Nsigincep/nkeytag',
|
|
$this->rdata
|
|
);
|
|
|
|
$this->typecovered = Net_DNS2_Lookups::$rr_types_by_id[$x['tc']];
|
|
$this->algorithm = $x['algorithm'];
|
|
$this->labels = $x['labels'];
|
|
$this->origttl = Net_DNS2::expandUint32($x['origttl']);
|
|
|
|
//
|
|
|
|
//
|
|
$this->sigexp = gmdate('YmdHis', $x['sigexp']);
|
|
$this->sigincep = gmdate('YmdHis', $x['sigincep']);
|
|
|
|
//
|
|
|
|
//
|
|
$this->keytag = $x['keytag'];
|
|
|
|
//
|
|
|
|
//
|
|
$offset = $packet->offset + 18;
|
|
$sigoffset = $offset;
|
|
|
|
$this->signname = strtolower(
|
|
Net_DNS2_Packet::expand($packet, $sigoffset)
|
|
);
|
|
$this->signature = base64_encode(
|
|
substr($this->rdata, 18 + ($sigoffset - $offset))
|
|
);
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected function rrGet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if (strlen($this->signature) > 0) {
|
|
|
|
//
|
|
|
|
//
|
|
preg_match(
|
|
'/(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})/', $this->sigexp, $e
|
|
);
|
|
preg_match(
|
|
'/(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})/', $this->sigincep, $i
|
|
);
|
|
|
|
//
|
|
|
|
//
|
|
$data = pack(
|
|
'nCCNNNn',
|
|
Net_DNS2_Lookups::$rr_types_by_name[$this->typecovered],
|
|
$this->algorithm,
|
|
$this->labels,
|
|
$this->origttl,
|
|
gmmktime($e[4], $e[5], $e[6], $e[2], $e[3], $e[1]),
|
|
gmmktime($i[4], $i[5], $i[6], $i[2], $i[3], $i[1]),
|
|
$this->keytag
|
|
);
|
|
|
|
//
|
|
|
|
//
|
|
$names = explode('.', strtolower($this->signname));
|
|
foreach ($names as $name) {
|
|
|
|
$data .= chr(strlen($name));
|
|
$data .= $name;
|
|
}
|
|
$data .= "\0";
|
|
|
|
//
|
|
|
|
//
|
|
$data .= base64_decode($this->signature);
|
|
|
|
$packet->offset += strlen($data);
|
|
|
|
return $data;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_RR_RT extends Net_DNS2_RR
|
|
{
|
|
|
|
public $preference;
|
|
|
|
public $intermediatehost;
|
|
|
|
protected function rrToString()
|
|
{
|
|
return $this->preference . ' ' .
|
|
$this->cleanString($this->intermediatehost) . '.';
|
|
}
|
|
|
|
protected function rrFromString(array $rdata)
|
|
{
|
|
$this->preference = $rdata[0];
|
|
$this->intermediatehost = $this->cleanString($rdata[1]);
|
|
|
|
return true;
|
|
}
|
|
|
|
protected function rrSet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if ($this->rdlength > 0) {
|
|
|
|
//
|
|
|
|
//
|
|
$x = unpack('npreference', $this->rdata);
|
|
|
|
$this->preference = $x['preference'];
|
|
$offset = $packet->offset + 2;
|
|
|
|
$this->intermediatehost = Net_DNS2_Packet::expand($packet, $offset);
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected function rrGet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if (strlen($this->intermediatehost) > 0) {
|
|
|
|
$data = pack('n', $this->preference);
|
|
$packet->offset += 2;
|
|
|
|
$data .= $packet->compress($this->intermediatehost, $packet->offset);
|
|
|
|
return $data;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_RR_SIG extends Net_DNS2_RR
|
|
{
|
|
|
|
public $private_key = null;
|
|
|
|
public $typecovered;
|
|
|
|
public $algorithm;
|
|
|
|
public $labels;
|
|
|
|
public $origttl;
|
|
|
|
public $sigexp;
|
|
|
|
public $sigincep;
|
|
|
|
public $keytag;
|
|
|
|
public $signname;
|
|
|
|
public $signature;
|
|
|
|
protected function rrToString()
|
|
{
|
|
return $this->typecovered . ' ' . $this->algorithm . ' ' .
|
|
$this->labels . ' ' . $this->origttl . ' ' .
|
|
$this->sigexp . ' ' . $this->sigincep . ' ' .
|
|
$this->keytag . ' ' . $this->cleanString($this->signname) . '. ' .
|
|
$this->signature;
|
|
}
|
|
|
|
protected function rrFromString(array $rdata)
|
|
{
|
|
$this->typecovered = strtoupper(array_shift($rdata));
|
|
$this->algorithm = array_shift($rdata);
|
|
$this->labels = array_shift($rdata);
|
|
$this->origttl = array_shift($rdata);
|
|
$this->sigexp = array_shift($rdata);
|
|
$this->sigincep = array_shift($rdata);
|
|
$this->keytag = array_shift($rdata);
|
|
$this->signname = $this->cleanString(array_shift($rdata));
|
|
|
|
foreach ($rdata as $line) {
|
|
|
|
$this->signature .= $line;
|
|
}
|
|
|
|
$this->signature = trim($this->signature);
|
|
|
|
return true;
|
|
}
|
|
|
|
protected function rrSet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if ($this->rdlength > 0) {
|
|
|
|
//
|
|
|
|
//
|
|
$x = unpack(
|
|
'ntc/Calgorithm/Clabels/Norigttl/Nsigexp/Nsigincep/nkeytag',
|
|
$this->rdata
|
|
);
|
|
|
|
$this->typecovered = Net_DNS2_Lookups::$rr_types_by_id[$x['tc']];
|
|
$this->algorithm = $x['algorithm'];
|
|
$this->labels = $x['labels'];
|
|
$this->origttl = Net_DNS2::expandUint32($x['origttl']);
|
|
|
|
//
|
|
|
|
//
|
|
$this->sigexp = gmdate('YmdHis', $x['sigexp']);
|
|
$this->sigincep = gmdate('YmdHis', $x['sigincep']);
|
|
|
|
//
|
|
|
|
//
|
|
$this->keytag = $x['keytag'];
|
|
|
|
//
|
|
|
|
//
|
|
$offset = $packet->offset + 18;
|
|
$sigoffset = $offset;
|
|
|
|
$this->signname = strtolower(
|
|
Net_DNS2_Packet::expand($packet, $sigoffset)
|
|
);
|
|
$this->signature = base64_encode(
|
|
substr($this->rdata, 18 + ($sigoffset - $offset))
|
|
);
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected function rrGet(Net_DNS2_Packet &$packet)
|
|
{
|
|
//
|
|
|
|
//
|
|
preg_match(
|
|
'/(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})/', $this->sigexp, $e
|
|
);
|
|
preg_match(
|
|
'/(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})/', $this->sigincep, $i
|
|
);
|
|
|
|
//
|
|
|
|
//
|
|
$data = pack(
|
|
'nCCNNNn',
|
|
Net_DNS2_Lookups::$rr_types_by_name[$this->typecovered],
|
|
$this->algorithm,
|
|
$this->labels,
|
|
$this->origttl,
|
|
gmmktime($e[4], $e[5], $e[6], $e[2], $e[3], $e[1]),
|
|
gmmktime($i[4], $i[5], $i[6], $i[2], $i[3], $i[1]),
|
|
$this->keytag
|
|
);
|
|
|
|
//
|
|
|
|
//
|
|
$names = explode('.', strtolower($this->signname));
|
|
foreach ($names as $name) {
|
|
|
|
$data .= chr(strlen($name));
|
|
$data .= $name;
|
|
}
|
|
|
|
$data .= chr('0');
|
|
|
|
//
|
|
|
|
//
|
|
if ( (strlen($this->signature) == 0)
|
|
&& ($this->private_key instanceof Net_DNS2_PrivateKey)
|
|
&& (extension_loaded('openssl') === true)
|
|
) {
|
|
|
|
//
|
|
|
|
//
|
|
$new_packet = new Net_DNS2_Packet_Request('example.com', 'SOA', 'IN');
|
|
|
|
//
|
|
|
|
//
|
|
$new_packet->copy($packet);
|
|
|
|
//
|
|
|
|
//
|
|
array_pop($new_packet->additional);
|
|
$new_packet->header->arcount = count($new_packet->additional);
|
|
|
|
//
|
|
|
|
//
|
|
$sigdata = $data . $new_packet->get();
|
|
|
|
//
|
|
|
|
//
|
|
$algorithm = 0;
|
|
|
|
switch($this->algorithm) {
|
|
|
|
//
|
|
|
|
//
|
|
case Net_DNS2_Lookups::DNSSEC_ALGORITHM_RSAMD5:
|
|
|
|
$algorithm = OPENSSL_ALGO_MD5;
|
|
break;
|
|
|
|
//
|
|
|
|
//
|
|
case Net_DNS2_Lookups::DNSSEC_ALGORITHM_RSASHA1:
|
|
|
|
$algorithm = OPENSSL_ALGO_SHA1;
|
|
break;
|
|
|
|
//
|
|
|
|
//
|
|
case Net_DNS2_Lookups::DNSSEC_ALGORITHM_RSASHA256:
|
|
|
|
if (version_compare(PHP_VERSION, '5.4.8', '<') == true) {
|
|
|
|
throw new Net_DNS2_Exception(
|
|
'SHA256 support is only available in PHP >= 5.4.8',
|
|
Net_DNS2_Lookups::E_OPENSSL_INV_ALGO
|
|
);
|
|
}
|
|
|
|
$algorithm = OPENSSL_ALGO_SHA256;
|
|
break;
|
|
|
|
//
|
|
|
|
//
|
|
case Net_DNS2_Lookups::DNSSEC_ALGORITHM_RSASHA512:
|
|
|
|
if (version_compare(PHP_VERSION, '5.4.8', '<') == true) {
|
|
|
|
throw new Net_DNS2_Exception(
|
|
'SHA512 support is only available in PHP >= 5.4.8',
|
|
Net_DNS2_Lookups::E_OPENSSL_INV_ALGO
|
|
);
|
|
}
|
|
|
|
$algorithm = OPENSSL_ALGO_SHA512;
|
|
break;
|
|
|
|
//
|
|
|
|
//
|
|
case Net_DNS2_Lookups::DNSSEC_ALGORITHM_DSA:
|
|
case Net_DNS2_Lookups::DSNSEC_ALGORITHM_RSASHA1NSEC3SHA1:
|
|
case Net_DNS2_Lookups::DNSSEC_ALGORITHM_DSANSEC3SHA1:
|
|
default:
|
|
throw new Net_DNS2_Exception(
|
|
'invalid or unsupported algorithm',
|
|
Net_DNS2_Lookups::E_OPENSSL_INV_ALGO
|
|
);
|
|
break;
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
if (openssl_sign($sigdata, $this->signature, $this->private_key->instance, $algorithm) == false) {
|
|
|
|
throw new Net_DNS2_Exception(
|
|
openssl_error_string(),
|
|
Net_DNS2_Lookups::E_OPENSSL_ERROR
|
|
);
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
switch($this->algorithm) {
|
|
|
|
//
|
|
|
|
//
|
|
case Net_DNS2_Lookups::DNSSEC_ALGORITHM_RSAMD5:
|
|
case Net_DNS2_Lookups::DNSSEC_ALGORITHM_RSASHA1:
|
|
case Net_DNS2_Lookups::DNSSEC_ALGORITHM_RSASHA256:
|
|
case Net_DNS2_Lookups::DNSSEC_ALGORITHM_RSASHA512:
|
|
|
|
$this->signature = base64_encode($this->signature);
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
$data .= base64_decode($this->signature);
|
|
|
|
$packet->offset += strlen($data);
|
|
|
|
return $data;
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_RR_SOA extends Net_DNS2_RR
|
|
{
|
|
|
|
public $mname;
|
|
|
|
public $rname;
|
|
|
|
public $serial;
|
|
|
|
public $refresh;
|
|
|
|
public $retry;
|
|
|
|
public $expire;
|
|
|
|
public $minimum;
|
|
|
|
protected function rrToString()
|
|
{
|
|
return $this->cleanString($this->mname) . '. ' .
|
|
$this->cleanString($this->rname) . '. ' .
|
|
$this->serial . ' ' . $this->refresh . ' ' . $this->retry . ' ' .
|
|
$this->expire . ' ' . $this->minimum;
|
|
}
|
|
|
|
protected function rrFromString(array $rdata)
|
|
{
|
|
$this->mname = $this->cleanString($rdata[0]);
|
|
$this->rname = $this->cleanString($rdata[1]);
|
|
|
|
$this->serial = $rdata[2];
|
|
$this->refresh = $rdata[3];
|
|
$this->retry = $rdata[4];
|
|
$this->expire = $rdata[5];
|
|
$this->minimum = $rdata[6];
|
|
|
|
return true;
|
|
}
|
|
|
|
protected function rrSet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if ($this->rdlength > 0) {
|
|
|
|
//
|
|
|
|
//
|
|
$offset = $packet->offset;
|
|
|
|
$this->mname = Net_DNS2_Packet::expand($packet, $offset);
|
|
$this->rname = Net_DNS2_Packet::expand($packet, $offset);
|
|
|
|
//
|
|
|
|
//
|
|
$x = unpack(
|
|
'@' . $offset . '/Nserial/Nrefresh/Nretry/Nexpire/Nminimum/',
|
|
$packet->rdata
|
|
);
|
|
|
|
$this->serial = Net_DNS2::expandUint32($x['serial']);
|
|
$this->refresh = Net_DNS2::expandUint32($x['refresh']);
|
|
$this->retry = Net_DNS2::expandUint32($x['retry']);
|
|
$this->expire = Net_DNS2::expandUint32($x['expire']);
|
|
$this->minimum = Net_DNS2::expandUint32($x['minimum']);
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected function rrGet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if (strlen($this->mname) > 0) {
|
|
|
|
$data = $packet->compress($this->mname, $packet->offset);
|
|
$data .= $packet->compress($this->rname, $packet->offset);
|
|
|
|
$data .= pack(
|
|
'N5', $this->serial, $this->refresh, $this->retry,
|
|
$this->expire, $this->minimum
|
|
);
|
|
|
|
$packet->offset += 20;
|
|
|
|
return $data;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_RR_SPF extends Net_DNS2_RR_TXT
|
|
{
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_RR_SRV extends Net_DNS2_RR
|
|
{
|
|
|
|
public $priority;
|
|
|
|
public $weight;
|
|
|
|
public $port;
|
|
|
|
public $target;
|
|
|
|
protected function rrToString()
|
|
{
|
|
return $this->priority . ' ' . $this->weight . ' ' .
|
|
$this->port . ' ' . $this->cleanString($this->target) . '.';
|
|
}
|
|
|
|
protected function rrFromString(array $rdata)
|
|
{
|
|
$this->priority = $rdata[0];
|
|
$this->weight = $rdata[1];
|
|
$this->port = $rdata[2];
|
|
|
|
$this->target = $this->cleanString($rdata[3]);
|
|
|
|
return true;
|
|
}
|
|
|
|
protected function rrSet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if ($this->rdlength > 0) {
|
|
|
|
//
|
|
|
|
//
|
|
$x = unpack('npriority/nweight/nport', $this->rdata);
|
|
|
|
$this->priority = $x['priority'];
|
|
$this->weight = $x['weight'];
|
|
$this->port = $x['port'];
|
|
|
|
$offset = $packet->offset + 6;
|
|
$this->target = Net_DNS2_Packet::expand($packet, $offset);
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected function rrGet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if (strlen($this->target) > 0) {
|
|
|
|
$data = pack('nnn', $this->priority, $this->weight, $this->port);
|
|
$packet->offset += 6;
|
|
|
|
$data .= $packet->compress($this->target, $packet->offset);
|
|
|
|
return $data;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_RR_SSHFP extends Net_DNS2_RR
|
|
{
|
|
|
|
public $algorithm;
|
|
|
|
public $fp_type;
|
|
|
|
public $fingerprint;
|
|
|
|
const SSHFP_ALGORITHM_RES = 0;
|
|
const SSHFP_ALGORITHM_RSA = 1;
|
|
const SSHFP_ALGORITHM_DSS = 2;
|
|
|
|
const SSHFP_FPTYPE_RES = 0;
|
|
const SSHFP_FPTYPE_SHA1 = 1;
|
|
|
|
protected function rrToString()
|
|
{
|
|
return $this->algorithm . ' ' . $this->fp_type . ' ' . $this->fingerprint;
|
|
}
|
|
|
|
protected function rrFromString(array $rdata)
|
|
{
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
$algorithm = array_shift($rdata);
|
|
$fp_type = array_shift($rdata);
|
|
$fingerprint = strtolower(implode('', $rdata));
|
|
|
|
//
|
|
|
|
//
|
|
if ( ($algorithm != self::SSHFP_ALGORITHM_RSA)
|
|
&& ($algorithm != self::SSHFP_ALGORITHM_DSS)
|
|
) {
|
|
return false;
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
if ($fp_type != self::SSHFP_FPTYPE_SHA1) {
|
|
return false;
|
|
}
|
|
|
|
$this->algorithm = $algorithm;
|
|
$this->fp_type = $fp_type;
|
|
$this->fingerprint = $fingerprint;
|
|
|
|
return true;
|
|
}
|
|
|
|
protected function rrSet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if ($this->rdlength > 0) {
|
|
|
|
//
|
|
|
|
//
|
|
$x = unpack('Calgorithm/Cfp_type', $this->rdata);
|
|
|
|
$this->algorithm = $x['algorithm'];
|
|
$this->fp_type = $x['fp_type'];
|
|
|
|
//
|
|
|
|
//
|
|
if ( ($this->algorithm != self::SSHFP_ALGORITHM_RSA)
|
|
&& ($this->algorithm != self::SSHFP_ALGORITHM_DSS)
|
|
) {
|
|
return false;
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
if ($this->fp_type != self::SSHFP_FPTYPE_SHA1) {
|
|
return false;
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
$fp = unpack('H*a', substr($this->rdata, 2));
|
|
$this->fingerprint = strtolower($fp['a']);
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected function rrGet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if (strlen($this->fingerprint) > 0) {
|
|
|
|
$data = pack(
|
|
'CCH*', $this->algorithm, $this->fp_type, $this->fingerprint
|
|
);
|
|
|
|
$packet->offset += strlen($data);
|
|
|
|
return $data;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_RR_TA extends Net_DNS2_RR_DS
|
|
{
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_RR_TALINK extends Net_DNS2_RR
|
|
{
|
|
|
|
public $previous;
|
|
|
|
public $next;
|
|
|
|
protected function rrToString()
|
|
{
|
|
return $this->cleanString($this->previous) . '. ' .
|
|
$this->cleanString($this->next) . '.';
|
|
}
|
|
|
|
protected function rrFromString(array $rdata)
|
|
{
|
|
$this->previous = $this->cleanString($rdata[0]);
|
|
$this->next = $this->cleanString($rdata[1]);
|
|
|
|
return true;
|
|
}
|
|
|
|
protected function rrSet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if ($this->rdlength > 0) {
|
|
|
|
$offset = $packet->offset;
|
|
|
|
$this->previous = Net_DNS2_Packet::label($packet, $offset);
|
|
$this->next = Net_DNS2_Packet::label($packet, $offset);
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected function rrGet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if ( (strlen($this->previous) > 0) || (strlen($this->next) > 0) ) {
|
|
|
|
$data = chr(strlen($this->previous)) . $this->previous .
|
|
chr(strlen($this->next)) . $this->next;
|
|
|
|
$packet->offset += strlen($data);
|
|
|
|
return $data;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_RR_TKEY extends Net_DNS2_RR
|
|
{
|
|
public $algorithm;
|
|
public $inception;
|
|
public $expiration;
|
|
public $mode;
|
|
public $error;
|
|
public $key_size;
|
|
public $key_data;
|
|
public $other_size;
|
|
public $other_data;
|
|
|
|
const TSIG_MODE_RES = 0;
|
|
const TSIG_MODE_SERV_ASSIGN = 1;
|
|
const TSIG_MODE_DH = 2;
|
|
const TSIG_MODE_GSS_API = 3;
|
|
const TSIG_MODE_RESV_ASSIGN = 4;
|
|
const TSIG_MODE_KEY_DELE = 5;
|
|
|
|
public $tsgi_mode_id_to_name = array(
|
|
|
|
self::TSIG_MODE_RES => 'Reserved',
|
|
self::TSIG_MODE_SERV_ASSIGN => 'Server Assignment',
|
|
self::TSIG_MODE_DH => 'Diffie-Hellman',
|
|
self::TSIG_MODE_GSS_API => 'GSS-API',
|
|
self::TSIG_MODE_RESV_ASSIGN => 'Resolver Assignment',
|
|
self::TSIG_MODE_KEY_DELE => 'Key Deletion'
|
|
);
|
|
|
|
protected function rrToString()
|
|
{
|
|
$out = $this->cleanString($this->algorithm) . '. ' . $this->mode;
|
|
if ($this->key_size > 0) {
|
|
|
|
$out .= ' ' . trim($this->key_data, '.') . '.';
|
|
} else {
|
|
|
|
$out .= ' .';
|
|
}
|
|
|
|
return $out;
|
|
}
|
|
|
|
protected function rrFromString(array $rdata)
|
|
{
|
|
//
|
|
|
|
//
|
|
$this->algorithm = $this->cleanString(array_shift($rdata));
|
|
$this->mode = array_shift($rdata);
|
|
$this->key_data = trim(array_shift($rdata), '.');
|
|
|
|
//
|
|
|
|
//
|
|
$this->inception = time();
|
|
$this->expiration = time() + 86400;
|
|
$this->error = 0;
|
|
$this->key_size = strlen($this->key_data);
|
|
$this->other_size = 0;
|
|
$this->other_data = '';
|
|
|
|
return true;
|
|
}
|
|
|
|
protected function rrSet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if ($this->rdlength > 0) {
|
|
|
|
//
|
|
|
|
//
|
|
$offset = $packet->offset;
|
|
$this->algorithm = Net_DNS2_Packet::expand($packet, $offset);
|
|
|
|
//
|
|
|
|
//
|
|
$x = unpack(
|
|
'@' . $offset . '/Ninception/Nexpiration/nmode/nerror/nkey_size',
|
|
$packet->rdata
|
|
);
|
|
|
|
$this->inception = Net_DNS2::expandUint32($x['inception']);
|
|
$this->expiration = Net_DNS2::expandUint32($x['expiration']);
|
|
$this->mode = $x['mode'];
|
|
$this->error = $x['error'];
|
|
$this->key_size = $x['key_size'];
|
|
|
|
$offset += 14;
|
|
|
|
//
|
|
|
|
//
|
|
if ($this->key_size > 0) {
|
|
|
|
$this->key_data = substr($packet->rdata, $offset, $this->key_size);
|
|
$offset += $this->key_size;
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
$x = unpack('@' . $offset . '/nother_size', $packet->rdata);
|
|
|
|
$this->other_size = $x['other_size'];
|
|
$offset += 2;
|
|
|
|
//
|
|
|
|
//
|
|
if ($this->other_size > 0) {
|
|
|
|
$this->other_data = substr(
|
|
$packet->rdata, $offset, $this->other_size
|
|
);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected function rrGet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if (strlen($this->algorithm) > 0) {
|
|
|
|
//
|
|
|
|
//
|
|
$this->key_size = strlen($this->key_data);
|
|
$this->other_size = strlen($this->other_data);
|
|
|
|
//
|
|
|
|
//
|
|
$data = Net_DNS2_Packet::pack($this->algorithm);
|
|
|
|
//
|
|
|
|
//
|
|
$data .= pack(
|
|
'NNnnn', $this->inception, $this->expiration,
|
|
$this->mode, 0, $this->key_size
|
|
);
|
|
|
|
//
|
|
|
|
//
|
|
if ($this->key_size > 0) {
|
|
|
|
$data .= $this->key_data;
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
$data .= pack('n', $this->other_size);
|
|
if ($this->other_size > 0) {
|
|
|
|
$data .= $this->other_data;
|
|
}
|
|
|
|
$packet->offset += strlen($data);
|
|
|
|
return $data;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_RR_TLSA extends Net_DNS2_RR
|
|
{
|
|
|
|
public $cert_usage;
|
|
|
|
public $selector;
|
|
|
|
public $matching_type;
|
|
|
|
public $certificate;
|
|
|
|
protected function rrToString()
|
|
{
|
|
return $this->cert_usage . ' ' . $this->selector . ' ' .
|
|
$this->matching_type . ' ' . base64_encode($this->certificate);
|
|
}
|
|
|
|
protected function rrFromString(array $rdata)
|
|
{
|
|
$this->cert_usage = array_shift($rdata);
|
|
$this->selector = array_shift($rdata);
|
|
$this->matching_type = array_shift($rdata);
|
|
$this->certificate = base64_decode(implode('', $rdata));
|
|
|
|
return true;
|
|
}
|
|
|
|
protected function rrSet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if ($this->rdlength > 0) {
|
|
|
|
//
|
|
|
|
//
|
|
$x = unpack('Cusage/Cselector/Ctype', $this->rdata);
|
|
|
|
$this->cert_usage = $x['usage'];
|
|
$this->selector = $x['selector'];
|
|
$this->matching_type = $x['type'];
|
|
|
|
//
|
|
|
|
//
|
|
$this->certificate = substr($this->rdata, 3, $this->rdlength - 3);
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected function rrGet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if (strlen($this->certificate) > 0) {
|
|
|
|
$data = pack(
|
|
'CCC', $this->cert_usage, $this->selector, $this->matching_type
|
|
) . $this->certificate;
|
|
|
|
$packet->offset += strlen($data);
|
|
|
|
return $data;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_RR_TSIG extends Net_DNS2_RR
|
|
{
|
|
|
|
const HMAC_MD5 = 'hmac-md5.sig-alg.reg.int';
|
|
const GSS_TSIG = 'gss-tsig';
|
|
const HMAC_SHA1 = 'hmac-sha1';
|
|
const HMAC_SHA224 = 'hmac-sha224';
|
|
const HMAC_SHA256 = 'hmac-sha256';
|
|
const HMAC_SHA384 = 'hmac-sha384';
|
|
const HMAC_SHA512 = 'hmac-sha512';
|
|
|
|
public static $hash_algorithms = array(
|
|
|
|
self::HMAC_MD5 => 'md5',
|
|
self::HMAC_SHA1 => 'sha1',
|
|
self::HMAC_SHA224 => 'sha224',
|
|
self::HMAC_SHA256 => 'sha256',
|
|
self::HMAC_SHA384 => 'sha384',
|
|
self::HMAC_SHA512 => 'sha512'
|
|
);
|
|
|
|
public $algorithm;
|
|
|
|
public $time_signed;
|
|
|
|
public $fudge;
|
|
|
|
public $mac_size;
|
|
|
|
public $mac;
|
|
|
|
public $original_id;
|
|
|
|
public $error;
|
|
|
|
public $other_length;
|
|
|
|
public $other_data;
|
|
|
|
public $key;
|
|
|
|
protected function rrToString()
|
|
{
|
|
$out = $this->cleanString($this->algorithm) . '. ' .
|
|
$this->time_signed . ' ' .
|
|
$this->fudge . ' ' . $this->mac_size . ' ' .
|
|
base64_encode($this->mac) . ' ' . $this->original_id . ' ' .
|
|
$this->error . ' '. $this->other_length;
|
|
|
|
if ($this->other_length > 0) {
|
|
|
|
$out .= ' ' . $this->other_data;
|
|
}
|
|
|
|
return $out;
|
|
}
|
|
|
|
protected function rrFromString(array $rdata)
|
|
{
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
$this->key = preg_replace('/\s+/', '', array_shift($rdata));
|
|
|
|
//
|
|
|
|
//
|
|
$this->algorithm = self::HMAC_MD5;
|
|
$this->time_signed = time();
|
|
$this->fudge = 300;
|
|
$this->mac_size = 0;
|
|
$this->mac = '';
|
|
$this->original_id = 0;
|
|
$this->error = 0;
|
|
$this->other_length = 0;
|
|
$this->other_data = '';
|
|
|
|
//
|
|
|
|
//
|
|
$this->class = 'ANY';
|
|
$this->ttl = 0;
|
|
|
|
return true;
|
|
}
|
|
|
|
protected function rrSet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if ($this->rdlength > 0) {
|
|
|
|
//
|
|
|
|
//
|
|
$newoffset = $packet->offset;
|
|
$this->algorithm = Net_DNS2_Packet::expand($packet, $newoffset);
|
|
$offset = $newoffset - $packet->offset;
|
|
|
|
//
|
|
|
|
//
|
|
$x = unpack(
|
|
'@' . $offset . '/ntime_high/Ntime_low/nfudge/nmac_size',
|
|
$this->rdata
|
|
);
|
|
|
|
$this->time_signed = Net_DNS2::expandUint32($x['time_low']);
|
|
$this->fudge = $x['fudge'];
|
|
$this->mac_size = $x['mac_size'];
|
|
|
|
$offset += 10;
|
|
|
|
//
|
|
|
|
//
|
|
if ($this->mac_size > 0) {
|
|
|
|
$this->mac = substr($this->rdata, $offset, $this->mac_size);
|
|
$offset += $this->mac_size;
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
$x = unpack(
|
|
'@' . $offset . '/noriginal_id/nerror/nother_length',
|
|
$this->rdata
|
|
);
|
|
|
|
$this->original_id = $x['original_id'];
|
|
$this->error = $x['error'];
|
|
$this->other_length = $x['other_length'];
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
if ($this->error == Net_DNS2_Lookups::RCODE_BADTIME) {
|
|
|
|
if ($this->other_length != 6) {
|
|
|
|
return false;
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
$x = unpack(
|
|
'nhigh/nlow',
|
|
substr($this->rdata, $offset + 6, $this->other_length)
|
|
);
|
|
$this->other_data = $x['low'];
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected function rrGet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if (strlen($this->key) > 0) {
|
|
|
|
//
|
|
|
|
//
|
|
$new_packet = new Net_DNS2_Packet_Request('example.com', 'SOA', 'IN');
|
|
|
|
//
|
|
|
|
//
|
|
$new_packet->copy($packet);
|
|
|
|
//
|
|
|
|
//
|
|
array_pop($new_packet->additional);
|
|
$new_packet->header->arcount = count($new_packet->additional);
|
|
|
|
//
|
|
|
|
//
|
|
$sig_data = $new_packet->get();
|
|
|
|
//
|
|
|
|
//
|
|
$sig_data .= Net_DNS2_Packet::pack($this->name);
|
|
|
|
//
|
|
|
|
//
|
|
$sig_data .= pack(
|
|
'nN', Net_DNS2_Lookups::$classes_by_name[$this->class], $this->ttl
|
|
);
|
|
|
|
//
|
|
|
|
//
|
|
$sig_data .= Net_DNS2_Packet::pack(strtolower($this->algorithm));
|
|
|
|
//
|
|
|
|
//
|
|
$sig_data .= pack(
|
|
'nNnnn', 0, $this->time_signed, $this->fudge,
|
|
$this->error, $this->other_length
|
|
);
|
|
if ($this->other_length > 0) {
|
|
|
|
$sig_data .= pack('nN', 0, $this->other_data);
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
$this->mac = $this->_signHMAC(
|
|
$sig_data, base64_decode($this->key), $this->algorithm
|
|
);
|
|
$this->mac_size = strlen($this->mac);
|
|
|
|
//
|
|
|
|
//
|
|
$data = Net_DNS2_Packet::pack(strtolower($this->algorithm));
|
|
|
|
//
|
|
|
|
//
|
|
$data .= pack(
|
|
'nNnn', 0, $this->time_signed, $this->fudge, $this->mac_size
|
|
);
|
|
$data .= $this->mac;
|
|
|
|
//
|
|
|
|
//
|
|
if ($this->error == Net_DNS2_Lookups::RCODE_BADTIME) {
|
|
|
|
$this->other_length = strlen($this->other_data);
|
|
if ($this->other_length != 6) {
|
|
|
|
return null;
|
|
}
|
|
} else {
|
|
|
|
$this->other_length = 0;
|
|
$this->other_data = '';
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
$data .= pack(
|
|
'nnn', $packet->header->id, $this->error, $this->other_length
|
|
);
|
|
if ($this->other_length > 0) {
|
|
|
|
$data .= pack('nN', 0, $this->other_data);
|
|
}
|
|
|
|
$packet->offset += strlen($data);
|
|
|
|
return $data;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private function _signHMAC($data, $key = null, $algorithm = self::HMAC_MD5)
|
|
{
|
|
//
|
|
|
|
//
|
|
if (extension_loaded('hash')) {
|
|
|
|
if (!isset(self::$hash_algorithms[$algorithm])) {
|
|
|
|
throw new Net_DNS2_Exception(
|
|
'invalid or unsupported algorithm',
|
|
Net_DNS2_Lookups::E_PARSE_ERROR
|
|
);
|
|
}
|
|
|
|
return hash_hmac(self::$hash_algorithms[$algorithm], $data, $key, true);
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
if ($algorithm != self::HMAC_MD5) {
|
|
|
|
throw new Net_DNS2_Exception(
|
|
'only HMAC-MD5 supported. please install the php-extension ' .
|
|
'"hash" in order to use the sha-family',
|
|
Net_DNS2_Lookups::E_PARSE_ERROR
|
|
);
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
if (is_null($key)) {
|
|
|
|
return pack('H*', md5($data));
|
|
}
|
|
|
|
$key = str_pad($key, 64, chr(0x00));
|
|
if (strlen($key) > 64) {
|
|
|
|
$key = pack('H*', md5($key));
|
|
}
|
|
|
|
$k_ipad = $key ^ str_repeat(chr(0x36), 64);
|
|
$k_opad = $key ^ str_repeat(chr(0x5c), 64);
|
|
|
|
return $this->_signHMAC(
|
|
$k_opad . pack('H*', md5($k_ipad . $data)), null, $algorithm
|
|
);
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_RR_TXT extends Net_DNS2_RR
|
|
{
|
|
|
|
public $text = array();
|
|
|
|
protected function rrToString()
|
|
{
|
|
if (count($this->text) == 0) {
|
|
return '""';
|
|
}
|
|
|
|
$data = '';
|
|
|
|
foreach ($this->text as $t) {
|
|
|
|
$data .= $this->formatString($t) . ' ';
|
|
}
|
|
|
|
return trim($data);
|
|
}
|
|
|
|
protected function rrFromString(array $rdata)
|
|
{
|
|
$data = $this->buildString($rdata);
|
|
if (count($data) > 0) {
|
|
|
|
$this->text = $data;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
protected function rrSet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if ($this->rdlength > 0) {
|
|
|
|
$length = $packet->offset + $this->rdlength;
|
|
$offset = $packet->offset;
|
|
|
|
while ($length > $offset) {
|
|
|
|
$this->text[] = Net_DNS2_Packet::label($packet, $offset);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected function rrGet(Net_DNS2_Packet &$packet)
|
|
{
|
|
$data = null;
|
|
|
|
foreach ($this->text as $t) {
|
|
|
|
$data .= chr(strlen($t)) . $t;
|
|
}
|
|
|
|
$packet->offset += strlen($data);
|
|
|
|
return $data;
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_RR_URI extends Net_DNS2_RR
|
|
{
|
|
|
|
public $priority;
|
|
|
|
public $weight;
|
|
|
|
public $target;
|
|
|
|
protected function rrToString()
|
|
{
|
|
//
|
|
|
|
//
|
|
return $this->priority . ' ' . $this->weight . ' "' .
|
|
$this->cleanString($this->target) . '"';
|
|
}
|
|
|
|
protected function rrFromString(array $rdata)
|
|
{
|
|
$this->priority = $rdata[0];
|
|
$this->weight = $rdata[1];
|
|
|
|
//
|
|
|
|
//
|
|
$this->target = trim($this->cleanString($rdata[2]), '"');
|
|
|
|
return true;
|
|
}
|
|
|
|
protected function rrSet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if ($this->rdlength > 0) {
|
|
|
|
//
|
|
|
|
//
|
|
$x = unpack('npriority/nweight', $this->rdata);
|
|
|
|
$this->priority = $x['priority'];
|
|
$this->weight = $x['weight'];
|
|
|
|
$offset = $packet->offset + 4;
|
|
$this->target = Net_DNS2_Packet::expand($packet, $offset);
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected function rrGet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if (strlen($this->target) > 0) {
|
|
|
|
$data = pack('nn', $this->priority, $this->weight);
|
|
$packet->offset += 4;
|
|
|
|
$data .= $packet->compress(trim($this->target, '"'), $packet->offset);
|
|
|
|
return $data;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_RR_WKS extends Net_DNS2_RR
|
|
{
|
|
|
|
public $address;
|
|
|
|
public $protocol;
|
|
|
|
public $bitmap = array();
|
|
|
|
protected function rrToString()
|
|
{
|
|
$data = $this->address . ' ' . $this->protocol;
|
|
|
|
foreach ($this->bitmap as $port) {
|
|
$data .= ' ' . $port;
|
|
}
|
|
|
|
return $data;
|
|
}
|
|
|
|
protected function rrFromString(array $rdata)
|
|
{
|
|
$this->address = strtolower(trim(array_shift($rdata), '.'));
|
|
$this->protocol = array_shift($rdata);
|
|
$this->bitmap = $rdata;
|
|
|
|
return true;
|
|
}
|
|
|
|
protected function rrSet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if ($this->rdlength > 0) {
|
|
|
|
//
|
|
|
|
//
|
|
$x = unpack('Naddress/Cprotocol', $this->rdata);
|
|
|
|
$this->address = long2ip($x['address']);
|
|
$this->protocol = $x['protocol'];
|
|
|
|
//
|
|
|
|
//
|
|
$port = 0;
|
|
foreach (unpack('@5/C*', $this->rdata) as $set) {
|
|
|
|
$s = sprintf('%08b', $set);
|
|
|
|
for ($i=0; $i<8; $i++, $port++) {
|
|
if ($s[$i] == '1') {
|
|
$this->bitmap[] = $port;
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected function rrGet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if (strlen($this->address) > 0) {
|
|
|
|
$data = pack('NC', ip2long($this->address), $this->protocol);
|
|
|
|
$ports = array();
|
|
|
|
$n = 0;
|
|
foreach ($this->bitmap as $port) {
|
|
$ports[$port] = 1;
|
|
|
|
if ($port > $n) {
|
|
$n = $port;
|
|
}
|
|
}
|
|
for ($i=0; $i<ceil($n/8)*8; $i++) {
|
|
if (!isset($ports[$i])) {
|
|
$ports[$i] = 0;
|
|
}
|
|
}
|
|
|
|
ksort($ports);
|
|
|
|
$string = '';
|
|
$n = 0;
|
|
|
|
foreach ($ports as $s) {
|
|
|
|
$string .= $s;
|
|
$n++;
|
|
|
|
if ($n == 8) {
|
|
|
|
$data .= chr(bindec($string));
|
|
$string = '';
|
|
$n = 0;
|
|
}
|
|
}
|
|
|
|
$packet->offset += strlen($data);
|
|
|
|
return $data;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_RR_X25 extends Net_DNS2_RR
|
|
{
|
|
|
|
public $psdnaddress;
|
|
|
|
protected function rrToString()
|
|
{
|
|
return $this->formatString($this->psdnaddress);
|
|
}
|
|
|
|
protected function rrFromString(array $rdata)
|
|
{
|
|
$data = $this->buildString($rdata);
|
|
if (count($data) == 1) {
|
|
|
|
$this->psdnaddress = $data[0];
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected function rrSet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if ($this->rdlength > 0) {
|
|
|
|
$this->psdnaddress = Net_DNS2_Packet::label($packet, $packet->offset);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected function rrGet(Net_DNS2_Packet &$packet)
|
|
{
|
|
if (strlen($this->psdnaddress) > 0) {
|
|
|
|
$data = chr(strlen($this->psdnaddress)) . $this->psdnaddress;
|
|
|
|
$packet->offset += strlen($data);
|
|
|
|
return $data;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_Socket_Sockets extends Net_DNS2_Socket
|
|
{
|
|
|
|
public function open()
|
|
{
|
|
//
|
|
|
|
//
|
|
if (Net_DNS2::isIPv4($this->host) == true) {
|
|
|
|
$this->sock = @socket_create(
|
|
AF_INET, $this->type,
|
|
($this->type == Net_DNS2_Socket::SOCK_STREAM) ? SOL_TCP : SOL_UDP
|
|
);
|
|
|
|
} else if (Net_DNS2::isIPv6($this->host) == true) {
|
|
|
|
$this->sock = @socket_create(
|
|
AF_INET6, $this->type,
|
|
($this->type == Net_DNS2_Socket::SOCK_STREAM) ? SOL_TCP : SOL_UDP
|
|
);
|
|
|
|
} else {
|
|
|
|
$this->last_error = 'invalid address type: ' . $this->host;
|
|
return false;
|
|
}
|
|
|
|
if ($this->sock === false) {
|
|
|
|
$this->last_error = socket_strerror(socket_last_error());
|
|
return false;
|
|
}
|
|
|
|
@socket_set_option($this->sock, SOL_SOCKET, SO_REUSEADDR, 1);
|
|
|
|
//
|
|
|
|
//
|
|
if (strlen($this->local_host) > 0) {
|
|
|
|
$result = @socket_bind(
|
|
$this->sock, $this->local_host,
|
|
($this->local_port > 0) ? $this->local_port : null
|
|
);
|
|
if ($result === false) {
|
|
|
|
$this->last_error = socket_strerror(socket_last_error());
|
|
return false;
|
|
}
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
if (@socket_set_nonblock($this->sock) === false) {
|
|
|
|
$this->last_error = socket_strerror(socket_last_error());
|
|
return false;
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
@socket_connect($this->sock, $this->host, $this->port);
|
|
|
|
$read = null;
|
|
$write = array($this->sock);
|
|
$except = null;
|
|
|
|
//
|
|
|
|
//
|
|
$result = @socket_select($read, $write, $except, $this->timeout);
|
|
if ($result === false) {
|
|
|
|
$this->last_error = socket_strerror(socket_last_error());
|
|
return false;
|
|
|
|
} else if ($result == 0) {
|
|
|
|
$this->last_error = 'timeout on write select for connect()';
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public function close()
|
|
{
|
|
if (is_resource($this->sock) === true) {
|
|
|
|
@socket_close($this->sock);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public function write($data)
|
|
{
|
|
$length = strlen($data);
|
|
if ($length == 0) {
|
|
|
|
$this->last_error = 'empty data on write()';
|
|
return false;
|
|
}
|
|
|
|
$read = null;
|
|
$write = array($this->sock);
|
|
$except = null;
|
|
|
|
//
|
|
|
|
//
|
|
$result = @socket_select($read, $write, $except, $this->timeout);
|
|
if ($result === false) {
|
|
|
|
$this->last_error = socket_strerror(socket_last_error());
|
|
return false;
|
|
|
|
} else if ($result == 0) {
|
|
|
|
$this->last_error = 'timeout on write select()';
|
|
return false;
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
if ($this->type == Net_DNS2_Socket::SOCK_STREAM) {
|
|
|
|
$s = chr($length >> 8) . chr($length);
|
|
|
|
if (@socket_write($this->sock, $s) === false) {
|
|
|
|
$this->last_error = socket_strerror(socket_last_error());
|
|
return false;
|
|
}
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
$size = @socket_write($this->sock, $data);
|
|
if ( ($size === false) || ($size != $length) ) {
|
|
|
|
$this->last_error = socket_strerror(socket_last_error());
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public function read(&$size, $max_size)
|
|
{
|
|
$read = array($this->sock);
|
|
$write = null;
|
|
$except = null;
|
|
|
|
//
|
|
|
|
//
|
|
if (@socket_set_nonblock($this->sock) === false) {
|
|
|
|
$this->last_error = socket_strerror(socket_last_error());
|
|
return false;
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
$result = @socket_select($read, $write, $except, $this->timeout);
|
|
if ($result === false) {
|
|
|
|
$this->last_error = socket_strerror(socket_last_error());
|
|
return false;
|
|
|
|
} else if ($result == 0) {
|
|
|
|
$this->last_error = 'timeout on read select()';
|
|
return false;
|
|
}
|
|
|
|
$data = '';
|
|
$length = $max_size;
|
|
|
|
//
|
|
|
|
//
|
|
if ($this->type == Net_DNS2_Socket::SOCK_STREAM) {
|
|
|
|
if (($size = @socket_recv($this->sock, $data, 2, 0)) === false) {
|
|
|
|
$this->last_error = socket_strerror(socket_last_error());
|
|
return false;
|
|
}
|
|
|
|
$length = ord($data[0]) << 8 | ord($data[1]);
|
|
if ($length < Net_DNS2_Lookups::DNS_HEADER_SIZE) {
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
if (@socket_set_block($this->sock) === false) {
|
|
|
|
$this->last_error = socket_strerror(socket_last_error());
|
|
return false;
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
$data = '';
|
|
$size = 0;
|
|
|
|
while (1) {
|
|
|
|
$chunk_size = @socket_recv($this->sock, $chunk, $length, MSG_WAITALL);
|
|
if ($chunk_size === false) {
|
|
|
|
$size = $chunk_size;
|
|
$this->last_error = socket_strerror(socket_last_error());
|
|
|
|
return false;
|
|
}
|
|
|
|
$data .= $chunk;
|
|
$size += $chunk_size;
|
|
|
|
$length -= $chunk_size;
|
|
if ( ($length <= 0) || ($this->type == Net_DNS2_Socket::SOCK_DGRAM) ) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
return $data;
|
|
}
|
|
}
|
|
|
|
?><?php
|
|
|
|
class Net_DNS2_Socket_Streams extends Net_DNS2_Socket
|
|
{
|
|
private $_context;
|
|
|
|
public function open()
|
|
{
|
|
//
|
|
|
|
//
|
|
$opts = array('socket' => array());
|
|
|
|
//
|
|
|
|
//
|
|
if (strlen($this->local_host) > 0) {
|
|
|
|
$opts['socket']['bindto'] = $this->local_host;
|
|
if ($this->local_port > 0) {
|
|
|
|
$opts['socket']['bindto'] .= ':' . $this->local_port;
|
|
}
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
$this->_context = @stream_context_create($opts);
|
|
|
|
//
|
|
|
|
//
|
|
$errno;
|
|
$errstr;
|
|
|
|
switch($this->type) {
|
|
case Net_DNS2_Socket::SOCK_STREAM:
|
|
|
|
if (Net_DNS2::isIPv4($this->host) == true) {
|
|
|
|
$this->sock = @stream_socket_client(
|
|
'tcp://' . $this->host . ':' . $this->port,
|
|
$errno, $errstr, $this->timeout,
|
|
STREAM_CLIENT_CONNECT, $this->_context
|
|
);
|
|
} else if (Net_DNS2::isIPv6($this->host) == true) {
|
|
|
|
$this->sock = @stream_socket_client(
|
|
'tcp://[' . $this->host . ']:' . $this->port,
|
|
$errno, $errstr, $this->timeout,
|
|
STREAM_CLIENT_CONNECT, $this->_context
|
|
);
|
|
} else {
|
|
|
|
$this->last_error = 'invalid address type: ' . $this->host;
|
|
return false;
|
|
}
|
|
|
|
break;
|
|
|
|
case Net_DNS2_Socket::SOCK_DGRAM:
|
|
|
|
if (Net_DNS2::isIPv4($this->host) == true) {
|
|
|
|
$this->sock = @stream_socket_client(
|
|
'udp://' . $this->host . ':' . $this->port,
|
|
$errno, $errstr, $this->timeout,
|
|
STREAM_CLIENT_CONNECT, $this->_context
|
|
);
|
|
} else if (Net_DNS2::isIPv6($this->host) == true) {
|
|
|
|
$this->sock = @stream_socket_client(
|
|
'udp://[' . $this->host . ']:' . $this->port,
|
|
$errno, $errstr, $this->timeout,
|
|
STREAM_CLIENT_CONNECT, $this->_context
|
|
);
|
|
} else {
|
|
|
|
$this->last_error = 'invalid address type: ' . $this->host;
|
|
return false;
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
$this->last_error = 'Invalid socket type: ' . $this->type;
|
|
return false;
|
|
}
|
|
|
|
if ($this->sock === false) {
|
|
|
|
$this->last_error = $errstr;
|
|
return false;
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
@stream_set_blocking($this->sock, 0);
|
|
@stream_set_timeout($this->sock, $this->timeout);
|
|
|
|
return true;
|
|
}
|
|
|
|
public function close()
|
|
{
|
|
if (is_resource($this->sock) === true) {
|
|
|
|
@fclose($this->sock);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public function write($data)
|
|
{
|
|
$length = strlen($data);
|
|
if ($length == 0) {
|
|
|
|
$this->last_error = 'empty data on write()';
|
|
return false;
|
|
}
|
|
|
|
$read = null;
|
|
$write = array($this->sock);
|
|
$except = null;
|
|
|
|
//
|
|
|
|
//
|
|
$result = stream_select($read, $write, $except, $this->timeout);
|
|
if ($result === false) {
|
|
|
|
$this->last_error = 'failed on write select()';
|
|
return false;
|
|
|
|
} else if ($result == 0) {
|
|
|
|
$this->last_error = 'timeout on write select()';
|
|
return false;
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
if ($this->type == Net_DNS2_Socket::SOCK_STREAM) {
|
|
|
|
$s = chr($length >> 8) . chr($length);
|
|
|
|
if (@fwrite($this->sock, $s) === false) {
|
|
|
|
$this->last_error = 'failed to fwrite() 16bit length';
|
|
return false;
|
|
}
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
$size = @fwrite($this->sock, $data);
|
|
if ( ($size === false) || ($size != $length) ) {
|
|
|
|
$this->last_error = 'failed to fwrite() packet';
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public function read(&$size, $max_size)
|
|
{
|
|
$read = array($this->sock);
|
|
$write = null;
|
|
$except = null;
|
|
|
|
//
|
|
|
|
//
|
|
@stream_set_blocking($this->sock, 0);
|
|
|
|
//
|
|
|
|
//
|
|
$result = stream_select($read, $write, $except, $this->timeout);
|
|
if ($result === false) {
|
|
|
|
$this->last_error = 'error on read select()';
|
|
return false;
|
|
|
|
} else if ($result == 0) {
|
|
|
|
$this->last_error = 'timeout on read select()';
|
|
return false;
|
|
}
|
|
|
|
$data = '';
|
|
$length = $max_size;
|
|
|
|
//
|
|
|
|
//
|
|
if ($this->type == Net_DNS2_Socket::SOCK_STREAM) {
|
|
|
|
if (($data = fread($this->sock, 2)) === false) {
|
|
|
|
$this->last_error = 'failed on fread() for data length';
|
|
return false;
|
|
}
|
|
|
|
$length = ord($data[0]) << 8 | ord($data[1]);
|
|
if ($length < Net_DNS2_Lookups::DNS_HEADER_SIZE) {
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
@stream_set_blocking($this->sock, 1);
|
|
|
|
//
|
|
|
|
//
|
|
$data = '';
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
if ($this->type == Net_DNS2_Socket::SOCK_STREAM) {
|
|
|
|
$chunk = '';
|
|
$chunk_size = $length;
|
|
|
|
//
|
|
|
|
//
|
|
while (1) {
|
|
|
|
$chunk = fread($this->sock, $chunk_size);
|
|
if ($chunk === false) {
|
|
|
|
$this->last_error = 'failed on fread() for data';
|
|
return false;
|
|
}
|
|
|
|
$data .= $chunk;
|
|
$chunk_size -= strlen($chunk);
|
|
|
|
if (strlen($data) >= $length) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
} else {
|
|
|
|
//
|
|
|
|
//
|
|
$data = fread($this->sock, $length);
|
|
if ($length === false) {
|
|
|
|
$this->last_error = 'failed on fread() for data';
|
|
return false;
|
|
}
|
|
}
|
|
|
|
$size = strlen($data);
|
|
|
|
return $data;
|
|
}
|
|
}
|
|
|
|
?>
|