Decoder::decodeType() - Code Metrics - Inspection of "Merge branch Version-1" - samuelwilliams/PHP-DNS-SERVER - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 282f78...6dce89 )

by Sam

created 2018-10-27 09:29 UTC

Decoder::decodeType() C

↳ Parent: Decoder

Complexity

Conditions	12
Paths	12

Size

Total Lines	49
Code Lines	37

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	12
eloc	37
nc	12
nop	2
dl	0
loc	49
rs	6.9666
c	0
b	0
f	0

How to fix Complexity

<?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;

class Decoder
{
    /**
     * @param string $message
     *
     * @return Message
     *
     * @throws UnsupportedTypeException
     */
    public static function decodeMessage(string $message): Message
    {
        $offset = 0;
        $header = self::decodeHeader($message, $offset);

        return (new Message($header))
            ->setQuestions(self::decodeResourceRecords($message, $header->getQuestionCount(), $offset, true))
            ->setAnswers(self::decodeResourceRecords($message, $header->getAnswerCount(), $offset))
            ->setAuthoritatives(self::decodeResourceRecords($message, $header->getNameServerCount(), $offset))
            ->setAdditionals(self::decodeResourceRecords($message, $header->getAdditionalRecordsCount(), $offset));
    }

    /**
     * @param string $string
     * @param int    $offset
     *
     * @return string
     */
    public static function decodeDomainName(string $string, int &$offset = 0): string
    {
        $len = ord($string[$offset]);
        ++$offset;

        if (0 === $len) {
            return '.';
        }

        $domainName = '';
        while (0 !== $len) {
            $domainName .= substr($string, $offset, $len).'.';
            $offset += $len;
            $len = ord($string[$offset]);
            ++$offset;
        }

        return $domainName;
    }

    /**
     * @param string $pkt
     * @param int    $offset
     * @param int    $count      The number of resource records to decode
     * @param bool   $isQuestion Is the resource record from the question section
     *
     * @return ResourceRecord[]
     *
     * @throws UnsupportedTypeException
     */
    public static function decodeResourceRecords(string $pkt, int $count = 1, int &$offset = 0, bool $isQuestion = false): array
    {
        $resourceRecords = [];

        for ($i = 0; $i < $count; ++$i) {
            ($rr = new ResourceRecord())
                ->setQuestion($isQuestion)
                ->setName(self::decodeDomainName($pkt, $offset));

            if ($rr->isQuestion()) {
                $values = unpack('ntype/nclass', substr($pkt, $offset, 4));
                $rr->setType($values['type'])->setClass($values['class']);
                $offset += 4;
            } else {
                $values = unpack('ntype/nclass/Nttl/ndlength', substr($pkt, $offset, 10));
                $rr->setType($values['type'])->setClass($values['class'])->setTtl($values['ttl']);
                $offset += 10;
                $rr->setRdata(self::decodeRdata($rr->getType(), substr($pkt, $offset, $values['dlength'])));
                $offset += $values['dlength'];
            }

            $resourceRecords[] = $rr;
        }

        return $resourceRecords;
    }

    /**
     * @param int    $type
     * @param string $rdata
     *
     * @return array|string|null
     *
     * @throws UnsupportedTypeException
     */
    public static function decodeRdata(int $type, string $rdata)
    {
        switch ($type) {
            case RecordTypeEnum::TYPE_A:
            case RecordTypeEnum::TYPE_AAAA:
                return inet_ntop($rdata);
            case RecordTypeEnum::TYPE_NS:
            case RecordTypeEnum::TYPE_CNAME:
            case RecordTypeEnum::TYPE_PTR:
                return self::decodeDomainName($rdata);
            case RecordTypeEnum::TYPE_SOA:
                $offset = 0;

                return array_merge(
                    [
                        'mname' => self::decodeDomainName($rdata, $offset),
                        'rname' => self::decodeDomainName($rdata, $offset),
                    ],
                    unpack('Nserial/Nrefresh/Nretry/Nexpire/Nminimum', substr($rdata, $offset))
                );
            case RecordTypeEnum::TYPE_MX:
                return [
                    'preference' => unpack('npreference', $rdata)['preference'],
                    'exchange' => self::decodeDomainName(substr($rdata, 2)),
                ];
            case RecordTypeEnum::TYPE_TXT:
                $len = ord($rdata[0]);
                if ((strlen($rdata) + 1) < $len) {
                    return null;
                }

                return substr($rdata, 1, $len);
            case RecordTypeEnum::TYPE_SRV:
                $offset = 6;
                $values = unpack('npriority/nweight/nport', $rdata);
                $values['target'] = self::decodeDomainName($rdata, $offset);

                return $values;
            case RecordTypeEnum::TYPE_AXFR:
            case RecordTypeEnum::TYPE_ANY:
                return null;
            default:
                throw new UnsupportedTypeException(
                    sprintf('Record type "%s" is not a supported type.', RecordTypeEnum::getName($type))
                );
        }
    }

    /**
     * @param string $pkt
     * @param int    $offset
     *
     * @return Header
     */
    public static function decodeHeader(string $pkt, int &$offset = 0): Header
    {
        $data = unpack('nid/nflags/nqdcount/nancount/nnscount/narcount', $pkt);
        $flags = self::decodeFlags($data['flags']);
        $offset += 12;

        return (new Header())
            ->setId($data['id'])
            ->setResponse($flags['qr'])
            ->setOpcode($flags['opcode'])
            ->setAuthoritative($flags['aa'])
            ->setTruncated($flags['tc'])
            ->setRecursionDesired($flags['rd'])
            ->setRecursionAvailable($flags['ra'])
            ->setZ($flags['z'])
            ->setRcode($flags['rcode'])
            ->setQuestionCount($data['qdcount'])
            ->setAnswerCount($data['ancount'])
            ->setNameServerCount($data['nscount'])
            ->setAdditionalRecordsCount($data['arcount']);
    }

    /**
     * @param string $flags
     *
     * @return array
     */
    private static function decodeFlags($flags): array
    {
        return [
            'qr' => $flags >> 15 & 0x1,
            'opcode' => $flags >> 11 & 0xf,
            'aa' => $flags >> 10 & 0x1,
            'tc' => $flags >> 9 & 0x1,
            'rd' => $flags >> 8 & 0x1,
            'ra' => $flags >> 7 & 0x1,
            'z' => $flags >> 4 & 0x7,
            'rcode' => $flags & 0xf,
        ];
    }
}


1			<?php
2			/*
3			* This file is part of PHP DNS Server.
4			*
5			* (c) Yif Swery <[email protected]>
6			*
7			* For the full copyright and license information, please view the LICENSE
8			* file that was distributed with this source code.
9			*/
10
11			namespace yswery\DNS;
12
13			class Decoder
14			{
15			/**
16			* @param string $message
17			*
18			* @return Message
19			*
20			* @throws UnsupportedTypeException
21			*/
22			public static function decodeMessage(string $message): Message
23			{
24			$offset = 0;
25			$header = self::decodeHeader($message, $offset);
26
27			return (new Message($header))
28			->setQuestions(self::decodeResourceRecords($message, $header->getQuestionCount(), $offset, true))
29			->setAnswers(self::decodeResourceRecords($message, $header->getAnswerCount(), $offset))
30			->setAuthoritatives(self::decodeResourceRecords($message, $header->getNameServerCount(), $offset))
31			->setAdditionals(self::decodeResourceRecords($message, $header->getAdditionalRecordsCount(), $offset));
32			}
33
34			/**
35			* @param string $string
36			* @param int $offset
37			*
38			* @return string
39			*/
40			public static function decodeDomainName(string $string, int &$offset = 0): string
41			{
42			$len = ord($string[$offset]);
43			++$offset;
44
45			if (0 === $len) {
46			return '.';
47			}
48
49			$domainName = '';
50			while (0 !== $len) {
51			$domainName .= substr($string, $offset, $len).'.';
52			$offset += $len;
53			$len = ord($string[$offset]);
54			++$offset;
55			}
56
57			return $domainName;
58			}
59
60			/**
61			* @param string $pkt
62			* @param int $offset
63			* @param int $count The number of resource records to decode
64			* @param bool $isQuestion Is the resource record from the question section
65			*
66			* @return ResourceRecord[]
67			*
68			* @throws UnsupportedTypeException
69			*/
70			public static function decodeResourceRecords(string $pkt, int $count = 1, int &$offset = 0, bool $isQuestion = false): array
71			{
72			$resourceRecords = [];
73
74			for ($i = 0; $i < $count; ++$i) {
75			($rr = new ResourceRecord())
76			->setQuestion($isQuestion)
77			->setName(self::decodeDomainName($pkt, $offset));
78
79			if ($rr->isQuestion()) {
80			$values = unpack('ntype/nclass', substr($pkt, $offset, 4));
81			$rr->setType($values['type'])->setClass($values['class']);
82			$offset += 4;
83			} else {
84			$values = unpack('ntype/nclass/Nttl/ndlength', substr($pkt, $offset, 10));
85			$rr->setType($values['type'])->setClass($values['class'])->setTtl($values['ttl']);
86			$offset += 10;
87			$rr->setRdata(self::decodeRdata($rr->getType(), substr($pkt, $offset, $values['dlength'])));
88			$offset += $values['dlength'];
89			}
90
91			$resourceRecords[] = $rr;
92			}
93
94			return $resourceRecords;
95			}
96
97			/**
98			* @param int $type
99			* @param string $rdata
100			*
101			* @return array\|string\|null
102			*
103			* @throws UnsupportedTypeException
104			*/
105			public static function decodeRdata(int $type, string $rdata)
106			{
107			switch ($type) {
108			case RecordTypeEnum::TYPE_A:
109			case RecordTypeEnum::TYPE_AAAA:
110			return inet_ntop($rdata);
111			case RecordTypeEnum::TYPE_NS:
112			case RecordTypeEnum::TYPE_CNAME:
113			case RecordTypeEnum::TYPE_PTR:
114			return self::decodeDomainName($rdata);
115			case RecordTypeEnum::TYPE_SOA:
116			$offset = 0;
117
118			return array_merge(
119			[
120			'mname' => self::decodeDomainName($rdata, $offset),
121			'rname' => self::decodeDomainName($rdata, $offset),
122			],
123			unpack('Nserial/Nrefresh/Nretry/Nexpire/Nminimum', substr($rdata, $offset))
124			);
125			case RecordTypeEnum::TYPE_MX:
126			return [
127			'preference' => unpack('npreference', $rdata)['preference'],
128			'exchange' => self::decodeDomainName(substr($rdata, 2)),
129			];
130			case RecordTypeEnum::TYPE_TXT:
131			$len = ord($rdata[0]);
132			if ((strlen($rdata) + 1) < $len) {
133			return null;
134			}
135
136			return substr($rdata, 1, $len);
137			case RecordTypeEnum::TYPE_SRV:
138			$offset = 6;
139			$values = unpack('npriority/nweight/nport', $rdata);
140			$values['target'] = self::decodeDomainName($rdata, $offset);
141
142			return $values;
143			case RecordTypeEnum::TYPE_AXFR:
144			case RecordTypeEnum::TYPE_ANY:
145			return null;
146			default:
147			throw new UnsupportedTypeException(
148			sprintf('Record type "%s" is not a supported type.', RecordTypeEnum::getName($type))
149			);
150			}
151			}
152
153			/**
154			* @param string $pkt
155			* @param int $offset
156			*
157			* @return Header
158			*/
159			public static function decodeHeader(string $pkt, int &$offset = 0): Header
160			{
161			$data = unpack('nid/nflags/nqdcount/nancount/nnscount/narcount', $pkt);
162			$flags = self::decodeFlags($data['flags']);
163			$offset += 12;
164
165			return (new Header())
166			->setId($data['id'])
167			->setResponse($flags['qr'])
168			->setOpcode($flags['opcode'])
169			->setAuthoritative($flags['aa'])
170			->setTruncated($flags['tc'])
171			->setRecursionDesired($flags['rd'])
172			->setRecursionAvailable($flags['ra'])
173			->setZ($flags['z'])
174			->setRcode($flags['rcode'])
175			->setQuestionCount($data['qdcount'])
176			->setAnswerCount($data['ancount'])
177			->setNameServerCount($data['nscount'])
178			->setAdditionalRecordsCount($data['arcount']);
179			}
180
181			/**
182			* @param string $flags
183			*
184			* @return array
185			*/
186			private static function decodeFlags($flags): array
187			{
188			return [
189			'qr' => $flags >> 15 & 0x1,
190			'opcode' => $flags >> 11 & 0xf,
191			'aa' => $flags >> 10 & 0x1,
192			'tc' => $flags >> 9 & 0x1,
193			'rd' => $flags >> 8 & 0x1,
194			'ra' => $flags >> 7 & 0x1,
195			'z' => $flags >> 4 & 0x7,
196			'rcode' => $flags & 0xf,
197			];
198			}
199			}
200

samuelwilliams / PHP-DNS-SERVER

Push — master ( 282f78...6dce89 )

Decoder::decodeType() C

Complexity

Size

Duplication

Importance

How to fix Complexity

Long Method

Duplication Side-by-Side

Filter issues like