bgp_proto.cc

Go to the documentation of this file.

/*
 * Copyright (c) 2013 Juniper Networks, Inc. All rights reserved.
 */
 
#include "bgp/bgp_proto.h"
 
#include <boost/foreach.hpp>
 
#include <algorithm>
#include <list>
#include <map>
#include <utility>
 
#include "base/proto.h"
#include "bgp/bgp_log.h"
#include "bgp/bgp_peer.h"
#include "bgp/bgp_server.h"
#include "net/bgp_af.h"
 
using boost::system::error_code;
using boost::tie;
using std::cout;
using std::endl;
using std::string;
using std::vector;
 
namespace mpl = boost::mpl;
 
BgpProto::OpenMessage::OpenMessage()
    : BgpMessage(OPEN), as_num(-1), holdtime(-1), identifier(-1) {
}
 
BgpProto::OpenMessage::~OpenMessage() {
    STLDeleteValues(&opt_params);
}
 
//
// Validate the capabilities in an incoming Open Message.
//
// Return the capability code that's missing if a problem is detected.
// Return 0 if capabilities in the message are OK.
//
// Note that we must not generate an error if we see a capability that we
// do not support.
//
// Go through all the capabilities and make sure that there's at least one
// MpExtension with an (afi, safi) pair that's also configured on the peer.
//
//
int BgpProto::OpenMessage::ValidateCapabilities(BgpPeer *peer) const {
    bool mp_extension_ok = false;
 
    // Go through each OptParam in the OpenMessage.
    for (vector<OptParam *>::const_iterator param_it = opt_params.begin();
         param_it != opt_params.end(); ++param_it) {
        const OptParam *param = *param_it;
 
        // Go through each Capability in the OptParam.
        for (vector<Capability *>::const_iterator cap_it =
             param->capabilities.begin();
             cap_it != param->capabilities.end(); ++cap_it) {
            const Capability *cap = *cap_it;
 
            // See if the (afi,safi) in the MpExtension is configured on peer.
            if (cap->code == Capability::MpExtension) {
                const uint8_t *data = cap->capability.data();
                uint16_t afi = get_value(data, 2);
                uint8_t safi = get_value(data + 3, 1);
                Address::Family family = BgpAf::AfiSafiToFamily(afi, safi);
                if (peer->LookupFamily(family))
                    mp_extension_ok = true;
            }
 
            if (cap->code == Capability::AS4Support &&
                    peer->server()->enable_4byte_as()) {
                const uint8_t *data = cap->capability.data();
                as_t asn = get_value(data, 4);
                if (asn != peer->peer_as()) {
                    BGP_LOG_PEER_WARNING(Message, peer, BGP_LOG_FLAG_ALL,
                             BGP_PEER_DIR_IN, "Bad Peer AS Number: " << asn <<
                             ", Configured peer ASN: " << peer->peer_as());
                    return BgpProto::Notification::BadPeerAS;
                }
            }
        }
    }
 
    if (!mp_extension_ok) {
        BGP_LOG_PEER_WARNING(Message, peer, BGP_LOG_FLAG_ALL,
                     BGP_PEER_DIR_IN, "Unsupported Capability: " <<
                     Capability::CapabilityToString(Capability::MpExtension) <<
                     " (" << Capability::MpExtension << ")");
        return BgpProto::Notification::UnsupportedCapability;
    }
 
    return 0;
}
 
//
// Validate an incoming Open Message.
//
// Return one of the values from BgpProto::Notification::OpenMsgSubCode if
// an error is detected.
// Return 0 if message is OK.
//
int BgpProto::OpenMessage::Validate(BgpPeer *peer) const {
    if (identifier == 0) {
        BGP_LOG_PEER_WARNING(Message, peer, BGP_LOG_FLAG_ALL,
                     BGP_PEER_DIR_IN, "Bad BGP Identifier: " << 0);
        return BgpProto::Notification::BadBgpId;
    }
    if (identifier == peer->server()->bgp_identifier()) {
        BGP_LOG_PEER_WARNING(Message, peer, BGP_LOG_FLAG_ALL,
                     BGP_PEER_DIR_IN,
                     "Bad (Same as mine) BGP Identifier: " <<
                     Ip4Address(identifier).to_string());
        return BgpProto::Notification::BadBgpId;
    }
    if (as_num != AS_TRANS && as_num != peer->peer_as()) {
        BGP_LOG_PEER_WARNING(Message, peer, BGP_LOG_FLAG_ALL,
                     BGP_PEER_DIR_IN, "Bad Peer AS Number: " << as_num);
        return BgpProto::Notification::BadPeerAS;
    }
 
    return ValidateCapabilities(peer);
}
 
BgpProto::OpenMessage::Capability *
BgpProto::OpenMessage::Capability::GR::Encode(
        uint16_t gr_time, bool restarted, bool notification,
        const vector<uint8_t> &gr_afi_flags,
        const vector<Address::Family> &gr_families) {
    assert((gr_time & ~RestartTimeMask) == 0);
    uint16_t restart_flags = restarted ? RestartedFlag : 0;
    restart_flags |= notification ? NotificationFlag : 0;
    const uint16_t gr_bytes = restart_flags | gr_time;
 
    vector<uint8_t> restart_cap;
    restart_cap.push_back(gr_bytes >> 8);
    restart_cap.push_back(gr_bytes & 0xFF);
 
    size_t i = 0;
    BOOST_FOREACH(const Address::Family family, gr_families) {
        uint16_t afi;
        uint8_t safi;
        tie(afi, safi) = BgpAf::FamilyToAfiSafi(family);
        restart_cap.push_back(0);
        restart_cap.push_back(afi);
        restart_cap.push_back(safi);
        restart_cap.push_back(gr_afi_flags[i++]);
    }
    return new Capability(GracefulRestart, restart_cap.data(),
                          restart_cap.size());
}
 
void BgpProto::OpenMessage::Capability::GR::GetFamilies(const GR &gr_params,
        vector<string> *families) {
    families->clear();
    BOOST_FOREACH(Capability::GR::Family gr_family, gr_params.families) {
        Address::Family family =
            BgpAf::AfiSafiToFamily(gr_family.afi, gr_family.safi);
        if (family == Address::UNSPEC) {
            families->push_back(BgpAf::ToString(gr_family.afi, gr_family.safi));
        } else {
            families->push_back(Address::FamilyToString(family));
        }
    }
 
    // Keep the list sorted and unique.
    sort(families->begin(), families->end());
    families->erase(unique(families->begin(), families->end()),
                    families->end() );
}
 
bool BgpProto::OpenMessage::Capability::GR::Decode(GR *gr_params,
        const vector<Capability *> &capabilities) {
    gr_params->Initialize();
 
    // Find and process all GR capabilities. We are expected to receive only
    // one. Otherwise, the only the last one should be taken into effect.
    bool found = false;
    for (vector<Capability *>::const_iterator cap_it = capabilities.begin();
            cap_it != capabilities.end(); ++cap_it) {
        if ((*cap_it)->code != GracefulRestart)
            continue;
        found = true;
        gr_params->Initialize();
 
        uint8_t *data = (*cap_it)->capability.data();
        uint16_t bytes = get_value(data, 2);
        gr_params->set_flags(bytes);
        gr_params->set_time(bytes);
 
        size_t offset = 2;
        while (offset < (*cap_it)->capability.size()) {
            uint16_t afi = get_value(data + offset, 2);
            uint8_t safi = get_value(data + offset + 2, 1);
            uint8_t flags = get_value(data + offset + 3, 1);
            gr_params->families.push_back(Family(afi, safi, flags));
            offset += 4;
        }
    }
    return found;
}
 
BgpProto::OpenMessage::Capability *
BgpProto::OpenMessage::Capability::LLGR::Encode(uint32_t llgr_time,
        uint8_t llgr_afi_flags, const vector<Address::Family> &llgr_families) {
    assert((llgr_time & ~RestartTimeMask) == 0);
    vector<uint8_t> llgr_cap;
    BOOST_FOREACH(const Address::Family family, llgr_families) {
        uint16_t afi;
        uint8_t safi;
        tie(afi, safi) = BgpAf::FamilyToAfiSafi(family);
        llgr_cap.push_back(0);
        llgr_cap.push_back(afi);
        llgr_cap.push_back(safi);
        llgr_cap.push_back(llgr_afi_flags);
        llgr_cap.push_back((llgr_time & 0x00FF0000) >> 16);
        llgr_cap.push_back((llgr_time & 0x0000FF00) >>  8);
        llgr_cap.push_back((llgr_time & 0x000000FF) >>  0);
    }
    return new Capability(LongLivedGracefulRestart, llgr_cap.data(),
                          llgr_cap.size());
}
 
bool BgpProto::OpenMessage::Capability::LLGR::Decode(LLGR *llgr_params,
        const vector<Capability *> &capabilities) {
    llgr_params->Initialize();
 
    // Find and process all LLGR capabilities. We are expected to receive only
    // one. Otherwise, the only the last one should be taken into effect.
    bool found = false;
    for (vector<Capability *>::const_iterator cap_it = capabilities.begin();
            cap_it != capabilities.end(); ++cap_it) {
        if ((*cap_it)->code != LongLivedGracefulRestart)
            continue;
        found = true;
        llgr_params->Initialize();
 
        uint8_t *data = (*cap_it)->capability.data();
        size_t offset = 0;
        uint32_t max_time = 0;
        while (offset < (*cap_it)->capability.size()) {
            uint16_t afi = get_value(data + offset, 2);
            uint8_t safi = get_value(data + offset + 2, 1);
            uint8_t flags = get_value(data + offset + 3, 1);
            uint32_t time = get_value(data + offset + 4, 3);
            llgr_params->families.push_back(Family(afi, safi, flags, time));
 
            if (time > max_time)
                max_time = time;
            offset += 7;
        }
        llgr_params->time = max_time;
    }
    return found;
}
 
void BgpProto::OpenMessage::Capability::LLGR::GetFamilies(
        const LLGR &llgr_params, vector<string> *families) {
    families->clear();
    BOOST_FOREACH(Capability::LLGR::Family llgr_family, llgr_params.families) {
        Address::Family family =
            BgpAf::AfiSafiToFamily(llgr_family.afi, llgr_family.safi);
        if (family == Address::UNSPEC) {
            families->push_back(BgpAf::ToString(llgr_family.afi,
                                                llgr_family.safi));
        } else {
            families->push_back(Address::FamilyToString(family));
        }
    }
 
    // Keep the list sorted and unique.
    sort(families->begin(), families->end());
    families->erase(unique(families->begin(), families->end()),
                    families->end() );
}
 
const string BgpProto::OpenMessage::ToString() const {
    std::ostringstream os;
 
    error_code ec;
    os << "AS " << as_num;
    os << ", Hold Time " << holdtime;
    os << ", Identifier " << Ip4Address(identifier).to_string(ec);
 
    // Go through each OptParam in the OpenMessage.
    for (vector<OptParam *>::const_iterator param_it = opt_params.begin();
         param_it != opt_params.end(); ++param_it) {
        const OptParam *param = *param_it;
 
        // Go through each Capability in the OptParam.
        vector<Capability *>::const_iterator cap_it =
             param->capabilities.begin();
        while (cap_it != param->capabilities.end()) {
            const Capability *cap = *cap_it;
 
            os << ", Code " << Capability::CapabilityToString(cap->code);
 
            if (cap->code == Capability::MpExtension) {
                const uint8_t *data = cap->capability.data();
                uint16_t afi = get_value(data, 2);
                uint8_t safi = get_value(data + 3, 1);
                Address::Family family = BgpAf::AfiSafiToFamily(afi, safi);
                os << " Family " << Address::FamilyToString(family);
            }
 
            if (++cap_it == param->capabilities.end())
                break;
        }
 
        Capability::GR gr_params = Capability::GR();
        if (Capability::GR::Decode(&gr_params, param->capabilities)) {
            os << ", GR_Flags 0x" << std::hex << int(gr_params.flags);
            os << ", GR_Time " << gr_params.time;
            BOOST_FOREACH(Capability::GR::Family family, gr_params.families) {
                os << ", GR_family " <<
                    BgpAf::AfiSafiToFamily(family.afi, family.safi);
                os << ", GR_family_flags 0x" << std::hex << int(family.flags);
            }
        }
 
        Capability::LLGR llgr_params = Capability::LLGR();
        if (Capability::LLGR::Decode(&llgr_params, param->capabilities)) {
            BOOST_FOREACH(Capability::LLGR::Family family,
                          llgr_params.families) {
                os << ", LLGR_family " <<
                    BgpAf::AfiSafiToFamily(family.afi, family.safi);
                os << ", LLGR_family_flags 0x" << std::hex << int(family.flags);
                os << ", LLGR_Time " << family.time << " Seconds";
            }
        }
    }
 
    return os.str();
}
 
BgpProto::Notification::Notification()
    : BgpMessage(NOTIFICATION), error(0), subcode(0) {
}
 
const string BgpProto::Notification::ToString() const {
    return toString(static_cast<BgpProto::Notification::Code>(error), subcode);
}
 
const string BgpProto::Notification::toString(
        BgpProto::Notification::Code code, int sub_code) {
    string msg("");
    switch (code) {
        case MsgHdrErr:
            msg += string("Message Header Error:") +
                MsgHdrSubcodeToString(static_cast<MsgHdrSubCode>(sub_code));
            break;
        case OpenMsgErr:
            msg += string("OPEN Message Error:") +
                OpenMsgSubcodeToString(static_cast<OpenMsgSubCode>(sub_code));
            break;
        case UpdateMsgErr:
            msg += string("UPDATE Message Error:") +
                UpdateMsgSubCodeToString(
                    static_cast<UpdateMsgSubCode>(sub_code));
            break;
        case HoldTimerExp:
            msg += "Hold Timer Expired";
            break;
        case FSMErr:
            msg += string("Finite State Machine Error:") +
                FsmSubcodeToString(static_cast<FsmSubcode>(sub_code));
            break;
        case Cease:
            msg += string("Cease:") +
                CeaseSubcodeToString(static_cast<CeaseSubCode>(sub_code));
            break;
        default:
            msg += "Unknown";
            break;
    }
    return msg;
}
 
BgpProto::Keepalive::Keepalive()
    : BgpMessage(KEEPALIVE) {
}
 
BgpProto::Update::Update()
    : BgpMessage(UPDATE) {
}
 
BgpProto::Update::~Update() {
    STLDeleteValues(&withdrawn_routes);
    STLDeleteValues(&path_attributes);
    STLDeleteValues(&nlri);
}
 
struct BgpAttrCodeCompare {
    bool operator()(BgpAttribute *lhs, BgpAttribute *rhs) {
        return lhs->code < rhs->code;
    }
};
 
//
// Validate an incoming Update Message
// Returns 0 if message is OK
// Returns one of the values from enum UpdateMsgSubCode if an error is detected
//
int BgpProto::Update::Validate(const BgpPeer *peer, string *data) {
    BgpAttrCodeCompare comp;
    std::sort(path_attributes.begin(), path_attributes.end(), comp);
    bool origin = false, nh = false, as_path = false, mp_reach_nlri = false,
         local_pref = false;
 
    bool ibgp = (peer->PeerType() == IBGP);
 
    BgpAttrSpec::const_iterator it;
    string rxed_attr("Path attributes : ");
    for (it = path_attributes.begin(); it < path_attributes.end(); it++) {
        if (it+1 < path_attributes.end() && (*it)->code == (*(it+1))->code) {
            // Duplicate attributes
            return BgpProto::Notification::MalformedAttributeList;
        }
 
        rxed_attr +=  (*it)->ToString() + " ";
 
        if ((*it)->code == BgpAttribute::Origin)
            origin = true;
        if ((*it)->code == BgpAttribute::LocalPref) {
            local_pref = true;
        } else if ((*it)->code == BgpAttribute::NextHop) {
            nh = true;
        } else if ((*it)->code == BgpAttribute::AsPath) {
            as_path = true;
            if (peer && peer->IsAs4Supported()) {
                AsPath4ByteSpec *asp = static_cast<AsPath4ByteSpec *>(*it);
                // Check segments size for ebgp.
                // IBGP can have empty path for routes that are originated.
                if (!ibgp) {
                    if (!asp->path_segments.size() ||
                        !asp->path_segments[0]->path_segment.size())
                        return BgpProto::Notification::MalformedASPath;
                }
            } else {
                AsPathSpec *asp = static_cast<AsPathSpec *>(*it);
                // Check segments size for ebgp.
                // IBGP can have empty path for routes that are originated.
                if (!ibgp) {
                    if (!asp->path_segments.size() ||
                        !asp->path_segments[0]->path_segment.size())
                        return BgpProto::Notification::MalformedASPath;
                }
            }
        } else if ((*it)->code == BgpAttribute::MPReachNlri) {
            mp_reach_nlri = true;
        }
    }
 
    BGP_LOG_PEER(Message, const_cast<BgpPeer *>(peer),
                 SandeshLevel::SYS_DEBUG, BGP_LOG_FLAG_TRACE,
                 BGP_PEER_DIR_IN, rxed_attr);
    if (nlri.size() > 0 && !nh) {
        // next-hop attribute must be present if IPv4 NLRI is present
        char attrib_type = BgpAttribute::NextHop;
        *data = string(&attrib_type, 1);
        return BgpProto::Notification::MissingWellKnownAttrib;
    }
    if (nlri.size() > 0 || mp_reach_nlri) {
        // origin and as_path must be present if any NLRI is present
        if (!origin) {
            char attrib_type = BgpAttribute::Origin;
            *data = string(&attrib_type, 1);
            return BgpProto::Notification::MissingWellKnownAttrib;
        }
        if (!as_path) {
            char attrib_type = BgpAttribute::AsPath;
            *data = string(&attrib_type, 1);
            return BgpProto::Notification::MissingWellKnownAttrib;
        }
 
        // All validations for IBGP
        if (ibgp && !local_pref) {
            // If IBGP, local_pref is mandatory
            char attrib_type = BgpAttribute::LocalPref;
            *data = string(&attrib_type, 1);
            return BgpProto::Notification::MissingWellKnownAttrib;
        }
    }
    return 0;
}
 
int BgpProto::Update::CompareTo(const BgpProto::Update &rhs) const {
    KEY_COMPARE(withdrawn_routes.size(), rhs.withdrawn_routes.size());
    for (size_t i = 0; i < withdrawn_routes.size(); i++) {
        KEY_COMPARE(withdrawn_routes[i]->prefixlen,
                    rhs.withdrawn_routes[i]->prefixlen);
        KEY_COMPARE(withdrawn_routes[i]->prefix,
                    rhs.withdrawn_routes[i]->prefix);
    }
 
    KEY_COMPARE(path_attributes.size(), rhs.path_attributes.size());
    for (size_t i = 0; i < rhs.path_attributes.size(); i++) {
        int ret = path_attributes[i]->CompareTo(*rhs.path_attributes[i]);
        if (ret != 0) {
            cout << "Unequal " << TYPE_NAME(*path_attributes[i]) << endl;
            return ret;
        }
    }
 
    KEY_COMPARE(nlri.size(), rhs.nlri.size());
    for (size_t i = 0; i < rhs.nlri.size(); i++) {
        KEY_COMPARE(nlri[i]->prefixlen, rhs.nlri[i]->prefixlen);
        KEY_COMPARE(nlri[i]->prefix, rhs.nlri[i]->prefix);
    }
    return 0;
}
 
class BgpMarker : public ProtoElement<BgpMarker> {
public:
    static const int kSize = 16;
    static const int kErrorCode = BgpProto::Notification::MsgHdrErr;
    static const int kErrorSubcode = BgpProto::Notification::ConnNotSync;
    static bool Verifier(const void *obj, const uint8_t *data, size_t size,
                         ParseContext *context) {
        for (int i = 0; i < 16; i++) {
            if (data[i] != 0xff) return false;
        }
        return true;
    }
    static void Writer(const void *msg, uint8_t *data, size_t size) {
        for (int i = 0; i < 16; i++) {
            data[i] = 0xff;
        }
    }
};
 
class BgpMsgLength : public ProtoElement<BgpMsgLength> {
public:
    static const int kSize = 2;
    static const int kErrorCode = BgpProto::Notification::MsgHdrErr;
    static const int kErrorSubcode = BgpProto::Notification::BadMsgLength;
    struct Offset {
        string operator()() {
            return "BgpMsgLength";
        }
    };
    typedef Offset SaveOffset;
    static bool Verifier(const void *obj, const uint8_t *data, size_t size,
                         ParseContext *context) {
        int value = get_short(data);
        if (value < BgpProto::kMinMessageSize ||
            value > BgpProto::kMaxMessageSize) {
            return false;
        }
        if ((size_t) value < context->offset() + size) {
            return false;
        }
        return true;
    }
    struct SetLength {
        static void Callback(EncodeContext *context, uint8_t *data,
                             int offset, int element_size) {
            put_value(data, kSize, context->length());
        }
    };
    typedef SetLength EncodingCallback;
};
 
// BGP OPEN
class BgpOpenVersion : public ProtoElement<BgpOpenVersion> {
public:
    static const int kSize = 1;
    static const int kErrorCode = BgpProto::Notification::OpenMsgErr;
    static const int kErrorSubcode = BgpProto::Notification::UnsupportedVersion;
    static bool Verifier(const void * obj, const uint8_t *data, size_t size,
                          ParseContext *context) {
        return data[0] == 0x4;
    }
    static void Writer(const void *msg, uint8_t *data, size_t size) {
        *data = 0x4;
    }
};
 
class BgpOpenAsNum : public ProtoElement<BgpOpenAsNum> {
public:
    static const int kSize = 2;
    typedef Accessor<BgpProto::OpenMessage, uint32_t,
        &BgpProto::OpenMessage::as_num> Setter;
};
 
class BgpHoldTime : public ProtoElement<BgpHoldTime> {
public:
    static const int kSize = 2;
    static const int kErrorCode = BgpProto::Notification::OpenMsgErr;
    static const int kErrorSubcode =
            BgpProto::Notification::UnacceptableHoldTime;
    static bool Verifier(const BgpProto::OpenMessage *obj, const uint8_t *data,
                         size_t size, ParseContext *context) {
        uint16_t value = get_value(data, 2);
        return (value == 0 || value >= 3);
    }
    typedef Accessor<BgpProto::OpenMessage, int32_t,
        &BgpProto::OpenMessage::holdtime> Setter;
};
 
class BgpIdentifier : public ProtoElement<BgpIdentifier> {
public:
    static const int kSize = 4;
    typedef Accessor<BgpProto::OpenMessage, uint32_t,
        &BgpProto::OpenMessage::identifier> Setter;
};
 
class BgpOpenCapabilityCode : public ProtoElement<BgpOpenCapabilityCode> {
public:
    static const int kSize = 1;
    typedef Accessor<BgpProto::OpenMessage::Capability, int,
        &BgpProto::OpenMessage::Capability::code> Setter;
};
 
class BgpOpenCapabilityLength : public ProtoElement<BgpOpenCapabilityLength> {
public:
    static const int kSize = 1;
    typedef int SequenceLength;
};
 
class BgpOpenCapabilityValue : public ProtoElement<BgpOpenCapabilityValue> {
public:
    static const int kSize = -1;
    typedef VectorAccessor<BgpProto::OpenMessage::Capability, uint8_t,
        &BgpProto::OpenMessage::Capability::capability> Setter;
};
 
class BgpOpenCapability : public ProtoSequence<BgpOpenCapability> {
public:
    typedef mpl::list<BgpOpenCapabilityCode, BgpOpenCapabilityLength,
        BgpOpenCapabilityValue> Sequence;
};
 
class BgpOpenCapabilities : public ProtoSequence<BgpOpenCapabilities> {
public:
    static const int kSize = 1;
    static const int kMinOccurs = 0;
    static const int kMaxOccurs = -1;
    typedef mpl::list<BgpOpenCapability> Sequence;
 
    typedef CollectionAccessor<BgpProto::OpenMessage::OptParam,
        vector<BgpProto::OpenMessage::Capability *>,
        &BgpProto::OpenMessage::OptParam::capabilities> ContextStorer;
 
    struct OptMatch {
        bool match(const BgpProto::OpenMessage::OptParam *ctx) {
            return !ctx->capabilities.empty();
        }
    };
    typedef OptMatch ContextMatch;
};
 
class BgpOpenOptParamChoice : public ProtoChoice<BgpOpenOptParamChoice> {
public:
    static const int kSize = 1;
    static const int kErrorCode = BgpProto::Notification::OpenMsgErr;
    static const int kErrorSubcode =
            BgpProto::Notification::UnsupportedOptionalParam;
    typedef mpl::map<
        mpl::pair<mpl::int_<BgpProto::OpenMessage::OPEN_OPT_CAPABILITIES>,
                  BgpOpenCapabilities>
    > Choice;
};
 
class BgpOpenOptParam : public ProtoSequence<BgpOpenOptParam> {
public:
    static const int kSize = 1;
    static const int kMinOccurs = 0;
    static const int kMaxOccurs = -1;
    typedef CollectionAccessor<BgpProto::OpenMessage,
        vector<BgpProto::OpenMessage::OptParam *>,
        &BgpProto::OpenMessage::opt_params> ContextStorer;
    typedef mpl::list<BgpOpenOptParamChoice> Sequence;
};
 
class BgpOpenMessage : public ProtoSequence<BgpOpenMessage> {
public:
    typedef mpl::list<BgpOpenVersion,
                      BgpOpenAsNum,
                      BgpHoldTime,
                      BgpIdentifier,
                      BgpOpenOptParam> Sequence;
    typedef BgpProto::OpenMessage ContextType;
};
 
class NotificationErrorCode : public ProtoElement<NotificationErrorCode> {
public:
    static const int kSize = 1;
    typedef Accessor<BgpProto::Notification, int,
        &BgpProto::Notification::error> Setter;
};
 
class NotificationErrorSubcode : public ProtoElement<NotificationErrorSubcode> {
public:
    static const int kSize = 1;
    typedef Accessor<BgpProto::Notification, int,
        &BgpProto::Notification::subcode> Setter;
};
 
class NotificationData : public ProtoElement<NotificationData> {
public:
    static const int kSize = -1;
    typedef Accessor<BgpProto::Notification, string,
        &BgpProto::Notification::data> Setter;
};
 
class BgpNotificationMessage : public ProtoSequence<BgpNotificationMessage> {
public:
    typedef mpl::list<NotificationErrorCode,
                      NotificationErrorSubcode,
                      NotificationData> Sequence;
    typedef BgpProto::Notification ContextType;
};
 
class BgpKeepaliveMessage : public ProtoSequence<BgpKeepaliveMessage> {
public:
    typedef mpl::list<> Sequence;
    typedef BgpProto::Keepalive ContextType;
};
 
class BgpPrefixLen : public ProtoElement<BgpPrefixLen> {
public:
    static const int kSize = 1;
    struct PrefixLen {
        int operator()(BgpProtoPrefix *obj, const uint8_t *data, size_t size) {
            int bits = data[0];
            return (bits + 7) / 8;
        }
    };
    typedef PrefixLen SequenceLength;
    typedef Accessor<BgpProtoPrefix, int,
            &BgpProtoPrefix::prefixlen> Setter;
};
 
class BgpPrefixAddress : public ProtoElement<BgpPrefixAddress> {
public:
    static const int kSize = -1;
    typedef VectorAccessor<BgpProtoPrefix, uint8_t,
            &BgpProtoPrefix::prefix> Setter;
};
 
class BgpUpdateWithdrawnRoutes :
    public ProtoSequence<BgpUpdateWithdrawnRoutes> {
public:
    static const int kSize = 2;
    static const int kMinOccurs = 0;
    static const int kMaxOccurs = -1;
    static const int kErrorCode = BgpProto::Notification::UpdateMsgErr;
    static const int kErrorSubcode =
            BgpProto::Notification::MalformedAttributeList;
 
    typedef CollectionAccessor<BgpProto::Update,
            vector<BgpProtoPrefix *>,
            &BgpProto::Update::withdrawn_routes> ContextStorer;
 
    struct OptMatch {
        bool match(const BgpProto::Update *ctx) {
            return !ctx->withdrawn_routes.empty();
        }
    };
    typedef OptMatch ContextMatch;
 
    typedef mpl::list<BgpPrefixLen, BgpPrefixAddress> Sequence;
};
 
class BgpPathAttrLength : public ProtoElement<BgpPathAttrLength> {
public:
    static const int kSize = -1;
    struct AttrLen {
        int operator()(BgpAttribute *obj,
                       const uint8_t *data, size_t &size) {
            if (obj->flags & BgpAttribute::ExtendedLength) {
                // Extended Length: use 2 bytes to read
                size = 2;
            } else {
                size = 1;
            }
            return get_value(data, size);
        }
    };
    typedef AttrLen SequenceLength;
    struct AttrSizeSet {
        static int get(const BgpAttribute *obj) {
            if (obj->GetEncodeFlags() & BgpAttribute::ExtendedLength) {
                // Extended Length: use 2 bytes to read
                return 2;
            } else {
                return 1;
            }
        }
    };
    typedef AttrSizeSet SizeSetter;
};
 
template <class Derived>
struct BgpContextSwap {
    Derived *operator()(const BgpAttribute *attr) {
        return new Derived(*attr);
    }
};
 
template <class C>
struct BgpAttributeVerifier {
    static bool Verifier(const C *obj, const uint8_t *data, size_t size,
                         ParseContext *context) {
        int pre = (obj->flags & BgpAttribute::ExtendedLength) ? 4 : 3;
        if (C::kSize > 0 &&
            static_cast<int>(context->total_size()) != C::kSize) {
            int offset = pre + context->total_size() - context->size();
            context->SetError(BgpProto::Notification::UpdateMsgErr,
                    BgpProto::Notification::AttribLengthError,
                    TYPE_NAME(C), data - offset, context->total_size() + pre);
            return false;
        }
        if ((obj->flags & BgpAttribute::FLAG_MASK) != C::kFlags) {
            int offset = pre + context->total_size() - context->size();
            context->SetError(BgpProto::Notification::UpdateMsgErr,
                    BgpProto::Notification::AttribFlagsError,
                    TYPE_NAME(C), data - offset, context->total_size() + pre);
            return false;
        }
        return true;
    }
};
 
template <>
struct BgpAttributeVerifier<BgpAttrOrigin> {
    static bool Verifier(const BgpAttrOrigin *obj, const uint8_t *data,
                         size_t size, ParseContext *context) {
        int pre = (obj->flags & BgpAttribute::ExtendedLength) ? 4 : 3;
        if (context->size() != 1) {
            context->SetError(BgpProto::Notification::UpdateMsgErr,
                    BgpProto::Notification::AttribLengthError,
                    "BgpAttrOrigin", data - pre, size + pre);
            return false;
        }
        if ((obj->flags & BgpAttribute::FLAG_MASK) != BgpAttrOrigin::kFlags) {
            context->SetError(BgpProto::Notification::UpdateMsgErr,
                    BgpProto::Notification::AttribFlagsError,
                    "BgpAttrOrigin", data - pre, size + pre);
            return false;
        }
        uint8_t value = data[0];
        if (value != BgpAttrOrigin::IGP && value != BgpAttrOrigin::EGP &&
                value != BgpAttrOrigin::INCOMPLETE) {
            context->SetError(BgpProto::Notification::UpdateMsgErr,
                    BgpProto::Notification::InvalidOrigin,
                    "BgpAttrOrigin", data - pre, size + pre);
            return false;
        }
        return true;
    }
};
 
template <>
struct BgpAttributeVerifier<BgpAttrNextHop> {
    static bool Verifier(const BgpAttrNextHop *obj, const uint8_t *data,
                         size_t size, ParseContext *context) {
        int pre = (obj->flags & BgpAttribute::ExtendedLength) ? 4 : 3;
        if (static_cast<int>(context->size()) != BgpAttrNextHop::kSize) {
            context->SetError(BgpProto::Notification::UpdateMsgErr,
                    BgpProto::Notification::AttribLengthError,
                    "BgpAttrNextHop", data - pre, size + pre);
            return false;
        }
        if ((obj->flags & BgpAttribute::FLAG_MASK) != BgpAttrNextHop::kFlags) {
            context->SetError(BgpProto::Notification::UpdateMsgErr,
                    BgpProto::Notification::AttribFlagsError,
                    "BgpAttrNextHop", data - pre, size + pre);
            return false;
        }
        uint32_t value = get_value(data, size);
        // TODO(sbansal): More checks are needed
        if (value == 0) {
            context->SetError(BgpProto::Notification::UpdateMsgErr,
                    BgpProto::Notification::InvalidNH,
                    "BgpAttrNextHop", data - pre, size + pre);
        return false;
    }
    return true;
    }
};
 
template <>
struct BgpAttributeVerifier<AsPathSpec::PathSegment> {
    static bool Verifier(const AsPathSpec::PathSegment *obj,
                         const uint8_t *data, size_t size,
                         ParseContext *context) {
        return true;
    }
};
 
template <>
struct BgpAttributeVerifier<AsPath4ByteSpec::PathSegment> {
    static bool Verifier(const AsPath4ByteSpec::PathSegment *obj,
                         const uint8_t *data, size_t size,
                         ParseContext *context) {
        return true;
    }
};
 
template <>
struct BgpAttributeVerifier<As4PathSpec::PathSegment> {
    static bool Verifier(const As4PathSpec::PathSegment *obj,
                         const uint8_t *data, size_t size,
                         ParseContext *context) {
        return true;
    }
};
 
template <int Size, class C, typename T, T C::*Member>
class BgpAttributeValue :
    public ProtoElement<BgpAttributeValue<Size, C, T, Member> > {
public:
    static const int kSize = Size;
    static bool Verifier(const C *obj, const uint8_t *data, size_t size,
                             ParseContext *context) {
        return BgpAttributeVerifier<C>::Verifier(obj, data, size, context);
    }
    typedef Accessor<C, T, Member> Setter;
};
 
template <class C, int Size, typename T, T C::*M>
class BgpAttrTemplate :
    public ProtoSequence<BgpAttrTemplate<C, Size, T, M> > {
public:
    static const int kErrorCode = BgpProto::Notification::UpdateMsgErr;
    static const int kErrorSubcode = BgpProto::Notification::AttribLengthError;
    typedef C ContextType;
    typedef BgpContextSwap<C> ContextSwap;
    typedef mpl::list<BgpPathAttrLength, BgpAttributeValue<Size, C, T, M>
            > Sequence;
};
 
class BgpPathAttributeAtomicAggregate :
    public ProtoSequence<BgpPathAttributeAtomicAggregate> {
public:
    static bool Verifier(const BgpAttrAtomicAggregate * obj,
                         const uint8_t *data, size_t size,
                         ParseContext *context) {
        if (data[0] != 0) {
            context->SetError(BgpProto::Notification::UpdateMsgErr,
                    BgpProto::Notification::AttribLengthError,
                    "BgpAttrAtomicAggregate", data - 2, data[0] + 3);
            return false;
        }
        if (obj->flags != BgpAttrAtomicAggregate::kFlags) {
            context->SetError(BgpProto::Notification::UpdateMsgErr,
                    BgpProto::Notification::AttribFlagsError,
                    "BgpAttrAtomicAggregate", data - 2, 3);
            return false;
        }
        return true;
    }
    typedef BgpAttrAtomicAggregate ContextType;
    typedef BgpContextSwap<BgpAttrAtomicAggregate> ContextSwap;
    typedef mpl::list<BgpPathAttrLength> Sequence;
};
 
class BgpPathAttributeAggregator :
    public ProtoSequence<BgpPathAttributeAggregator> {
public:
    typedef BgpAttrAggregator ContextType;
    typedef BgpContextSwap<BgpAttrAggregator> ContextSwap;
    typedef mpl::list<BgpPathAttrLength,
            BgpAttributeValue<2, BgpAttrAggregator, as2_t,
                                  &BgpAttrAggregator::as_num>,
            BgpAttributeValue<4, BgpAttrAggregator, uint32_t,
                                  &BgpAttrAggregator::address>
    > Sequence;
};
 
class BgpPathAttributeAggregator4Byte :
    public ProtoSequence<BgpPathAttributeAggregator4Byte> {
public:
    typedef BgpAttr4ByteAggregator ContextType;
    typedef BgpContextSwap<BgpAttr4ByteAggregator> ContextSwap;
    typedef mpl::list<BgpPathAttrLength,
            BgpAttributeValue<4, BgpAttr4ByteAggregator, as_t,
                                  &BgpAttr4ByteAggregator::as_num>,
            BgpAttributeValue<4, BgpAttr4ByteAggregator, uint32_t,
                                  &BgpAttr4ByteAggregator::address>
    > Sequence;
};
 
class BgpPathAttributeAs4Aggregator :
    public ProtoSequence<BgpPathAttributeAs4Aggregator> {
public:
    typedef BgpAttrAs4Aggregator ContextType;
    typedef BgpContextSwap<BgpAttrAs4Aggregator> ContextSwap;
    typedef mpl::list<BgpPathAttrLength,
            BgpAttributeValue<4, BgpAttrAs4Aggregator, as_t,
                                  &BgpAttrAs4Aggregator::as_num>,
            BgpAttributeValue<4, BgpAttrAs4Aggregator, uint32_t,
                                  &BgpAttrAs4Aggregator::address>
    > Sequence;
};
 
class BgpPathAttrAsPathSegmentLength :
    public ProtoElement<BgpPathAttrAsPathSegmentLength> {
public:
    static const int kSize = 1;
    struct PathSegmentLength {
        int operator()(AsPathSpec::PathSegment *obj,
                       const uint8_t *data, size_t size) {
            return get_value(data, 1) * 2;
        }
    };
    typedef PathSegmentLength SequenceLength;
    struct SetLength {
        static void Callback(EncodeContext *context, uint8_t *data,
                             int offset, int element_size) {
            int len = get_value(data, kSize);
            put_value(data, kSize, len/2);
        }
    };
    typedef SetLength EncodingCallback;
};
 
class BgpPathAttrAsPath4ByteSegmentLength :
    public ProtoElement<BgpPathAttrAsPath4ByteSegmentLength> {
public:
    static const int kSize = 1;
    struct PathSegmentLength {
        int operator()(AsPath4ByteSpec::PathSegment *obj,
                       const uint8_t *data, size_t size) {
            return get_value(data, 1) * 4;
        }
    };
    typedef PathSegmentLength SequenceLength;
    struct SetLength {
        static void Callback(EncodeContext *context, uint8_t *data,
                             int offset, int element_size) {
            int len = get_value(data, kSize);
            put_value(data, kSize, len/4);
        }
    };
    typedef SetLength EncodingCallback;
};
 
class BgpPathAttrAs4PathSegmentLength :
    public ProtoElement<BgpPathAttrAs4PathSegmentLength> {
public:
    static const int kSize = 1;
    struct PathSegmentLength {
        int operator()(As4PathSpec::PathSegment *obj,
                       const uint8_t *data, size_t size) {
            return get_value(data, 1) * 4;
        }
    };
    typedef PathSegmentLength SequenceLength;
    struct SetLength {
        static void Callback(EncodeContext *context, uint8_t *data,
                             int offset, int element_size) {
            int len = get_value(data, kSize);
            put_value(data, kSize, len/4);
        }
    };
    typedef SetLength EncodingCallback;
};
 
 
class BgpPathAttrAsPathSegmentValue :
    public ProtoElement<BgpPathAttrAsPathSegmentValue> {
public:
    static const int kSize = -1;
    typedef VectorAccessor<AsPathSpec::PathSegment, as2_t,
                           &AsPathSpec::PathSegment::path_segment> Setter;
};
 
class BgpPathAttrAsPath4ByteSegmentValue :
    public ProtoElement<BgpPathAttrAsPath4ByteSegmentValue> {
public:
    static const int kSize = -1;
    typedef VectorAccessor<AsPath4ByteSpec::PathSegment, as_t,
                           &AsPath4ByteSpec::PathSegment::path_segment> Setter;
};
 
class BgpPathAttrAs4PathSegmentValue :
    public ProtoElement<BgpPathAttrAs4PathSegmentValue> {
public:
    static const int kSize = -1;
    typedef VectorAccessor<As4PathSpec::PathSegment, as_t,
                           &As4PathSpec::PathSegment::path_segment> Setter;
};
 
class BgpPathAttrAsPathSegmentList :
    public ProtoSequence<BgpPathAttrAsPathSegmentList> {
public:
    static const int kMinOccurs = 0;
    static const int kMaxOccurs = -1;
 
    static bool Verifier(const AsPathSpec *obj, const uint8_t *data,
                         size_t size, ParseContext *context) {
        return BgpAttributeVerifier<AsPathSpec>::Verifier(obj, data, size,
                                                          context);
    }
 
    typedef CollectionAccessor<AsPathSpec,
            vector<AsPathSpec::PathSegment *>,
            &AsPathSpec::path_segments> ContextStorer;
 
    typedef mpl::list<BgpAttributeValue<1, AsPathSpec::PathSegment, int,
                      &AsPathSpec::PathSegment::path_segment_type>,
            BgpPathAttrAsPathSegmentLength,
            BgpPathAttrAsPathSegmentValue
    > Sequence;
};
 
class BgpPathAttrAsPath4ByteSegmentList :
    public ProtoSequence<BgpPathAttrAsPath4ByteSegmentList> {
public:
    static const int kMinOccurs = 0;
    static const int kMaxOccurs = -1;
 
    static bool Verifier(const AsPath4ByteSpec *obj, const uint8_t *data,
                         size_t size, ParseContext *context) {
        return BgpAttributeVerifier<AsPath4ByteSpec>::Verifier(obj, data, size,
                                                          context);
    }
 
    typedef CollectionAccessor<AsPath4ByteSpec,
            vector<AsPath4ByteSpec::PathSegment *>,
            &AsPath4ByteSpec::path_segments> ContextStorer;
 
    typedef mpl::list<BgpAttributeValue<1, AsPath4ByteSpec::PathSegment, int,
                      &AsPath4ByteSpec::PathSegment::path_segment_type>,
            BgpPathAttrAsPath4ByteSegmentLength,
            BgpPathAttrAsPath4ByteSegmentValue
    > Sequence;
};
 
class BgpPathAttrAs4PathSegmentList :
    public ProtoSequence<BgpPathAttrAs4PathSegmentList> {
public:
    static const int kMinOccurs = 0;
    static const int kMaxOccurs = -1;
 
    static bool Verifier(const As4PathSpec *obj, const uint8_t *data,
                         size_t size, ParseContext *context) {
        return BgpAttributeVerifier<As4PathSpec>::Verifier(obj, data, size,
                                                          context);
    }
 
    typedef CollectionAccessor<As4PathSpec,
            vector<As4PathSpec::PathSegment *>,
            &As4PathSpec::path_segments> ContextStorer;
 
    typedef mpl::list<BgpAttributeValue<1, As4PathSpec::PathSegment, int,
                      &As4PathSpec::PathSegment::path_segment_type>,
            BgpPathAttrAs4PathSegmentLength,
            BgpPathAttrAs4PathSegmentValue
    > Sequence;
};
 
class BgpPathAttributeAsPath : public ProtoSequence<BgpPathAttributeAsPath> {
public:
    typedef AsPathSpec ContextType;
    typedef BgpContextSwap<AsPathSpec> ContextSwap;
    typedef mpl::list<BgpPathAttrLength, BgpPathAttrAsPathSegmentList> Sequence;
};
 
class BgpPathAttributeAsPath4Byte :
    public ProtoSequence<BgpPathAttributeAsPath4Byte> {
public:
    typedef AsPath4ByteSpec ContextType;
    typedef BgpContextSwap<AsPath4ByteSpec> ContextSwap;
    typedef mpl::list<BgpPathAttrLength,
            BgpPathAttrAsPath4ByteSegmentList> Sequence;
};
 
class BgpPathAttributeAs4Path : public ProtoSequence<BgpPathAttributeAs4Path> {
public:
    typedef As4PathSpec ContextType;
    typedef BgpContextSwap<As4PathSpec> ContextSwap;
    typedef mpl::list<BgpPathAttrLength, BgpPathAttrAs4PathSegmentList> Sequence;
};
 
class BgpPathAttributeFlags : public ProtoElement<BgpPathAttributeFlags> {
public:
    static const int kSize = 1;
    struct FlagsAccessor {
        static void set(BgpAttribute *obj, uint8_t value) {
            obj->flags = value;
        }
        static uint8_t get(const BgpAttribute *obj) {
            return obj->GetEncodeFlags();
        }
    };
    typedef FlagsAccessor Setter;
};
 
class BgpPathAttributeCommunityList :
    public ProtoElement<BgpPathAttributeCommunityList> {
public:
    static const int kSize = -1;
    static bool Verifier(const CommunitySpec *obj, const uint8_t *data,
                         size_t size, ParseContext *context) {
        return BgpAttributeVerifier<CommunitySpec>::Verifier(obj, data, size,
                                                             context);
    }
 
    typedef VectorAccessor<CommunitySpec, uint32_t,
                           &CommunitySpec::communities> Setter;
};
 
class BgpPathAttributeCommunities :
    public ProtoSequence<BgpPathAttributeCommunities> {
public:
    typedef CommunitySpec ContextType;
    typedef BgpContextSwap<CommunitySpec> ContextSwap;
    typedef mpl::list<BgpPathAttrLength,
                      BgpPathAttributeCommunityList> Sequence;
};
 
class BgpPathAttributeExtendedCommunityList :
    public ProtoElement<BgpPathAttributeExtendedCommunityList> {
public:
    static const int kSize = -1;
    static bool Verifier(const ExtCommunitySpec *obj, const uint8_t *data,
                         size_t size, ParseContext *context) {
        return BgpAttributeVerifier<ExtCommunitySpec>::Verifier(obj, data, size,
                                                                context);
    }
 
    typedef VectorAccessor<ExtCommunitySpec, uint64_t,
                           &ExtCommunitySpec::communities> Setter;
};
 
class BgpPathAttributeExtendedCommunities :
    public ProtoSequence<BgpPathAttributeExtendedCommunities> {
public:
    typedef ExtCommunitySpec ContextType;
    typedef BgpContextSwap<ExtCommunitySpec> ContextSwap;
    typedef mpl::list<BgpPathAttrLength,
                      BgpPathAttributeExtendedCommunityList> Sequence;
};
 
class BgpPathAttributeLargeCommunityList :
    public ProtoElement<BgpPathAttributeLargeCommunityList> {
public:
    static const int kSize = -1;
    static bool Verifier(const LargeCommunitySpec *obj, const uint8_t *data,
                         size_t size, ParseContext *context) {
        return BgpAttributeVerifier<LargeCommunitySpec>::Verifier(obj, data,
                                                                  size,
                                                                  context);
    }
 
    typedef VectorAccessor<LargeCommunitySpec, uint32_t,
                           &LargeCommunitySpec::communities> Setter;
};
 
class BgpPathAttributeLargeCommunities :
    public ProtoSequence<BgpPathAttributeLargeCommunities> {
public:
    typedef LargeCommunitySpec ContextType;
    typedef BgpContextSwap<LargeCommunitySpec> ContextSwap;
    typedef mpl::list<BgpPathAttrLength,
                      BgpPathAttributeLargeCommunityList> Sequence;
};
 
class BgpPathAttributeClusterListData :
    public ProtoElement<BgpPathAttributeClusterListData> {
public:
    static const int kSize = -1;
    typedef VectorAccessor<ClusterListSpec, uint32_t,
                           &ClusterListSpec::cluster_list> Setter;
};
 
class BgpPathAttributeClusterList :
    public ProtoSequence<BgpPathAttributeClusterList> {
public:
    typedef ClusterListSpec ContextType;
    typedef BgpContextSwap<ClusterListSpec> ContextSwap;
    typedef mpl::list<BgpPathAttrLength,
                      BgpPathAttributeClusterListData> Sequence;
};
 
class BgpPathAttributeOriginVnList :
    public ProtoElement<BgpPathAttributeOriginVnList> {
public:
    static const int kSize = -1;
    static bool Verifier(const OriginVnPathSpec *obj, const uint8_t *data,
                         size_t size, ParseContext *context) {
        return BgpAttributeVerifier<OriginVnPathSpec>::Verifier(obj, data, size,
                                                                context);
    }
 
    typedef VectorAccessor<OriginVnPathSpec, uint64_t,
                           &OriginVnPathSpec::origin_vns> Setter;
};
 
class BgpPathAttributeOriginVnPath :
    public ProtoSequence<BgpPathAttributeOriginVnPath> {
public:
    typedef OriginVnPathSpec ContextType;
    typedef BgpContextSwap<OriginVnPathSpec> ContextSwap;
    typedef mpl::list<BgpPathAttrLength, BgpPathAttributeOriginVnList> Sequence;
};
 
class BgpPathAttributePmsiTunnelIdentifier :
    public ProtoElement<BgpPathAttributePmsiTunnelIdentifier> {
public:
    static const int kSize = -1;
    static bool Verifier(const PmsiTunnelSpec *obj, const uint8_t *data,
                         size_t size, ParseContext *context) {
        return BgpAttributeVerifier<PmsiTunnelSpec>::Verifier(
                obj, data, size, context);
    }
 
    typedef VectorAccessor<PmsiTunnelSpec, uint8_t,
        &PmsiTunnelSpec::identifier> Setter;
};
 
class BgpPathAttributePmsiTunnel :
    public ProtoSequence<BgpPathAttributePmsiTunnel> {
public:
    typedef PmsiTunnelSpec ContextType;
    typedef BgpContextSwap<PmsiTunnelSpec> ContextSwap;
    typedef mpl::list<BgpPathAttrLength,
        BgpAttributeValue<1, PmsiTunnelSpec,
            uint8_t, &PmsiTunnelSpec::tunnel_flags>,
        BgpAttributeValue<1, PmsiTunnelSpec,
            uint8_t, &PmsiTunnelSpec::tunnel_type>,
        BgpAttributeValue<3, PmsiTunnelSpec,
            uint32_t, &PmsiTunnelSpec::label>,
        BgpPathAttributePmsiTunnelIdentifier> Sequence;
};
 
class BgpPathAttributeDiscoveryEdgeAddressLen :
    public ProtoElement<BgpPathAttributeDiscoveryEdgeAddressLen> {
public:
    static const int kSize = 1;
    static bool Verifier(const void *obj, const uint8_t *data,
                         size_t size, ParseContext *context) {
        uint8_t value = get_value(data, 1);
        return (value == 4);
    }
    typedef int SequenceLength;
};
 
class BgpPathAttributeDiscoveryEdgeAddressValue :
    public ProtoElement<BgpPathAttributeDiscoveryEdgeAddressValue> {
public:
    static const int kSize = -1;
    typedef VectorAccessor<EdgeDiscoverySpec::Edge, uint8_t,
            &EdgeDiscoverySpec::Edge::address> Setter;
};
 
class BgpPathAttributeDiscoveryEdgeAddress :
    public ProtoSequence<BgpPathAttributeDiscoveryEdgeAddress> {
public:
    typedef mpl::list<BgpPathAttributeDiscoveryEdgeAddressLen,
            BgpPathAttributeDiscoveryEdgeAddressValue> Sequence;
};
 
class BgpPathAttributeDiscoveryEdgeLabelLen :
    public ProtoElement<BgpPathAttributeDiscoveryEdgeLabelLen> {
public:
    static const int kSize = 1;
    static bool Verifier(const void *obj, const uint8_t *data,
                         size_t size, ParseContext *context) {
        uint8_t value = get_value(data, 1);
        return (value > 0 && value % 8 == 0);
    }
    typedef int SequenceLength;
};
 
class BgpPathAttributeDiscoveryEdgeLabelValues :
    public ProtoElement<BgpPathAttributeDiscoveryEdgeLabelValues> {
public:
    static const int kSize = -1;
    typedef VectorAccessor<EdgeDiscoverySpec::Edge, uint32_t,
            &EdgeDiscoverySpec::Edge::labels> Setter;
};
 
class BgpPathAttributeDiscoveryEdgeLabels :
    public ProtoSequence<BgpPathAttributeDiscoveryEdgeLabels> {
public:
    typedef mpl::list<BgpPathAttributeDiscoveryEdgeLabelLen,
            BgpPathAttributeDiscoveryEdgeLabelValues> Sequence;
};
 
class BgpPathAttributeDiscoveryEdgeList :
    public ProtoSequence<BgpPathAttributeDiscoveryEdgeList> {
public:
    static const int kMinOccurs = 1;
    static const int kMaxOccurs = -1;
 
    static bool Verifier(const EdgeDiscoverySpec *obj, const uint8_t *data,
                         size_t size, ParseContext *context) {
        return BgpAttributeVerifier<EdgeDiscoverySpec>::Verifier(
                obj, data, size, context);
    }
 
    typedef CollectionAccessor<EdgeDiscoverySpec,
            vector<EdgeDiscoverySpec::Edge *>,
            &EdgeDiscoverySpec::edge_list> ContextStorer;
 
    typedef mpl::list<BgpPathAttributeDiscoveryEdgeAddress,
            BgpPathAttributeDiscoveryEdgeLabels> Sequence;
};
 
class BgpPathAttributeEdgeDiscovery :
    public ProtoSequence<BgpPathAttributeEdgeDiscovery> {
public:
    typedef EdgeDiscoverySpec ContextType;
    typedef BgpContextSwap<EdgeDiscoverySpec> ContextSwap;
    typedef mpl::list<BgpPathAttrLength,
            BgpPathAttributeDiscoveryEdgeList> Sequence;
};
 
class BgpPathAttributeForwardingEdgeLen :
    public ProtoElement<BgpPathAttributeForwardingEdgeLen> {
public:
    static const int kSize = 1;
    static bool Verifier(const void *obj, const uint8_t *data,
                         size_t size, ParseContext *context) {
        uint8_t value = get_value(data, 1);
        return (value == 4);
    }
    struct GetLength {
        int operator()(EdgeForwardingSpec::Edge *obj,
                       const uint8_t *data, size_t size) {
            obj->address_len = get_value(data, 1) * 2 + 8;
            return obj->address_len;
        }
    };
    typedef GetLength SequenceLength;
    struct SetLength {
        static void Callback(EncodeContext *context, uint8_t *data,
                             int offset, int element_size) {
            int len = get_value(data, kSize);
            put_value(data, kSize, (len - 8) / 2);
        }
    };
    typedef SetLength EncodingCallback;
};
 
class BgpPathAttributeForwardingEdgeAddressLen :
    public ProtoElement<BgpPathAttributeForwardingEdgeAddressLen> {
public:
    static const int kSize = 0;
    struct GetLength {
        int operator()(EdgeForwardingSpec::Edge *obj,
                       const uint8_t *data, size_t size) {
            return (obj->address_len - 8) / 2;
        }
    };
    typedef GetLength SequenceLength;
};
 
class BgpPathAttributeForwardingEdgeInAddressValue :
    public ProtoElement<BgpPathAttributeForwardingEdgeInAddressValue> {
public:
    static const int kSize = -1;
    typedef VectorAccessor<EdgeForwardingSpec::Edge, uint8_t,
            &EdgeForwardingSpec::Edge::inbound_address> Setter;
};
 
class BgpPathAttributeForwardingEdgeInAddress :
    public ProtoSequence<BgpPathAttributeForwardingEdgeInAddress> {
public:
    static const int kMinOccurs = 1;
    static const int kMaxOccurs = 1;
    typedef mpl::list<BgpPathAttributeForwardingEdgeAddressLen,
            BgpPathAttributeForwardingEdgeInAddressValue> Sequence;
};
 
class BgpPathAttributeForwardingEdgeInLabel :
    public ProtoElement<BgpPathAttributeForwardingEdgeInLabel> {
public:
    static const int kSize = 4;
    typedef Accessor<EdgeForwardingSpec::Edge, uint32_t,
            &EdgeForwardingSpec::Edge::inbound_label> Setter;
};
 
class BgpPathAttributeForwardingEdgeOutAddressValue :
    public ProtoElement<BgpPathAttributeForwardingEdgeOutAddressValue> {
public:
    static const int kSize = -1;
    typedef VectorAccessor<EdgeForwardingSpec::Edge, uint8_t,
            &EdgeForwardingSpec::Edge::outbound_address> Setter;
};
 
class BgpPathAttributeForwardingEdgeOutAddress :
    public ProtoSequence<BgpPathAttributeForwardingEdgeOutAddress> {
public:
    static const int kMinOccurs = 1;
    static const int kMaxOccurs = 1;
    typedef mpl::list<BgpPathAttributeForwardingEdgeAddressLen,
            BgpPathAttributeForwardingEdgeOutAddressValue> Sequence;
};
 
class BgpPathAttributeForwardingEdgeOutLabel :
    public ProtoElement<BgpPathAttributeForwardingEdgeOutLabel> {
public:
    static const int kSize = 4;
    typedef Accessor<EdgeForwardingSpec::Edge, uint32_t,
            &EdgeForwardingSpec::Edge::outbound_label> Setter;
};
 
class BgpPathAttributeForwardingEdgeList :
    public ProtoSequence<BgpPathAttributeForwardingEdgeList> {
public:
    static const int kMinOccurs = 1;
    static const int kMaxOccurs = -1;
 
    static bool Verifier(const EdgeForwardingSpec *obj, const uint8_t *data,
                         size_t size, ParseContext *context) {
        return BgpAttributeVerifier<EdgeForwardingSpec>::Verifier(
                obj, data, size, context);
    }
 
    typedef CollectionAccessor<EdgeForwardingSpec,
            vector<EdgeForwardingSpec::Edge *>,
            &EdgeForwardingSpec::edge_list> ContextStorer;
 
    typedef mpl::list<BgpPathAttributeForwardingEdgeLen,
            BgpPathAttributeForwardingEdgeInAddress,
            BgpPathAttributeForwardingEdgeInLabel,
            BgpPathAttributeForwardingEdgeOutAddress,
            BgpPathAttributeForwardingEdgeOutLabel> Sequence;
};
 
class BgpPathAttributeEdgeForwarding :
    public ProtoSequence<BgpPathAttributeEdgeForwarding> {
public:
    typedef EdgeForwardingSpec ContextType;
    typedef BgpContextSwap<EdgeForwardingSpec> ContextSwap;
    typedef mpl::list<BgpPathAttrLength,
            BgpPathAttributeForwardingEdgeList> Sequence;
};
 
class BgpPathAttributeReserved : public ProtoElement<BgpPathAttributeReserved> {
public:
    static const int kSize = 1;
    static void Writer(const void *msg, uint8_t *data, size_t size) {
        *data = 0;
    }
};
 
class BgpPathAttributeMpNlriNextHopLength :
    public ProtoElement<BgpPathAttributeMpNlriNextHopLength> {
public:
    static const int kSize = 1;
    static const int kErrorCode = BgpProto::Notification::UpdateMsgErr;
    static const int kErrorSubcode =
            BgpProto::Notification::OptionalAttribError;
    typedef int SequenceLength;
    static bool Verifier(const BgpMpNlri *obj, const uint8_t *data, size_t size,
                         ParseContext *context) {
        uint8_t len = get_value(data, kSize);
        uint16_t afi = obj->afi;
        uint8_t safi = obj->safi;
        if (afi == BgpAf::IPv4 && safi == BgpAf::Unicast) {
            return (len == Address::kMaxV4Bytes);
        } else if (afi == BgpAf::IPv4 && safi == BgpAf::Mpls) {
            return (len == Address::kMaxV4Bytes);
        } else if (afi == BgpAf::IPv4 && safi == BgpAf::Vpn) {
            return (len == RouteDistinguisher::kSize + Address::kMaxV4Bytes);
        } else if (afi == BgpAf::IPv6 && safi == BgpAf::Unicast) {
            return (len == Address::kMaxV6Bytes ||
                len == 2 * Address::kMaxV6Bytes);
        } else if (afi == BgpAf::IPv6 && safi == BgpAf::Vpn) {
            return (len == RouteDistinguisher::kSize + Address::kMaxV6Bytes);
        } else if (afi == BgpAf::L2Vpn && safi == BgpAf::EVpn) {
            return (len == Address::kMaxV4Bytes);
        } else if (afi == BgpAf::IPv4 && safi == BgpAf::RTarget) {
            return (len == Address::kMaxV4Bytes);
        } else if (afi == BgpAf::IPv4 && safi == BgpAf::ErmVpn) {
            return (len == Address::kMaxV4Bytes);
        } else if (afi == BgpAf::IPv4 && safi == BgpAf::MVpn) {
            return (len == Address::kMaxV4Bytes);
        }
        return false;
    }
};
 
 
class BgpPathAttributeMpNlriNexthopAddr :
    public ProtoElement<BgpPathAttributeMpNlriNexthopAddr> {
public:
    static const int kSize = -1;
    typedef VectorAccessor<BgpMpNlri, uint8_t, &BgpMpNlri::nexthop> Setter;
};
 
class BgpPathAttributeMpNlriNextHop :
    public ProtoSequence<BgpPathAttributeMpNlriNextHop> {
public:
    typedef mpl::list<BgpPathAttributeMpNlriNextHopLength,
                      BgpPathAttributeMpNlriNexthopAddr> Sequence;
};
 
class BgpPathAttributeMpNlri : public ProtoSequence<BgpPathAttributeMpNlri> {
public:
    static const int kMinOccurs = 0;
    static const int kMaxOccurs = -1;
 
    struct OptMatch {
        bool match(const BgpMpNlri *obj) {
            return ((obj->afi == BgpAf::IPv4 && obj->safi == BgpAf::Unicast) ||
                (obj->afi == BgpAf::IPv4 && obj->safi == BgpAf::Mpls) ||
                (obj->afi == BgpAf::IPv4 && obj->safi == BgpAf::Vpn) ||
                (obj->afi == BgpAf::IPv6 && obj->safi == BgpAf::Unicast) ||
                (obj->afi == BgpAf::IPv6 && obj->safi == BgpAf::Vpn) ||
                (obj->afi == BgpAf::IPv4 && obj->safi == BgpAf::RTarget));
        }
    };
 
    typedef OptMatch ContextMatch;
    typedef CollectionAccessor<BgpMpNlri, vector<BgpProtoPrefix *>,
            &BgpMpNlri::nlri> ContextStorer;
    typedef mpl::list<BgpPrefixLen, BgpPrefixAddress> Sequence;
};
 
class BgpMvpnNlriType : public ProtoElement<BgpMvpnNlriType> {
public:
    static const int kSize = 1;
    typedef Accessor<BgpProtoPrefix, uint8_t,
            &BgpProtoPrefix::type> Setter;
};
 
class BgpMvpnNlriLen : public ProtoElement<BgpMvpnNlriLen> {
public:
    static const int kSize = 1;
 
    struct MvpnPrefixLen {
        static void set(BgpProtoPrefix *obj, int value) {
            obj->prefixlen = value * 8;
        }
 
        static int get(const BgpProtoPrefix *obj) {
            return obj->prefixlen / 8;
        }
    };
 
 
    typedef int SequenceLength;
 
    typedef MvpnPrefixLen Setter;
};
 
class BgpPathAttributeMpMvpnNlri
    : public ProtoSequence<BgpPathAttributeMpMvpnNlri> {
public:
    static const int kMinOccurs = 0;
    static const int kMaxOccurs = -1;
 
    struct OptMatch {
        bool match(const BgpMpNlri *obj) {
            return ((obj->afi == BgpAf::IPv4) && (obj->safi == BgpAf::MVpn));
        }
    };
 
    typedef OptMatch ContextMatch;
 
    typedef CollectionAccessor<BgpMpNlri, vector<BgpProtoPrefix *>,
            &BgpMpNlri::nlri> ContextStorer;
 
    typedef mpl::list<BgpMvpnNlriType, BgpMvpnNlriLen,
        BgpPrefixAddress> Sequence;
};
 
class BgpErmVpnNlriType : public ProtoElement<BgpErmVpnNlriType> {
public:
    static const int kSize = 1;
    typedef Accessor<BgpProtoPrefix, uint8_t,
            &BgpProtoPrefix::type> Setter;
};
 
class BgpErmVpnNlriLen : public ProtoElement<BgpErmVpnNlriLen> {
public:
    static const int kSize = 1;
 
    struct ErmVpnPrefixLen {
        static void set(BgpProtoPrefix *obj, int value) {
            obj->prefixlen = value * 8;
        }
 
        static int get(const BgpProtoPrefix *obj) {
            return obj->prefixlen / 8;
        }
    };
 
 
    typedef int SequenceLength;
 
    typedef ErmVpnPrefixLen Setter;
};
 
class BgpPathAttributeMpErmVpnNlri
    : public ProtoSequence<BgpPathAttributeMpErmVpnNlri> {
public:
    static const int kMinOccurs = 0;
    static const int kMaxOccurs = -1;
 
    struct OptMatch {
        bool match(const BgpMpNlri *obj) {
            return ((obj->afi == BgpAf::IPv4) && (obj->safi == BgpAf::ErmVpn));
        }
    };
 
    typedef OptMatch ContextMatch;
 
    typedef CollectionAccessor<BgpMpNlri, vector<BgpProtoPrefix *>,
            &BgpMpNlri::nlri> ContextStorer;
 
    typedef mpl::list<BgpErmVpnNlriType, BgpErmVpnNlriLen,
        BgpPrefixAddress> Sequence;
};
 
class BgpEvpnNlriType : public ProtoElement<BgpEvpnNlriType> {
public:
    static const int kSize = 1;
    typedef Accessor<BgpProtoPrefix, uint8_t,
            &BgpProtoPrefix::type> Setter;
};
 
class BgpEvpnNlriLen : public ProtoElement<BgpEvpnNlriLen> {
public:
    static const int kSize = 1;
 
    struct EvpnPrefixLen {
        static void set(BgpProtoPrefix *obj, int value) {
            obj->prefixlen = value * 8;
        }
 
        static int get(const BgpProtoPrefix *obj) {
            return obj->prefixlen / 8;
        }
    };
 
 
    typedef int SequenceLength;
 
    typedef EvpnPrefixLen Setter;
};
 
class BgpPathAttributeMpEvpnNlri :
    public ProtoSequence<BgpPathAttributeMpEvpnNlri> {
public:
    static const int kMinOccurs = 0;
    static const int kMaxOccurs = -1;
 
    struct OptMatch {
        bool match(const BgpMpNlri *obj) {
            return ((obj->afi == BgpAf::L2Vpn) && (obj->safi == BgpAf::EVpn));
        }
    };
 
    typedef OptMatch ContextMatch;
    typedef CollectionAccessor<BgpMpNlri, vector<BgpProtoPrefix *>,
            &BgpMpNlri::nlri> ContextStorer;
    typedef mpl::list<BgpEvpnNlriType, BgpEvpnNlriLen,
        BgpPrefixAddress> Sequence;
};
 
class BgpPathAttributeMpNlriChoice :
    public ProtoChoice<BgpPathAttributeMpNlriChoice> {
public:
    static const int kSize = 0;
    struct MpChoice {
        static void set(BgpMpNlri *obj, int &value) {
            if ((obj->afi == BgpAf::IPv4) && (obj->safi == BgpAf::Unicast)) {
                value = 0;
            }
            if ((obj->afi == BgpAf::IPv4) && (obj->safi == BgpAf::Mpls)) {
                value = 0;
            }
            if ((obj->afi == BgpAf::IPv4) && (obj->safi == BgpAf::Vpn)) {
                value = 0;
            }
            if ((obj->afi == BgpAf::IPv6) && (obj->safi == BgpAf::Unicast)) {
                value = 0;
            }
            if ((obj->afi == BgpAf::IPv6) && (obj->safi == BgpAf::Vpn)) {
                value = 0;
            }
            if ((obj->afi == BgpAf::IPv4) && (obj->safi == BgpAf::RTarget)) {
                value = 0;
            }
            if ((obj->afi == BgpAf::L2Vpn) && (obj->safi == BgpAf::EVpn)) {
                value = 1;
            }
            if ((obj->afi == BgpAf::IPv4) && (obj->safi == BgpAf::ErmVpn)) {
                value = 2;
            }
            if ((obj->afi == BgpAf::IPv4) && (obj->safi == BgpAf::MVpn)) {
                value = 3;
            }
        }
 
        static int get(BgpMpNlri *obj) {
            if ((obj->afi == BgpAf::IPv4) && (obj->safi == BgpAf::Unicast)) {
                return 0;
            }
            if ((obj->afi == BgpAf::IPv4) && (obj->safi == BgpAf::Mpls)) {
                return 0;
            }
            if ((obj->afi == BgpAf::IPv4) && (obj->safi == BgpAf::Vpn)) {
                return 0;
            }
            if ((obj->afi == BgpAf::IPv6) && (obj->safi == BgpAf::Unicast)) {
                return 0;
            }
            if ((obj->afi == BgpAf::IPv6) && (obj->safi == BgpAf::Vpn)) {
                return 0;
            }
            if ((obj->afi == BgpAf::IPv4) && (obj->safi == BgpAf::RTarget)) {
                return 0;
            }
            if ((obj->afi == BgpAf::L2Vpn) && (obj->safi == BgpAf::EVpn)) {
                return 1;
            }
            if ((obj->afi == BgpAf::IPv4) && (obj->safi == BgpAf::ErmVpn)) {
                return 2;
            }
            if ((obj->afi == BgpAf::IPv4) && (obj->safi == BgpAf::MVpn)) {
                return 3;
            }
            return -1;
        }
    };
 
    typedef MpChoice Setter;
    typedef mpl::map<
          mpl::pair<mpl::int_<0>, BgpPathAttributeMpNlri>,
          mpl::pair<mpl::int_<1>, BgpPathAttributeMpEvpnNlri>,
          mpl::pair<mpl::int_<2>, BgpPathAttributeMpErmVpnNlri>,
          mpl::pair<mpl::int_<3>, BgpPathAttributeMpMvpnNlri>
    > Choice;
};
 
class BgpPathAttributeMpReachNlriSequence :
public ProtoSequence<BgpPathAttributeMpReachNlriSequence> {
public:
    struct Offset {
        string operator()() {
            return "MpReachUnreachNlri";
        }
    };
    typedef Offset SaveOffset;
    typedef BgpMpNlri ContextType;
    typedef BgpContextSwap<BgpMpNlri> ContextSwap;
    typedef mpl::list<BgpPathAttrLength,
                  BgpAttributeValue<2, BgpMpNlri, uint16_t, &BgpMpNlri::afi>,
                  BgpAttributeValue<1, BgpMpNlri, uint8_t, &BgpMpNlri::safi>,
                  BgpPathAttributeMpNlriNextHop,
                  BgpPathAttributeReserved,
                  BgpPathAttributeMpNlriChoice> Sequence;
};
 
class BgpPathAttributeMpUnreachNlriSequence :
public ProtoSequence<BgpPathAttributeMpUnreachNlriSequence> {
public:
    struct Offset {
        string operator()() {
            return "MpReachUnreachNlri";
        }
    };
    typedef Offset SaveOffset;
    typedef BgpMpNlri ContextType;
    typedef BgpContextSwap<BgpMpNlri> ContextSwap;
    typedef mpl::list<BgpPathAttrLength,
                  BgpAttributeValue<2, BgpMpNlri, uint16_t, &BgpMpNlri::afi>,
                  BgpAttributeValue<1, BgpMpNlri, uint8_t, &BgpMpNlri::safi>,
                  BgpPathAttributeMpNlriChoice> Sequence;
};
 
class BgpPathAttrUnknownValue : public ProtoElement<BgpPathAttrUnknownValue> {
public:
    static const int kSize = -1;
    static bool Verifier(BgpAttrUnknown *obj, const uint8_t *data, size_t size,
                         ParseContext *context) {
        int pre = (obj->flags & BgpAttribute::ExtendedLength) ? 4 : 3;
        if (!(obj->flags & BgpAttribute::Optional)) {
            context->SetError(BgpProto::Notification::UpdateMsgErr,
                BgpProto::Notification::UnrecognizedWellKnownAttrib,
                "BgpAttrUnknown", data - pre, context->size() + pre);
            return false;
        }
        return true;
    }
    typedef VectorAccessor<BgpAttrUnknown, uint8_t,
        &BgpAttrUnknown::value> Setter;
};
 
class BgpPathAttributeUnknown : public ProtoSequence<BgpPathAttributeUnknown> {
public:
    typedef BgpAttrUnknown ContextType;
    typedef BgpContextSwap<BgpAttrUnknown> ContextSwap;
    typedef mpl::list<BgpPathAttrLength, BgpPathAttrUnknownValue> Sequence;
};
 
class BgpPathAttribute : public ProtoChoice<BgpPathAttribute> {
public:
    static const int kSize = 1;
 
    typedef Accessor<BgpAttribute, uint8_t, &BgpAttribute::code> Setter;
    typedef mpl::map<
          mpl::pair<mpl::int_<BgpAttribute::Origin>,
                    BgpAttrTemplate<BgpAttrOrigin, 1, int,
                                    &BgpAttrOrigin::origin> >,
          mpl::pair<mpl::int_<BgpAttribute::AsPath>, BgpPathAttributeAsPath>,
          mpl::pair<mpl::int_<BgpAttribute::As4Path>, BgpPathAttributeAs4Path>,
          mpl::pair<mpl::int_<BgpAttribute::NextHop>,
                    BgpAttrTemplate<BgpAttrNextHop, 4, uint32_t,
                                    &BgpAttrNextHop::nexthop> >,
          mpl::pair<mpl::int_<BgpAttribute::MultiExitDisc>,
                    BgpAttrTemplate<BgpAttrMultiExitDisc, 4, uint32_t,
                                    &BgpAttrMultiExitDisc::med> >,
          mpl::pair<mpl::int_<BgpAttribute::LocalPref>,
                    BgpAttrTemplate<BgpAttrLocalPref, 4, uint32_t,
                                    &BgpAttrLocalPref::local_pref> >,
          mpl::pair<mpl::int_<BgpAttribute::AtomicAggregate>,
                    BgpPathAttributeAtomicAggregate>,
          mpl::pair<mpl::int_<BgpAttribute::Aggregator>,
                    BgpPathAttributeAggregator>,
          mpl::pair<mpl::int_<BgpAttribute::As4Aggregator>,
                    BgpPathAttributeAs4Aggregator>,
          mpl::pair<mpl::int_<BgpAttribute::Communities>,
                    BgpPathAttributeCommunities>,
          mpl::pair<mpl::int_<BgpAttribute::OriginatorId>,
                    BgpAttrTemplate<BgpAttrOriginatorId, 4, uint32_t,
                                    &BgpAttrOriginatorId::originator_id> >,
          mpl::pair<mpl::int_<BgpAttribute::ClusterList>,
                    BgpPathAttributeClusterList>,
          mpl::pair<mpl::int_<BgpAttribute::MPReachNlri>,
                    BgpPathAttributeMpReachNlriSequence>,
          mpl::pair<mpl::int_<BgpAttribute::MPUnreachNlri>,
                    BgpPathAttributeMpUnreachNlriSequence>,
          mpl::pair<mpl::int_<BgpAttribute::ExtendedCommunities>,
                    BgpPathAttributeExtendedCommunities>,
          mpl::pair<mpl::int_<BgpAttribute::LargeCommunities>,
                    BgpPathAttributeLargeCommunities>,
          mpl::pair<mpl::int_<BgpAttribute::PmsiTunnel>,
                    BgpPathAttributePmsiTunnel>,
          mpl::pair<mpl::int_<BgpAttribute::McastEdgeDiscovery>,
                    BgpPathAttributeEdgeDiscovery>,
          mpl::pair<mpl::int_<BgpAttribute::McastEdgeForwarding>,
                    BgpPathAttributeEdgeForwarding>,
          mpl::pair<mpl::int_<BgpAttribute::OriginVnPath>,
                    BgpPathAttributeOriginVnPath>,
          mpl::pair<mpl::int_<-1>, BgpPathAttributeUnknown>
    > Choice;
};
 
class BgpPathAttributeAs4 : public ProtoChoice<BgpPathAttributeAs4> {
public:
    static const int kSize = 1;
 
    typedef Accessor<BgpAttribute, uint8_t, &BgpAttribute::code> Setter;
    typedef mpl::map<
          mpl::pair<mpl::int_<BgpAttribute::Origin>,
                    BgpAttrTemplate<BgpAttrOrigin, 1, int,
                                    &BgpAttrOrigin::origin> >,
          mpl::pair<mpl::int_<BgpAttribute::AsPath>,
                              BgpPathAttributeAsPath4Byte>,
          mpl::pair<mpl::int_<BgpAttribute::As4Path>, BgpPathAttributeAs4Path>,
          mpl::pair<mpl::int_<BgpAttribute::NextHop>,
                    BgpAttrTemplate<BgpAttrNextHop, 4, uint32_t,
                                    &BgpAttrNextHop::nexthop> >,
          mpl::pair<mpl::int_<BgpAttribute::MultiExitDisc>,
                    BgpAttrTemplate<BgpAttrMultiExitDisc, 4, uint32_t,
                                    &BgpAttrMultiExitDisc::med> >,
          mpl::pair<mpl::int_<BgpAttribute::LocalPref>,
                    BgpAttrTemplate<BgpAttrLocalPref, 4, uint32_t,
                                    &BgpAttrLocalPref::local_pref> >,
          mpl::pair<mpl::int_<BgpAttribute::AtomicAggregate>,
                    BgpPathAttributeAtomicAggregate>,
          mpl::pair<mpl::int_<BgpAttribute::Aggregator>,
                    BgpPathAttributeAggregator4Byte>,
          mpl::pair<mpl::int_<BgpAttribute::As4Aggregator>,
                    BgpPathAttributeAs4Aggregator>,
          mpl::pair<mpl::int_<BgpAttribute::Communities>,
                    BgpPathAttributeCommunities>,
          mpl::pair<mpl::int_<BgpAttribute::OriginatorId>,
                    BgpAttrTemplate<BgpAttrOriginatorId, 4, uint32_t,
                                    &BgpAttrOriginatorId::originator_id> >,
          mpl::pair<mpl::int_<BgpAttribute::ClusterList>,
                    BgpPathAttributeClusterList>,
          mpl::pair<mpl::int_<BgpAttribute::MPReachNlri>,
                    BgpPathAttributeMpReachNlriSequence>,
          mpl::pair<mpl::int_<BgpAttribute::MPUnreachNlri>,
                    BgpPathAttributeMpUnreachNlriSequence>,
          mpl::pair<mpl::int_<BgpAttribute::ExtendedCommunities>,
                    BgpPathAttributeExtendedCommunities>,
          mpl::pair<mpl::int_<BgpAttribute::LargeCommunities>,
                    BgpPathAttributeLargeCommunities>,
          mpl::pair<mpl::int_<BgpAttribute::PmsiTunnel>,
                    BgpPathAttributePmsiTunnel>,
          mpl::pair<mpl::int_<BgpAttribute::McastEdgeDiscovery>,
                    BgpPathAttributeEdgeDiscovery>,
          mpl::pair<mpl::int_<BgpAttribute::McastEdgeForwarding>,
                    BgpPathAttributeEdgeForwarding>,
          mpl::pair<mpl::int_<BgpAttribute::OriginVnPath>,
                    BgpPathAttributeOriginVnPath>,
          mpl::pair<mpl::int_<-1>, BgpPathAttributeUnknown>
    > Choice;
};
 
class BgpPathAttributeList : public ProtoSequence<BgpPathAttributeList> {
public:
    static const int kSize = 2;
    static const int kMinOccurs = 0;
    static const int kMaxOccurs = -1;
    static const int kErrorCode = BgpProto::Notification::UpdateMsgErr;
    static const int kErrorSubcode =
            BgpProto::Notification::MalformedAttributeList;
    struct Offset {
        string operator()() {
            return "BgpPathAttribute";
        }
    };
    typedef Offset SaveOffset;
    typedef CollectionAccessor<BgpProto::Update,
                vector<BgpAttribute *>,
                &BgpProto::Update::path_attributes> ContextStorer;
    typedef mpl::list<BgpPathAttributeFlags, BgpPathAttribute> Sequence;
};
 
class BgpPathAttributeAs4List : public ProtoSequence<BgpPathAttributeAs4List> {
public:
    static const int kSize = 2;
    static const int kMinOccurs = 0;
    static const int kMaxOccurs = -1;
    static const int kErrorCode = BgpProto::Notification::UpdateMsgErr;
    static const int kErrorSubcode =
            BgpProto::Notification::MalformedAttributeList;
    struct Offset {
        string operator()() {
            return "BgpPathAttribute";
        }
    };
    typedef Offset SaveOffset;
    typedef CollectionAccessor<BgpProto::Update,
                vector<BgpAttribute *>,
                &BgpProto::Update::path_attributes> ContextStorer;
    typedef mpl::list<BgpPathAttributeFlags, BgpPathAttributeAs4> Sequence;
};
 
class BgpUpdateNlri : public ProtoSequence<BgpUpdateNlri> {
public:
    static const int kMinOccurs = 0;
    static const int kMaxOccurs = -1;
 
    typedef CollectionAccessor<BgpProto::Update,
            vector<BgpProtoPrefix *>,
            &BgpProto::Update::nlri> ContextStorer;
 
    struct OptMatch {
        bool match(const BgpProto::Update *ctx) {
            return !ctx->nlri.empty();
        }
    };
    typedef OptMatch ContextMatch;
    typedef mpl::list<BgpPrefixLen, BgpPrefixAddress> Sequence;
};
 
class BgpUpdateMessageAs4 : public ProtoSequence<BgpUpdateMessageAs4> {
public:
    typedef mpl::list<BgpUpdateWithdrawnRoutes, BgpPathAttributeAs4List,
                      BgpUpdateNlri> Sequence;
    typedef BgpProto::Update ContextType;
};
 
class BgpUpdateMessage : public ProtoSequence<BgpUpdateMessage> {
public:
    typedef mpl::list<BgpUpdateWithdrawnRoutes, BgpPathAttributeList,
                      BgpUpdateNlri> Sequence;
    typedef BgpProto::Update ContextType;
};
 
class BgpMsgType : public ProtoChoice<BgpMsgType> {
public:
    static const int kSize = 1;
    static const int kErrorCode = BgpProto::Notification::MsgHdrErr;
    static const int kErrorSubcode = BgpProto::Notification::BadMsgType;
    typedef mpl::map<
        mpl::pair<mpl::int_<BgpProto::OPEN>, BgpOpenMessage>,
        mpl::pair<mpl::int_<BgpProto::NOTIFICATION>, BgpNotificationMessage>,
        mpl::pair<mpl::int_<BgpProto::KEEPALIVE>, BgpKeepaliveMessage>,
        mpl::pair<mpl::int_<BgpProto::UPDATE>, BgpUpdateMessage>
    > Choice;
};
 
class BgpMsgTypeAs4 : public ProtoChoice<BgpMsgTypeAs4> {
public:
    static const int kSize = 1;
    static const int kErrorCode = BgpProto::Notification::MsgHdrErr;
    static const int kErrorSubcode = BgpProto::Notification::BadMsgType;
    typedef mpl::map<
        mpl::pair<mpl::int_<BgpProto::OPEN>, BgpOpenMessage>,
        mpl::pair<mpl::int_<BgpProto::NOTIFICATION>, BgpNotificationMessage>,
        mpl::pair<mpl::int_<BgpProto::KEEPALIVE>, BgpKeepaliveMessage>,
        mpl::pair<mpl::int_<BgpProto::UPDATE>, BgpUpdateMessageAs4>
    > Choice;
};
 
class BgpProtocol : public ProtoSequence<BgpProtocol> {
public:
    typedef mpl::list<BgpMarker, BgpMsgLength, BgpMsgType> Sequence;
};
 
class BgpProtocolAs4 : public ProtoSequence<BgpProtocolAs4> {
public:
    typedef mpl::list<BgpMarker, BgpMsgLength, BgpMsgTypeAs4> Sequence;
};
 
BgpProto::BgpMessage *BgpProto::Decode(const uint8_t *data, size_t size,
                                       ParseErrorContext *ec, bool as4) {
    ParseContext context;
    int result;
    if (as4) {
       result  = BgpProtocolAs4::Parse(data, size, &context,
                                       reinterpret_cast<void *>(NULL));
    } else {
       result  = BgpProtocol::Parse(data, size, &context,
                                    reinterpret_cast<void *>(NULL));
    }
    if (result < 0) {
        if (ec) {
            *ec = context.error_context();
        }
        return NULL;
    }
    return static_cast<BgpMessage *>(context.release());
}
 
int BgpProto::Encode(const BgpMessage *msg, uint8_t *data, size_t size,
                     EncodeOffsets *offsets, bool as4) {
    EncodeContext ctx;
    int result;
    if (as4) {
        result = BgpProtocolAs4::Encode(&ctx, msg, data, size);
    } else {
        result = BgpProtocol::Encode(&ctx, msg, data, size);
    }
    if (offsets) {
        *offsets = ctx.encode_offsets();
    }
    return result;
}
 
int BgpProto::Encode(const BgpMpNlri *msg, uint8_t *data, size_t size,
                     EncodeOffsets *offsets) {
    EncodeContext ctx;
    int result = 0;
    if ((msg->afi == BgpAf::L2Vpn) && (msg->safi == BgpAf::EVpn)) {
        result = BgpPathAttributeMpEvpnNlri::Encode(&ctx, msg, data, size);
    } else if ((msg->afi == BgpAf::IPv4) && (msg->safi == BgpAf::ErmVpn)) {
        result = BgpPathAttributeMpErmVpnNlri::Encode(&ctx, msg, data, size);
    } else if ((msg->afi == BgpAf::IPv4) && (msg->safi == BgpAf::MVpn)) {
        result = BgpPathAttributeMpMvpnNlri::Encode(&ctx, msg, data, size);
    } else {
        result = BgpPathAttributeMpNlri::Encode(&ctx, msg, data, size);
    }
    if (offsets) {
        *offsets = ctx.encode_offsets();
    }
    return result;
}