AbstractResolver::supportsSaving() - Code Metrics - Inspection of "Added humbug/box as dev dependency." - samuelwilliams/PHP-DNS-SERVER - Measure and Improve Code Quality continuously with Scrutinizer

Test Setup Failed

Push — master ( 46ef65...ecf71f )

by Sam

created 2020-02-21 19:42 UTC

AbstractResolver::supportsSaving() A

↳ Parent: AbstractResolver

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

Metric	Value
cc	1
eloc	1
c	0
b	0
f	0
nc	1
nop	0
dl	0
loc	3
ccs	2
cts	2
cp	1
crap	1
rs	10

<?php

/*
 * This file is part of PHP DNS Server.
 *
 * (c) Yif Swery <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace yswery\DNS\Resolver;

use yswery\DNS\ResourceRecord;
use yswery\DNS\RecordTypeEnum;
use yswery\DNS\UnsupportedTypeException;

abstract class AbstractResolver implements ResolverInterface
{
    /**
     * @var bool
     */
    protected $allowRecursion;

    /**
     * @var bool
     */
    protected $isAuthoritative;

    /**
     * @var bool
     */
    protected $supportsSaving = false;

    /**
     * @var ResourceRecord[]
     */
    protected $resourceRecords = [];

    /**
     * Wildcard records are stored as an associative array of labels in reverse. E.g.
     * ResourceRecord for "*.example.com." is stored as ['com']['example']['*'][<CLASS>][<TYPE>][].
     *
     * @var ResourceRecord[]
     */
    protected $wildcardRecords = [];

    /**
     * @param ResourceRecord[] $queries
     *
     * @return array
     */
    public function getAnswer(array $queries, ?string $client = null): array
    {
        $answers = [];
        foreach ($queries as $query) {
            $answer = $this->resourceRecords[$query->getName()][$query->getType()][$query->getClass()] ?? [];
            if (empty($answer)) {
                $answer = $this->findWildcardEntry($query);
            }

            $answers = array_merge($answers, $answer);
        }

        return $answers;
    }

    /**
     * {@inheritdoc}
     */
    public function allowsRecursion(): bool
    {
        return $this->allowRecursion;
    }

    /**
     * {@inheritdoc}
     */
    public function isAuthority($domain): bool
    {
        return $this->isAuthoritative;
    }

    /**
     * {@inheritdoc}
     */
    public function supportsSaving()
    {
        return $this->supportsSaving;
    }

    /**
     * Determine if a domain is a wildcard domain.
     *
     * @param string $domain
     *
     * @return bool
     */
    public function isWildcardDomain(string $domain): bool
    {
        $domain = rtrim($domain, '.').'.';
        $pattern = '/^\*\.(?:[a-zA-Z0-9\-\_]+\.)*$/';

        return (bool) preg_match($pattern, $domain);
    }

    /**
     * @param ResourceRecord[] $resourceRecords
     */
    protected function addZone(array $resourceRecords): void
    {
        foreach ($resourceRecords as $resourceRecord) {
            if ($this->isWildcardDomain($resourceRecord->getName())) {
                $this->addWildcardRecord($resourceRecord);
                continue;
            }
            $this->resourceRecords[$resourceRecord->getName()][$resourceRecord->getType()][$resourceRecord->getClass()][] = $resourceRecord;
        }
    }

    /**
     * Add a wildcard ResourceRecord.
     *
     * @param ResourceRecord $resourceRecord
     */
    protected function addWildcardRecord(ResourceRecord $resourceRecord): void
    {
        $labels = explode('.', rtrim($resourceRecord->getName(), '.'));
        $labels = array_reverse($labels);

        $array = &$this->wildcardRecords;
        foreach ($labels as $label) {
            if ('*' === $label) {
                $array[$label][$resourceRecord->getClass()][$resourceRecord->getType()][] = $resourceRecord;
                break;
            }

            $array = &$array[$label];
        }
    }

    /**
     * @param ResourceRecord $query
     *
     * @return array
     */
    protected function findWildcardEntry(ResourceRecord $query): array
    {
        $labels = explode('.', rtrim($query->getName(), '.'));
        $labels = array_reverse($labels);

        /** @var ResourceRecord[] $wildcards */
        $wildcards = [];
        $array = &$this->wildcardRecords;
        foreach ($labels as $label) {
            if (array_key_exists($label, $array)) {
                $array = &$array[$label];
                continue;
            }

            if (array_key_exists('*', $array)) {
                $wildcards = $array['*'][$query->getClass()][$query->getType()] ?? [];
            }
        }

        $answers = [];
        foreach ($wildcards as $wildcard) {
            $rr = clone $wildcard;
            $rr->setName($query->getName());
            $answers[] = $rr;
        }

        return $answers;
    }

    /**
     * Add the parent domain to names that are not fully qualified.
     *
     * AbstractResolver::handleName('www', 'example.com.') //Outputs 'www.example.com.'
     * AbstractResolver::handleName('@', 'example.com.') //Outputs 'example.com.'
     * AbstractResolver::handleName('ns1.example.com.', 'example.com.') //Outputs 'ns1.example.com.'
     *
     * @param $name
     * @param $parent
     *
     * @return string
     */
    protected function handleName(string $name, string $parent)
    {
        if ('@' === $name || '' === $name) {
            return $parent;
        }

        if ('.' !== substr($name, -1, 1)) {
            return $name.'.'.$parent;
        }

        return $name;
    }

    /**
     * @param array  $resourceRecord
     * @param int    $type
     * @param string $parent
     *
     * @return mixed
     *
     * @throws UnsupportedTypeException
     */
    protected function extractRdata(array $resourceRecord, int $type, string $parent)
    {
        switch ($type) {
            case RecordTypeEnum::TYPE_A:
            case RecordTypeEnum::TYPE_AAAA:
                return $resourceRecord['address'];
            case RecordTypeEnum::TYPE_NS:
            case RecordTypeEnum::TYPE_CNAME:
            case RecordTypeEnum::TYPE_PTR:
                return $this->handleName($resourceRecord['target'], $parent);
            case RecordTypeEnum::TYPE_SOA:
                return [
                    'mname' => $this->handleName($resourceRecord['mname'], $parent),
                    'rname' => $this->handleName($resourceRecord['rname'], $parent),
                    'serial' => $resourceRecord['serial'],
                    'refresh' => $resourceRecord['refresh'],
                    'retry' => $resourceRecord['retry'],
                    'expire' => $resourceRecord['expire'],
                    'minimum' => $resourceRecord['minimum'],
                ];
            case RecordTypeEnum::TYPE_MX:
                return [
                    'preference' => $resourceRecord['preference'],
                    'exchange' => $this->handleName($resourceRecord['exchange'], $parent),
                ];
            case RecordTypeEnum::TYPE_TXT:
                return $resourceRecord['text'];
            case RecordTypeEnum::TYPE_SRV:
                return [
                    'priority' => (int) $resourceRecord['priority'],
                    'weight' => (int) $resourceRecord['weight'],
                    'port' => (int) $resourceRecord['port'],
                    'target' => $this->handleName($resourceRecord['target'], $parent),
                ];
            case RecordTypeEnum::TYPE_AXFR:
            case RecordTypeEnum::TYPE_ANY:
                return '';
            default:
                throw new UnsupportedTypeException(
                    sprintf('Resource Record type "%s" is not a supported type.', RecordTypeEnum::getName($type))
                );
        }
    }
}


1		<?php
2
3		/*
4		* This file is part of PHP DNS Server.
5		*
6		* (c) Yif Swery <[email protected]>
7		*
8		* For the full copyright and license information, please view the LICENSE
9		* file that was distributed with this source code.
10		*/
11
12		namespace yswery\DNS\Resolver;
13
14		use yswery\DNS\ResourceRecord;
15		use yswery\DNS\RecordTypeEnum;
16		use yswery\DNS\UnsupportedTypeException;
17
18		abstract class AbstractResolver implements ResolverInterface
19		{
20		/**
21		* @var bool
22		*/
23		protected $allowRecursion;
24
25		/**
26		* @var bool
27		*/
28		protected $isAuthoritative;
29
30		/**
31		* @var bool
32		*/
33		protected $supportsSaving = false;
34
35		/**
36		* @var ResourceRecord[]
37		*/
38		protected $resourceRecords = [];
39
40		/**
41		* Wildcard records are stored as an associative array of labels in reverse. E.g.
42		* ResourceRecord for ".example.com." is stored as ['com']['example'][''][<CLASS>][<TYPE>][].
43		*
44		* @var ResourceRecord[]
45		*/
46		protected $wildcardRecords = [];
47
48	28	/**
49		* @param ResourceRecord[] $queries
50	28	*
51	28	* @return array
52	27	*/
53	27	public function getAnswer(array $queries, ?string $client = null): array
54	11	{
55		$answers = [];
56		foreach ($queries as $query) {
57	27	$answer = $this->resourceRecords[$query->getName()][$query->getType()][$query->getClass()] ?? [];
58		if (empty($answer)) {
59		$answer = $this->findWildcardEntry($query);
60	28	}
61
62		$answers = array_merge($answers, $answer);
63		}
64
65		return $answers;
66	10	}
67
68	10	/**
69		* {@inheritdoc}
70		*/
71		public function allowsRecursion(): bool
72		{
73		return $this->allowRecursion;
74	9	}
75
76	9	/**
77		* {@inheritdoc}
78		*/
79		public function isAuthority($domain): bool
80		{
81		return $this->isAuthoritative;
82		}
83
84		/**
85		* {@inheritdoc}
86	42	*/
87		public function supportsSaving()
88	42	{
89	42	return $this->supportsSaving;
90		}
91	42
92		/**
93		* Determine if a domain is a wildcard domain.
94		*
95		* @param string $domain
96		*
97	42	* @return bool
98		*/
99	42	public function isWildcardDomain(string $domain): bool
100	42	{
101	42	$domain = rtrim($domain, '.').'.';
102	42	$pattern = '/^\\.(?:[a-zA-Z0-9\-\_]+\.)$/';
103
104	42	return (bool) preg_match($pattern, $domain);
105		}
106	42
107		/**
108		* @param ResourceRecord[] $resourceRecords
109		*/
110		protected function addZone(array $resourceRecords): void
111		{
112		foreach ($resourceRecords as $resourceRecord) {
113	42	if ($this->isWildcardDomain($resourceRecord->getName())) {
114		$this->addWildcardRecord($resourceRecord);
115	42	continue;
116	42	}
117		$this->resourceRecords[$resourceRecord->getName()][$resourceRecord->getType()][$resourceRecord->getClass()][] = $resourceRecord;
118	42	}
119	42	}
120	42
121	42	/**
122	42	* Add a wildcard ResourceRecord.
123		*
124		* @param ResourceRecord $resourceRecord
125	42	*/
126		protected function addWildcardRecord(ResourceRecord $resourceRecord): void
127	42	{
128		$labels = explode('.', rtrim($resourceRecord->getName(), '.'));
129		$labels = array_reverse($labels);
130
131		$array = &$this->wildcardRecords;
132		foreach ($labels as $label) {
133		if ('*' === $label) {
134	11	$array[$label][$resourceRecord->getClass()][$resourceRecord->getType()][] = $resourceRecord;
135		break;
136	11	}
137	11
138		$array = &$array[$label];
139		}
140	11	}
141	11
142	11	/**
143	11	* @param ResourceRecord $query
144	11	*
145	11	* @return array
146		*/
147		protected function findWildcardEntry(ResourceRecord $query): array
148	11	{
149	4	$labels = explode('.', rtrim($query->getName(), '.'));
150		$labels = array_reverse($labels);
151
152		/** @var ResourceRecord[] $wildcards */
153	11	$wildcards = [];
154	11	$array = &$this->wildcardRecords;
155	4	foreach ($labels as $label) {
156	4	if (array_key_exists($label, $array)) {
157	4	$array = &$array[$label];
158		continue;
159		}
160	11
161		if (array_key_exists('*', $array)) {
162		$wildcards = $array['*'][$query->getClass()][$query->getType()] ?? [];
163		}
164		}
165
166		$answers = [];
167		foreach ($wildcards as $wildcard) {
168		$rr = clone $wildcard;
169		$rr->setName($query->getName());
170		$answers[] = $rr;
171		}
172
173		return $answers;
174		}
175	42
176		/**
177	42	* Add the parent domain to names that are not fully qualified.
178	42	*
179		* AbstractResolver::handleName('www', 'example.com.') //Outputs 'www.example.com.'
180		* AbstractResolver::handleName('@', 'example.com.') //Outputs 'example.com.'
181	42	* AbstractResolver::handleName('ns1.example.com.', 'example.com.') //Outputs 'ns1.example.com.'
182	42	*
183		* @param $name
184		* @param $parent
185	42	*
186		* @return string
187		*/
188		protected function handleName(string $name, string $parent)
189		{
190		if ('@' === $name \|\| '' === $name) {
191		return $parent;
192		}
193
194		if ('.' !== substr($name, -1, 1)) {
195		return $name.'.'.$parent;
196		}
197	42
198		return $name;
199	42	}
200
201		/**
202	42	* @param array $resourceRecord
203		* @param int $type
204		* @param string $parent
205		*
206	42	* @return mixed
207		*
208		* @throws UnsupportedTypeException
209	42	*/
210	42	protected function extractRdata(array $resourceRecord, int $type, string $parent)
211	42	{
212	42	switch ($type) {
213	42	case RecordTypeEnum::TYPE_A:
214	42	case RecordTypeEnum::TYPE_AAAA:
215	42	return $resourceRecord['address'];
216		case RecordTypeEnum::TYPE_NS:
217		case RecordTypeEnum::TYPE_CNAME:
218		case RecordTypeEnum::TYPE_PTR:
219	42	return $this->handleName($resourceRecord['target'], $parent);
220	42	case RecordTypeEnum::TYPE_SOA:
221		return [
222		'mname' => $this->handleName($resourceRecord['mname'], $parent),
223	23	'rname' => $this->handleName($resourceRecord['rname'], $parent),
224		'serial' => $resourceRecord['serial'],
225		'refresh' => $resourceRecord['refresh'],
226	42	'retry' => $resourceRecord['retry'],
227	42	'expire' => $resourceRecord['expire'],
228	42	'minimum' => $resourceRecord['minimum'],
229	42	];
230		case RecordTypeEnum::TYPE_MX:
231		return [
232		'preference' => $resourceRecord['preference'],
233		'exchange' => $this->handleName($resourceRecord['exchange'], $parent),
234		];
235		case RecordTypeEnum::TYPE_TXT:
236		return $resourceRecord['text'];
237		case RecordTypeEnum::TYPE_SRV:
238		return [
239		'priority' => (int) $resourceRecord['priority'],
240		'weight' => (int) $resourceRecord['weight'],
241		'port' => (int) $resourceRecord['port'],
242		'target' => $this->handleName($resourceRecord['target'], $parent),
243		];
244		case RecordTypeEnum::TYPE_AXFR:
245		case RecordTypeEnum::TYPE_ANY:
246		return '';
247		default:
248		throw new UnsupportedTypeException(
249		sprintf('Resource Record type "%s" is not a supported type.', RecordTypeEnum::getName($type))
250		);
251		}
252		}
253		}
254

samuelwilliams / PHP-DNS-SERVER

Push — master ( 46ef65...ecf71f )

AbstractResolver::supportsSaving() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like