wpallstars/wp-multisite-waas
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial Commit

Browse Source
This commit is contained in:
David Stone
2024-11-30 18:24:12 -07:00
commit e8f7955c1c
5432 changed files with 1397750 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

39
dependencies/daverandom/libdns/src/Records/Question.php vendored Normal file
View File

@@ -0,0 +1,39 @@
<?php
declare (strict_types=1);
/**
* Represents a DNS question record
*
* PHP version 5.4
*
* @category LibDNS
* @package Records
* @author Chris Wright <https://github.com/DaveRandom>
* @copyright Copyright (c) Chris Wright <https://github.com/DaveRandom>
* @license http://www.opensource.org/licenses/mit-license.html MIT License
* @version 2.0.0
*/
namespace WP_Ultimo\Dependencies\LibDNS\Records;
use WP_Ultimo\Dependencies\LibDNS\Records\Types\TypeFactory;
/**
* Represents a DNS question record
*
* @category LibDNS
* @package Records
* @author Chris Wright <https://github.com/DaveRandom>
*/
class Question extends Record
{
/**
* Constructor
*
* @param \LibDNS\Records\Types\TypeFactory $typeFactory
* @param int $type Resource type being requested, can be indicated using the ResourceQTypes enum
*/
public function __construct(TypeFactory $typeFactory, int $type)
{
$this->typeFactory = $typeFactory;
$this->type = $type;
}
}

38
dependencies/daverandom/libdns/src/Records/QuestionFactory.php vendored Normal file
View File

@@ -0,0 +1,38 @@
<?php
declare (strict_types=1);
/**
* Creates Question objects
*
* PHP version 5.4
*
* @category LibDNS
* @package Records
* @author Chris Wright <https://github.com/DaveRandom>
* @copyright Copyright (c) Chris Wright <https://github.com/DaveRandom>
* @license http://www.opensource.org/licenses/mit-license.html MIT License
* @version 2.0.0
*/
namespace WP_Ultimo\Dependencies\LibDNS\Records;
use WP_Ultimo\Dependencies\LibDNS\Records\Types\TypeFactory;
/**
* Creates Question objects
*
* @category LibDNS
* @package Records
* @author Chris Wright <https://github.com/DaveRandom>
*/
class QuestionFactory
{
/**
* Create a new Question object
*
* @param int $type The resource type
* @return \LibDNS\Records\Question
*/
public function create(int $type) : Question
{
return new Question(new TypeFactory(), $type);
}
}

138
dependencies/daverandom/libdns/src/Records/RData.php vendored Normal file
View File

@@ -0,0 +1,138 @@
<?php
declare (strict_types=1);
/**
* Represents the RDATA section of a resource record
*
* PHP version 5.4
*
* @category LibDNS
* @package Records
* @author Chris Wright <https://github.com/DaveRandom>
* @copyright Copyright (c) Chris Wright <https://github.com/DaveRandom>
* @license http://www.opensource.org/licenses/mit-license.html MIT License
* @version 2.0.0
*/
namespace WP_Ultimo\Dependencies\LibDNS\Records;
use WP_Ultimo\Dependencies\LibDNS\Records\Types\Type;
use WP_Ultimo\Dependencies\LibDNS\Records\TypeDefinitions\TypeDefinition;
/**
* Represents a data type comprising multiple simple types
*
* @category LibDNS
* @package Records
* @author Chris Wright <https://github.com/DaveRandom>
*/
class RData implements \IteratorAggregate, \Countable
{
/**
* @var \LibDNS\Records\Types\Type[] The items that make up the complex type
*/
private $fields = [];
/**
* @var \LibDNS\Records\TypeDefinitions\TypeDefinition Structural definition of the fields
*/
private $typeDef;
/**
* Constructor
*
* @param \LibDNS\Records\TypeDefinitions\TypeDefinition $typeDef
*/
public function __construct(TypeDefinition $typeDef)
{
$this->typeDef = $typeDef;
}
/**
* Magic method for type coersion to string
*
* @return string
*/
public function __toString()
{
if ($handler = $this->typeDef->getToStringFunction()) {
$result = \call_user_func_array($handler, $this->fields);
} else {
$result = \implode(',', $this->fields);
}
return $result;
}
/**
* Get the field indicated by the supplied index
*
* @param int $index
* @return \LibDNS\Records\Types\Type
* @throws \OutOfBoundsException When the supplied index does not refer to a valid field
*/
public function getField(int $index)
{
if (!isset($this->fields[$index])) {
throw new \OutOfBoundsException('Index ' . $index . ' does not refer to a valid field');
}
return $this->fields[$index];
}
/**
* Set the field indicated by the supplied index
*
* @param int $index
* @param \LibDNS\Records\Types\Type $value
* @throws \InvalidArgumentException When the supplied index/value pair does not match the type definition
*/
public function setField(int $index, Type $value)
{
if (!$this->typeDef->getFieldDefinition($index)->assertDataValid($value)) {
throw new \InvalidArgumentException('The supplied value is not valid for the specified index');
}
$this->fields[$index] = $value;
}
/**
* Get the field indicated by the supplied name
*
* @param string $name
* @return \LibDNS\Records\Types\Type
* @throws \OutOfBoundsException When the supplied name does not refer to a valid field
*/
public function getFieldByName(string $name) : Type
{
return $this->getField($this->typeDef->getFieldIndexByName($name));
}
/**
* Set the field indicated by the supplied name
*
* @param string $name
* @param \LibDNS\Records\Types\Type $value
* @throws \OutOfBoundsException When the supplied name does not refer to a valid field
* @throws \InvalidArgumentException When the supplied value does not match the type definition
*/
public function setFieldByName(string $name, Type $value)
{
$this->setField($this->typeDef->getFieldIndexByName($name), $value);
}
/**
* Get the structural definition of the fields
*
* @return \LibDNS\Records\TypeDefinitions\TypeDefinition
*/
public function getTypeDefinition() : TypeDefinition
{
return $this->typeDef;
}
/**
* Retrieve an iterator (IteratorAggregate interface)
*
* @return \Iterator
*/
public function getIterator() : \Iterator
{
return new \ArrayIterator($this->fields);
}
/**
* Get the number of fields (Countable interface)
*
* @return int
*/
public function count() : int
{
return \count($this->fields);
}
}

62
dependencies/daverandom/libdns/src/Records/RDataBuilder.php vendored Normal file
View File

@@ -0,0 +1,62 @@
<?php
declare (strict_types=1);
/**
* Builds RData objects from a type definition
*
* PHP version 5.4
*
* @category LibDNS
* @package Records
* @author Chris Wright <https://github.com/DaveRandom>
* @copyright Copyright (c) Chris Wright <https://github.com/DaveRandom>
* @license http://www.opensource.org/licenses/mit-license.html MIT License
* @version 2.0.0
*/
namespace WP_Ultimo\Dependencies\LibDNS\Records;
use WP_Ultimo\Dependencies\LibDNS\Records\TypeDefinitions\TypeDefinition;
use WP_Ultimo\Dependencies\LibDNS\Records\Types\TypeBuilder;
/**
* Creates RData objects
*
* @category LibDNS
* @package Records
* @author Chris Wright <https://github.com/DaveRandom>
*/
class RDataBuilder
{
/**
* @var \LibDNS\Records\RDataFactory
*/
private $rDataFactory;
/**
* @var \LibDNS\Records\Types\TypeBuilder
*/
private $typeBuilder;
/**
* Constructor
*
* @param \LibDNS\Records\RDataFactory $rDataFactory
* @param \LibDNS\Records\Types\TypeBuilder $typeBuilder
*/
public function __construct(RDataFactory $rDataFactory, TypeBuilder $typeBuilder)
{
$this->rDataFactory = $rDataFactory;
$this->typeBuilder = $typeBuilder;
}
/**
* Create a new RData object
*
* @param \LibDNS\Records\TypeDefinitions\TypeDefinition $typeDefinition
* @return \LibDNS\Records\RData
*/
public function build(TypeDefinition $typeDefinition) : RData
{
$rData = $this->rDataFactory->create($typeDefinition);
foreach ($typeDefinition as $index => $type) {
$rData->setField($index, $this->typeBuilder->build($type->getType()));
}
return $rData;
}
}

38
dependencies/daverandom/libdns/src/Records/RDataFactory.php vendored Normal file
View File

@@ -0,0 +1,38 @@
<?php
declare (strict_types=1);
/**
* Creates RData objects
*
* PHP version 5.4
*
* @category LibDNS
* @package Records
* @author Chris Wright <https://github.com/DaveRandom>
* @copyright Copyright (c) Chris Wright <https://github.com/DaveRandom>
* @license http://www.opensource.org/licenses/mit-license.html MIT License
* @version 2.0.0
*/
namespace WP_Ultimo\Dependencies\LibDNS\Records;
use WP_Ultimo\Dependencies\LibDNS\Records\TypeDefinitions\TypeDefinition;
/**
* Creates RData objects
*
* @category LibDNS
* @package Records
* @author Chris Wright <https://github.com/DaveRandom>
*/
class RDataFactory
{
/**
* Create a new RData object
*
* @param \LibDNS\Records\TypeDefinitions\TypeDefinition $typeDefinition
* @return \LibDNS\Records\RData
*/
public function create(TypeDefinition $typeDefinition) : RData
{
return new RData($typeDefinition);
}
}

97
dependencies/daverandom/libdns/src/Records/Record.php vendored Normal file
View File

@@ -0,0 +1,97 @@
<?php
declare (strict_types=1);
/**
* Represents a DNS record
*
* PHP version 5.4
*
* @category LibDNS
* @package Records
* @author Chris Wright <https://github.com/DaveRandom>
* @copyright Copyright (c) Chris Wright <https://github.com/DaveRandom>
* @license http://www.opensource.org/licenses/mit-license.html MIT License
* @version 2.0.0
*/
namespace WP_Ultimo\Dependencies\LibDNS\Records;
use WP_Ultimo\Dependencies\LibDNS\Records\Types\DomainName;
/**
* Represents a DNS record
*
* @category LibDNS
* @package Records
* @author Chris Wright <https://github.com/DaveRandom>
*/
abstract class Record
{
/**
* @var \LibDNS\Records\Types\TypeFactory
*/
protected $typeFactory;
/**
* @var \LibDNS\Records\Types\DomainName
*/
protected $name;
/**
* @var int
*/
protected $type;
/**
* @var int
*/
protected $class = ResourceClasses::IN;
/**
* Get the value of the record name field
*
* @return \LibDNS\Records\Types\DomainName
*/
public function getName() : DomainName
{
return $this->name;
}
/**
* Set the value of the record name field
*
* @param string|\LibDNS\Records\Types\DomainName $name
* @throws \UnexpectedValueException When the supplied value is not a valid domain name
*/
public function setName($name)
{
if (!$name instanceof DomainName) {
$name = $this->typeFactory->createDomainName((string) $name);
}
$this->name = $name;
}
/**
* Get the value of the record type field
*
* @return int
*/
public function getType() : int
{
return $this->type;
}
/**
* Get the value of the record class field
*
* @return int
*/
public function getClass() : int
{
return $this->class;
}
/**
* Set the value of the record class field
*
* @param int $class The new value, can be indicated using the ResourceClasses/ResourceQClasses enums
* @throws \RangeException When the supplied value is outside the valid range 0 - 65535
*/
public function setClass(int $class)
{
if ($class < 0 || $class > 65535) {
throw new \RangeException('Record class must be in the range 0 - 65535');
}
$this->class = $class;
}
}

219
dependencies/daverandom/libdns/src/Records/RecordCollection.php vendored Normal file
View File

@@ -0,0 +1,219 @@
<?php
declare (strict_types=1);
/**
* Collection of Record objects
*
* PHP version 5.4
*
* @category LibDNS
* @package Records
* @author Chris Wright <https://github.com/DaveRandom>
* @copyright Copyright (c) Chris Wright <https://github.com/DaveRandom>
* @license http://www.opensource.org/licenses/mit-license.html MIT License
* @version 2.0.0
*/
namespace WP_Ultimo\Dependencies\LibDNS\Records;
/**
* Collection of Record objects
*
* @category LibDNS
* @package Records
* @author Chris Wright <https://github.com/DaveRandom>
*/
class RecordCollection implements \IteratorAggregate, \Countable
{
/**
* @var \LibDNS\Records\Record[] List of records held in the collection
*/
private $records = [];
/**
* @var \LibDNS\Records\Record[][] Map of Records in the collection grouped by record name
*/
private $nameMap = [];
/**
* @var int Number of Records in the collection
*/
private $length = 0;
/**
* @var int Whether the collection holds question or resource records
*/
private $type;
/**
* Constructor
*
* @param int $type Can be indicated using the RecordTypes enum
* @throws \InvalidArgumentException When the specified record type is invalid
*/
public function __construct($type)
{
if ($type !== RecordTypes::QUESTION && $type !== RecordTypes::RESOURCE) {
throw new \InvalidArgumentException('Record type must be QUESTION or RESOURCE');
}
$this->type = $type;
}
/**
* Add a record to the correct bucket in the name map
*
* @param \LibDNS\Records\Record $record The record to add
*/
private function addToNameMap(Record $record)
{
if (!isset($this->nameMap[$name = (string) $record->getName()])) {
$this->nameMap[$name] = [];
}
$this->nameMap[$name][] = $record;
}
/**
* Remove a record from the name map
*
* @param \LibDNS\Records\Record $record The record to remove
*/
private function removeFromNameMap(Record $record)
{
if (!empty($this->nameMap[$name = (string) $record->getName()])) {
foreach ($this->nameMap[$name] as $key => $item) {
if ($item === $record) {
\array_splice($this->nameMap[$name], $key, 1);
break;
}
}
}
if (empty($this->nameMap[$name])) {
unset($this->nameMap[$name]);
}
}
/**
* Add a record to the collection
*
* @param \LibDNS\Records\Record $record The record to add
* @throws \InvalidArgumentException When the wrong record type is supplied
*/
public function add(Record $record)
{
if ($this->type === RecordTypes::QUESTION && !$record instanceof Question || $this->type === RecordTypes::RESOURCE && !$record instanceof Resource) {
throw new \InvalidArgumentException('Incorrect record type for this collection');
}
$this->records[] = $record;
$this->addToNameMap($record);
$this->length++;
}
/**
* Remove a record from the collection
*
* @param \LibDNS\Records\Record $record The record to remove
*/
public function remove(Record $record)
{
foreach ($this->records as $key => $item) {
if ($item === $record) {
\array_splice($this->records, $key, 1);
$this->removeFromNameMap($record);
$this->length--;
return;
}
}
throw new \InvalidArgumentException('The supplied record is not a member of this collection');
}
/**
* Test whether the collection contains a specific record
*
* @param \LibDNS\Records\Record $record The record to search for
* @param bool $sameInstance Whether to perform strict comparisons in search
* @return bool
*/
public function contains(Record $record, bool $sameInstance = \false) : bool
{
return \in_array($record, $this->records, $sameInstance);
}
/**
* Get all records in the collection that refer to the specified name
*
* @param string $name The name to match records against
* @return \LibDNS\Records\Record[]
*/
public function getRecordsByName(string $name) : array
{
return $this->nameMap[\strtolower($name)] ?? [];
}
/**
* Get a record from the collection by index
*
* @param int $index Record index
* @return \LibDNS\Records\Record
* @throws \OutOfBoundsException When the supplied index does not refer to a valid record
*/
public function getRecordByIndex(int $index) : Record
{
if (isset($this->records[$index])) {
return $this->records[$index];
}
throw new \OutOfBoundsException('The specified index ' . $index . ' does not exist in the collection');
}
/**
* Remove all records in the collection that refer to the specified name
*
* @param string $name The name to match records against
* @return int The number of records removed
*/
public function clearRecordsByName(string $name) : int
{
$count = 0;
if (isset($this->nameMap[$name = \strtolower($name)])) {
unset($this->nameMap[$name]);
foreach ($this->records as $index => $record) {
if ($record->getName() === $name) {
unset($this->records[$index]);
$count++;
}
}
$this->records = \array_values($this->records);
}
return $count;
}
/**
* Remove all records from the collection
*/
public function clear()
{
$this->records = $this->nameMap = [];
$this->length = 0;
}
/**
* Get a list of all names referenced by records in the collection
*
* @return string[]
*/
public function getNames() : array
{
return \array_keys($this->nameMap);
}
/**
* Get whether the collection holds question or resource records
*
* @return int
*/
public function getType() : int
{
return $this->type;
}
/**
* Retrieve an iterator (IteratorAggregate interface)
*
* @return \Iterator
*/
public function getIterator() : \Iterator
{
return new \ArrayIterator($this->records);
}
/**
* Get the number of records in the collection (Countable interface)
*
* @return int
*/
public function count() : int
{
return $this->length;
}
}

38
dependencies/daverandom/libdns/src/Records/RecordCollectionFactory.php vendored Normal file
View File

@@ -0,0 +1,38 @@
<?php
declare (strict_types=1);
/**
* Creates RecordCollection objects
*
* PHP version 5.4
*
* @category LibDNS
* @package Records
* @author Chris Wright <https://github.com/DaveRandom>
* @copyright Copyright (c) Chris Wright <https://github.com/DaveRandom>
* @license http://www.opensource.org/licenses/mit-license.html MIT License
* @version 2.0.0
*/
namespace WP_Ultimo\Dependencies\LibDNS\Records;
/**
* Creates RecordCollection objects
*
* @category LibDNS
* @package Records
* @author Chris Wright <https://github.com/DaveRandom>
*/
class RecordCollectionFactory
{
/**
* Create a new RecordCollection object
*
* @param int $type Can be indicated using the RecordTypes enum
* @return \LibDNS\Records\RecordCollection
* @throws \InvalidArgumentException When the specified record type is invalid
*/
public function create(int $type) : RecordCollection
{
return new RecordCollection($type);
}
}

30
dependencies/daverandom/libdns/src/Records/RecordTypes.php vendored Normal file
View File

@@ -0,0 +1,30 @@
<?php
declare (strict_types=1);
/**
* Enumeration of possible record types
*
* PHP version 5.4
*
* @category LibDNS
* @package Records
* @author Chris Wright <https://github.com/DaveRandom>
* @copyright Copyright (c) Chris Wright <https://github.com/DaveRandom>
* @license http://www.opensource.org/licenses/mit-license.html MIT License
* @version 2.0.0
*/
namespace WP_Ultimo\Dependencies\LibDNS\Records;
use WP_Ultimo\Dependencies\LibDNS\Enumeration;
/**
* Enumeration of possible record types
*
* @category LibDNS
* @package Records
* @author Chris Wright <https://github.com/DaveRandom>
*/
final class RecordTypes extends Enumeration
{
const QUESTION = 0;
const RESOURCE = 1;
}

80
dependencies/daverandom/libdns/src/Records/Resource.php vendored Normal file
View File

@@ -0,0 +1,80 @@
<?php
declare (strict_types=1);
/**
* Represents a DNS resource record
*
* PHP version 5.4
*
* @category LibDNS
* @package Records
* @author Chris Wright <https://github.com/DaveRandom>
* @copyright Copyright (c) Chris Wright <https://github.com/DaveRandom>
* @license http://www.opensource.org/licenses/mit-license.html MIT License
* @version 2.0.0
*/
namespace WP_Ultimo\Dependencies\LibDNS\Records;
use WP_Ultimo\Dependencies\LibDNS\Records\Types\TypeFactory;
/**
* Represents a DNS resource record
*
* @category LibDNS
* @package Records
* @author Chris Wright <https://github.com/DaveRandom>
*/
class Resource extends Record
{
/**
* @var int Value of the resource's time-to-live property
*/
private $ttl;
/**
* @var \LibDNS\Records\RData
*/
private $data;
/**
* Constructor
*
* @param \LibDNS\Records\Types\TypeFactory $typeFactory
* @param int $type Can be indicated using the ResourceTypes enum
* @param \LibDNS\Records\RData $data
*/
public function __construct(TypeFactory $typeFactory, int $type, RData $data)
{
$this->typeFactory = $typeFactory;
$this->type = $type;
$this->data = $data;
}
/**
* Get the value of the record TTL field
*
* @return int
*/
public function getTTL() : int
{
return $this->ttl;
}
/**
* Set the value of the record TTL field
*
* @param int $ttl The new value
* @throws \RangeException When the supplied value is outside the valid range 0 - 4294967296
*/
public function setTTL(int $ttl)
{
if ($ttl < 0 || $ttl > 4294967296) {
throw new \RangeException('Record class must be in the range 0 - 4294967296');
}
$this->ttl = $ttl;
}
/**
* Get the value of the resource data field
*
* @return \LibDNS\Records\RData
*/
public function getData() : RData
{
return $this->data;
}
}

65
dependencies/daverandom/libdns/src/Records/ResourceBuilder.php vendored Normal file
View File

@@ -0,0 +1,65 @@
<?php
declare (strict_types=1);
/**
* Builds Resource objects of a specific type
*
* PHP version 5.4
*
* @category LibDNS
* @package Records
* @author Chris Wright <https://github.com/DaveRandom>
* @copyright Copyright (c) Chris Wright <https://github.com/DaveRandom>
* @license http://www.opensource.org/licenses/mit-license.html MIT License
* @version 2.0.0
*/
namespace WP_Ultimo\Dependencies\LibDNS\Records;
use WP_Ultimo\Dependencies\LibDNS\Records\TypeDefinitions\TypeDefinitionManager;
/**
* Builds Resource objects of a specific type
*
* @category LibDNS
* @package Records
* @author Chris Wright <https://github.com/DaveRandom>
*/
class ResourceBuilder
{
/**
* @var \LibDNS\Records\ResourceFactory
*/
private $resourceFactory;
/**
* @var \LibDNS\Records\RDataBuilder
*/
private $rDataBuilder;
/**
* @var \LibDNS\Records\TypeDefinitions\TypeDefinitionManager
*/
private $typeDefinitionManager;
/**
* Constructor
*
* @param \LibDNS\Records\ResourceFactory $resourceFactory
* @param \LibDNS\Records\RDataBuilder $rDataBuilder
* @param \LibDNS\Records\TypeDefinitions\TypeDefinitionManager $typeDefinitionManager
*/
public function __construct(ResourceFactory $resourceFactory, RDataBuilder $rDataBuilder, TypeDefinitionManager $typeDefinitionManager)
{
$this->resourceFactory = $resourceFactory;
$this->rDataBuilder = $rDataBuilder;
$this->typeDefinitionManager = $typeDefinitionManager;
}
/**
* Create a new Resource object
*
* @param int $type Type of the resource, can be indicated using the ResourceTypes enum
* @return \LibDNS\Records\Resource
*/
public function build(int $type) : Resource
{
$typeDefinition = $this->typeDefinitionManager->getTypeDefinition($type);
$rData = $this->rDataBuilder->build($typeDefinition);
return $this->resourceFactory->create($type, $rData);
}
}

42
dependencies/daverandom/libdns/src/Records/ResourceBuilderFactory.php vendored Normal file
View File

@@ -0,0 +1,42 @@
<?php
declare (strict_types=1);
/**
* Creates ResourceBuilder objects
*
* PHP version 5.4
*
* @category LibDNS
* @package Records
* @author Chris Wright <https://github.com/DaveRandom>
* @copyright Copyright (c) Chris Wright <https://github.com/DaveRandom>
* @license http://www.opensource.org/licenses/mit-license.html MIT License
* @version 2.0.0
*/
namespace WP_Ultimo\Dependencies\LibDNS\Records;
use WP_Ultimo\Dependencies\LibDNS\Records\Types\TypeBuilder;
use WP_Ultimo\Dependencies\LibDNS\Records\Types\TypeFactory;
use WP_Ultimo\Dependencies\LibDNS\Records\TypeDefinitions\TypeDefinitionManager;
use WP_Ultimo\Dependencies\LibDNS\Records\TypeDefinitions\TypeDefinitionFactory;
use WP_Ultimo\Dependencies\LibDNS\Records\TypeDefinitions\FieldDefinitionFactory;
/**
* Creates ResourceBuilder objects
*
* @category LibDNS
* @package Records
* @author Chris Wright <https://github.com/DaveRandom>
*/
class ResourceBuilderFactory
{
/**
* Create a new ResourceBuilder object
*
* @param \LibDNS\Records\TypeDefinitions\TypeDefinitionManager $typeDefinitionManager
* @return \LibDNS\Records\ResourceBuilder
*/
public function create(TypeDefinitionManager $typeDefinitionManager = null) : ResourceBuilder
{
return new ResourceBuilder(new ResourceFactory(), new RDataBuilder(new RDataFactory(), new TypeBuilder(new TypeFactory())), $typeDefinitionManager ?: new TypeDefinitionManager(new TypeDefinitionFactory(), new FieldDefinitionFactory()));
}
}

32
dependencies/daverandom/libdns/src/Records/ResourceClasses.php vendored Normal file
View File

@@ -0,0 +1,32 @@
<?php
declare (strict_types=1);
/**
* Enumeration of possible resource CLASS values
*
* PHP version 5.4
*
* @category LibDNS
* @package Records
* @author Chris Wright <https://github.com/DaveRandom>
* @copyright Copyright (c) Chris Wright <https://github.com/DaveRandom>
* @license http://www.opensource.org/licenses/mit-license.html MIT License
* @version 2.0.0
*/
namespace WP_Ultimo\Dependencies\LibDNS\Records;
use WP_Ultimo\Dependencies\LibDNS\Enumeration;
/**
* Enumeration of possible resource CLASS values
*
* @category LibDNS
* @package Records
* @author Chris Wright <https://github.com/DaveRandom>
*/
abstract class ResourceClasses extends Enumeration
{
const IN = 1;
const CS = 2;
const CH = 3;
const HS = 4;
}

39
dependencies/daverandom/libdns/src/Records/ResourceFactory.php vendored Normal file
View File

@@ -0,0 +1,39 @@
<?php
declare (strict_types=1);
/**
* Creates Resource objects
*
* PHP version 5.4
*
* @category LibDNS
* @package Records
* @author Chris Wright <https://github.com/DaveRandom>
* @copyright Copyright (c) Chris Wright <https://github.com/DaveRandom>
* @license http://www.opensource.org/licenses/mit-license.html MIT License
* @version 2.0.0
*/
namespace WP_Ultimo\Dependencies\LibDNS\Records;
use WP_Ultimo\Dependencies\LibDNS\Records\Types\TypeFactory;
/**
* Creates Resource objects
*
* @category LibDNS
* @package Records
* @author Chris Wright <https://github.com/DaveRandom>
*/
class ResourceFactory
{
/**
* Create a new Resource object
*
* @param int $type Can be indicated using the ResourceTypes enum
* @param \LibDNS\Records\RData $data
* @return \LibDNS\Records\Resource
*/
public function create(int $type, RData $data) : Resource
{
return new Resource(new TypeFactory(), $type, $data);
}
}

28
dependencies/daverandom/libdns/src/Records/ResourceQClasses.php vendored Normal file
View File

@@ -0,0 +1,28 @@
<?php
declare (strict_types=1);
/**
* Enumeration of possible resource QCLASS values
*
* PHP version 5.4
*
* @category LibDNS
* @package Records
* @author Chris Wright <https://github.com/DaveRandom>
* @copyright Copyright (c) Chris Wright <https://github.com/DaveRandom>
* @license http://www.opensource.org/licenses/mit-license.html MIT License
* @version 2.0.0
*/
namespace WP_Ultimo\Dependencies\LibDNS\Records;
/**
* Enumeration of possible resource QCLASS values
*
* @category LibDNS
* @package Records
* @author Chris Wright <https://github.com/DaveRandom>
*/
final class ResourceQClasses extends ResourceClasses
{
const ANY = 255;
}

31
dependencies/daverandom/libdns/src/Records/ResourceQTypes.php vendored Normal file
View File

@@ -0,0 +1,31 @@
<?php
declare (strict_types=1);
/**
* Enumeration of possible resource QTYPE values
*
* PHP version 5.4
*
* @category LibDNS
* @package Records
* @author Chris Wright <https://github.com/DaveRandom>
* @copyright Copyright (c) Chris Wright <https://github.com/DaveRandom>
* @license http://www.opensource.org/licenses/mit-license.html MIT License
* @version 2.0.0
*/
namespace WP_Ultimo\Dependencies\LibDNS\Records;
/**
* Enumeration of possible resource QTYPE values
*
* @category LibDNS
* @package Records
* @author Chris Wright <https://github.com/DaveRandom>
*/
final class ResourceQTypes extends ResourceTypes
{
const AXFR = 252;
const MAILB = 253;
const MAILA = 254;
const ALL = 255;
}

71
dependencies/daverandom/libdns/src/Records/ResourceTypes.php vendored Normal file
View File

@@ -0,0 +1,71 @@
<?php
declare (strict_types=1);
/**
* Enumeration of possible resource TYPE values
*
* PHP version 5.4
*
* @category LibDNS
* @package Records
* @author Chris Wright <https://github.com/DaveRandom>
* @copyright Copyright (c) Chris Wright <https://github.com/DaveRandom>
* @license http://www.opensource.org/licenses/mit-license.html MIT License
* @version 2.0.0
*/
namespace WP_Ultimo\Dependencies\LibDNS\Records;
use WP_Ultimo\Dependencies\LibDNS\Enumeration;
/**
* Enumeration of possible resource TYPE values
*
* @category LibDNS
* @package Records
* @author Chris Wright <https://github.com/DaveRandom>
*/
abstract class ResourceTypes extends Enumeration
{
const A = 1;
const AAAA = 28;
const AFSDB = 18;
// const APL = 42;
const CAA = 257;
const CERT = 37;
const CNAME = 5;
const DHCID = 49;
const DLV = 32769;
const DNAME = 39;
const DNSKEY = 48;
const DS = 43;
const HINFO = 13;
// const HIP = 55;
// const IPSECKEY = 45;
const KEY = 25;
const KX = 36;
const ISDN = 20;
const LOC = 29;
const MB = 7;
const MD = 3;
const MF = 4;
const MG = 8;
const MINFO = 14;
const MR = 9;
const MX = 15;
const NAPTR = 35;
const NS = 2;
// const NSEC = 47;
// const NSEC3 = 50;
// const NSEC3PARAM = 50;
const NULL = 10;
const PTR = 12;
const RP = 17;
// const RRSIG = 46;
const RT = 21;
const SIG = 24;
const SOA = 6;
const SPF = 99;
const SRV = 33;
const TXT = 16;
const WKS = 11;
const X25 = 19;
}

130
dependencies/daverandom/libdns/src/Records/TypeDefinitions/FieldDefinition.php vendored Normal file
View File

@@ -0,0 +1,130 @@
<?php
declare (strict_types=1);
/**
* Defines a field in a type
*
* PHP version 5.4
*
* @category LibDNS
* @package TypeDefinitions
* @author Chris Wright <https://github.com/DaveRandom>
* @copyright Copyright (c) Chris Wright <https://github.com/DaveRandom>
* @license http://www.opensource.org/licenses/mit-license.html MIT License
* @version 2.0.0
*/
namespace WP_Ultimo\Dependencies\LibDNS\Records\TypeDefinitions;
use WP_Ultimo\Dependencies\LibDNS\Records\Types\Type;
use WP_Ultimo\Dependencies\LibDNS\Records\Types\Anything;
use WP_Ultimo\Dependencies\LibDNS\Records\Types\BitMap;
use WP_Ultimo\Dependencies\LibDNS\Records\Types\Char;
use WP_Ultimo\Dependencies\LibDNS\Records\Types\CharacterString;
use WP_Ultimo\Dependencies\LibDNS\Records\Types\DomainName;
use WP_Ultimo\Dependencies\LibDNS\Records\Types\IPv4Address;
use WP_Ultimo\Dependencies\LibDNS\Records\Types\IPv6Address;
use WP_Ultimo\Dependencies\LibDNS\Records\Types\Long;
use WP_Ultimo\Dependencies\LibDNS\Records\Types\Short;
use WP_Ultimo\Dependencies\LibDNS\Records\Types\Types;
/**
* Defines a field in a type
*
* @category LibDNS
* @package TypeDefinitions
* @author Chris Wright <https://github.com/DaveRandom>
*/
class FieldDefinition
{
/**
* @var int
*/
private $index;
/**
* @var string
*/
private $name;
/**
* @var int
*/
private $type;
/**
* @var bool
*/
private $allowsMultiple;
/**
* @var int
*/
private $minimumValues;
/**
* Constructor
*
* @param int $index
* @param string $name
* @param int $type
* @param bool $allowsMultiple
* @param int $minimumValues
*/
public function __construct(int $index, string $name, int $type, bool $allowsMultiple, int $minimumValues)
{
$this->index = $index;
$this->name = $name;
$this->type = $type;
$this->allowsMultiple = $allowsMultiple;
$this->minimumValues = $minimumValues;
}
/**
* Get the index of the field in the containing type
*
* @return int
*/
public function getIndex() : int
{
return $this->index;
}
/**
* Get the name of the field
*
* @return string
*/
public function getName() : string
{
return $this->name;
}
/**
* Get the type of the field
*
* @return int
*/
public function getType() : int
{
return $this->type;
}
/**
* Determine whether the field allows multiple values
*
* @return bool
*/
public function allowsMultiple() : bool
{
return $this->allowsMultiple;
}
/**
* Get the minimum number of values for the field
*
* @return int
*/
public function getMinimumValues() : int
{
return $this->minimumValues;
}
/**
* Assert that a Type object is valid for this field
*
* @param \LibDNS\Records\Types\Type
* @return bool
*/
public function assertDataValid(Type $value) : bool
{
return $this->type & Types::ANYTHING && $value instanceof Anything || $this->type & Types::BITMAP && $value instanceof BitMap || $this->type & Types::CHAR && $value instanceof Char || $this->type & Types::CHARACTER_STRING && $value instanceof CharacterString || $this->type & Types::DOMAIN_NAME && $value instanceof DomainName || $this->type & Types::IPV4_ADDRESS && $value instanceof IPv4Address || $this->type & Types::IPV6_ADDRESS && $value instanceof IPv6Address || $this->type & Types::LONG && $value instanceof Long || $this->type & Types::SHORT && $value instanceof Short;
}
}

41
dependencies/daverandom/libdns/src/Records/TypeDefinitions/FieldDefinitionFactory.php vendored Normal file
View File

@@ -0,0 +1,41 @@
<?php
declare (strict_types=1);
/**
* Creates FieldDefinition objects
*
* PHP version 5.4
*
* @category LibDNS
* @package TypeDefinitions
* @author Chris Wright <https://github.com/DaveRandom>
* @copyright Copyright (c) Chris Wright <https://github.com/DaveRandom>
* @license http://www.opensource.org/licenses/mit-license.html MIT License
* @version 2.0.0
*/
namespace WP_Ultimo\Dependencies\LibDNS\Records\TypeDefinitions;
/**
* Creates FieldDefinition objects
*
* @category LibDNS
* @package TypeDefinitions
* @author Chris Wright <https://github.com/DaveRandom>
*/
class FieldDefinitionFactory
{
/**
* Create a new FieldDefinition object
*
* @param int $index
* @param string $name
* @param int $type
* @param bool $allowsMultiple
* @param int $minimumValues
* @return \LibDNS\Records\TypeDefinitions\FieldDefinition
*/
public function create(int $index, string $name, int $type, bool $allowsMultiple, int $minimumValues) : FieldDefinition
{
return new FieldDefinition($index, $name, $type, $allowsMultiple, $minimumValues);
}
}

177
dependencies/daverandom/libdns/src/Records/TypeDefinitions/TypeDefinition.php vendored Normal file
View File

@@ -0,0 +1,177 @@
<?php
declare (strict_types=1);
/**
* Defines a data type comprising multiple fields
*
* PHP version 5.4
*
* @category LibDNS
* @package TypeDefinitions
* @author Chris Wright <https://github.com/DaveRandom>
* @copyright Copyright (c) Chris Wright <https://github.com/DaveRandom>
* @license http://www.opensource.org/licenses/mit-license.html MIT License
* @version 2.0.0
*/
namespace WP_Ultimo\Dependencies\LibDNS\Records\TypeDefinitions;
/**
* Defines a data type comprising multiple fields
*
* @category LibDNS
* @package TypeDefinitions
* @author Chris Wright <https://github.com/DaveRandom>
*/
class TypeDefinition implements \IteratorAggregate, \Countable
{
/**
* @var FieldDefinitionFactory Creates FieldDefinition objects
*/
private $fieldDefFactory;
/**
* @var int Number of fields in the type
*/
private $fieldCount;
/**
* @var \LibDNS\Records\TypeDefinitions\FieldDefinition The last field defined by the type
*/
private $lastField;
/**
* @var int[] Map of field indexes to type identifiers
*/
private $fieldDefs = [];
/**
* @var int[] Map of field names to indexes
*/
private $fieldNameMap = [];
/**
* @var callable Custom implementation for __toString() handling
*/
private $toStringFunction;
/**
* Constructor
*
* @param FieldDefinitionFactory $fieldDefFactory
* @param array $definition Structural definition of the fields
* @throws \InvalidArgumentException When the type definition is invalid
*/
public function __construct(FieldDefinitionFactory $fieldDefFactory, array $definition)
{
$this->fieldDefFactory = $fieldDefFactory;
if (isset($definition['__toString'])) {
if (!\is_callable($definition['__toString'])) {
throw new \InvalidArgumentException('Invalid type definition: __toString() implementation is not callable');
}
$this->toStringFunction = $definition['__toString'];
unset($definition['__toString']);
}
$this->fieldCount = \count($definition);
$index = 0;
foreach ($definition as $name => $type) {
$this->registerField($index++, $name, $type);
}
}
/**
* Register a field from the type definition
*
* @param int $index
* @param string $name
* @param int $type
* @throws \InvalidArgumentException When the field definition is invalid
*/
private function registerField(int $index, string $name, int $type)
{
if (!\preg_match('/^(?P<name>[\\w\\-]+)(?P<quantifier>\\+|\\*)?(?P<minimum>(?<=\\+)\\d+)?$/', \strtolower($name), $matches)) {
throw new \InvalidArgumentException('Invalid field definition ' . $name . ': Syntax error');
}
if (isset($matches['quantifier'])) {
if ($index !== $this->fieldCount - 1) {
throw new \InvalidArgumentException('Invalid field definition ' . $name . ': Quantifiers only allowed in last field');
}
if (!isset($matches['minimum'])) {
$matches['minimum'] = $matches['quantifier'] === '+' ? 1 : 0;
}
$allowsMultiple = \true;
$minimumValues = (int) $matches['minimum'];
} else {
$allowsMultiple = \false;
$minimumValues = 0;
}
$this->fieldDefs[$index] = $this->fieldDefFactory->create($index, $matches['name'], $type, $allowsMultiple, $minimumValues);
if ($index === $this->fieldCount - 1) {
$this->lastField = $this->fieldDefs[$index];
}
$this->fieldNameMap[$matches['name']] = $index;
}
/**
* Get the field definition indicated by the supplied index
*
* @param int $index
* @return \LibDNS\Records\TypeDefinitions\FieldDefinition
* @throws \OutOfBoundsException When the supplied index does not refer to a valid field
*/
public function getFieldDefinition(int $index) : FieldDefinition
{
if (isset($this->fieldDefs[$index])) {
$fieldDef = $this->fieldDefs[$index];
} else {
if ($index >= 0 && $this->lastField->allowsMultiple()) {
$fieldDef = $this->lastField;
} else {
throw new \OutOfBoundsException('Index ' . $index . ' does not refer to a valid field');
}
}
return $fieldDef;
}
/**
* Get the field index indicated by the supplied name
*
* @param string $name
* @return int
* @throws \OutOfBoundsException When the supplied name does not refer to a valid field
*/
public function getFieldIndexByName($name) : int
{
$fieldName = \strtolower($name);
if (!isset($this->fieldNameMap[$fieldName])) {
throw new \OutOfBoundsException('Name ' . $name . ' does not refer to a valid field');
}
return $this->fieldNameMap[$fieldName];
}
/**
* Get the __toString() implementation
*
* @return callable|null
*/
public function getToStringFunction()
{
return $this->toStringFunction;
}
/**
* Set the __toString() implementation
*
* @param callable $function
*/
public function setToStringFunction(callable $function)
{
$this->toStringFunction = $function;
}
/**
* Retrieve an iterator (IteratorAggregate interface)
*
* @return \Iterator
*/
public function getIterator() : \Iterator
{
return new \ArrayIterator($this->fieldDefs);
}
/**
* Get the number of fields (Countable interface)
*
* @return int
*/
public function count() : int
{
return $this->fieldCount;
}
}

39
dependencies/daverandom/libdns/src/Records/TypeDefinitions/TypeDefinitionFactory.php vendored Normal file
View File

@@ -0,0 +1,39 @@
<?php
declare (strict_types=1);
/**
* Creates TypeDefinition objects
*
* PHP version 5.4
*
* @category LibDNS
* @package TypeDefinitions
* @author Chris Wright <https://github.com/DaveRandom>
* @copyright Copyright (c) Chris Wright <https://github.com/DaveRandom>
* @license http://www.opensource.org/licenses/mit-license.html MIT License
* @version 2.0.0
*/
namespace WP_Ultimo\Dependencies\LibDNS\Records\TypeDefinitions;
/**
* Creates TypeDefinition objects
*
* @category LibDNS
* @package TypeDefinitions
* @author Chris Wright <https://github.com/DaveRandom>
*/
class TypeDefinitionFactory
{
/**
* Create a new TypeDefinition object
*
* @param FieldDefinitionFactory $fieldDefinitionFactory
* @param int[] $definition Structural definition of the fields
* @return \LibDNS\Records\TypeDefinitions\TypeDefinition
* @throws \InvalidArgumentException When the type definition is invalid
*/
public function create(FieldDefinitionFactory $fieldDefinitionFactory, array $definition) : TypeDefinition
{
return new TypeDefinition($fieldDefinitionFactory, $definition);
}
}

264
dependencies/daverandom/libdns/src/Records/TypeDefinitions/TypeDefinitionManager.php vendored Normal file
View File

@@ -0,0 +1,264 @@
<?php
declare (strict_types=1);
/**
* Holds data about how the RDATA sections of known resource record types are structured
*
* PHP version 5.4
*
* @category LibDNS
* @package TypeDefinitions
* @author Chris Wright <https://github.com/DaveRandom>
* @copyright Copyright (c) Chris Wright <https://github.com/DaveRandom>
* @license http://www.opensource.org/licenses/mit-license.html MIT License
* @version 2.0.0
*/
namespace WP_Ultimo\Dependencies\LibDNS\Records\TypeDefinitions;
use WP_Ultimo\Dependencies\LibDNS\Records\ResourceTypes;
use WP_Ultimo\Dependencies\LibDNS\Records\Types\Types;
use WP_Ultimo\Dependencies\LibDNS\Records\Types\DomainName;
/**
* Holds data about how the RDATA sections of known resource record types are structured
*
* @category LibDNS
* @package TypeDefinitions
* @author Chris Wright <https://github.com/DaveRandom>
*/
class TypeDefinitionManager
{
/**
* @var array[] How the RDATA sections of known resource record types are structured
*/
private $definitions = [];
/**
* @var array Cache of created definitions
*/
private $typeDefs = [];
/**
* @var \LibDNS\Records\TypeDefinitions\TypeDefinitionFactory
*/
private $typeDefFactory;
/**
* @var \LibDNS\Records\TypeDefinitions\FieldDefinitionFactory
*/
private $fieldDefFactory;
/**
* Constructor
*
* @param \LibDNS\Records\TypeDefinitions\TypeDefinitionFactory $typeDefFactory
* @param \LibDNS\Records\TypeDefinitions\FieldDefinitionFactory $fieldDefFactory
*/
public function __construct(TypeDefinitionFactory $typeDefFactory, FieldDefinitionFactory $fieldDefFactory)
{
$this->typeDefFactory = $typeDefFactory;
$this->fieldDefFactory = $fieldDefFactory;
$this->setDefinitions();
}
/**
* Set the internal definitions structure
*/
private function setDefinitions()
{
// This is defined in a method because PHP doesn't let you define properties with
// expressions at the class level. If anyone has a better way to do this I am open
// to any and all suggestions.
$this->definitions = [ResourceTypes::A => [
// RFC 1035
'address' => Types::IPV4_ADDRESS,
], ResourceTypes::AAAA => [
// RFC 3596
'address' => Types::IPV6_ADDRESS,
], ResourceTypes::AFSDB => [
// RFC 1183
'subtype' => Types::SHORT,
'hostname' => Types::DOMAIN_NAME,
], ResourceTypes::CAA => [
// RFC 6844
'flags' => Types::DOMAIN_NAME,
'tag' => Types::CHARACTER_STRING,
'value' => Types::ANYTHING,
], ResourceTypes::CERT => [
// RFC 4398
'type' => Types::SHORT,
'key-tag' => Types::SHORT,
'algorithm' => Types::CHAR,
'certificate' => Types::ANYTHING,
], ResourceTypes::CNAME => [
// RFC 1035
'cname' => Types::DOMAIN_NAME,
], ResourceTypes::DHCID => [
// RFC 4701
'identifier-type' => Types::SHORT,
'digest-type' => Types::CHAR,
'digest' => Types::ANYTHING,
], ResourceTypes::DLV => [
// RFC 4034
'key-tag' => Types::SHORT,
'algorithm' => Types::CHAR,
'digest-type' => Types::CHAR,
'digest' => Types::ANYTHING,
], ResourceTypes::DNAME => [
// RFC 4034
'target' => Types::DOMAIN_NAME,
], ResourceTypes::DNSKEY => [
// RFC 6672
'flags' => Types::SHORT,
'protocol' => Types::CHAR,
'algorithm' => Types::CHAR,
'public-key' => Types::ANYTHING,
], ResourceTypes::DS => [
// RFC 4034
'key-tag' => Types::SHORT,
'algorithm' => Types::CHAR,
'digest-type' => Types::CHAR,
'digest' => Types::ANYTHING,
], ResourceTypes::HINFO => [
// RFC 1035
'cpu' => Types::CHARACTER_STRING,
'os' => Types::CHARACTER_STRING,
], ResourceTypes::ISDN => [
// RFC 1183
'isdn-address' => Types::CHARACTER_STRING,
'sa' => Types::CHARACTER_STRING,
], ResourceTypes::KEY => [
// RFC 2535
'flags' => Types::SHORT,
'protocol' => Types::CHAR,
'algorithm' => Types::CHAR,
'public-key' => Types::ANYTHING,
], ResourceTypes::KX => [
// RFC 2230
'preference' => Types::SHORT,
'exchange' => Types::DOMAIN_NAME,
], ResourceTypes::LOC => [
// RFC 1876
'version' => Types::CHAR,
'size' => Types::CHAR,
'horizontal-precision' => Types::CHAR,
'vertical-precision' => Types::CHAR,
'latitude' => Types::LONG,
'longitude' => Types::LONG,
'altitude' => Types::LONG,
], ResourceTypes::MB => [
// RFC 1035
'madname' => Types::DOMAIN_NAME,
], ResourceTypes::MD => [
// RFC 1035
'madname' => Types::DOMAIN_NAME,
], ResourceTypes::MF => [
// RFC 1035
'madname' => Types::DOMAIN_NAME,
], ResourceTypes::MG => [
// RFC 1035
'mgmname' => Types::DOMAIN_NAME,
], ResourceTypes::MINFO => [
// RFC 1035
'rmailbx' => Types::DOMAIN_NAME,
'emailbx' => Types::DOMAIN_NAME,
], ResourceTypes::MR => [
// RFC 1035
'newname' => Types::DOMAIN_NAME,
], ResourceTypes::MX => [
// RFC 1035
'preference' => Types::SHORT,
'exchange' => Types::DOMAIN_NAME,
], ResourceTypes::NAPTR => [
// RFC 3403
'order' => Types::SHORT,
'preference' => Types::SHORT,
'flags' => Types::CHARACTER_STRING,
'services' => Types::CHARACTER_STRING,
'regexp' => Types::CHARACTER_STRING,
'replacement' => Types::DOMAIN_NAME,
], ResourceTypes::NS => [
// RFC 1035
'nsdname' => Types::DOMAIN_NAME,
], ResourceTypes::NULL => [
// RFC 1035
'data' => Types::ANYTHING,
], ResourceTypes::PTR => [
// RFC 1035
'ptrdname' => Types::DOMAIN_NAME,
], ResourceTypes::RP => [
// RFC 1183
'mbox-dname' => Types::DOMAIN_NAME,
'txt-dname' => Types::DOMAIN_NAME,
], ResourceTypes::RT => [
// RFC 1183
'preference' => Types::SHORT,
'intermediate-host' => Types::DOMAIN_NAME,
], ResourceTypes::SIG => [
// RFC 4034
'type-covered' => Types::SHORT,
'algorithm' => Types::CHAR,
'labels' => Types::CHAR,
'original-ttl' => Types::LONG,
'signature-expiration' => Types::LONG,
'signature-inception' => Types::LONG,
'key-tag' => Types::SHORT,
'signers-name' => Types::DOMAIN_NAME,
'signature' => Types::ANYTHING,
], ResourceTypes::SOA => [
// RFC 1035
'mname' => Types::DOMAIN_NAME,
'rname' => Types::DOMAIN_NAME,
'serial' => Types::LONG,
'refresh' => Types::LONG,
'retry' => Types::LONG,
'expire' => Types::LONG,
'minimum' => Types::LONG,
], ResourceTypes::SPF => [
// RFC 4408
'data+' => Types::CHARACTER_STRING,
], ResourceTypes::SRV => [
// RFC 2782
'priority' => Types::SHORT,
'weight' => Types::SHORT,
'port' => Types::SHORT,
'name' => Types::DOMAIN_NAME | DomainName::FLAG_NO_COMPRESSION,
], ResourceTypes::TXT => [
// RFC 1035
'txtdata+' => Types::CHARACTER_STRING,
], ResourceTypes::WKS => [
// RFC 1035
'address' => Types::IPV4_ADDRESS,
'protocol' => Types::SHORT,
'bit-map' => Types::BITMAP,
], ResourceTypes::X25 => [
// RFC 1183
'psdn-address' => Types::CHARACTER_STRING,
]];
}
/**
* Get a type definition for a record type if it is known
*
* @param int $recordType Resource type, can be indicated using the ResourceTypes enum
* @return \LibDNS\Records\TypeDefinitions\TypeDefinition
*/
public function getTypeDefinition(int $recordType)
{
if (!isset($this->typeDefs[$recordType])) {
$definition = isset($this->definitions[$recordType]) ? $this->definitions[$recordType] : ['data' => Types::ANYTHING];
$this->typeDefs[$recordType] = $this->typeDefFactory->create($this->fieldDefFactory, $definition);
}
return $this->typeDefs[$recordType];
}
/**
* Register a custom type definition
*
* @param int $recordType Resource type, can be indicated using the ResourceTypes enum
* @param int[]|\LibDNS\Records\TypeDefinitions\TypeDefinition $definition
* @throws \InvalidArgumentException When the type definition is invalid
*/
public function registerTypeDefinition(int $recordType, $definition)
{
if (!$definition instanceof TypeDefinition) {
if (!\is_array($definition)) {
throw new \InvalidArgumentException('Definition must be an array or an instance of ' . __NAMESPACE__ . '\\TypeDefinition');
}
$definition = $this->typeDefFactory->create($this->fieldDefFactory, $definition);
}
$this->typeDefs[$recordType] = $definition;
}
}

36
dependencies/daverandom/libdns/src/Records/TypeDefinitions/TypeDefinitionManagerFactory.php vendored Normal file
View File

@@ -0,0 +1,36 @@
<?php
declare (strict_types=1);
/**
* Creates TypeDefinitionManager objects
*
* PHP version 5.4
*
* @category LibDNS
* @package TypeDefinitions
* @author Chris Wright <https://github.com/DaveRandom>
* @copyright Copyright (c) Chris Wright <https://github.com/DaveRandom>
* @license http://www.opensource.org/licenses/mit-license.html MIT License
* @version 2.0.0
*/
namespace WP_Ultimo\Dependencies\LibDNS\Records\TypeDefinitions;
/**
* Creates TypeDefinitionManager objects
*
* @category LibDNS
* @package TypeDefinitions
* @author Chris Wright <https://github.com/DaveRandom>
*/
class TypeDefinitionManagerFactory
{
/**
* Create a new TypeDefinitionManager object
*
* @return \LibDNS\Records\TypeDefinitions\TypeDefinitionManager
*/
public function create() : TypeDefinitionManager
{
return new TypeDefinitionManager(new TypeDefinitionFactory(), new FieldDefinitionFactory());
}
}

45
dependencies/daverandom/libdns/src/Records/Types/Anything.php vendored Normal file
View File

@@ -0,0 +1,45 @@
<?php
declare (strict_types=1);
/**
* Represents a generic binary data string
*
* PHP version 5.4
*
* @category LibDNS
* @package Types
* @author Chris Wright <https://github.com/DaveRandom>
* @copyright Copyright (c) Chris Wright <https://github.com/DaveRandom>
* @license http://www.opensource.org/licenses/mit-license.html MIT License
* @version 2.0.0
*/
namespace WP_Ultimo\Dependencies\LibDNS\Records\Types;
/**
* Represents a generic binary data string
*
* @category LibDNS
* @package Types
* @author Chris Wright <https://github.com/DaveRandom>
*/
class Anything extends Type
{
/**
* @var string
*/
protected $value = '';
/**
* Set the internal value
*
* @param string $value The new value
* @throws \UnexpectedValueException When the supplied value is outside the valid length range 0 - 65535
*/
public function setValue($value)
{
$value = (string) $value;
if (\strlen($value) > 65535) {
throw new \UnexpectedValueException('Untyped string length must be in the range 0 - 65535');
}
$this->value = $value;
}
}

63
dependencies/daverandom/libdns/src/Records/Types/BitMap.php vendored Normal file
View File

@@ -0,0 +1,63 @@
<?php
declare (strict_types=1);
/**
* Represents a bit map
*
* PHP version 5.4
*
* @category LibDNS
* @package Types
* @author Chris Wright <https://github.com/DaveRandom>
* @copyright Copyright (c) Chris Wright <https://github.com/DaveRandom>
* @license http://www.opensource.org/licenses/mit-license.html MIT License
* @version 2.0.0
*/
namespace WP_Ultimo\Dependencies\LibDNS\Records\Types;
/**
* Represents a bit map
*
* @category LibDNS
* @package Types
* @author Chris Wright <https://github.com/DaveRandom>
*/
class BitMap extends Type
{
/**
* @var string
*/
protected $value = '';
/**
* Set the internal value
*
* @param string $value The new value
*/
public function setValue($value)
{
$this->value = (string) $value;
}
/**
* Inspect the value of the bit at the specific index and optionally set a new value
*
* @param int $index
* @param bool $newValue The new value
* @return bool The old value
*/
public function isBitSet(int $index, bool $newValue = null) : bool
{
$charIndex = (int) ($index / 8);
$bitMask = 0b10000000 >> $index % 8;
$result = \false;
if (isset($this->value[$charIndex])) {
$result = (bool) (\ord($this->value[$charIndex]) & $bitMask);
}
if (isset($newValue) && $newValue != $result) {
if (!isset($this->value[$charIndex])) {
$this->value = \str_pad($this->value, $charIndex + 1, "\x00", \STR_PAD_RIGHT);
}
$this->value[$charIndex] = \chr(\ord($this->value[$charIndex]) & ~$bitMask | ($newValue ? $bitMask : 0));
}
return $result;
}
}

50
dependencies/daverandom/libdns/src/Records/Types/Char.php vendored Normal file
View File

@@ -0,0 +1,50 @@
<?php
declare (strict_types=1);
/**
* Represents an 8-bit unsigned integer
*
* PHP version 5.4
*
* @category LibDNS
* @package Types
* @author Chris Wright <https://github.com/DaveRandom>
* @copyright Copyright (c) Chris Wright <https://github.com/DaveRandom>
* @license http://www.opensource.org/licenses/mit-license.html MIT License
* @version 2.0.0
*/
namespace WP_Ultimo\Dependencies\LibDNS\Records\Types;
/**
* Represents an 8-bit unsigned integer
*
* @category LibDNS
* @package Types
* @author Chris Wright <https://github.com/DaveRandom>
*/
class Char extends Type
{
/**
* @var int
*/
protected $value = 0;
/**
* Set the internal value
*
* @param string $value The new value
* @throws \UnderflowException When the supplied value is less than 0
* @throws \OverflowException When the supplied value is greater than 255
*/
public function setValue($value)
{
$value = (int) $value;
if ($value < 0) {
throw new \UnderflowException('Char value must be in the range 0 - 255');
} else {
if ($value > 255) {
throw new \OverflowException('Char value must be in the range 0 - 255');
}
}
$this->value = $value;
}
}

45
dependencies/daverandom/libdns/src/Records/Types/CharacterString.php vendored Normal file
View File

@@ -0,0 +1,45 @@
<?php
declare (strict_types=1);
/**
* Represents a binary character string
*
* PHP version 5.4
*
* @category LibDNS
* @package Types
* @author Chris Wright <https://github.com/DaveRandom>
* @copyright Copyright (c) Chris Wright <https://github.com/DaveRandom>
* @license http://www.opensource.org/licenses/mit-license.html MIT License
* @version 2.0.0
*/
namespace WP_Ultimo\Dependencies\LibDNS\Records\Types;
/**
* Represents a binary character string
*
* @category LibDNS
* @package Types
* @author Chris Wright <https://github.com/DaveRandom>
*/
class CharacterString extends Type
{
/**
* @var string
*/
protected $value = '';
/**
* Set the internal value
*
* @param string $value The new value
* @throws \UnexpectedValueException When the supplied value is outside the valid length range 0 - 255
*/
public function setValue($value)
{
$value = (string) $value;
if (\strlen($value) > 255) {
throw new \UnexpectedValueException('Character string length must be in the range 0 - 255');
}
$this->value = $value;
}
}

104
dependencies/daverandom/libdns/src/Records/Types/DomainName.php vendored Normal file
View File

@@ -0,0 +1,104 @@
<?php
declare (strict_types=1);
/**
* Represents a fully qualified domain name
*
* PHP version 5.4
*
* @category LibDNS
* @package Types
* @author Chris Wright <https://github.com/DaveRandom>
* @copyright Copyright (c) Chris Wright <https://github.com/DaveRandom>
* @license http://www.opensource.org/licenses/mit-license.html MIT License
* @version 2.0.0
*/
namespace WP_Ultimo\Dependencies\LibDNS\Records\Types;
/**
* Represents a fully qualified domain name
*
* @category LibDNS
* @package Types
* @author Chris Wright <https://github.com/DaveRandom>
*/
class DomainName extends Type
{
const FLAG_NO_COMPRESSION = \PHP_INT_SIZE === 4 ? -2147483648 : 0x80000000;
/**
* @var string
*/
protected $value = '';
/**
* @var string[] The value as a list of labels
*/
private $labels = [];
/**
* Constructor
*
* @param string|string[] $value
* @throws \UnexpectedValueException When the supplied value is not a valid domain name
*/
public function __construct($value = null)
{
if (\is_array($value)) {
$this->setLabels($value);
} else {
parent::__construct($value);
}
}
/**
* Set the internal value
*
* @param string $value The new value
* @throws \UnexpectedValueException When the supplied value is not a valid domain name
*/
public function setValue($value)
{
$this->setLabels(\explode('.', (string) $value));
}
/**
* Get the domain name labels
*
* @param bool $tldFirst Whether to return the label list ordered with the TLD label first
* @return string[]
*/
public function getLabels($tldFirst = \false) : array
{
return $tldFirst ? \array_reverse($this->labels) : $this->labels;
}
/**
* Set the domain name labels
*
* @param string[] $labels The new label list
* @param bool $tldFirst Whether the supplied label list is ordered with the TLD label first
* @throws \UnexpectedValueException When the supplied label list is not a valid domain name
*/
public function setLabels(array $labels, $tldFirst = \false)
{
if (!$labels) {
$this->labels = [];
$this->value = '';
return;
}
$length = $count = 0;
foreach ($labels as &$label) {
$label = \WP_Ultimo\Dependencies\LibDNS\normalize_name($label);
$labelLength = \strlen($label);
if ($labelLength > 63) {
throw new \InvalidArgumentException('Label list is not a valid domain name: Label ' . $label . ' length exceeds 63 byte limit');
}
$length += $labelLength + 1;
$count++;
}
$tld = $tldFirst ? $labels[0] : $labels[$count - 1];
if ($tld === '') {
$length--;
}
if ($length + 1 > 255) {
throw new \InvalidArgumentException('Label list is not a valid domain name: Total length exceeds 255 byte limit');
}
$this->labels = $tldFirst ? \array_reverse($labels) : $labels;
$this->value = \implode('.', $this->labels);
}
}

88
dependencies/daverandom/libdns/src/Records/Types/IPv4Address.php vendored Normal file
View File

@@ -0,0 +1,88 @@
<?php
declare (strict_types=1);
/**
* Represents an IPv4 address
*
* PHP version 5.4
*
* @category LibDNS
* @package Types
* @author Chris Wright <https://github.com/DaveRandom>
* @copyright Copyright (c) Chris Wright <https://github.com/DaveRandom>
* @license http://www.opensource.org/licenses/mit-license.html MIT License
* @version 2.0.0
*/
namespace WP_Ultimo\Dependencies\LibDNS\Records\Types;
/**
* Represents an IPv4 address
*
* @category LibDNS
* @package Types
* @author Chris Wright <https://github.com/DaveRandom>
*/
class IPv4Address extends Type
{
/**
* @var string
*/
protected $value = '0.0.0.0';
/**
* @var int[] The octets of the address
*/
private $octets = [0, 0, 0, 0];
/**
* Constructor
*
* @param string|int[] $value String representation or octet list
* @throws \UnexpectedValueException When the supplied value is not a valid IPv4 address
*/
public function __construct($value = null)
{
if (\is_array($value)) {
$this->setOctets($value);
} else {
parent::__construct($value);
}
}
/**
* Set the internal value
*
* @param string $value The new value
* @throws \UnexpectedValueException When the supplied value is outside the valid length range 0 - 65535
*/
public function setValue($value)
{
$this->setOctets(\explode('.', (string) $value));
}
/**
* Get the address octets
*
* @return int[]
*/
public function getOctets() : array
{
return $this->octets;
}
/**
* Set the address octets
*
* @param int[] $octets The new address octets
* @throws \UnexpectedValueException When the supplied octet list is not a valid IPv4 address
*/
public function setOctets(array $octets)
{
if (\count($octets) !== 4) {
throw new \UnexpectedValueException('Octet list is not a valid IPv4 address: invalid octet count');
}
foreach ($octets as &$octet) {
if (!\is_int($octet) && !\ctype_digit((string) $octet) || $octet < 0x0 || $octet > 0xff) {
throw new \UnexpectedValueException('Octet list is not a valid IPv4 address: invalid octet value ' . $octet);
}
$octet = (int) $octet;
}
$this->octets = \array_values($octets);
$this->value = \implode('.', $this->octets);
}
}

152
dependencies/daverandom/libdns/src/Records/Types/IPv6Address.php vendored Normal file
View File

@@ -0,0 +1,152 @@
<?php
declare (strict_types=1);
/**
* Represents an IPv6 address
*
* PHP version 5.4
*
* @category LibDNS
* @package Types
* @author Chris Wright <https://github.com/DaveRandom>
* @copyright Copyright (c) Chris Wright <https://github.com/DaveRandom>
* @license http://www.opensource.org/licenses/mit-license.html MIT License
* @version 2.0.0
*/
namespace WP_Ultimo\Dependencies\LibDNS\Records\Types;
/**
* Represents an IPv6 address
*
* @category LibDNS
* @package Types
* @author Chris Wright <https://github.com/DaveRandom>
*/
class IPv6Address extends Type
{
/**
* @var string
*/
protected $value = '::';
/**
* @var int[] The shorts of the address
*/
private $shorts = [0, 0, 0, 0, 0, 0, 0, 0];
/**
* Create a compressed string representation of an IPv6 address
*
* @param int[] $shorts Address shorts
* @return string
*/
private function createCompressedString($shorts)
{
$compressLen = $compressPos = $currentLen = $currentPos = 0;
$inBlock = \false;
for ($i = 0; $i < 8; $i++) {
if ($shorts[$i] === 0) {
if (!$inBlock) {
$inBlock = \true;
$currentPos = $i;
}
$currentLen++;
} else {
if ($inBlock) {
if ($currentLen > $compressLen) {
$compressLen = $currentLen;
$compressPos = $currentPos;
}
$inBlock = \false;
$currentPos = $currentLen = 0;
}
}
$shorts[$i] = \dechex($shorts[$i]);
}
if ($inBlock) {
$compressLen = $currentLen;
$compressPos = $currentPos;
}
if ($compressLen > 1) {
if ($compressLen === 8) {
$replace = ['', '', ''];
} else {
if ($compressPos === 0 || $compressPos + $compressLen === 8) {
$replace = ['', ''];
} else {
$replace = [''];
}
}
\array_splice($shorts, $compressPos, $compressLen, $replace);
}
return \implode(':', $shorts);
}
/**
* Constructor
*
* @param string|int[] $value String representation or shorts list
* @throws \UnexpectedValueException When the supplied value is not a valid IPv6 address
*/
public function __construct($value = null)
{
if (\is_array($value)) {
$this->setShorts($value);
} else {
parent::__construct($value);
}
}
/**
* Set the internal value
*
* @param string $value The new value
* @throws \UnexpectedValueException When the supplied value is outside the valid length range 0 - 65535
*/
public function setValue($value)
{
$shorts = \explode(':', (string) $value);
$count = \count($shorts);
if ($count < 3 || $count > 8) {
throw new \UnexpectedValueException('Value is not a valid IPv6 address: invalid short count');
} else {
if ($shorts[0] === '' && $shorts[1] === '') {
$shorts = \array_pad($shorts, -8, '0');
} else {
if ($shorts[$count - 2] === '' && $shorts[$count - 1] === '') {
$shorts = \array_pad($shorts, 8, '0');
} else {
if (\false !== ($pos = \array_search('', $shorts, \true))) {
\array_splice($shorts, $pos, 1, \array_fill(0, 8 - ($count - 1), '0'));
}
}
}
}
$this->setShorts(\array_map('hexdec', $shorts));
}
/**
* Get the address shorts
*
* @return int[]
*/
public function getShorts() : array
{
return $this->shorts;
}
/**
* Set the address shorts
*
* @param int[] $shorts The new address shorts
* @throws \UnexpectedValueException When the supplied short list is not a valid IPv6 address
*/
public function setShorts(array $shorts)
{
if (\count($shorts) !== 8) {
throw new \UnexpectedValueException('Short list is not a valid IPv6 address: invalid short count');
}
foreach ($shorts as &$short) {
if (!\is_int($short) && !\ctype_digit((string) $short) || $short < 0x0 || $short > 0xffff) {
throw new \UnexpectedValueException('Short list is not a valid IPv6 address: invalid short value ' . $short);
}
$short = (int) $short;
}
$this->shorts = \array_values($shorts);
$this->value = $this->createCompressedString($this->shorts);
}
}

52
dependencies/daverandom/libdns/src/Records/Types/Long.php vendored Normal file
View File

@@ -0,0 +1,52 @@
<?php
declare (strict_types=1);
/**
* Represents a 32-bit unsigned integer
*
* PHP version 5.4
*
* @category LibDNS
* @package Types
* @author Chris Wright <https://github.com/DaveRandom>
* @copyright Copyright (c) Chris Wright <https://github.com/DaveRandom>
* @license http://www.opensource.org/licenses/mit-license.html MIT License
* @version 2.0.0
*/
namespace WP_Ultimo\Dependencies\LibDNS\Records\Types;
/**
* Represents a 32-bit unsigned integer
*
* @category LibDNS
* @package Types
* @author Chris Wright <https://github.com/DaveRandom>
*/
class Long extends Type
{
/**
* @var int
*/
protected $value = 0;
/**
* Set the internal value
*
* @param string $value The new value
* @throws \UnderflowException When the supplied value is less than 0
* @throws \OverflowException When the supplied value is greater than 4294967296
*/
public function setValue($value)
{
$value = (int) $value;
if (\PHP_INT_SIZE > 4) {
if ($value < 0) {
throw new \UnderflowException('Long integer value must be in the range 0 - 4294967296');
} else {
if ($value > 0xffffffff) {
throw new \OverflowException('Long integer value must be in the range 0 - 4294967296');
}
}
}
$this->value = $value;
}
}

50
dependencies/daverandom/libdns/src/Records/Types/Short.php vendored Normal file
View File

@@ -0,0 +1,50 @@
<?php
declare (strict_types=1);
/**
* Represents a 16-bit unsigned integer
*
* PHP version 5.4
*
* @category LibDNS
* @package Types
* @author Chris Wright <https://github.com/DaveRandom>
* @copyright Copyright (c) Chris Wright <https://github.com/DaveRandom>
* @license http://www.opensource.org/licenses/mit-license.html MIT License
* @version 2.0.0
*/
namespace WP_Ultimo\Dependencies\LibDNS\Records\Types;
/**
* Represents a 16-bit unsigned integer
*
* @category LibDNS
* @package Types
* @author Chris Wright <https://github.com/DaveRandom>
*/
class Short extends Type
{
/**
* @var int
*/
protected $value = 0;
/**
* Set the internal value
*
* @param string $value The new value
* @throws \UnderflowException When the supplied value is less than 0
* @throws \OverflowException When the supplied value is greater than 65535
*/
public function setValue($value)
{
$value = (int) $value;
if ($value < 0) {
throw new \UnderflowException('Short integer value must be in the range 0 - 65535');
} else {
if ($value > 0xffff) {
throw new \OverflowException('Short integer value must be in the range 0 - 65535');
}
}
$this->value = $value;
}
}

68
dependencies/daverandom/libdns/src/Records/Types/Type.php vendored Normal file
View File

@@ -0,0 +1,68 @@
<?php
declare (strict_types=1);
/**
* Base class for simple data types
*
* PHP version 5.4
*
* @category LibDNS
* @package Types
* @author Chris Wright <https://github.com/DaveRandom>
* @copyright Copyright (c) Chris Wright <https://github.com/DaveRandom>
* @license http://www.opensource.org/licenses/mit-license.html MIT License
* @version 2.0.0
*/
namespace WP_Ultimo\Dependencies\LibDNS\Records\Types;
/**
* Base class for simple data types
*
* @category LibDNS
* @package Types
* @author Chris Wright <https://github.com/DaveRandom>
*/
abstract class Type
{
/**
* @var mixed The internal value
*/
protected $value;
/**
* Constructor
*
* @param string $value Internal value
* @throws \RuntimeException When the supplied value is invalid
*/
public function __construct(string $value = null)
{
if (isset($value)) {
$this->setValue($value);
}
}
/**
* Magic method for type coercion to string
*
* @return string
*/
public function __toString() : string
{
return (string) $this->value;
}
/**
* Get the internal value
*
* @return mixed
*/
public function getValue()
{
return $this->value;
}
/**
* Set the internal value
*
* @param string $value The new value
* @throws \RuntimeException When the supplied value is invalid
*/
public abstract function setValue($value);
}

54
dependencies/daverandom/libdns/src/Records/Types/TypeBuilder.php vendored Normal file
View File

@@ -0,0 +1,54 @@
<?php
declare (strict_types=1);
/**
* Builds Types from type definitions
*
* PHP version 5.4
*
* @category LibDNS
* @package Types
* @author Chris Wright <https://github.com/DaveRandom>
* @copyright Copyright (c) Chris Wright <https://github.com/DaveRandom>
* @license http://www.opensource.org/licenses/mit-license.html MIT License
* @version 2.0.0
*/
namespace WP_Ultimo\Dependencies\LibDNS\Records\Types;
/**
* Builds Types from type definitions
*
* @category LibDNS
* @package Types
* @author Chris Wright <https://github.com/DaveRandom>
*/
class TypeBuilder
{
/**
* @var \LibDNS\Records\Types\TypeFactory
*/
private $typeFactory;
/**
* Constructor
*
* @param \LibDNS\Records\Types\TypeFactory $typeFactory
*/
public function __construct(TypeFactory $typeFactory)
{
$this->typeFactory = $typeFactory;
}
/**
* Build a new Type object corresponding to a resource record type
*
* @param int $type Data type, can be indicated using the Types enum
* @return \LibDNS\Records\Types\Type
*/
public function build(int $type) : Type
{
static $typeMap = [Types::ANYTHING => 'createAnything', Types::BITMAP => 'createBitMap', Types::CHAR => 'createChar', Types::CHARACTER_STRING => 'createCharacterString', Types::DOMAIN_NAME => 'createDomainName', Types::IPV4_ADDRESS => 'createIPv4Address', Types::IPV6_ADDRESS => 'createIPv6Address', Types::LONG => 'createLong', Types::SHORT => 'createShort'];
if (!isset($typeMap[$type])) {
throw new \InvalidArgumentException('Invalid Type identifier ' . $type);
}
return $this->typeFactory->{$typeMap[$type]}();
}
}

117
dependencies/daverandom/libdns/src/Records/Types/TypeFactory.php vendored Normal file
View File

@@ -0,0 +1,117 @@
<?php
declare (strict_types=1);
/**
* Creates Type objects
*
* PHP version 5.4
*
* @category LibDNS
* @package Types
* @author Chris Wright <https://github.com/DaveRandom>
* @copyright Copyright (c) Chris Wright <https://github.com/DaveRandom>
* @license http://www.opensource.org/licenses/mit-license.html MIT License
* @version 2.0.0
*/
namespace WP_Ultimo\Dependencies\LibDNS\Records\Types;
/**
* Creates Type objects
*
* @category LibDNS
* @package Types
* @author Chris Wright <https://github.com/DaveRandom>
*/
class TypeFactory
{
/**
* Create a new Anything object
*
* @param string $value
* @return \LibDNS\Records\Types\Anything
*/
public function createAnything(string $value = null)
{
return new Anything($value);
}
/**
* Create a new BitMap object
*
* @param string $value
* @return \LibDNS\Records\Types\BitMap
*/
public function createBitMap(string $value = null)
{
return new BitMap($value);
}
/**
* Create a new Char object
*
* @param int $value
* @return \LibDNS\Records\Types\Char
*/
public function createChar(int $value = null)
{
return new Char((string) $value);
}
/**
* Create a new CharacterString object
*
* @param string $value
* @return \LibDNS\Records\Types\CharacterString
*/
public function createCharacterString(string $value = null)
{
return new CharacterString($value);
}
/**
* Create a new DomainName object
*
* @param string|string[] $value
* @return \LibDNS\Records\Types\DomainName
*/
public function createDomainName($value = null)
{
return new DomainName($value);
}
/**
* Create a new IPv4Address object
*
* @param string|int[] $value
* @return \LibDNS\Records\Types\IPv4Address
*/
public function createIPv4Address($value = null)
{
return new IPv4Address($value);
}
/**
* Create a new IPv6Address object
*
* @param string|int[] $value
* @return \LibDNS\Records\Types\IPv6Address
*/
public function createIPv6Address($value = null)
{
return new IPv6Address($value);
}
/**
* Create a new Long object
*
* @param int $value
* @return \LibDNS\Records\Types\Long
*/
public function createLong(int $value = null)
{
return new Long((string) $value);
}
/**
* Create a new Short object
*
* @param int $value
* @return \LibDNS\Records\Types\Short
*/
public function createShort(int $value = null)
{
return new Short((string) $value);
}
}

37
dependencies/daverandom/libdns/src/Records/Types/Types.php vendored Normal file
View File

@@ -0,0 +1,37 @@
<?php
declare (strict_types=1);
/**
* Enumeration of simple data types
*
* PHP version 5.4
*
* @category LibDNS
* @package Types
* @author Chris Wright <https://github.com/DaveRandom>
* @copyright Copyright (c) Chris Wright <https://github.com/DaveRandom>
* @license http://www.opensource.org/licenses/mit-license.html MIT License
* @version 2.0.0
*/
namespace WP_Ultimo\Dependencies\LibDNS\Records\Types;
use WP_Ultimo\Dependencies\LibDNS\Enumeration;
/**
* Enumeration of simple data types
*
* @category LibDNS
* @package Types
* @author Chris Wright <https://github.com/DaveRandom>
*/
final class Types extends Enumeration
{
const ANYTHING = 0b1;
const BITMAP = 0b10;
const CHAR = 0b100;
const CHARACTER_STRING = 0b1000;
const DOMAIN_NAME = 0b10000;
const IPV4_ADDRESS = 0b100000;
const IPV6_ADDRESS = 0b1000000;
const LONG = 0b10000000;
const SHORT = 0b100000000;
}