validatordomain.cpp

/*
 * Copyright (C) 2018 Matthias Fehring <kontakt@buschmann23.de>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */
 
#include "validatordomain_p.h"
#include <QUrl>
#include <QStringList>
#include <QEventLoop>
#include <QDnsLookup>
#include <QTimer>
 
using namespace Cutelyst;
 
ValidatorDomain::ValidatorDomain(const QString &field, bool checkDNS, const ValidatorMessages &messages, const QString &defValKey) :
    ValidatorRule(* new ValidatorDomainPrivate(field, checkDNS, messages, defValKey))
{
}
 
ValidatorDomain::~ValidatorDomain()
{
}
 
bool ValidatorDomain::validate(const QString &value, bool checkDNS, Cutelyst::ValidatorDomain::Diagnose *diagnose, QString *extractedValue)
{
    bool valid = true;
 
    Diagnose diag = Valid;
 
    QString _v = value;
    bool hasRootDot = false;
    if (_v.endsWith(QLatin1Char('.'))) {
        hasRootDot = true;
        _v.chop(1);
    }
 
    // convert to lower case puny code
    const QString v = QString::fromLatin1(QUrl::toAce(_v)).toLower();
 
    // split up the utf8 string into parts to get the non puny code TLD
    const QStringList nonAceParts = _v.split(QLatin1Char('.'));
    if (!nonAceParts.empty()) {
        const QString tld = nonAceParts.last();
        if (!tld.isEmpty()) {
            // there are no TLDs with digits inside, but IDN TLDs can
            // have digits in their puny code representation, so we have
            // to check at first if the IDN TLD contains digits before
            // checking the ACE puny code
            for (const QChar &ch : tld) {
                const ushort &uc = ch.unicode();
                if (((uc > 47) && (uc < 58)) || (uc == 45)) {
                    diag = InvalidTLD;
                    valid = false;
                    break;
                }
            }
 
            if (valid) {
                if (!v.isEmpty()) {
                    // maximum length of the name in the DNS is 253 without the last dot
                    if (v.length() < 254) {
#if (QT_VERSION >= QT_VERSION_CHECK(5, 14, 0))
                        const QStringList parts = v.split(QLatin1Char('.'), Qt::KeepEmptyParts);
#else
                        const QStringList parts = v.split(QLatin1Char('.'), QString::KeepEmptyParts);
#endif
                        // there has to be more than only the TLD
                        if (parts.size() > 1) {
                            // the TLD can not have only 1 char
                            if (parts.last().length() > 1) {
                                for (int i = 0; i < parts.size(); ++i) {
                                    if (valid) {
                                        const QString part = parts.at(i);
                                        if (!part.isEmpty()) {
                                            // labels/parts can have a maximum length of 63 chars
                                            if (part.length() < 64) {
                                                bool isTld = (i == (parts.size() -1));
                                                bool isPunyCode = part.startsWith(QLatin1String("xn--"));
                                                for (int j = 0; j < part.size(); ++j) {
                                                    const ushort &uc = part.at(j).unicode();
                                                    const bool isDigit = ((uc > 47) && (uc < 58));
                                                    const bool isDash = (uc == 45);
                                                    // no part/label can start with a digit or a dash
                                                    if ((j == 0) && (isDash || isDigit)) {
                                                        valid = false;
                                                        diag = isDash ? DashStart : DigitStart;
                                                        break;
                                                    }
                                                    // no part/label can end with a dash
                                                    if ((j == (part.size() - 1)) && isDash) {
                                                        valid = false;
                                                        diag = DashEnd;
                                                        break;
                                                    }
                                                    const bool isChar = ((uc > 96) && (uc < 123));
                                                    if (!isTld) {
                                                        // if it is not the tld, it can have a-z 0-9 and -
                                                        if (!(isDigit || isDash || isChar)) {
                                                            valid = false;
                                                            diag = InvalidChars;
                                                            break;
                                                        }
                                                    } else {
                                                        if (isPunyCode) {
                                                            if (!(isDigit || isDash || isChar)) {
                                                                valid = false;
                                                                diag = InvalidTLD;
                                                                break;
                                                            }
                                                        } else {
                                                            if (!isChar) {
                                                                valid = false;
                                                                diag = InvalidTLD;
                                                                break;
                                                            }
                                                        }
                                                    }
                                                }
                                            } else {
                                                valid = false;
                                                diag = LabelTooLong;
                                                break;
                                            }
                                        } else {
                                            valid = false;
                                            diag = EmptyLabel;
                                            break;
                                        }
                                    } else {
                                        break;
                                    }
                                }
                            } else {
                                valid = false;
                                diag = InvalidTLD;
                            }
                        } else {
                            valid = false;
                            diag = InvalidLabelCount;
                        }
                    } else {
                        valid = false;
                        diag = TooLong;
                    }
                } else {
                    valid = false;
                    diag = EmptyLabel;
                }
            }
        } else {
            valid = false;
            diag = EmptyLabel;
        }
    } else {
        valid = false;
        diag = EmptyLabel;
    }
 
 
    if (valid && checkDNS) {
        QDnsLookup alookup(QDnsLookup::A, v);
        QEventLoop aloop;
        QObject::connect(&alookup, &QDnsLookup::finished, &aloop, &QEventLoop::quit);
        QTimer::singleShot(3100, &alookup, &QDnsLookup::abort);
        alookup.lookup();
        aloop.exec();
 
        if (((alookup.error() != QDnsLookup::NoError) && (alookup.error() != QDnsLookup::OperationCancelledError)) || alookup.hostAddressRecords().empty()) {
            QDnsLookup aaaaLookup(QDnsLookup::AAAA, v);
            QEventLoop aaaaLoop;
            QObject::connect(&aaaaLookup, &QDnsLookup::finished, &aaaaLoop, &QEventLoop::quit);
            QTimer::singleShot(3100, &aaaaLookup, &QDnsLookup::abort);
            aaaaLookup.lookup();
            aaaaLoop.exec();
 
            if (((aaaaLookup.error() != QDnsLookup::NoError) && (aaaaLookup.error() != QDnsLookup::OperationCancelledError)) || aaaaLookup.hostAddressRecords().empty()) {
                valid = false;
                diag = MissingDNS;
            } else if (aaaaLookup.error() == QDnsLookup::OperationCancelledError) {
                valid = false;
                diag = DNSTimeout;
            }
        } else if (alookup.error() == QDnsLookup::OperationCancelledError) {
            valid = false;
            diag = DNSTimeout;
        }
    }
 
    if (diagnose) {
        *diagnose = diag;
    }
 
    if (valid && extractedValue) {
        if (hasRootDot) {
            *extractedValue = v + QLatin1Char('.');
        } else {
            *extractedValue = v;
        }
    }
 
    return valid;
}
 
QString ValidatorDomain::diagnoseString(Context *c, Diagnose diagnose, const QString &label)
{
    QString error;
 
    if (label.isEmpty()) {
        switch (diagnose) {
        case MissingDNS:
            error = c->translate("Cutelyst::ValidatorDomain", "The domain name seems to be valid but could not be found in the domain name system.");
            break;
        case InvalidChars:
            error = c->translate("Cutelyst::ValidatorDomain", "The domain name contains characters that are not allowed.");
            break;
        case LabelTooLong:
            error = c->translate("Cutelyst::ValidatorDomain", "At least one of the sections separated by dots exceeds the maximum allowed length of 63 characters. Note that internationalized domain names can be longer internally than they are displayed.");
            break;
        case TooLong:
            error = c->translate("Cutelyst::ValidatorDomain", "The full name of the domain must not be longer than 253 characters. Note that internationalized domain names can be longer internally than they are displayed.");
            break;
        case InvalidLabelCount:
            error = c->translate("Cutelyst::ValidatorDomain", "This is not a valid domain name because it has either no parts (is empty) or only has a top level domain.");
            break;
        case EmptyLabel:
            error = c->translate("Cutelyst::ValidatorDomain", "At least one of the sections separated by dots is empty. Check whether you have entered two dots consecutively.");
            break;
        case InvalidTLD:
            error = c->translate("Cutelyst::ValidatorDomain", "The top level domain (last part) contains characters that are not allowed, like digits and/or dashes.");
            break;
        case DashStart:
            error = c->translate("Cutelyst::ValidatorDomain", "Domain name sections are not allowed to start with a dash.");
            break;
        case DashEnd:
            error = c->translate("Cutelyst::ValidatorDomain", "Domain name sections are not allowed to end with a dash.");
            break;
        case DigitStart:
            error = c->translate("Cutelyst::ValidatorDomain", "Domain name sections are not allowed to start with a digit.");
            break;
        case Valid:
            error = c->translate("Cutelyst::ValidatorDomain", "The domain name is valid.");
            break;
        case DNSTimeout:
            error = c->translate("Cutelyst::ValidatorDomain", "The DNS lookup was aborted because it took too long.");
            break;
        default:
            Q_ASSERT_X(false, "domain validation diagnose", "invalid diagnose");
            break;
        }
    } else {
        switch (diagnose) {
        case MissingDNS:
            error = c->translate("Cutelyst::ValidatorDomain", "The domain name in the “%1“ field seems to be valid but could not be found in the domain name system.").arg(label);
            break;
        case InvalidChars:
            error = c->translate("Cutelyst::ValidatorDomain", "The domain name in the “%1“ field contains characters that are not allowed.").arg(label);
            break;
        case LabelTooLong:
            error = c->translate("Cutelyst::ValidatorDomain", "The domain name in the “%1“ field is not valid because at least one of the sections separated by dots exceeds the maximum allowed length of 63 characters. Note that internationalized domain names can be longer internally than they are displayed.").arg(label);
            break;
        case TooLong:
            error = c->translate("Cutelyst::ValidatorDomain", "The full name of the domain in the “%1” field must not be longer than 253 characters. Note that internationalized domain names can be longer internally than they are displayed.").arg(label);
            break;
        case InvalidLabelCount:
            error = c->translate("Cutelyst::ValidatorDomain", "The “%1” field does not contain a valid domain name because it has either no parts (is empty) or only has a top level domain.").arg(label);
            break;
        case EmptyLabel:
            error = c->translate("Cutelyst::ValidatorDomain", "The domain name in the “%1“ field is not valid because at least one of the sections separated by dots is empty. Check whether you have entered two dots consecutively.").arg(label);
            break;
        case InvalidTLD:
            error = c->translate("Cutelyst::ValidatorDomain", "The top level domain (last part) of the domain name in the “%1” field contains characters that are not allowed, like digits and or dashes.").arg(label);
            break;
        case DashStart:
            error = c->translate("Cutelyst::ValidatorDomain", "The domain name in the “%1“ field is not valid because domain name sections are not allowed to start with a dash.").arg(label);
            break;
        case DashEnd:
            error = c->translate("Cutelyst::ValidatorDomain", "The domain name in the “%1“ field is not valid because domain name sections are not allowed to end with a dash.").arg(label);
            break;
        case DigitStart:
            error = c->translate("Cutelyst::ValidatorDomain", "The domain name in the “%1“ field is not valid because domain name sections are not allowed to start with a digit.").arg(label);
            break;
        case Valid:
            error = c->translate("Cutelyst::ValidatorDomain", "The domain name in the “%1” field is valid.").arg(label);
            break;
        case DNSTimeout:
            error = c->translate("Cutelyst::ValidatorDomain", "The DNS lookup for the domain name in the “%1” field was aborted because it took too long.").arg(label);
            break;
        default:
            Q_ASSERT_X(false, "domain validation diagnose", "invalid diagnose");
            break;
        }
    }
 
    return error;
}
 
ValidatorReturnType ValidatorDomain::validate(Context *c, const ParamsMultiMap &params) const
{
    ValidatorReturnType result;
 
    const QString &v = value(params);
 
    if (!v.isEmpty()) {
        Q_D(const ValidatorDomain);
        QString exVal;
        Diagnose diag;
        if (ValidatorDomain::validate(v, d->checkDNS, &diag, &exVal)) {
            result.value.setValue(exVal);
        } else {
            result.errorMessage = validationError(c, diag);
        }
    } else {
        defaultValue(c, &result, "ValidatorDomain");
    }
 
    return result;
}
 
QString ValidatorDomain::genericValidationError(Context *c, const QVariant &errorData) const
{
    QString error;
    const QString _label = label(c);
    const Diagnose diag = errorData.value<Diagnose>();
    error = ValidatorDomain::diagnoseString(c, diag, _label);
    return error;
}
 
#include "moc_validatordomain.cpp"