tsigerror.h

Go to the documentation of this file.

// Copyright (C) 2011-2024 Internet Systems Consortium, Inc. ("ISC")
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
#ifndef TSIGERROR_H
#define TSIGERROR_H
 
#include <ostream>
#include <string>
 
#include <dns/rcode.h>
 
namespace isc {
namespace dns {
class TSIGError {
public:
    enum CodeValue {
        BAD_SIG_CODE = 16,  
        BAD_KEY_CODE = 17,  
        BAD_TIME_CODE = 18, 
        BAD_MODE_CODE = 19, 
        BAD_NAME_CODE = 20, 
        BAD_ALG_CODE = 21,  
        BAD_TRUNC_CODE = 22 
    };
 
 
 
    explicit TSIGError(uint16_t error_code) : code_(error_code) {}
 
    explicit TSIGError(Rcode rcode);
 
    uint16_t getCode() const {
        return (code_);
    }
 
    bool equals(const TSIGError& other) const {
        return (code_ == other.code_);
    }
 
    bool operator==(const TSIGError& other) const {
        return (equals(other));
    }
 
    bool nequals(const TSIGError& other) const {
        return (code_ != other.code_);
    }
 
    bool operator!=(const TSIGError& other) const {
        return (nequals(other));
    }
 
    std::string toText() const;
 
    Rcode toRcode() const;
 
    static const TSIGError& NOERROR();
 
    static const TSIGError& FORMERR();
 
    static const TSIGError& SERVFAIL();
 
    static const TSIGError& NXDOMAIN();
 
    static const TSIGError& NOTIMP();
 
    static const TSIGError& REFUSED();
 
    static const TSIGError& YXDOMAIN();
 
    static const TSIGError& YXRRSET();
 
    static const TSIGError& NXRRSET();
 
    static const TSIGError& NOTAUTH();
 
    static const TSIGError& NOTZONE();
 
    static const TSIGError& RESERVED11();
 
    static const TSIGError& RESERVED12();
 
    static const TSIGError& RESERVED13();
 
    static const TSIGError& RESERVED14();
 
    static const TSIGError& RESERVED15();
 
    static const TSIGError& BAD_SIG();
 
    static const TSIGError& BAD_KEY();
 
    static const TSIGError& BAD_TIME();
 
    static const TSIGError& BAD_MODE();
 
    static const TSIGError& BAD_NAME();
 
    static const TSIGError& BAD_ALG();
 
    static const TSIGError& BAD_TRUNC();
 
private:
    // This is internally used to specify the maximum possible RCODE value
    // that can be convertible to TSIGErrors.
    static const int MAX_RCODE_FOR_TSIGERROR = 15;
 
    uint16_t code_;
};
 
inline const TSIGError&
TSIGError::NOERROR() {
    static TSIGError e(Rcode::NOERROR());
    return (e);
}
 
inline const TSIGError&
TSIGError::FORMERR() {
    static TSIGError e(Rcode::FORMERR());
    return (e);
}
 
inline const TSIGError&
TSIGError::SERVFAIL() {
    static TSIGError e(Rcode::SERVFAIL());
    return (e);
}
 
inline const TSIGError&
TSIGError::NXDOMAIN() {
    static TSIGError e(Rcode::NXDOMAIN());
    return (e);
}
 
inline const TSIGError&
TSIGError::NOTIMP() {
    static TSIGError e(Rcode::NOTIMP());
    return (e);
}
 
inline const TSIGError&
TSIGError::REFUSED() {
    static TSIGError e(Rcode::REFUSED());
    return (e);
}
 
inline const TSIGError&
TSIGError::YXDOMAIN() {
    static TSIGError e(Rcode::YXDOMAIN());
    return (e);
}
 
inline const TSIGError&
TSIGError::YXRRSET() {
    static TSIGError e(Rcode::YXRRSET());
    return (e);
}
 
inline const TSIGError&
TSIGError::NXRRSET() {
    static TSIGError e(Rcode::NXRRSET());
    return (e);
}
 
inline const TSIGError&
TSIGError::NOTAUTH() {
    static TSIGError e(Rcode::NOTAUTH());
    return (e);
}
 
inline const TSIGError&
TSIGError::NOTZONE() {
    static TSIGError e(Rcode::NOTZONE());
    return (e);
}
 
inline const TSIGError&
TSIGError::RESERVED11() {
    static TSIGError e(Rcode::RESERVED11());
    return (e);
}
 
inline const TSIGError&
TSIGError::RESERVED12() {
    static TSIGError e(Rcode::RESERVED12());
    return (e);
}
 
inline const TSIGError&
TSIGError::RESERVED13() {
    static TSIGError e(Rcode::RESERVED13());
    return (e);
}
 
inline const TSIGError&
TSIGError::RESERVED14() {
    static TSIGError e(Rcode::RESERVED14());
    return (e);
}
 
inline const TSIGError&
TSIGError::RESERVED15() {
    static TSIGError e(Rcode::RESERVED15());
    return (e);
}
 
inline const TSIGError&
TSIGError::BAD_SIG() {
    static TSIGError e(BAD_SIG_CODE);
    return (e);
}
 
inline const TSIGError&
TSIGError::BAD_KEY() {
    static TSIGError e(BAD_KEY_CODE);
    return (e);
}
 
inline const TSIGError&
TSIGError::BAD_TIME() {
    static TSIGError e(BAD_TIME_CODE);
    return (e);
}
 
inline const TSIGError&
TSIGError::BAD_MODE() {
    static TSIGError e(BAD_MODE_CODE);
    return (e);
}
 
inline const TSIGError&
TSIGError::BAD_NAME() {
    static TSIGError e(BAD_NAME_CODE);
    return (e);
}
 
inline const TSIGError&
TSIGError::BAD_ALG() {
    static TSIGError e(BAD_ALG_CODE);
    return (e);
}
 
inline const TSIGError&
TSIGError::BAD_TRUNC() {
    static TSIGError e(BAD_TRUNC_CODE);
    return (e);
}
 
std::ostream& operator<<(std::ostream& os, const TSIGError& tsig_error);
}
}
 
#endif  // TSIGERROR_H