AbstractResolver::extractRdata() - Code Metrics - Inspection of "System resolver can now handle multiple queries." - samuelwilliams/PHP-DNS-SERVER - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 6d3196...8c517a )

by Sam

created 2018-11-23 08:51 UTC

AbstractResolver::extractRdata() C

↳ Parent: AbstractResolver

Complexity

Conditions	12
Paths	12

Size

Total Lines	40
Code Lines	35

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	26
CRAP Score	12.6043

Importance

Changes

Metric	Value
cc	12
eloc	35
nc	12
nop	3
dl	0
loc	40
ccs	26
cts	31
cp	0.8387
crap	12.6043
rs	6.9666
c	0
b	0
f	0

How to fix Complexity

<?php

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 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): 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;
    }

    /**
     * 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()] ?? null;
            }
        }

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

samuelwilliams / PHP-DNS-SERVER

Push — master ( 6d3196...8c517a )

AbstractResolver::extractRdata() C

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Complexity

Long Method

Duplication Side-by-Side

Filter issues like