Badcow\DNS\Rdata\NSEC

Complexity

Total Complexity

17

Size/Duplication

Total Lines	179
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

100%

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	getNextDomainName()	0	4	1
A	setNextDomainName()	0	4	1
A	addType()	0	4	1
A	clearTypes()	0	4	1
A	getTypes()	0	4	1
A	toText()	0	8	1
A	toWire()	0	4	1
A	fromText()	0	13	2
A	fromWire()	0	10	1
A	parseBitmap()	0	21	4
A	renderBitmap()	0	24	3

<?php

declare(strict_types=1);

/*
 * This file is part of Badcow DNS Library.
 *
 * (c) Samuel Williams <sam@badcow.co>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Badcow\DNS\Rdata;

use Badcow\DNS\Parser\Tokens;

class NSEC implements RdataInterface
{
    use RdataTrait;

    const TYPE = 'NSEC';
    const TYPE_CODE = 47;

    /**
     * The Next Domain field contains the next owner name (in the canonical
     * ordering of the zone) that has authoritative data or contains a
     * delegation point NS RR set.
     * {@link https://tools.ietf.org/html/rfc4034#section-4.1.1}.
     *
     * @var string
     */
    private $nextDomainName;

    /**
     * @var array
     */
    private $types = [];

    /**
     * @return string
     */
    public function getNextDomainName(): string
    {
        return $this->nextDomainName;
    }

    /**
     * @param string $nextDomainName
     */
    public function setNextDomainName(string $nextDomainName): void
    {
        $this->nextDomainName = $nextDomainName;
    }

    /**
     * @param string $type
     */
    public function addType(string $type): void
    {
        $this->types[] = $type;
    }

    /**
     * Clears the types from the RDATA.
     */
    public function clearTypes(): void
    {
        $this->types = [];
    }

    /**
     * @return array
     */
    public function getTypes(): array
    {
        return $this->types;
    }

    /**
     * {@inheritdoc}
     */
    public function toText(): string
    {
        return sprintf(
            '%s %s',
            $this->nextDomainName,
            implode(' ', $this->types)
        );
    }

    /**
     * {@inheritdoc}
     *
     * @throws UnsupportedTypeException
     */
    public function toWire(): string
    {
        return self::encodeName($this->nextDomainName).self::renderBitmap($this->types);
    }

    /**
     * {@inheritdoc}
     */
    public static function fromText(string $text): RdataInterface
    {
        $iterator = new \ArrayIterator(explode(Tokens::SPACE, $text));
        $nsec = new self();
        $nsec->setNextDomainName($iterator->current());
        $iterator->next();
        while ($iterator->valid()) {
            $nsec->addType($iterator->current());
            $iterator->next();
        }

        return $nsec;
    }

    /**
     * {@inheritdoc}
     *
     * @throws UnsupportedTypeException
     */
    public static function fromWire(string $rdata): RdataInterface
    {
        $nsec = new self();
        $offset = 0;
        $nsec->setNextDomainName(self::decodeName($rdata, $offset));
        $types = self::parseBitmap($rdata, $offset);
        array_map([$nsec, 'addType'], $types);

        return $nsec;
    }

    /**
     * @param string $rdata
     * @param int    $offset
     *
     * @return string[]
     *
     * @throws UnsupportedTypeException
     */
    public static function parseBitmap(string $rdata, int &$offset): array
    {
        $bytes = unpack('C*', $rdata, $offset);
        $types = [];

        while (count($bytes) > 0) {
            $mask = '';
            $window = array_shift($bytes);
            $len = array_shift($bytes);
            for ($i = 0; $i < $len; ++$i) {
                $mask .= str_pad(decbin(array_shift($bytes)), 8, '0', STR_PAD_LEFT);
            }
            $offset = 0;
            while (false !== $pos = strpos($mask, '1', $offset)) {
                $types[] = TypeCodes::getName((int) $window * 256 + $pos);
                $offset = $pos + 1;
            }
        }

        return $types;
    }

    /**
     * @param string[] $types
     *
     * @return string
     *
     * @throws UnsupportedTypeException
     */
    public static function renderBitmap(array $types): string
    {
        $blocks = [];

        foreach ($types as $type) {
            $int = TypeCodes::getTypeCode($type);
            $window = $int >> 8;
            $int = $int & 0b11111111;
            $mod = $int % 8;
            $mask = $blocks[$window] ?? str_repeat("\0", 32);
            $byteNum = ($int - $mod) / 8;
            $byte = ord($mask[$byteNum]) | (128 >> $mod);
            $mask[$byteNum] = chr($byte);
            $blocks[$window] = $mask;
        }

        $encoded = '';
        foreach ($blocks as $n => $mask) {
            $mask = rtrim($mask, "\0");
            $encoded .= chr($n).chr(strlen($mask)).$mask;
        }

        return $encoded;
    }
}