packet_assembly.hh

// -*- c-basic-offset: 4; tab-width: 8; indent-tabs-mode: t -*-

// Copyright (c) 2001-2009 XORP, Inc.
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License, Version 2, June
// 1991 as published by the Free Software Foundation. Redistribution
// and/or modification of this program under the terms of any other
// version of the GNU General Public License is not permitted.
// 
// This program is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. For more details,
// see the GNU General Public License, Version 2, a copy of which can be
// found in the XORP LICENSE.gpl file.
// 
// XORP Inc, 2953 Bunker Hill Lane, Suite 204, Santa Clara, CA 95054, USA;
// http://xorp.net

// $XORP: xorp/rip/packet_assembly.hh,v 1.16 2008/10/02 21:58:16 bms Exp $

#ifndef __RIP_PACKET_ASSEMBLY_HH__
#define __RIP_PACKET_ASSEMBLY_HH__

#include "rip_module.h"
#include "libxorp/xlog.h"

#include "auth.hh"
#include "packets.hh"
#include "port.hh"

template <typename A>
class PacketAssemblerSpecState
{};

template <>
class PacketAssemblerSpecState<IPv4>
{
private:
    AuthHandlerBase& _ah;
public:
    PacketAssemblerSpecState(Port<IPv4>& port)
    : _ah(*(port.af_state().auth_handler()))
    {}

    PacketAssemblerSpecState(AuthHandlerBase& auth_handler)
    : _ah(auth_handler)
    {}

    AuthHandlerBase&      ah()          { return _ah; }

    const AuthHandlerBase& ah() const       { return _ah; }
};


template <>
class PacketAssemblerSpecState<IPv6>
{
private:
    uint32_t _max_entries;
    IPv6     _lnh;

public:
    PacketAssemblerSpecState(Port<IPv6>& )
    : _max_entries(25), _lnh(IPv6::ALL_ONES())
    {}
    PacketAssemblerSpecState()
    : _max_entries(25), _lnh(IPv6::ALL_ONES())
    {}

    uint32_t    max_entries() const;
    void    reset_last_nexthop();
    void    set_last_nexthop(const IPv6& ip6);
    const IPv6& last_nexthop() const;
};

inline uint32_t
PacketAssemblerSpecState<IPv6>::max_entries() const
{
    return _max_entries;
}

inline void
PacketAssemblerSpecState<IPv6>::reset_last_nexthop()
{
    _lnh = IPv6::ALL_ONES();
}

inline void
PacketAssemblerSpecState<IPv6>::set_last_nexthop(const IPv6& ip6)
{
    _lnh = ip6;
}

inline const IPv6&
PacketAssemblerSpecState<IPv6>::last_nexthop() const
{
    return _lnh;
}


template <typename A>
class ResponsePacketAssembler {
public:
    typedef A               Addr;
    typedef IPNet<A>            Net;
    typedef PacketAssemblerSpecState<A> SpState;

public:
    ResponsePacketAssembler(Port<A>& port);

    ResponsePacketAssembler(SpState& sp);

    ~ResponsePacketAssembler();

    void packet_start(RipPacket<A>* pkt);

    bool packet_add_route(const Net&    net,
              const Addr&   nexthop,
              uint16_t  cost,
              uint16_t  tag);

    bool packet_full() const;

    bool packet_finish(list<RipPacket<A>* >& auth_packets);

private:
    ResponsePacketAssembler(const ResponsePacketAssembler&);

    ResponsePacketAssembler& operator=(const ResponsePacketAssembler&);

protected:
    RipPacket<A>* _pkt;
    uint32_t      _pos;
    SpState   _sp_state;
};


template <typename A>
class RequestTablePacketAssembler {
public:
    typedef A               Addr;
    typedef IPNet<A>            Net;
    typedef PacketAssemblerSpecState<A> SpState;

public:
    RequestTablePacketAssembler(Port<A>& port) : _sp_state(port) {}

    bool prepare(RipPacket<A>*      pkt,
         list<RipPacket<A>* >&  auth_packets);

protected:
    SpState _sp_state;
};


// ----------------------------------------------------------------------------
// ResponsePacketAssembler<IPv4> implementation

template <>
inline
ResponsePacketAssembler<IPv4>::ResponsePacketAssembler(Port<IPv4>& port)
    : _pkt(0), _pos(0), _sp_state(port)
{
}

template <>
inline
ResponsePacketAssembler<IPv4>::ResponsePacketAssembler(SpState& sp)
    : _pkt(0), _pos(0), _sp_state(sp)
{
}

template <>
inline
ResponsePacketAssembler<IPv4>::~ResponsePacketAssembler()
{
}

template <>
inline void
ResponsePacketAssembler<IPv4>::packet_start(RipPacket<IPv4>* pkt)
{
    _pkt = pkt;

    const AuthHandlerBase& ah = _sp_state.ah();
    _pos = ah.head_entries();
    _pkt->set_max_entries(ah.head_entries() + ah.max_routing_entries());

    RipPacketHeaderWriter rph(_pkt->header_ptr());
    rph.initialize(RipPacketHeader::RESPONSE, RipPacketHeader::IPv4_VERSION);
}

template <>
inline bool
ResponsePacketAssembler<IPv4>::packet_full() const
{
    const AuthHandlerBase& ah = _sp_state.ah();
    return _pos == ah.max_routing_entries();
}

template <>
inline bool
ResponsePacketAssembler<IPv4>::packet_add_route(const Net&  net,
                        const Addr& nexthop,
                        uint16_t    cost,
                        uint16_t    tag)
{
    if (packet_full()) {
    return false;
    }
    uint8_t* pre_ptr = _pkt->route_entry_ptr(_pos);
    PacketRouteEntryWriter<IPv4> pre(pre_ptr);
    pre.initialize(tag, net, nexthop, cost);
    _pos++;
    return true;
}

template <>
inline bool
ResponsePacketAssembler<IPv4>::packet_finish(
    list<RipPacket<IPv4>* >&    auth_packets)
{
    AuthHandlerBase& ah = _sp_state.ah();

    _pkt->set_max_entries(_pos);
    size_t n_routes = 0;
    if ((ah.authenticate_outbound(*_pkt, auth_packets, n_routes) != true)
    || (n_routes == 0)) {
    XLOG_ERROR("Outbound authentication error: %s\n", ah.error().c_str());
    return false;
    }
    return true;
}

// ----------------------------------------------------------------------------
// ResponsePacketAssembler<IPv6> implementation

template <>
inline
ResponsePacketAssembler<IPv6>::ResponsePacketAssembler(Port<IPv6>& port)
    : _pkt(0), _pos(0), _sp_state(port)
{
}

template <>
inline
ResponsePacketAssembler<IPv6>::ResponsePacketAssembler(SpState& sp)
    : _pkt(0), _pos(0), _sp_state(sp)
{
}

template <>
inline
ResponsePacketAssembler<IPv6>::~ResponsePacketAssembler()
{
}

template <>
inline void
ResponsePacketAssembler<IPv6>::packet_start(RipPacket<IPv6>* pkt)
{
    _pkt = pkt;
    _pos = 0;
    _sp_state.reset_last_nexthop();
    RipPacketHeaderWriter rph(_pkt->header_ptr());
    rph.initialize(RipPacketHeader::RESPONSE, RipPacketHeader::IPv6_VERSION);
}

template <>
inline bool
ResponsePacketAssembler<IPv6>::packet_full() const
{
    return (_sp_state.max_entries() - _pos) <= 2;
}

template <>
inline bool
ResponsePacketAssembler<IPv6>::packet_add_route(const Net&  net,
                        const Addr& nexthop,
                        uint16_t    cost,
                        uint16_t    tag)
{
    uint8_t* pre_ptr;

    if (packet_full()) {
    return false;
    }
    if (nexthop != _sp_state.last_nexthop()) {
    pre_ptr = _pkt->route_entry_ptr(_pos);
    PacketRouteEntryWriter<IPv6> pre(pre_ptr);
    pre.initialize_nexthop(nexthop);
    _pos++;
    _sp_state.set_last_nexthop(nexthop);
    }
    pre_ptr = _pkt->route_entry_ptr(_pos);
    PacketRouteEntryWriter<IPv6> pre(pre_ptr);
    pre.initialize_route(tag, net, cost);
    _pos++;
    return true;
}

template <>
inline bool
ResponsePacketAssembler<IPv6>::packet_finish(
    list<RipPacket<IPv6>* >&    auth_packets)
{
    _pkt->set_max_entries(_pos);

    RipPacket<IPv6>* packet = new RipPacket<IPv6>(*_pkt);
    auth_packets.push_back(packet);
    
    return true;
}


// ----------------------------------------------------------------------------
// RequestTablePacketAssembler<IPv4> implementation

template<>
inline bool
RequestTablePacketAssembler<IPv4>::prepare(RipPacket<IPv4>*     pkt,
                       list<RipPacket<IPv4>* >& auth_packets)
{
    RipPacketHeaderWriter rph(pkt->header_ptr());
    rph.initialize(RipPacketHeader::REQUEST, RipPacketHeader::IPv4_VERSION);

    AuthHandlerBase& ah = _sp_state.ah();
    pkt->set_max_entries(1 + ah.head_entries());

    uint8_t* pre_ptr = pkt->route_entry_ptr(ah.head_entries());
    PacketRouteEntryWriter<IPv4> pre(pre_ptr);
    pre.initialize_table_request();

    size_t n_routes = 0;
    if ((ah.authenticate_outbound(*pkt, auth_packets, n_routes) != true)
    || (n_routes == 0)) {
    XLOG_ERROR("Outbound authentication error: %s\n", ah.error().c_str());
    return false;
    }
    return true;
}


// ----------------------------------------------------------------------------
// RequestTablePacketAssembler<IPv6> implementation

template<>
inline bool
RequestTablePacketAssembler<IPv6>::prepare(RipPacket<IPv6>*     pkt,
                       list<RipPacket<IPv6>* >& auth_packets)
{
    RipPacketHeaderWriter rph(pkt->header_ptr());
    rph.initialize(RipPacketHeader::REQUEST, RipPacketHeader::IPv6_VERSION);
    pkt->set_max_entries(1);

    uint8_t* pre_ptr = pkt->route_entry_ptr(0);
    PacketRouteEntryWriter<IPv6> pre(pre_ptr);
    pre.initialize_table_request();

    RipPacket<IPv6>* packet = new RipPacket<IPv6>(*pkt);
    auth_packets.push_back(packet);

    return true;
}

#endif // __RIP_PACKET_ASSEMBLY_HH__