Afonso\Dns\Serializer

Complexity

Total Complexity

22

Size/Duplication

Total Lines	244
Duplicated Lines	0 %

Test Coverage

Coverage

98.35%

Importance

Changes	5
Bugs	0	Features	0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	serializeRequest()	0	51	3
A	readInt()	0	7	2
C	deserializeResponse()	0	139	12
A	readNameField()	0	28	5

<?php

declare(strict_types=1);

namespace Afonso\Dns;

class Serializer implements SerializerInterface
{
    public function serializeRequest(Request $request): string
    {
        $bytes = [];

        /*
         * Header
         */
        // ID (0x00 - 0x15)
        $bytes = array_merge($bytes, [0xAA, 0xAA]);

        // QR, OPCODE, AA, TC, RD, RA, RCODE (0x16 - 0x31)
        $bytes += array_merge($bytes, [0x01, 0x00]);

        // QDCOUNT (0x32 - 0x47)
        $bytes += array_merge($bytes, [0x00, 0x01]);

        // ANCOUNT (0x48 - 0x63)
        $bytes += array_merge($bytes, [0x00, 0x00]);

        // NSCOUNT (0x64 - 0x79)
        $bytes += array_merge($bytes, [0x00, 0x00]);

        // ARCOUNT (0x80 - 0x95)
        $bytes += array_merge($bytes, [0x00, 0x00]);

        /*
         * Question
         */
        // QNAME
        $qname = [];
        $labels = explode('.', $request->getName());
        foreach ($labels as $label) {
            $labelLength = strlen($label);
            if ($labelLength > 63) {
                throw new \InvalidArgumentException(
                    'At least one of the labels of the specified domain exceeds the allowed maximum length'
                );
            }
            $qname = array_merge($qname, [$labelLength]);
            $qname = array_merge($qname, array_map('ord', str_split($label)));
        }
        $qname = array_merge($qname, [0x00]);
        $bytes += array_merge($bytes, $qname);

        // QTYPE
        $bytes += array_merge($bytes, [0x00, $request->getType()]);

        // QCLASS
        $bytes += array_merge($bytes, [0x00, 0x01]);

        return implode(array_map('chr', $bytes));
    }

    public function deserializeResponse(string $response): Response
    {
        $responseObj = new Response();

        $bytes = array_map('ord', str_split($response));

        // To-Do: check that response is actually a response (QR)

        /*
         * Header
         */
        $isAuthoritative = (bool) ($bytes[2] & 0x04);
        $isRecursionAvailable = (bool) ($bytes[3] & 0x80);
        $type = $bytes[3] & 0x0F;

        [$_, $qdCount] = $this->readInt($bytes, 4, 2);

This list assign is not used and could be removed.

        [$_, $anCount] = $this->readInt($bytes, 6, 2);
        [$_, $nsCount] = $this->readInt($bytes, 8, 2);

This list assign is not used and could be removed.

        [$_, $arCount] = $this->readInt($bytes, 10, 2);

This list assign is not used and could be removed.

        $responseObj->setAuthoritative($isAuthoritative);
        $responseObj->setRecursionAvailable($isRecursionAvailable);
        $responseObj->setType($type);

        // From now on there are variable-length fields, so we need to keep
        // track of the current byte position.
        $ptr = 12;

        /*
         * Question
         */
        // QNAME
        while ($bytes[$ptr] > 0x00) {
            $labelLength = $bytes[$ptr];
            // Just skip the label for the time being
            // $label = implode('', array_map('chr', array_slice($bytes, $ptr + 1, $labelLength)));
            $ptr += $labelLength + 1;
        }
        $ptr++; // End of field

        // QTYPE
        $ptr += 2;

        // CLASS
        $ptr += 2;

        /*
         * Answer
         */
        for ($i = 0; $i < $anCount; $i++) {
            // NAME
            [$ptr, $name] = $this->readNameField($bytes, $ptr);

            // TYPE
            [$ptr, $type] = $this->readInt($bytes, $ptr, 2);

            // CLASS
            $ptr += 2;

            // TTL
            [$ptr, $ttl] = $this->readInt($bytes, $ptr, 4);

            // RDATA
            [$ptr, $rdLength] = $this->readInt($bytes, $ptr, 2);
            switch ($type) {
                case ResourceRecord::TYPE_A:
                    $address = $bytes[$ptr++] . '.' . $bytes[$ptr++] . '.' . $bytes[$ptr++] . '.' . $bytes[$ptr++];
                    $record = new AResourceRecord($name, $ttl, $address);
                    break;
                case ResourceRecord::TYPE_NS:
                    [$ptr, $nameserver] = $this->readNameField($bytes, $ptr);
                    $record = new NsResourceRecord($name, $ttl, $nameserver);
                    break;
                case ResourceRecord::TYPE_CNAME:
                    [$ptr, $canonicalName] = $this->readNameField($bytes, $ptr);
                    $record= new CnameResourceRecord($name, $ttl, $canonicalName);
                    break;
                case ResourceRecord::TYPE_PTR:
                    [$ptr, $targetName] = $this->readNameField($bytes, $ptr);
                    $record = new PtrResourceRecord($name, $ttl, $targetName);
                    break;
                case ResourceRecord::TYPE_SOA:
                    [$ptr, $primaryNs] = $this->readNameField($bytes, $ptr);
                    [$ptr, $adminMb] = $this->readNameField($bytes, $ptr);
                    [$ptr, $serialNo] = $this->readInt($bytes, $ptr, 4);
                    [$ptr, $refreshInterval] = $this->readInt($bytes, $ptr, 4);
                    [$ptr, $retryInterval] = $this->readInt($bytes, $ptr, 4);
                    [$ptr, $expirationLimit] = $this->readInt($bytes, $ptr, 4);
                    [$ptr, $minimumTtl] = $this->readInt($bytes, $ptr, 4);
                    $record = new SoaResourceRecord(
                        $name,
                        $ttl,
                        $primaryNs,
                        $adminMb,
                        $serialNo,
                        $refreshInterval,
                        $retryInterval,
                        $expirationLimit,
                        $minimumTtl
                    );
                    break;
                case ResourceRecord::TYPE_MX:
                    [$ptr, $preference] = $this->readInt($bytes, $ptr, 2);
                    [$ptr, $exchanger] = $this->readNameField($bytes, $ptr);
                    $record= new MxResourceRecord($name, $ttl, $preference, $exchanger);
                    break;
                case ResourceRecord::TYPE_SRV:
                    [$ptr, $priority] = $this->readInt($bytes, $ptr, 2);
                    [$ptr, $weight] = $this->readInt($bytes, $ptr, 2);
                    [$ptr, $port] = $this->readInt($bytes, $ptr, 2);
                    [$ptr, $target] = $this->readNameField($bytes, $ptr);
                    $record = new SrvResourceRecord($name, $ttl, $priority, $weight, $port, $target);
                    break;
                case ResourceRecord::TYPE_AAAA:
                    $packed = '';
                    for ($i = 0; $i < 16; $i++) {
                        $packed .= chr($bytes[$ptr++]);
                    }
                    $address = inet_ntop($packed);
                    $record = new AaaaResourceRecord($name, $ttl, $address);
                    break;
                default:
                    throw new \RuntimeException("Reading responses for resource type '{$type}' is not implemented");
            }

            $responseObj->addResourceRecord($record);
        }

        /*
         * Authority
         */
        // Intentionally skipped

        /*
         * Additional
         */
        // Intentionally skipped

        return $responseObj;
    }

    private function readNameField(array $bytes, int $ptr): array
    {
        while (true) {
            // Zero byte means we hit end of name field. Break the loop.
            if ($bytes[$ptr] == 0) {
                $ptr++;
                break;
            }

            $format = $bytes[$ptr] & 0xC0;
            $length = $offset = 0;

The assignment to $length is dead and can be removed.

            if ($format == 0xC0) { // Pointer format
                $offset = ($bytes[$ptr++] << 8 | $bytes[$ptr++]) & 0x3F;
                [$_, $label] = $this->readNameField($bytes, $offset);
                $labels[] = $label;
                // Pointer ends the name field. Break the loop.
                break;
            } elseif ($format == 0x00) {  // Label format
                $length = $bytes[$ptr++] & 0x3F;
                $labels[] = implode('', array_map('chr', array_slice($bytes, $ptr, $length)));
                $ptr += $length;
            } else {
                throw new \RuntimeException("Unrecognized format '${format}' in response");
            }
        }

        return [$ptr, implode('.', $labels)];

The variable $labels does not seem to be defined for all execution paths leading up to this point.

    }

    /**
     * Reads and returns an integer from the given byte array, at the specified
     * offset and with the specified length in bytes.
     *
     * @param int[] $byteArray
     * @param int $ptr
     * @param int $bytes
     * @return int[] An array of size 2, the first item being the updated
     * pointer (after the read operation) and the second item being the actual
     * integer that was read.
     */
    private function readInt(array $byteArray, int $ptr, int $bytes): array
    {
        $int = 0;
        for ($i = $bytes - 1; $i >= 0; $i--) {
            $int |= $byteArray[$ptr++] << 8 * $i;
        }
        return [$ptr, $int];
    }
}