Factory::NAPTR() - Code Metrics - Inspection of "Implement HIP record." - Badcow/DNS - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — Version3 (b919d6)

by Sam

created 2019-11-26 11:49 UTC

Factory::NAPTR() A

↳ Parent: Factory

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	9
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	12
ccs	9
cts	9
cp	1
rs	9.8666
c	0
b	0
f	0
cc	1
nc	1
nop	6
crap	1

<?php

declare(strict_types=1);

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

namespace Badcow\DNS\Rdata;

use PhpIP\IPBlock;

class Factory
{
    /**
     * Creates a new RData object from a name.
     *
     * @param string $name
     *
     * @throws UnsupportedTypeException
     *
     * @return RdataInterface
     */
    public static function newRdataFromName(string $name): RdataInterface
    {
        if (!self::isTypeImplemented($name)) {
            throw new UnsupportedTypeException($name);
        }

        $className = self::getRdataClassName($name);

        return new $className();
    }

    /**
     * @param int $id
     *
     * @return RdataInterface
     *
     * @throws UnsupportedTypeException
     */
    public static function newRdataFromId(int $id): RdataInterface
    {
        return self::newRdataFromName(TypeCodes::getName($id));
    }

    /**
     * @param string $name
     *
     * @return bool
     */
    public static function isTypeImplemented(string $name): bool
    {
        return class_exists(self::getRdataClassName($name));
    }

    /**
     * @param string $type
     * @param string $text
     *
     * @return RdataInterface
     */
    public static function textToRdataType(string $type, string $text): RdataInterface
    {
        if (!self::isTypeImplemented($type)) {
            return new PolymorphicRdata($type, $text);
        }

        /** @var callable $callable */
        $callable = self::getRdataClassName($type).'::fromText';

        return call_user_func($callable, $text);
    }

    /**
     * Get the fully qualified class name of the RData class for $type.
     *
     * @param string $type
     *
     * @return string
     */
    public static function getRdataClassName(string $type): string
    {
        return __NAMESPACE__.'\\'.strtoupper($type);
    }

    /**
     * Create a new AAAA R-Data object.
     *
     * @param string $address
     *
     * @return AAAA
     */
    public static function AAAA(string $address): AAAA
    {
        $rdata = new AAAA();
        $rdata->setAddress($address);

        return $rdata;
    }

    /**
     * Create a new A R-Data object.
     *
     * @param string $address
     *
     * @return A
     */
    public static function A(string $address): A
    {
        $rdata = new A();
        $rdata->setAddress($address);

        return $rdata;
    }

    /**
     * Create a new CNAME object.
     *
     * @param string $cname
     *
     * @return CNAME
     */
    public static function CNAME(string $cname): CNAME
    {
        $rdata = new CNAME();
        $rdata->setTarget($cname);

        return $rdata;
    }

    /**
     * @param string $cpu
     * @param string $os
     *
     * @return HINFO
     */
    public static function HINFO(string $cpu, string $os): HINFO
    {
        $rdata = new HINFO();
        $rdata->setCpu($cpu);
        $rdata->setOs($os);

        return $rdata;
    }

    /**
     * @param int    $preference
     * @param string $exchange
     *
     * @return MX
     */
    public static function MX(int $preference, string $exchange): MX
    {
        $rdata = new MX();
        $rdata->setPreference($preference);
        $rdata->setExchange($exchange);

        return $rdata;
    }

    /**
     * @param string $mname
     * @param string $rname
     * @param int    $serial
     * @param int    $refresh
     * @param int    $retry
     * @param int    $expire
     * @param int    $minimum
     *
     * @return SOA
     */
    public static function SOA(string $mname, string $rname, int $serial, int $refresh, int $retry, int $expire, int $minimum): SOA
    {
        $rdata = new SOA();
        $rdata->setMname($mname);
        $rdata->setRname($rname);
        $rdata->setSerial($serial);
        $rdata->setRefresh($refresh);
        $rdata->setRetry($retry);
        $rdata->setExpire($expire);
        $rdata->setMinimum($minimum);

        return $rdata;
    }

    /**
     * @param string $nsdname
     *
     * @return NS
     */
    public static function NS(string $nsdname): NS
    {
        $rdata = new NS();
        $rdata->setTarget($nsdname);

        return $rdata;
    }

    /**
     * @param string $text
     *
     * @return TXT
     */
    public static function TXT(string $text): TXT
    {
        $rdata = new TXT();
        $rdata->setText($text);

        return $rdata;
    }

    /**
     * @param string $target
     *
     * @return DNAME
     */
    public static function DNAME(string $target): DNAME
    {
        $rdata = new DNAME();
        $rdata->setTarget($target);

        return $rdata;
    }

    /**
     * @param float $lat
     * @param float $lon
     * @param float $alt
     * @param float $size
     * @param float $hp
     * @param float $vp
     *
     * @return LOC
     */
    public static function LOC(float $lat, float $lon, $alt = 0.0, $size = 1.0, $hp = 10000.0, $vp = 10.0): LOC
    {
        $loc = new LOC();
        $loc->setLatitude($lat);
        $loc->setLongitude($lon);
        $loc->setAltitude($alt);
        $loc->setSize($size);
        $loc->setHorizontalPrecision($hp);
        $loc->setVerticalPrecision($vp);

        return $loc;
    }

    /**
     * @param string $target
     *
     * @return PTR
     */
    public static function PTR(string $target): PTR
    {
        $ptr = new PTR();
        $ptr->setTarget($target);

        return $ptr;
    }

    /**
     * @param int    $flags
     * @param int    $algorithm
     * @param string $publicKey
     *
     * @return DNSKEY
     */
    public static function DNSKEY(int $flags, int $algorithm, string $publicKey): DNSKEY
    {
        $rdata = new DNSKEY();
        $rdata->setFlags($flags);
        $rdata->setAlgorithm($algorithm);
        $rdata->setPublicKey($publicKey);

        return $rdata;
    }

    /**
     * @param int    $keyTag
     * @param int    $algorithm
     * @param string $digest
     * @param int    $digestType
     *
     * @return DS
     */
    public static function DS(int $keyTag, int $algorithm, string $digest, int $digestType = DS::DIGEST_SHA1): DS
    {
        $rdata = new DS();
        $rdata->setKeyTag($keyTag);
        $rdata->setAlgorithm($algorithm);
        $rdata->setDigest($digest);
        $rdata->setDigestType($digestType);

        return $rdata;
    }

    /**
     * @param string $nextDomainName
     * @param array  $types
     *
     * @return NSEC
     */
    public static function NSEC(string $nextDomainName, array $types): NSEC
    {
        $rdata = new NSEC();
        $rdata->setNextDomainName($nextDomainName);
        array_map([$rdata, 'addType'], $types);

        return $rdata;
    }

    /**
     * @param string    $typeCovered
     * @param int       $algorithm
     * @param int       $labels
     * @param int       $originalTtl
     * @param \DateTime $signatureExpiration
     * @param \DateTime $signatureInception
     * @param int       $keyTag
     * @param string    $signersName
     * @param string    $signature
     *
     * @return RRSIG
     */
    public static function RRSIG(string $typeCovered, int $algorithm, int $labels, int $originalTtl,
                                    \DateTime $signatureExpiration, \DateTime $signatureInception, int $keyTag,
                                    string $signersName, string $signature): RRSIG
    {
        $rrsig = new RRSIG();
        $rrsig->setTypeCovered($typeCovered);
        $rrsig->setAlgorithm($algorithm);
        $rrsig->setLabels($labels);
        $rrsig->setOriginalTtl($originalTtl);
        $rrsig->setSignatureExpiration($signatureExpiration);
        $rrsig->setSignatureInception($signatureInception);
        $rrsig->setKeyTag($keyTag);
        $rrsig->setSignersName($signersName);
        $rrsig->setSignature($signature);

        return $rrsig;
    }

    /**
     * @param int    $priority
     * @param int    $weight
     * @param int    $port
     * @param string $target
     *
     * @return SRV
     */
    public static function SRV(int $priority, int $weight, int $port, string $target): SRV
    {
        $rdata = new SRV();
        $rdata->setPriority($priority);
        $rdata->setWeight($weight);
        $rdata->setPort($port);
        $rdata->setTarget($target);

        return $rdata;
    }

    /**
     * @param IPBlock[] $includedRanges
     * @param IPBlock[] $excludedRanges
     *
     * @return APL
     */
    public static function APL(array $includedRanges = [], array $excludedRanges = []): APL
    {
        $rdata = new APL();

        foreach ($includedRanges as $ipBlock) {
            $rdata->addAddressRange($ipBlock, true);
        }

        foreach ($excludedRanges as $ipBlock) {
            $rdata->addAddressRange($ipBlock, false);
        }

        return $rdata;
    }

    /**
     * @param int    $flag
     * @param string $tag
     * @param string $value
     *
     * @return CAA
     */
    public static function CAA(int $flag, string $tag, string $value): CAA
    {
        $rdata = new CAA();
        $rdata->setFlag($flag);
        $rdata->setTag($tag);
        $rdata->setValue($value);

        return $rdata;
    }

    /**
     * @param int    $subType
     * @param string $hostname
     *
     * @return AFSDB
     */
    public static function AFSDB(int $subType, string $hostname): AFSDB
    {
        $afsdb = new AFSDB();
        $afsdb->setSubType($subType);
        $afsdb->setHostname($hostname);

        return $afsdb;
    }

    /**
     * @param int    $flags
     * @param int    $algorithm
     * @param string $publicKey
     *
     * @return CDNSKEY
     */
    public static function CDNSKEY(int $flags, int $algorithm, string $publicKey): CDNSKEY
    {
        $cdnskey = new CDNSKEY();
        $cdnskey->setFlags($flags);
        $cdnskey->setAlgorithm($algorithm);
        $cdnskey->setPublicKey($publicKey);

        return $cdnskey;
    }

    /**
     * @param int    $keyTag
     * @param int    $algorithm
     * @param string $digest
     * @param int    $digestType
     *
     * @return CDS
     */
    public static function CDS(int $keyTag, int $algorithm, string $digest, int $digestType = DS::DIGEST_SHA1): CDS
    {
        $cds = new CDS();
        $cds->setKeyTag($keyTag);
        $cds->setAlgorithm($algorithm);
        $cds->setDigest($digest);
        $cds->setDigestType($digestType);

        return $cds;
    }

    /**
     * @param int|string $certificateType
     * @param int        $keyTag
     * @param int        $algorithm
     * @param string     $certificate
     *
     * @return CERT
     */
    public static function CERT($certificateType, int $keyTag, int $algorithm, string $certificate): CERT
    {
        $cert = new CERT();
        $cert->setCertificateType($certificateType);
        $cert->setKeyTag($keyTag);
        $cert->setAlgorithm($algorithm);
        $cert->setCertificate($certificate);

        return $cert;
    }

    public static function CSYNC(int $soaSerial, int $flags, array $types): CSYNC
    {
        $csync = new CSYNC();
        $csync->setSoaSerial($soaSerial);
        $csync->setFlags($flags);
        array_map([$csync, 'addType'], $types);

        return $csync;
    }

    /**
     * @param string|null $digest         Set to &null if the $identifier and $fqdn are known
     * @param int         $identifierType 16-bit integer
     * @param string|null $identifier     This is ignored if $digest is not &null
     * @param string|null $fqdn           This is ignored if $digest is not &null
     *
     * @return DHCID
     */
    public static function DHCID(?string $digest, int $identifierType, ?string $identifier = null, ?string $fqdn = null): DHCID
    {
        $dhcid = new DHCID();
        if (null !== $digest) {
            $dhcid->setIdentifierType($identifierType);
            $dhcid->setDigest($digest);

            return $dhcid;
        }

        if (null === $identifier || null === $fqdn) {
            throw new \InvalidArgumentException('Identifier and FQDN cannot be null if digest is null.');
        }

        $dhcid->setIdentifier($identifierType, $identifier);
        $dhcid->setFqdn($fqdn);

        return $dhcid;
    }

    /**
     * @param int    $keyTag
     * @param int    $algorithm
     * @param string $digest
     * @param int    $digestType
     *
     * @return DLV
     */
    public static function DLV(int $keyTag, int $algorithm, string $digest, int $digestType = DS::DIGEST_SHA1): DLV
    {
        $rdata = new DLV();
        $rdata->setKeyTag($keyTag);
        $rdata->setAlgorithm($algorithm);
        $rdata->setDigest($digest);
        $rdata->setDigestType($digestType);

        return $rdata;
    }

    /**
     * @param int      $publicKeyAlgorithm
     * @param string   $hostIdentityTag
     * @param string   $publicKey
     * @param string[] $rendezvousServers
     *
     * @return HIP
     */
    public static function HIP(int $publicKeyAlgorithm, string $hostIdentityTag, string $publicKey, array $rendezvousServers): HIP
    {
        $hip = new HIP();
        $hip->setPublicKeyAlgorithm($publicKeyAlgorithm);
        $hip->setHostIdentityTag($hostIdentityTag);
        $hip->setPublicKey($publicKey);
        array_map([$hip, 'addRendezvousServer'], $rendezvousServers);

        return $hip;
    }

    /**
     * @param int         $precedence an 8-bit unsigned integer
     * @param string|null $gateway    either &null for no gateway, a fully qualified domain name, or an IPv4 or IPv6 address
     * @param int         $algorithm  either IPSECKEY::ALGORITHM_NONE, IPSECKEY::ALGORITHM_DSA, IPSECKEY::ALGORITHM_RSA, or IPSECKEY::ALGORITHM_ECDSA
     * @param string|null $publicKey  base64 encoded public key
     *
     * @return IPSECKEY
     */
    public static function IPSECKEY(int $precedence, ?string $gateway, int $algorithm = 0, ?string $publicKey = null): IPSECKEY
    {
        $ipseckey = new IPSECKEY();
        $ipseckey->setPrecedence($precedence);
        $ipseckey->setGateway($gateway);
        $ipseckey->setPublicKey($algorithm, $publicKey);

        return $ipseckey;
    }

    /**
     * @param int    $flags
     * @param int    $protocol
     * @param int    $algorithm
     * @param string $publicKey
     *
     * @return KEY
     */
    public static function KEY(int $flags, int $protocol, int $algorithm, string $publicKey): KEY
    {
        $key = new KEY();
        $key->setFlags($flags);
        $key->setProtocol($protocol);
        $key->setAlgorithm($algorithm);
        $key->setPublicKey($publicKey);

        return $key;
    }

    /**
     * @param int    $preference
     * @param string $exchanger
     *
     * @return KX
     */
    public static function KX(int $preference, string $exchanger): KX
    {
        $kx = new KX();
        $kx->setPreference($preference);
        $kx->setExchanger($exchanger);

        return $kx;
    }

    /**
     * @param int    $order
     * @param int    $preference
     * @param string $flags
     * @param string $services
     * @param string $regexp
     * @param string $replacement
     *
     * @return NAPTR
     */
    public static function NAPTR(int $order, int $preference, string $flags, string $services, string $regexp, string $replacement): NAPTR
    {
        $naptr = new NAPTR();
        $naptr->setOrder($order);
        $naptr->setPreference($preference);
        $naptr->setFlags($flags);
        $naptr->setServices($services);
        $naptr->setRegexp($regexp);
        $naptr->setReplacement($replacement);

        return $naptr;
    }

    public static function NSEC3(int $hashAlgorithm, bool $unsignedDelegationsCovered, int $iterations, string $salt, string $nextHashedOwnerName, array $types): NSEC3
    {
        $nsec3 = new NSEC3();
        $nsec3->setHashAlgorithm($hashAlgorithm);
        $nsec3->setUnsignedDelegationsCovered($unsignedDelegationsCovered);
        $nsec3->setIterations($iterations);
        $nsec3->setSalt($salt);
        $nsec3->setNextHashedOwnerName($nextHashedOwnerName);
        array_map([$nsec3, 'addType'], $types);

        return $nsec3;
    }

    /**
     * @param int    $hashAlgorithm
     * @param int    $flags
     * @param int    $iterations
     * @param string $salt
     *
     * @return NSEC3PARAM
     */
    public static function NSEC3PARAM(int $hashAlgorithm, int $flags, int $iterations, string $salt): NSEC3PARAM
    {
        $nsec3param = new NSEC3PARAM();
        $nsec3param->setHashAlgorithm($hashAlgorithm);
        $nsec3param->setFlags($flags);
        $nsec3param->setIterations($iterations);
        $nsec3param->setSalt($salt);

        return $nsec3param;
    }

    public static function RP(string $mboxDomain, string $txtDomain): RP
    {
        $rp = new RP();
        $rp->setMailboxDomainName($mboxDomain);
        $rp->setTxtDomainName($txtDomain);

        return $rp;
    }

    /**
     * @param string    $typeCovered
     * @param int       $algorithm
     * @param int       $labels
     * @param int       $originalTtl
     * @param \DateTime $signatureExpiration
     * @param \DateTime $signatureInception
     * @param int       $keyTag
     * @param string    $signersName
     * @param string    $signature
     *
     * @return SIG
     */
    public static function SIG(string $typeCovered, int $algorithm, int $labels, int $originalTtl,
                                 \DateTime $signatureExpiration, \DateTime $signatureInception, int $keyTag,
                                 string $signersName, string $signature): SIG
    {
        $sig = new SIG();
        $sig->setTypeCovered($typeCovered);
        $sig->setAlgorithm($algorithm);
        $sig->setLabels($labels);
        $sig->setOriginalTtl($originalTtl);
        $sig->setSignatureExpiration($signatureExpiration);
        $sig->setSignatureInception($signatureInception);
        $sig->setKeyTag($keyTag);
        $sig->setSignersName($signersName);
        $sig->setSignature($signature);

        return $sig;
    }

    /**
     * @param int    $algorithm
     * @param int    $fpType
     * @param string $fingerprint
     *
     * @return SSHFP
     */
    public static function SSHFP(int $algorithm, int $fpType, string $fingerprint): SSHFP
    {
        $sshfp = new SSHFP();
        $sshfp->setAlgorithm($algorithm);
        $sshfp->setFingerprintType($fpType);
        $sshfp->setFingerprint($fingerprint);

        return $sshfp;
    }

    /**
     * @param int    $keyTag
     * @param int    $algorithm
     * @param string $digest
     * @param int    $digestType
     *
     * @return TA
     */
    public static function TA(int $keyTag, int $algorithm, string $digest, int $digestType = DS::DIGEST_SHA1): TA
    {
        $ta = new TA();
        $ta->setKeyTag($keyTag);
        $ta->setAlgorithm($algorithm);
        $ta->setDigest($digest);
        $ta->setDigestType($digestType);

        return $ta;
    }

    /**
     * @param string    $algorithm
     * @param \DateTime $inception
     * @param \DateTime $expiration
     * @param int       $mode
     * @param int       $error
     * @param string    $keyData    binary string
     * @param string    $otherData  binary string
     *
     * @return TKEY
     */
    public static function TKEY(string $algorithm, \DateTime $inception, \DateTime $expiration, int $mode, int $error, string $keyData, string $otherData = ''): TKEY
    {
        $tkey = new TKEY();
        $tkey->setAlgorithm($algorithm);
        $tkey->setInception($inception);
        $tkey->setExpiration($expiration);
        $tkey->setMode($mode);
        $tkey->setError($error);
        $tkey->setKeyData($keyData);
        $tkey->setOtherData($otherData);

        return $tkey;
    }

    public static function TLSA(): TLSA
    {
        // TODO: Implement TLSA() method.
    }

    public static function TSIG(): TSIG
    {
        // TODO: Implement TSIG() method.
    }

    /**
     * @param int    $priority
     * @param int    $weight
     * @param string $target
     *
     * @return URI
     */
    public static function URI(int $priority, int $weight, string $target): URI
    {
        $uri = new URI();
        $uri->setPriority($priority);
        $uri->setWeight($weight);
        $uri->setTarget($target);

        return $uri;
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		/*
6		* This file is part of Badcow DNS Library.
7		*
8		* (c) Samuel Williams <[email protected]>
9		*
10		* For the full copyright and license information, please view the LICENSE
11		* file that was distributed with this source code.
12		*/
13
14		namespace Badcow\DNS\Rdata;
15
16		use PhpIP\IPBlock;
17
18		class Factory
19		{
20		/**
21		* Creates a new RData object from a name.
22		*
23		* @param string $name
24		*
25		* @throws UnsupportedTypeException
26		*
27		* @return RdataInterface
28		*/
29	1	public static function newRdataFromName(string $name): RdataInterface
30		{
31	1	if (!self::isTypeImplemented($name)) {
32	1	throw new UnsupportedTypeException($name);
33		}
34
35	1	$className = self::getRdataClassName($name);
36
37	1	return new $className();
38		}
39
40		/**
41		* @param int $id
42		*
43		* @return RdataInterface
44		*
45		* @throws UnsupportedTypeException
46		*/
47		public static function newRdataFromId(int $id): RdataInterface
48		{
49		return self::newRdataFromName(TypeCodes::getName($id));
50		}
51
52		/**
53		* @param string $name
54		*
55		* @return bool
56		*/
57	17	public static function isTypeImplemented(string $name): bool
58		{
59	17	return class_exists(self::getRdataClassName($name));
60		}
61
62		/**
63		* @param string $type
64		* @param string $text
65		*
66		* @return RdataInterface
67		*/
68	16	public static function textToRdataType(string $type, string $text): RdataInterface
69		{
70	16	if (!self::isTypeImplemented($type)) {
71	1	return new PolymorphicRdata($type, $text);
72		}
73
74		/** @var callable $callable */
75	15	$callable = self::getRdataClassName($type).'::fromText';
76
77	15	return call_user_func($callable, $text);
78		}
79
80		/**
81		* Get the fully qualified class name of the RData class for $type.
82		*
83		* @param string $type
84		*
85		* @return string
86		*/
87	17	public static function getRdataClassName(string $type): string
88		{
89	17	return __NAMESPACE__.'\\'.strtoupper($type);
90		}
91
92		/**
93		* Create a new AAAA R-Data object.
94		*
95		* @param string $address
96		*
97		* @return AAAA
98		*/
99	12	public static function AAAA(string $address): AAAA
100		{
101	12	$rdata = new AAAA();
102	12	$rdata->setAddress($address);
103
104	12	return $rdata;
105		}
106
107		/**
108		* Create a new A R-Data object.
109		*
110		* @param string $address
111		*
112		* @return A
113		*/
114	12	public static function A(string $address): A
115		{
116	12	$rdata = new A();
117	12	$rdata->setAddress($address);
118
119	12	return $rdata;
120		}
121
122		/**
123		* Create a new CNAME object.
124		*
125		* @param string $cname
126		*
127		* @return CNAME
128		*/
129	9	public static function CNAME(string $cname): CNAME
130		{
131	9	$rdata = new CNAME();
132	9	$rdata->setTarget($cname);
133
134	9	return $rdata;
135		}
136
137		/**
138		* @param string $cpu
139		* @param string $os
140		*
141		* @return HINFO
142		*/
143	9	public static function HINFO(string $cpu, string $os): HINFO
144		{
145	9	$rdata = new HINFO();
146	9	$rdata->setCpu($cpu);
147	9	$rdata->setOs($os);
148
149	9	return $rdata;
150		}
151
152		/**
153		* @param int $preference
154		* @param string $exchange
155		*
156		* @return MX
157		*/
158	11	public static function MX(int $preference, string $exchange): MX
159		{
160	11	$rdata = new MX();
161	11	$rdata->setPreference($preference);
162	11	$rdata->setExchange($exchange);
163
164	11	return $rdata;
165		}
166
167		/**
168		* @param string $mname
169		* @param string $rname
170		* @param int $serial
171		* @param int $refresh
172		* @param int $retry
173		* @param int $expire
174		* @param int $minimum
175		*
176		* @return SOA
177		*/
178	14	public static function SOA(string $mname, string $rname, int $serial, int $refresh, int $retry, int $expire, int $minimum): SOA
179		{
180	14	$rdata = new SOA();
181	14	$rdata->setMname($mname);
182	14	$rdata->setRname($rname);
183	14	$rdata->setSerial($serial);
184	14	$rdata->setRefresh($refresh);
185	14	$rdata->setRetry($retry);
186	14	$rdata->setExpire($expire);
187	14	$rdata->setMinimum($minimum);
188
189	14	return $rdata;
190		}
191
192		/**
193		* @param string $nsdname
194		*
195		* @return NS
196		*/
197	13	public static function NS(string $nsdname): NS
198		{
199	13	$rdata = new NS();
200	13	$rdata->setTarget($nsdname);
201
202	13	return $rdata;
203		}
204
205		/**
206		* @param string $text
207		*
208		* @return TXT
209		*/
210	10	public static function TXT(string $text): TXT
211		{
212	10	$rdata = new TXT();
213	10	$rdata->setText($text);
214
215	10	return $rdata;
216		}
217
218		/**
219		* @param string $target
220		*
221		* @return DNAME
222		*/
223	9	public static function DNAME(string $target): DNAME
224		{
225	9	$rdata = new DNAME();
226	9	$rdata->setTarget($target);
227
228	9	return $rdata;
229		}
230
231		/**
232		* @param float $lat
233		* @param float $lon
234		* @param float $alt
235		* @param float $size
236		* @param float $hp
237		* @param float $vp
238		*
239		* @return LOC
240		*/
241	10	public static function LOC(float $lat, float $lon, $alt = 0.0, $size = 1.0, $hp = 10000.0, $vp = 10.0): LOC
242		{
243	10	$loc = new LOC();
244	10	$loc->setLatitude($lat);
245	10	$loc->setLongitude($lon);
246	10	$loc->setAltitude($alt);
247	10	$loc->setSize($size);
248	10	$loc->setHorizontalPrecision($hp);
249	10	$loc->setVerticalPrecision($vp);
250
251	10	return $loc;
252		}
253
254		/**
255		* @param string $target
256		*
257		* @return PTR
258		*/
259	2	public static function PTR(string $target): PTR
260		{
261	2	$ptr = new PTR();
262	2	$ptr->setTarget($target);
263
264	2	return $ptr;
265		}
266
267		/**
268		* @param int $flags
269		* @param int $algorithm
270		* @param string $publicKey
271		*
272		* @return DNSKEY
273		*/
274	1	public static function DNSKEY(int $flags, int $algorithm, string $publicKey): DNSKEY
275		{
276	1	$rdata = new DNSKEY();
277	1	$rdata->setFlags($flags);
278	1	$rdata->setAlgorithm($algorithm);
279	1	$rdata->setPublicKey($publicKey);
280
281	1	return $rdata;
282		}
283
284		/**
285		* @param int $keyTag
286		* @param int $algorithm
287		* @param string $digest
288		* @param int $digestType
289		*
290		* @return DS
291		*/
292	1	public static function DS(int $keyTag, int $algorithm, string $digest, int $digestType = DS::DIGEST_SHA1): DS
293		{
294	1	$rdata = new DS();
295	1	$rdata->setKeyTag($keyTag);
296	1	$rdata->setAlgorithm($algorithm);
297	1	$rdata->setDigest($digest);
298	1	$rdata->setDigestType($digestType);
299
300	1	return $rdata;
301		}
302
303		/**
304		* @param string $nextDomainName
305		* @param array $types
306		*
307		* @return NSEC
308		*/
309	1	public static function NSEC(string $nextDomainName, array $types): NSEC
310		{
311	1	$rdata = new NSEC();
312	1	$rdata->setNextDomainName($nextDomainName);
313	1	array_map([$rdata, 'addType'], $types);
314
315	1	return $rdata;
316		}
317
318		/**
319		* @param string $typeCovered
320		* @param int $algorithm
321		* @param int $labels
322		* @param int $originalTtl
323		* @param \DateTime $signatureExpiration
324		* @param \DateTime $signatureInception
325		* @param int $keyTag
326		* @param string $signersName
327		* @param string $signature
328		*
329		* @return RRSIG
330		*/
331	1	public static function RRSIG(string $typeCovered, int $algorithm, int $labels, int $originalTtl,
332		\DateTime $signatureExpiration, \DateTime $signatureInception, int $keyTag,
333		string $signersName, string $signature): RRSIG
334		{
335	1	$rrsig = new RRSIG();
336	1	$rrsig->setTypeCovered($typeCovered);
337	1	$rrsig->setAlgorithm($algorithm);
338	1	$rrsig->setLabels($labels);
339	1	$rrsig->setOriginalTtl($originalTtl);
340	1	$rrsig->setSignatureExpiration($signatureExpiration);
341	1	$rrsig->setSignatureInception($signatureInception);
342	1	$rrsig->setKeyTag($keyTag);
343	1	$rrsig->setSignersName($signersName);
344	1	$rrsig->setSignature($signature);
345
346	1	return $rrsig;
347		}
348
349		/**
350		* @param int $priority
351		* @param int $weight
352		* @param int $port
353		* @param string $target
354		*
355		* @return SRV
356		*/
357	1	public static function SRV(int $priority, int $weight, int $port, string $target): SRV
358		{
359	1	$rdata = new SRV();
360	1	$rdata->setPriority($priority);
361	1	$rdata->setWeight($weight);
362	1	$rdata->setPort($port);
363	1	$rdata->setTarget($target);
364
365	1	return $rdata;
366		}
367
368		/**
369		* @param IPBlock[] $includedRanges
370		* @param IPBlock[] $excludedRanges
371		*
372		* @return APL
373		*/
374	2	public static function APL(array $includedRanges = [], array $excludedRanges = []): APL
375		{
376	2	$rdata = new APL();
377
378	2	foreach ($includedRanges as $ipBlock) {
379	2	$rdata->addAddressRange($ipBlock, true);
380		}
381
382	2	foreach ($excludedRanges as $ipBlock) {
383	2	$rdata->addAddressRange($ipBlock, false);
384		}
385
386	2	return $rdata;
387		}
388
389		/**
390		* @param int $flag
391		* @param string $tag
392		* @param string $value
393		*
394		* @return CAA
395		*/
396	1	public static function CAA(int $flag, string $tag, string $value): CAA
397		{
398	1	$rdata = new CAA();
399	1	$rdata->setFlag($flag);
400	1	$rdata->setTag($tag);
401	1	$rdata->setValue($value);
402
403	1	return $rdata;
404		}
405
406		/**
407		* @param int $subType
408		* @param string $hostname
409		*
410		* @return AFSDB
411		*/
412		public static function AFSDB(int $subType, string $hostname): AFSDB
413		{
414		$afsdb = new AFSDB();
415		$afsdb->setSubType($subType);
416		$afsdb->setHostname($hostname);
417
418		return $afsdb;
419		}
420
421		/**
422		* @param int $flags
423		* @param int $algorithm
424		* @param string $publicKey
425		*
426		* @return CDNSKEY
427		*/
428		public static function CDNSKEY(int $flags, int $algorithm, string $publicKey): CDNSKEY
429		{
430		$cdnskey = new CDNSKEY();
431		$cdnskey->setFlags($flags);
432		$cdnskey->setAlgorithm($algorithm);
433		$cdnskey->setPublicKey($publicKey);
434
435		return $cdnskey;
436		}
437
438		/**
439		* @param int $keyTag
440		* @param int $algorithm
441		* @param string $digest
442		* @param int $digestType
443		*
444		* @return CDS
445		*/
446		public static function CDS(int $keyTag, int $algorithm, string $digest, int $digestType = DS::DIGEST_SHA1): CDS
447		{
448		$cds = new CDS();
449		$cds->setKeyTag($keyTag);
450		$cds->setAlgorithm($algorithm);
451		$cds->setDigest($digest);
452		$cds->setDigestType($digestType);
453
454		return $cds;
455		}
456
457		/**
458		* @param int\|string $certificateType
459		* @param int $keyTag
460		* @param int $algorithm
461		* @param string $certificate
462		*
463		* @return CERT
464		*/
465	1	public static function CERT($certificateType, int $keyTag, int $algorithm, string $certificate): CERT
466		{
467	1	$cert = new CERT();
468	1	$cert->setCertificateType($certificateType);
469	1	$cert->setKeyTag($keyTag);
470	1	$cert->setAlgorithm($algorithm);
471	1	$cert->setCertificate($certificate);
472
473	1	return $cert;
474		}
475
476	1	public static function CSYNC(int $soaSerial, int $flags, array $types): CSYNC
477		{
478	1	$csync = new CSYNC();
479	1	$csync->setSoaSerial($soaSerial);
480	1	$csync->setFlags($flags);
481	1	array_map([$csync, 'addType'], $types);
482
483	1	return $csync;
484		}
485
486		/**
487		* @param string\|null $digest Set to &null if the $identifier and $fqdn are known
488		* @param int $identifierType 16-bit integer
489		* @param string\|null $identifier This is ignored if $digest is not &null
490		* @param string\|null $fqdn This is ignored if $digest is not &null
491		*
492		* @return DHCID
493		*/
494	3	public static function DHCID(?string $digest, int $identifierType, ?string $identifier = null, ?string $fqdn = null): DHCID
495		{
496	3	$dhcid = new DHCID();
497	3	if (null !== $digest) {
498		$dhcid->setIdentifierType($identifierType);
499		$dhcid->setDigest($digest);
500
501		return $dhcid;
502		}
503
504	3	if (null === $identifier \|\| null === $fqdn) {
505		throw new \InvalidArgumentException('Identifier and FQDN cannot be null if digest is null.');
506		}
507
508	3	$dhcid->setIdentifier($identifierType, $identifier);
509	3	$dhcid->setFqdn($fqdn);
510
511	3	return $dhcid;
512		}
513
514		/**
515		* @param int $keyTag
516		* @param int $algorithm
517		* @param string $digest
518		* @param int $digestType
519		*
520		* @return DLV
521		*/
522		public static function DLV(int $keyTag, int $algorithm, string $digest, int $digestType = DS::DIGEST_SHA1): DLV
523		{
524		$rdata = new DLV();
525		$rdata->setKeyTag($keyTag);
526		$rdata->setAlgorithm($algorithm);
527		$rdata->setDigest($digest);
528		$rdata->setDigestType($digestType);
529
530		return $rdata;
531		}
532
533		/**
534		* @param int $publicKeyAlgorithm
535		* @param string $hostIdentityTag
536		* @param string $publicKey
537		* @param string[] $rendezvousServers
538		*
539		* @return HIP
540		*/
541	1	public static function HIP(int $publicKeyAlgorithm, string $hostIdentityTag, string $publicKey, array $rendezvousServers): HIP
542		{
543	1	$hip = new HIP();
544	1	$hip->setPublicKeyAlgorithm($publicKeyAlgorithm);
545	1	$hip->setHostIdentityTag($hostIdentityTag);
546	1	$hip->setPublicKey($publicKey);
547	1	array_map([$hip, 'addRendezvousServer'], $rendezvousServers);
548
549	1	return $hip;
550		}
551
552		/**
553		* @param int $precedence an 8-bit unsigned integer
554		* @param string\|null $gateway either &null for no gateway, a fully qualified domain name, or an IPv4 or IPv6 address
555		* @param int $algorithm either IPSECKEY::ALGORITHM_NONE, IPSECKEY::ALGORITHM_DSA, IPSECKEY::ALGORITHM_RSA, or IPSECKEY::ALGORITHM_ECDSA
556		* @param string\|null $publicKey base64 encoded public key
557		*
558		* @return IPSECKEY
559		*/
560	6	public static function IPSECKEY(int $precedence, ?string $gateway, int $algorithm = 0, ?string $publicKey = null): IPSECKEY
561		{
562	6	$ipseckey = new IPSECKEY();
563	6	$ipseckey->setPrecedence($precedence);
564	6	$ipseckey->setGateway($gateway);
565	6	$ipseckey->setPublicKey($algorithm, $publicKey);
566
567	6	return $ipseckey;
568		}
569
570		/**
571		* @param int $flags
572		* @param int $protocol
573		* @param int $algorithm
574		* @param string $publicKey
575		*
576		* @return KEY
577		*/
578		public static function KEY(int $flags, int $protocol, int $algorithm, string $publicKey): KEY
579		{
580		$key = new KEY();
581		$key->setFlags($flags);
582		$key->setProtocol($protocol);
583		$key->setAlgorithm($algorithm);
584		$key->setPublicKey($publicKey);
585
586		return $key;
587		}
588
589		/**
590		* @param int $preference
591		* @param string $exchanger
592		*
593		* @return KX
594		*/
595		public static function KX(int $preference, string $exchanger): KX
596		{
597		$kx = new KX();
598		$kx->setPreference($preference);
599		$kx->setExchanger($exchanger);
600
601		return $kx;
602		}
603
604		/**
605		* @param int $order
606		* @param int $preference
607		* @param string $flags
608		* @param string $services
609		* @param string $regexp
610		* @param string $replacement
611		*
612		* @return NAPTR
613		*/
614	2	public static function NAPTR(int $order, int $preference, string $flags, string $services, string $regexp, string $replacement): NAPTR
615		{
616	2	$naptr = new NAPTR();
617	2	$naptr->setOrder($order);
618	2	$naptr->setPreference($preference);
619	2	$naptr->setFlags($flags);
620	2	$naptr->setServices($services);
621	2	$naptr->setRegexp($regexp);
622	2	$naptr->setReplacement($replacement);
623
624	2	return $naptr;
625		}
626
627	1	public static function NSEC3(int $hashAlgorithm, bool $unsignedDelegationsCovered, int $iterations, string $salt, string $nextHashedOwnerName, array $types): NSEC3
628		{
629	1	$nsec3 = new NSEC3();
630	1	$nsec3->setHashAlgorithm($hashAlgorithm);
631	1	$nsec3->setUnsignedDelegationsCovered($unsignedDelegationsCovered);
632	1	$nsec3->setIterations($iterations);
633	1	$nsec3->setSalt($salt);
634	1	$nsec3->setNextHashedOwnerName($nextHashedOwnerName);
635	1	array_map([$nsec3, 'addType'], $types);
636
637	1	return $nsec3;
638		}
639
640		/**
641		* @param int $hashAlgorithm
642		* @param int $flags
643		* @param int $iterations
644		* @param string $salt
645		*
646		* @return NSEC3PARAM
647		*/
648	1	public static function NSEC3PARAM(int $hashAlgorithm, int $flags, int $iterations, string $salt): NSEC3PARAM
649		{
650	1	$nsec3param = new NSEC3PARAM();
651	1	$nsec3param->setHashAlgorithm($hashAlgorithm);
652	1	$nsec3param->setFlags($flags);
653	1	$nsec3param->setIterations($iterations);
654	1	$nsec3param->setSalt($salt);
655
656	1	return $nsec3param;
657		}
658
659		public static function RP(string $mboxDomain, string $txtDomain): RP
660		{
661		$rp = new RP();
662		$rp->setMailboxDomainName($mboxDomain);
663		$rp->setTxtDomainName($txtDomain);
664
665		return $rp;
666		}
667
668		/**
669		* @param string $typeCovered
670		* @param int $algorithm
671		* @param int $labels
672		* @param int $originalTtl
673		* @param \DateTime $signatureExpiration
674		* @param \DateTime $signatureInception
675		* @param int $keyTag
676		* @param string $signersName
677		* @param string $signature
678		*
679		* @return SIG
680		*/
681		public static function SIG(string $typeCovered, int $algorithm, int $labels, int $originalTtl,
682		\DateTime $signatureExpiration, \DateTime $signatureInception, int $keyTag,
683		string $signersName, string $signature): SIG
684		{
685		$sig = new SIG();
686		$sig->setTypeCovered($typeCovered);
687		$sig->setAlgorithm($algorithm);
688		$sig->setLabels($labels);
689		$sig->setOriginalTtl($originalTtl);
690		$sig->setSignatureExpiration($signatureExpiration);
691		$sig->setSignatureInception($signatureInception);
692		$sig->setKeyTag($keyTag);
693		$sig->setSignersName($signersName);
694		$sig->setSignature($signature);
695
696		return $sig;
697		}
698
699		/**
700		* @param int $algorithm
701		* @param int $fpType
702		* @param string $fingerprint
703		*
704		* @return SSHFP
705		*/
706	8	public static function SSHFP(int $algorithm, int $fpType, string $fingerprint): SSHFP
707		{
708	8	$sshfp = new SSHFP();
709	8	$sshfp->setAlgorithm($algorithm);
710	6	$sshfp->setFingerprintType($fpType);
711	4	$sshfp->setFingerprint($fingerprint);
712
713	3	return $sshfp;
714		}
715
716		/**
717		* @param int $keyTag
718		* @param int $algorithm
719		* @param string $digest
720		* @param int $digestType
721		*
722		* @return TA
723		*/
724		public static function TA(int $keyTag, int $algorithm, string $digest, int $digestType = DS::DIGEST_SHA1): TA
725		{
726		$ta = new TA();
727		$ta->setKeyTag($keyTag);
728		$ta->setAlgorithm($algorithm);
729		$ta->setDigest($digest);
730		$ta->setDigestType($digestType);
731
732		return $ta;
733		}
734
735		/**
736		* @param string $algorithm
737		* @param \DateTime $inception
738		* @param \DateTime $expiration
739		* @param int $mode
740		* @param int $error
741		* @param string $keyData binary string
742		* @param string $otherData binary string
743		*
744		* @return TKEY
745		*/
746	1	public static function TKEY(string $algorithm, \DateTime $inception, \DateTime $expiration, int $mode, int $error, string $keyData, string $otherData = ''): TKEY
747		{
748	1	$tkey = new TKEY();
749	1	$tkey->setAlgorithm($algorithm);
750	1	$tkey->setInception($inception);
751	1	$tkey->setExpiration($expiration);
752	1	$tkey->setMode($mode);
753	1	$tkey->setError($error);
754	1	$tkey->setKeyData($keyData);
755	1	$tkey->setOtherData($otherData);
756
757	1	return $tkey;
758		}
759
760		public static function TLSA(): TLSA
761		{
762		// TODO: Implement TLSA() method.
763		}
764
765		public static function TSIG(): TSIG
766		{
767		// TODO: Implement TSIG() method.
768		}
769
770		/**
771		* @param int $priority
772		* @param int $weight
773		* @param string $target
774		*
775		* @return URI
776		*/
777	6	public static function URI(int $priority, int $weight, string $target): URI
778		{
779	6	$uri = new URI();
780	6	$uri->setPriority($priority);
781	4	$uri->setWeight($weight);
782	2	$uri->setTarget($target);
783
784	1	return $uri;
785		}
786		}
787

Badcow / DNS

Branch — Version3 (b919d6)

Factory::NAPTR() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like