token.h

Go to the documentation of this file.

// Copyright (C) 2015-2026 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 std::vector<uint16_t>& option_codes, const RepresentationType& rep_type)
        : option_path_(option_codes), representation_type_(rep_type) {}

    virtual unsigned evaluate(Pkt& pkt, ValueStack& values);

    std::vector<uint16_t> getOptions() const {
        return (option_path_);
    }

    RepresentationType getRepresentation() const {
        return (representation_type_);
    }
 
protected:
    virtual OptionPtr getOption(Pkt& pkt);

    virtual std::string pushFailure(ValueStack& values);

    std::vector<uint16_t> option_path_;

    RepresentationType representation_type_;
};

class TokenRelay4Option : public TokenOption {
public:

    TokenRelay4Option(const std::vector<uint16_t>& option_codes,
                      const RepresentationType& rep_type)
        : TokenOption(option_codes, rep_type) {}
 
protected:
    virtual OptionPtr getOption(Pkt& pkt);
};

class TokenRelay6Option : public TokenOption {
public:
    TokenRelay6Option(const int8_t nest_level,
                      const std::vector<uint16_t>& option_codes,
                      const RepresentationType& rep_type)
        : TokenOption(option_codes, 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 : uint16_t {
        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 : uint16_t {
        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 : uint16_t {
        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 : uint16_t {
        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 : uint16_t {
        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,
                const std::vector<uint16_t>& option_codes = {});

    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 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