mld6igmp_vif.cc

MLDv2 support igmpv3 lite

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

// Copyright (c) 2001-2008 XORP, Inc.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software")
// to deal in the Software without restriction, subject to the conditions
// listed in the XORP LICENSE file. These conditions include: you must
// preserve this copyright notice, and you cannot mention the copyright
// holders in advertising related to the Software without their permission.
// The Software is provided WITHOUT ANY WARRANTY, EXPRESS OR IMPLIED. This
// notice is a summary of the XORP LICENSE file; the license in that file is
// legally binding.

//
// The Lightweight IGMP/MLD modifications to this file are copyrighted by:
//
// Copyright (c) 2008 Huawei Technologies Co. Ltd
//

#ident "$XORP: xorp/contrib/mld6igmp_lite/mld6igmp_vif.cc,v 1.3 2008/07/23 05:09:49 pavlin Exp $"


//
// MLD6IGMP virtual interfaces implementation.
//


#include "mld6igmp_module.h"
#include "libxorp/xorp.h"
#include "libxorp/xlog.h"
#include "libxorp/debug.h"
#include "libxorp/ipvx.hh"

#include "libproto/checksum.h"

#include "mld6igmp_vif.hh"


//
// Exported variables
//

//
// Local constants definitions
//

//
// Local structures/classes, typedefs and macros
//

//
// Local variables
//

//
// Local functions prototypes
//


/**
 * Mld6igmpVif::Mld6igmpVif:
 * @mld6igmp_node: The MLD6IGMP node this interface belongs to.
 * @vif: The generic Vif interface that contains various information.
 * 
 * MLD6IGMP protocol vif constructor.
 **/
Mld6igmpVif::Mld6igmpVif(Mld6igmpNode& mld6igmp_node, const Vif& vif)
    : ProtoUnit(mld6igmp_node.family(), mld6igmp_node.module_id()),
      Vif(vif),
      _mld6igmp_node(mld6igmp_node),
      _proto_flags(0),
      _primary_addr(IPvX::ZERO(mld6igmp_node.family())),
      _querier_addr(IPvX::ZERO(mld6igmp_node.family())),
      _startup_query_count(0),
      _group_records(*this),
      _ip_router_alert_option_check(false),
      _configured_query_interval(
	  TimeVal(0, 0),
	  callback(this, &Mld6igmpVif::set_configured_query_interval_cb)),
      _effective_query_interval(TimeVal(0, 0)),
      _query_last_member_interval(
	  TimeVal(0, 0),
	  callback(this, &Mld6igmpVif::set_query_last_member_interval_cb)),
      _query_response_interval(
	  TimeVal(0, 0),
	  callback(this, &Mld6igmpVif::set_query_response_interval_cb)),
      _configured_robust_count(
	  0,
	  callback(this, &Mld6igmpVif::set_configured_robust_count_cb)),
      _effective_robustness_variable(0),
      _last_member_query_count(0),
      _group_membership_interval(TimeVal(0, 0)),
      _last_member_query_time(TimeVal(0, 0)),
      _older_version_host_present_interval(TimeVal(0, 0)),
      _dummy_flag(false)
{
    XLOG_ASSERT(proto_is_igmp() || proto_is_mld6());
    
    //
    // TODO: when more things become classes, most of this init should go away
    //
    _buffer_send = BUFFER_MALLOC(BUF_SIZE_DEFAULT);

    //
    // Set the protocol version
    //
    if (proto_is_igmp()) {
	set_proto_version_default(IGMP_VERSION_DEFAULT);
	_configured_query_interval.set(TimeVal(IGMP_QUERY_INTERVAL, 0));
	_query_last_member_interval.set(
	    TimeVal(IGMP_LAST_MEMBER_QUERY_INTERVAL, 0));
	_query_response_interval.set(TimeVal(IGMP_QUERY_RESPONSE_INTERVAL, 0));
	_configured_robust_count.set(IGMP_ROBUSTNESS_VARIABLE);
    }

    if (proto_is_mld6()) {
	set_proto_version_default(MLD_VERSION_DEFAULT);
	_configured_query_interval.set(TimeVal(MLD_QUERY_INTERVAL, 0));
	_query_last_member_interval.set(
	    TimeVal(MLD_LAST_LISTENER_QUERY_INTERVAL, 0));
	_query_response_interval.set(TimeVal(MLD_QUERY_RESPONSE_INTERVAL, 0));
	_configured_robust_count.set(MLD_ROBUSTNESS_VARIABLE);
    }

    set_proto_version(proto_version_default());
}

/**
 * Mld6igmpVif::~Mld6igmpVif:
 * @: 
 * 
 * MLD6IGMP protocol vif destructor.
 * 
 **/
Mld6igmpVif::~Mld6igmpVif()
{
    string error_msg;

    stop(error_msg);
    _group_records.delete_payload_and_clear();
    
    BUFFER_FREE(_buffer_send);
}

/**
 * Mld6igmpVif::set_proto_version:
 * @proto_version: The protocol version to set.
 * 
 * Set protocol version.
 * 
 * Return value: %XORP_OK is @proto_version is valid, otherwise %XORP_ERROR.
 **/
int
Mld6igmpVif::set_proto_version(int proto_version)
{
    if (proto_is_igmp()) {
	if ((proto_version < IGMP_VERSION_MIN)
	    || (proto_version > IGMP_VERSION_MAX)) {
	    return (XORP_ERROR);
	}
	if (proto_version < IGMP_V3) {
	    //
	    // XXX: Restore the variables that might have been adopted from
	    // the Querier.
	    //
	    restore_effective_variables();
	}
    }
    
    if (proto_is_mld6()) {
	if ((proto_version < MLD_VERSION_MIN)
	    || (proto_version > MLD_VERSION_MAX)) {
	    return (XORP_ERROR);
	}
	if (proto_version < IGMP_V3) {
	    //
	    // XXX: Restore the variables that might have been adopted from
	    // the Querier.
	    //
	    restore_effective_variables();
	}
    }
    
    ProtoUnit::set_proto_version(proto_version);
    
    return (XORP_OK);
}

/**
 * Mld6igmpVif::proto_is_ssm:
 * @: 
 * 
 * Test if the interface is running a source-specific multicast capable
 * protocol version (e.g. IGMPv3 or MLDv2).
 * 
 * Return value: @true if the protocol version is source-specific multicast
 * capable, otherwise @fa.se
 **/
bool
Mld6igmpVif::proto_is_ssm() const
{
    if (proto_is_igmp())
	return (proto_version() >= IGMP_V3);
    if (proto_is_mld6())
	return (proto_version() >= MLD_V2);
    
    return (false);
}

/**
 * Mld6igmpVif::start:
 * @error_msg: The error message (if error).
 * 
 * Start MLD or IGMP on a single virtual interface.
 * 
 * Return value: %XORP_OK on success, otherwise %XORP_ERROR.
 **/
int
Mld6igmpVif::start(string& error_msg)
{
    string dummy_error_msg;

    if (! is_enabled())
	return (XORP_OK);

    if (is_up() || is_pending_up())
	return (XORP_OK);

    if (! is_underlying_vif_up()) {
	error_msg = "underlying vif is not UP";
	return (XORP_ERROR);
    }

    //
    // Start the vif only if it is of the appropriate type:
    // multicast-capable (loopback excluded).
    //
    if (! (is_multicast_capable() && (! is_loopback()))) {
	error_msg = "the interface is not multicast capable";
	return (XORP_ERROR);
    }

    if (update_primary_address(error_msg) != XORP_OK)
	return (XORP_ERROR);

    if (ProtoUnit::start() != XORP_OK) {
	error_msg = "internal error";
	return (XORP_ERROR);
    }

    // On startup, assume I am the MLD6IGMP Querier
    set_querier_addr(primary_addr());
    set_i_am_querier(true);
    
    //
    // Register as a receiver with the kernel
    //
    if (mld6igmp_node().register_receiver(name(),
					  name(),
					  mld6igmp_node().ip_protocol_number(),
					  true)
	!= XORP_OK) {
	error_msg = c_format("cannot register as a receiver on vif %s "
			     "with the kernel",
			     name().c_str());
	return (XORP_ERROR);
    }
    
    //
    // Join the appropriate multicast groups: ALL-SYSTEMS, ALL-ROUTERS,
    // and SSM-ROUTERS.
    //
    list<IPvX> groups;
    list<IPvX>::iterator groups_iter;
    groups.push_back(IPvX::MULTICAST_ALL_SYSTEMS(family()));
    groups.push_back(IPvX::MULTICAST_ALL_ROUTERS(family()));
    groups.push_back(IPvX::SSM_ROUTERS(family()));
    for (groups_iter = groups.begin();
	 groups_iter != groups.end();
	 ++groups_iter) {
	const IPvX& group = *groups_iter;
	if (mld6igmp_node().join_multicast_group(name(),
						 name(),
						 mld6igmp_node().ip_protocol_number(),
						 group)
	    != XORP_OK) {
	    error_msg = c_format("cannot join group %s on vif %s",
				 cstring(group), name().c_str());
	    return (XORP_ERROR);
	}
    }
    
    //
    // Query all members on startup
    //
    TimeVal max_resp_time = query_response_interval().get();
    set<IPvX> no_sources;		// XXX: empty set
    mld6igmp_query_send(primary_addr(),
			IPvX::MULTICAST_ALL_SYSTEMS(family()),
			max_resp_time,
			IPvX::ZERO(family()),
			no_sources,
			false,
			dummy_error_msg);
    _startup_query_count = effective_robustness_variable();
    if (_startup_query_count > 0)
	_startup_query_count--;
    TimeVal startup_query_interval = effective_query_interval() / 4;
    _query_timer = mld6igmp_node().eventloop().new_oneoff_after(
	startup_query_interval,
	callback(this, &Mld6igmpVif::query_timer_timeout));

    XLOG_INFO("Interface started: %s%s",
	      this->str().c_str(), flags_string().c_str());
    
    return (XORP_OK);
}

/**
 * Mld6igmpVif::stop:
 * @error_msg: The error message (if error).
 * 
 * Stop MLD or IGMP on a single virtual interface.
 * 
 * Return value: %XORP_OK on success, otherwise %XORP_ERROR.
 **/
int
Mld6igmpVif::stop(string& error_msg)
{
    int ret_value = XORP_OK;

    if (is_down())
	return (XORP_OK);

    if (! (is_up() || is_pending_up() || is_pending_down())) {
	error_msg = "the vif state is not UP or PENDING_UP or PENDING_DOWN";
	return (XORP_ERROR);
    }

    if (ProtoUnit::pending_stop() != XORP_OK) {
	error_msg = "internal error";
	ret_value = XORP_ERROR;
    }
    
    //
    // XXX: we don't have to explicitly leave the multicast groups
    // we have joined on that interface, because this will happen
    // automatically when we stop the vif through the MFEA.
    //

    if (ProtoUnit::stop() != XORP_OK) {
	error_msg = "internal error";
	ret_value = XORP_ERROR;
    }
    
    set_i_am_querier(false);
    set_querier_addr(IPvX::ZERO(family()));		// XXX: ANY
    _other_querier_timer.unschedule();
    _query_timer.unschedule();
    _startup_query_count = 0;
    
    // Notify routing and remove all group records
    Mld6igmpGroupSet::const_iterator group_iter;
    for (group_iter = _group_records.begin();
	 group_iter != _group_records.end(); ++group_iter) {
	const Mld6igmpGroupRecord *group_record = group_iter->second;
	Mld6igmpSourceSet::const_iterator source_iter;
	// Clear the state for all included sources
	for (source_iter = group_record->do_forward_sources().begin();
	     source_iter != group_record->do_forward_sources().end();
	     ++source_iter) {
	    const Mld6igmpSourceRecord *source_record = source_iter->second;
	    join_prune_notify_routing(source_record->source(),
				      group_record->group(),
				      ACTION_PRUNE);
	}
	// Clear the state for all excluded sources
	if (group_record->is_asm_mode()) {
	    join_prune_notify_routing(IPvX::ZERO(family()),
				      group_record->group(), ACTION_PRUNE);
	}
    }
    _group_records.delete_payload_and_clear();
    
    //
    // Unregister as a receiver with the kernel
    //
    if (mld6igmp_node().unregister_receiver(name(),
					    name(),
					    mld6igmp_node().ip_protocol_number())
	!= XORP_OK) {
	XLOG_ERROR("Cannot unregister as a receiver on vif %s with the kernel",
		   name().c_str());
	ret_value = XORP_ERROR;
    }
    
    XLOG_INFO("Interface stopped: %s%s",
	      this->str().c_str(), flags_string().c_str());

    //
    // Inform the node that the vif has completed the shutdown
    //
    mld6igmp_node().vif_shutdown_completed(name());

    return (ret_value);
}

/**
 * Enable MLD/IGMP on a single virtual interface.
 * 
 * If an unit is not enabled, it cannot be start, or pending-start.
 */
void
Mld6igmpVif::enable()
{
    ProtoUnit::enable();

    XLOG_INFO("Interface enabled: %s%s",
	      this->str().c_str(), flags_string().c_str());
}

/**
 * Disable MLD/IGMP on a single virtual interface.
 * 
 * If an unit is disabled, it cannot be start or pending-start.
 * If the unit was runnning, it will be stop first.
 */
void
Mld6igmpVif::disable()
{
    string error_msg;

    stop(error_msg);
    ProtoUnit::disable();

    XLOG_INFO("Interface disabled: %s%s",
	      this->str().c_str(), flags_string().c_str());
}

/**
 * Mld6igmpVif::mld6igmp_send:
 * @src: The message source address.
 * @dst: The message destination address.
 * @message_type: The MLD or IGMP type of the message.
 * @max_resp_code: The "Maximum Response Code" or "Max Resp Code"
 * field in the MLD or IGMP headers respectively (in the particular
 * protocol resolution).
 * @group_address: The "Multicast Address" or "Group Address" field
 * in the MLD or IGMP headers respectively.
 * @buffer: The buffer with the rest of the message.
 * @error_msg: The error message (if error).
 * 
 * Send MLD or IGMP message.
 * 
 * Return value: %XORP_OK on success, otherwise %XORP_ERROR.
 **/
int
Mld6igmpVif::mld6igmp_send(const IPvX& src,
			   const IPvX& dst,
			   uint8_t message_type,
			   uint16_t max_resp_code,
			   const IPvX& group_address,
			   buffer_t *buffer,
			   string& error_msg)
{
    uint16_t cksum;
    int ret_value;
    size_t datalen;
    bool ip_router_alert = true;	// XXX: always use Router Alert option