AbstractResolver::allowsRecursion() - Code Metrics - samuelwilliams/PHP-DNS-SERVER - Measure and Improve Code Quality continuously with Scrutinizer

AbstractResolver::allowsRecursion() A
last analyzed 2020-03-05 01:39 UTC

↳ 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	1
Bugs	0	Features	0

Metric	Value
cc	1
eloc	1
c	1
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\RecordTypeEnum;
use yswery\DNS\ResourceRecord;
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\RecordTypeEnum;
15		use yswery\DNS\ResourceRecord;
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		/**
49		* @param ResourceRecord[] $queries
50		*
51		* @return array
52		*/
53	28	public function getAnswer(array $queries, ?string $client = null): array
54		{
55	28	$answers = [];
56	28	foreach ($queries as $query) {
57	27	$answer = $this->resourceRecords[$query->getName()][$query->getType()][$query->getClass()] ?? [];
58	27	if (empty($answer)) {
59	11	$answer = $this->findWildcardEntry($query);
60		}
61
62	27	$answers = array_merge($answers, $answer);
63		}
64
65	28	return $answers;
66		}
67
68		/**
69		* {@inheritdoc}
70		*/
71	10	public function allowsRecursion(): bool
72		{
73	10	return $this->allowRecursion;
74		}
75
76		/**
77		* {@inheritdoc}
78		*/
79	9	public function isAuthority($domain): bool
80		{
81	9	return $this->isAuthoritative;
82		}
83
84		/**
85		* {@inheritdoc}
86		*/
87		public function supportsSaving()
88		{
89		return $this->supportsSaving;
90		}
91
92		/**
93		* Determine if a domain is a wildcard domain.
94		*
95		* @param string $domain
96		*
97		* @return bool
98		*/
99	42	public function isWildcardDomain(string $domain): bool
100		{
101	42	$domain = rtrim($domain, '.').'.';
102	42	$pattern = '/^\\.(?:[a-zA-Z0-9\-\_]+\.)$/';
103
104	42	return (bool) preg_match($pattern, $domain);
105		}
106
107		/**
108		* @param ResourceRecord[] $resourceRecords
109		*/
110	42	protected function addZone(array $resourceRecords): void
111		{
112	42	foreach ($resourceRecords as $resourceRecord) {
113	42	if ($this->isWildcardDomain($resourceRecord->getName())) {
114	42	$this->addWildcardRecord($resourceRecord);
115	42	continue;
116		}
117	42	$this->resourceRecords[$resourceRecord->getName()][$resourceRecord->getType()][$resourceRecord->getClass()][] = $resourceRecord;
118		}
119	42	}
120
121		/**
122		* Add a wildcard ResourceRecord.
123		*
124		* @param ResourceRecord $resourceRecord
125		*/
126	42	protected function addWildcardRecord(ResourceRecord $resourceRecord): void
127		{
128	42	$labels = explode('.', rtrim($resourceRecord->getName(), '.'));
129	42	$labels = array_reverse($labels);
130
131	42	$array = &$this->wildcardRecords;
132	42	foreach ($labels as $label) {
133	42	if ('*' === $label) {
134	42	$array[$label][$resourceRecord->getClass()][$resourceRecord->getType()][] = $resourceRecord;
135	42	break;
136		}
137
138	42	$array = &$array[$label];
139		}
140	42	}
141
142		/**
143		* @param ResourceRecord $query
144		*
145		* @return array
146		*/
147	11	protected function findWildcardEntry(ResourceRecord $query): array
148		{
149	11	$labels = explode('.', rtrim($query->getName(), '.'));
150	11	$labels = array_reverse($labels);
151
152		/** @var ResourceRecord[] $wildcards */
153	11	$wildcards = [];
154	11	$array = &$this->wildcardRecords;
155	11	foreach ($labels as $label) {
156	11	if (array_key_exists($label, $array)) {
157	11	$array = &$array[$label];
158	11	continue;
159		}
160
161	11	if (array_key_exists('*', $array)) {
162	4	$wildcards = $array['*'][$query->getClass()][$query->getType()] ?? [];
163		}
164		}
165
166	11	$answers = [];
167	11	foreach ($wildcards as $wildcard) {
168	4	$rr = clone $wildcard;
169	4	$rr->setName($query->getName());
170	4	$answers[] = $rr;
171		}
172
173	11	return $answers;
174		}
175
176		/**
177		* Add the parent domain to names that are not fully qualified.
178		*
179		* AbstractResolver::handleName('www', 'example.com.') //Outputs 'www.example.com.'
180		* AbstractResolver::handleName('@', 'example.com.') //Outputs 'example.com.'
181		* AbstractResolver::handleName('ns1.example.com.', 'example.com.') //Outputs 'ns1.example.com.'
182		*
183		* @param $name
184		* @param $parent
185		*
186		* @return string
187		*/
188	42	protected function handleName(string $name, string $parent)
189		{
190	42	if ('@' === $name \|\| '' === $name) {
191	42	return $parent;
192		}
193
194	42	if ('.' !== substr($name, -1, 1)) {
195	42	return $name.'.'.$parent;
196		}
197
198	42	return $name;
199		}
200
201		/**
202		* @param array $resourceRecord
203		* @param int $type
204		* @param string $parent
205		*
206		* @return mixed
207		*
208		* @throws UnsupportedTypeException
209		*/
210	42	protected function extractRdata(array $resourceRecord, int $type, string $parent)
211		{
212	42	switch ($type) {
213		case RecordTypeEnum::TYPE_A:
214		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		case RecordTypeEnum::TYPE_SOA:
221		return [
222	42	'mname' => $this->handleName($resourceRecord['mname'], $parent),
223	42	'rname' => $this->handleName($resourceRecord['rname'], $parent),
224	42	'serial' => $resourceRecord['serial'],
225	42	'refresh' => $resourceRecord['refresh'],
226	42	'retry' => $resourceRecord['retry'],
227	42	'expire' => $resourceRecord['expire'],
228	42	'minimum' => $resourceRecord['minimum'],
229		];
230		case RecordTypeEnum::TYPE_MX:
231		return [
232	42	'preference' => $resourceRecord['preference'],
233	42	'exchange' => $this->handleName($resourceRecord['exchange'], $parent),
234		];
235		case RecordTypeEnum::TYPE_TXT:
236	23	return $resourceRecord['text'];
237		case RecordTypeEnum::TYPE_SRV:
238		return [
239	42	'priority' => (int) $resourceRecord['priority'],
240	42	'weight' => (int) $resourceRecord['weight'],
241	42	'port' => (int) $resourceRecord['port'],
242	42	'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(sprintf('Resource Record type "%s" is not a supported type.', RecordTypeEnum::getName($type)));
249		}
250		}
251		}
252

samuelwilliams / PHP-DNS-SERVER

AbstractResolver::allowsRecursion() A last analyzed 2020-03-05 01:39 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

AbstractResolver::allowsRecursion() A
last analyzed 2020-03-05 01:39 UTC