token.h

Go to the documentation of this file.

// Copyright (C) 2015-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 TOKEN_H
#define TOKEN_H
 
#include <exceptions/exceptions.h>
#include <dhcp/pkt.h>
#include <regex>
#include <stack>
 
namespace isc {
namespace dhcp {
 
class Token;
 
typedef boost::shared_ptr<Token> TokenPtr;
 
typedef std::vector<TokenPtr> Expression;
 
typedef boost::shared_ptr<Expression> ExpressionPtr;
 
typedef std::stack<std::string> ValueStack;
 
class EvalBadStack : public Exception {
public:
    EvalBadStack(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) { }
};
 
class EvalTypeError : public Exception {
public:
    EvalTypeError(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) { }
};
 
class EvalBadLabel : public Exception {
public:
    EvalBadLabel(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) { }
};
 
class Token {
public:
 
    virtual unsigned evaluate(Pkt& pkt, ValueStack& values) = 0;
 
    virtual ~Token() {}
 
    virtual unsigned getLabel() const {
        return (0U);
    }
 
    static inline bool toBool(std::string value) {
        if (value == "true") {
            return (true);
        } else if (value == "false") {
            return (false);
        } else {
            isc_throw(EvalTypeError, "Incorrect boolean. Expected exactly "
                      "\"false\" or \"true\", got \"" << value << "\"");
        }
    }
};
 
 
class TokenString : public Token {
public:
    TokenString(const std::string& str) : value_(str) {}
 
    virtual unsigned evaluate(Pkt& pkt, ValueStack& values);
 
protected:
    std::string value_; 
};
 
class TokenHexString : public Token {
public:
    TokenHexString(const std::string& str);
 
    virtual unsigned evaluate(Pkt& pkt, ValueStack& values);
 
protected:
    std::string value_; 
};
 
class TokenLowerCase : public Token {
public:
    TokenLowerCase() {}
 
    virtual unsigned evaluate(Pkt& pkt, ValueStack& values);
};
 
class TokenUpperCase : public Token {
public:
    TokenUpperCase() {}
 
    virtual unsigned evaluate(Pkt& pkt, ValueStack& values);
};
 
class TokenInteger : public TokenString {
public:
    TokenInteger(const uint32_t value);
 
    uint32_t getInteger() const {
        return (int_value_);
    }
 
protected:
    uint32_t int_value_; 
};
 
class TokenIpAddress : public Token {
public:
    TokenIpAddress(const std::string& addr);
 
    virtual unsigned evaluate(Pkt& pkt, ValueStack& values);
 
protected:
    std::string value_;
};
 
class TokenIpAddressToText : public Token {
public:
    TokenIpAddressToText() {}
 
    virtual unsigned evaluate(Pkt& pkt, ValueStack& values);
};
 
class TokenInt8ToText : public Token {
public:
    TokenInt8ToText() {}
 
    virtual unsigned evaluate(Pkt& pkt, ValueStack& values);
};
 
class TokenInt16ToText : public Token {
public:
    TokenInt16ToText() {}
 
    virtual unsigned evaluate(Pkt& pkt, ValueStack& values);
};
 
class TokenInt32ToText : public Token {
public:
    TokenInt32ToText() {}
 
    virtual unsigned evaluate(Pkt& pkt, ValueStack& values);
};
 
class TokenUInt8ToText : public Token {
public:
    TokenUInt8ToText() {}
 
    virtual unsigned evaluate(Pkt& pkt, ValueStack& values);
};
 
class TokenUInt16ToText : public Token {
public:
    TokenUInt16ToText() {}
 
    virtual unsigned evaluate(Pkt& pkt, ValueStack& values);
};
 
class TokenUInt32ToText : public Token {
public:
    TokenUInt32ToText() {}
 
    virtual unsigned evaluate(Pkt& pkt, ValueStack& values);
};
 
class TokenOption : public Token {
public:
 
    enum RepresentationType {
        TEXTUAL,
        HEXADECIMAL,
        EXISTS
    };
 
    TokenOption(const uint16_t option_code, const RepresentationType& rep_type)
        : option_code_(option_code), representation_type_(rep_type) {}
 
    virtual unsigned evaluate(Pkt& pkt, ValueStack& values);
 
    uint16_t getCode() const {
        return (option_code_);
    }
 
    RepresentationType getRepresentation() const {
        return (representation_type_);
    }
 
protected:
    virtual OptionPtr getOption(Pkt& pkt);
 
    virtual std::string pushFailure(ValueStack& values);
 
    uint16_t option_code_; 
    RepresentationType representation_type_; 
};
 
class TokenRelay4Option : public TokenOption {
public:
 
    TokenRelay4Option(const uint16_t option_code,
                      const RepresentationType& rep_type);
 
protected:
    virtual OptionPtr getOption(Pkt& pkt);
};
 
class TokenRelay6Option : public TokenOption {
public:
    TokenRelay6Option(const int8_t nest_level, const uint16_t option_code,
                      const RepresentationType& rep_type)
        : TokenOption(option_code, rep_type), nest_level_(nest_level) {}
 
    int8_t getNest() const {
        return (nest_level_);
    }
 
protected:
    virtual OptionPtr getOption(Pkt& pkt);
 
    int8_t nest_level_; 
};
 
class TokenPkt : public Token {
public:
 
    enum MetadataType : int {
        IFACE, 
        SRC,   
        DST,   
        LEN    
    };
 
    TokenPkt(const MetadataType type) : type_(type) {}
 
    virtual unsigned evaluate(Pkt& pkt, ValueStack& values);
 
    MetadataType getType() {
        return (type_);
    }
 
private:
    MetadataType type_;
};
 
class TokenPkt4 : public Token {
public:
 
    enum FieldType : int {
        CHADDR, 
        GIADDR, 
        CIADDR, 
        YIADDR, 
        SIADDR, 
        HLEN,   
        HTYPE,  
        MSGTYPE, 
        TRANSID, 
    };
 
    TokenPkt4(const FieldType type)
        : type_(type) {}
 
    virtual unsigned evaluate(Pkt& pkt, ValueStack& values);
 
    FieldType getType() {
        return (type_);
    }
 
private:
    FieldType type_;
};
 
class TokenPkt6 : public Token {
public:
    enum FieldType : int {
        MSGTYPE, 
        TRANSID  
    };
 
    TokenPkt6(const FieldType type)
        : type_(type) {}
 
    virtual unsigned evaluate(Pkt& pkt, ValueStack& values);
 
    FieldType getType() {
        return (type_);
    }
 
private:
    FieldType type_;
};
 
class TokenRelay6Field : public Token {
public:
 
    enum FieldType : int {
        PEERADDR, 
        LINKADDR  
    };
 
    TokenRelay6Field(const int8_t nest_level, const FieldType type)
        : nest_level_(nest_level), type_(type) {}
 
    virtual unsigned evaluate(Pkt& pkt, ValueStack& values);
 
    int8_t getNest() const {
        return (nest_level_);
    }
 
    FieldType getType() {
        return (type_);
    }
 
protected:
    int8_t nest_level_; 
    FieldType type_; 
};
 
class TokenEqual : public Token {
public:
    TokenEqual() {}
 
    virtual unsigned evaluate(Pkt& pkt, ValueStack& values);
};
 
class TokenSubstring : public Token {
public:
    TokenSubstring() {}
 
    virtual unsigned evaluate(Pkt& pkt, ValueStack& values);
};
 
class TokenSplit : public Token {
public:
    TokenSplit() {}
 
    virtual unsigned evaluate(Pkt& pkt, ValueStack& values);
};
 
class TokenConcat : public Token {
public:
    TokenConcat() {}
 
    virtual unsigned evaluate(Pkt& pkt, ValueStack& values);
};
 
class TokenIfElse : public Token {
public:
    TokenIfElse() {}
 
    virtual unsigned evaluate(Pkt& pkt, ValueStack& values);
};
 
class TokenToHexString : public Token {
public:
    TokenToHexString() {}
 
    virtual unsigned evaluate(Pkt& pkt, ValueStack& values);
};
 
class TokenNot : public Token {
public:
    TokenNot() {}
 
    virtual unsigned evaluate(Pkt& pkt, ValueStack& values);
};
 
class TokenAnd : public Token {
public:
    TokenAnd() {}
 
    virtual unsigned evaluate(Pkt& pkt, ValueStack& values);
};
 
class TokenOr : public Token {
public:
    TokenOr() {}
 
    virtual unsigned evaluate(Pkt& pkt, ValueStack& values);
};
 
class TokenMember : public Token {
public:
    TokenMember(const std::string& client_class)
        : client_class_(client_class) {
    }
 
    virtual unsigned evaluate(Pkt& pkt, ValueStack& values);
 
    const ClientClass& getClientClass() const {
        return (client_class_);
    }
 
protected:
    ClientClass client_class_;
};
 
class TokenVendor : public TokenOption {
public:
 
    enum FieldType : int {
        SUBOPTION,     
        ENTERPRISE_ID, 
        EXISTS,        
        DATA           
    };
 
    TokenVendor(Option::Universe u, uint32_t vendor_id, FieldType field);
 
    TokenVendor(Option::Universe u, uint32_t vendor_id, RepresentationType repr,
                uint16_t option_code = 0);
 
    uint32_t getVendorId() const;
 
    FieldType getField() const;
 
    virtual unsigned evaluate(Pkt& pkt, ValueStack& values);
 
protected:
    virtual OptionPtr getOption(Pkt& pkt);
 
    Option::Universe universe_;
 
    uint32_t vendor_id_;
 
    FieldType field_;
};
 
class TokenVendorClass : public TokenVendor {
public:
 
    TokenVendorClass(Option::Universe u, uint32_t vendor_id, RepresentationType repr);
 
    TokenVendorClass(Option::Universe u, uint32_t vendor_id, FieldType field,
                     uint16_t index = 0);
 
    uint16_t getDataIndex() const;
 
protected:
 
    virtual unsigned evaluate(Pkt& pkt, ValueStack& values);
 
    uint16_t index_;
};
 
class TokenSubOption : public virtual TokenOption {
public:
 
 
    TokenSubOption(const uint16_t option_code,
                   const uint16_t sub_option_code,
                   const RepresentationType& rep_type)
        : TokenOption(option_code, rep_type), sub_option_code_(sub_option_code) {}
 
    virtual unsigned evaluate(Pkt& pkt, ValueStack& values);
 
    uint16_t getSubCode() const {
        return (sub_option_code_);
    }
 
protected:
    virtual OptionPtr getSubOption(const OptionPtr& parent);
 
    uint16_t sub_option_code_; 
};
 
class TokenMatch : public Token {
public:
    TokenMatch(const std::string& reg_exp);
 
    virtual unsigned evaluate(Pkt& pkt, ValueStack& values);
 
    const std::string& getRegExp() const {
        return (reg_exp_str_);
    }
 
private:
    std::string reg_exp_str_;
 
    std::regex reg_exp_;
};
 
class TokenLabel : public Token {
public:
    TokenLabel(const unsigned label);
 
    virtual unsigned getLabel() const {
        return (label_);
    }
 
    virtual unsigned evaluate(Pkt& pkt, ValueStack& values);
 
protected:
    unsigned label_;
};
 
class TokenBranch : public Token {
public:
    TokenBranch(const unsigned target);
 
    unsigned getTarget() const {
        return (target_);
    }
 
    virtual unsigned evaluate(Pkt& pkt, ValueStack& values);
 
protected:
    unsigned target_;
};
 
class TokenPopOrBranchTrue : public TokenBranch {
public:
    TokenPopOrBranchTrue(const unsigned target);
 
    virtual unsigned evaluate(Pkt& pkt, ValueStack& values);
};
 
class TokenPopOrBranchFalse : public TokenBranch {
public:
    TokenPopOrBranchFalse(const unsigned target);
 
    virtual unsigned evaluate(Pkt& pkt, ValueStack& values);
};
 
class TokenPopAndBranchFalse : public TokenBranch {
public:
    TokenPopAndBranchFalse(const unsigned target);
 
    virtual unsigned evaluate(Pkt& pkt, ValueStack& values);
};
 
} // end of isc::dhcp namespace
} // end of isc namespace
#endif