token.h

Go to the documentation of this file.

// Copyright (C) 2015-2018 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 <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 Token {
public:

    virtual void evaluate(Pkt& pkt, ValueStack& values) = 0;

    virtual ~Token() {}

    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){
    }

    void evaluate(Pkt& pkt, ValueStack& values);

protected:
    std::string value_; 
};

class TokenHexString : public Token {
public:
    TokenHexString(const std::string& str);

    void evaluate(Pkt& pkt, ValueStack& values);

protected:
    std::string value_; 
};

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

    void evaluate(Pkt& pkt, ValueStack& values);

protected:
    std::string value_;
};

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) {}

    void 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 {
        IFACE, 
        SRC,   
        DST,   
        LEN    
    };

    TokenPkt(const MetadataType type)
        : type_(type) {}

    void evaluate(Pkt& pkt, ValueStack& values);

    MetadataType getType() {
        return (type_);
    }

private:
    MetadataType type_;
};

class TokenPkt4 : public Token {
public:

    enum FieldType {
        CHADDR, 
        GIADDR, 
        CIADDR, 
        YIADDR, 
        SIADDR, 
        HLEN,   
        HTYPE,  
        MSGTYPE, 
        TRANSID, 
    };

    TokenPkt4(const FieldType type)
        : type_(type) {}

    void evaluate(Pkt& pkt, ValueStack& values);

    FieldType getType() {
        return (type_);
    }

private:
    FieldType type_;
};

class TokenPkt6 : public Token {
public:
    enum FieldType {
        MSGTYPE, 
        TRANSID  
    };

    TokenPkt6(const FieldType type)
        : type_(type) {}

    void evaluate(Pkt& pkt, ValueStack& values);

    FieldType getType() {
        return(type_);
    }

private:
    FieldType type_;
};

class TokenRelay6Field : public Token {
public:

    enum FieldType {
        PEERADDR, 
        LINKADDR  
    };

    TokenRelay6Field(const int8_t nest_level, const FieldType type)
      : nest_level_(nest_level), type_(type) {}

    void 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() {}

    void evaluate(Pkt& pkt, ValueStack& values);
};

class TokenSubstring : public Token {
public:
    TokenSubstring() {}

    void evaluate(Pkt& pkt, ValueStack& values);
};

class TokenConcat : public Token {
public:
    TokenConcat() {}

    void evaluate(Pkt& pkt, ValueStack& values);
};

class TokenIfElse : public Token {
public:
    TokenIfElse() { }

    void evaluate(Pkt& pkt, ValueStack& values);
};

class TokenToHexString : public Token {
public:
    TokenToHexString() { }

    void evaluate(Pkt& pkt, ValueStack& values);
};

class TokenNot : public Token {
public:
    TokenNot() {}

    void evaluate(Pkt& pkt, ValueStack& values);
};

class TokenAnd : public Token {
public:
    TokenAnd() {}

    void evaluate(Pkt& pkt, ValueStack& values);
};

class TokenOr : public Token {
public:
    TokenOr() {}

    void evaluate(Pkt& pkt, ValueStack& values);
};

class TokenMember : public Token {
public:
    TokenMember(const std::string& client_class)
        :client_class_(client_class){
    }

    void evaluate(Pkt& pkt, ValueStack& values);

    const ClientClass& getClientClass() const {
        return (client_class_);
    }

protected:
    ClientClass client_class_;
};

class TokenVendor : public TokenOption {
public:

    enum FieldType {
        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 void 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:

    void evaluate(Pkt& pkt, ValueStack& values);

    uint16_t index_;
};

}; // end of isc::dhcp namespace
}; // end of isc namespace

#endif