mld6igmp_proto.cc

MLDv2 support igmpv3 lite

Mld6igmpVif::mld6igmp_ssm_membership_report_recv(const IPvX& src,
						 const IPvX& dst,
						 uint8_t message_type,
						 buffer_t *buffer)
{
    uint16_t group_records_n = 0;
    string error_msg;
    typedef pair<IPvX, set<IPvX> > gs_record;	// XXX: a handy typedef
    list<gs_record> mode_is_include_groups;
    list<gs_record> mode_is_exclude_groups;
    list<gs_record> change_to_include_mode_groups;
    list<gs_record> change_to_exclude_mode_groups;
    list<gs_record> allow_new_sources_groups;
    list<gs_record> block_old_sources_groups;
    list<gs_record>::iterator gs_iter;

    //
    // Decode the rest of the message header
    //
    BUFFER_GET_SKIP(2, buffer);		// The 'Reserved' field
    BUFFER_GET_HOST_16(group_records_n, buffer);

    //
    // Decode the array of group records
    //
    while (group_records_n != 0) {
	uint8_t record_type;
	uint8_t aux_data_len;
	uint16_t sources_n;
	IPvX group_address(family());
	set<IPvX> source_addresses;
	list<gs_record>* gs_record_ptr = NULL;

	BUFFER_GET_OCTET(record_type, buffer);
	BUFFER_GET_OCTET(aux_data_len, buffer);
	BUFFER_GET_HOST_16(sources_n, buffer);
	BUFFER_GET_IPVX(family(), group_address, buffer);

	// Decode the array of source addresses
	while (sources_n != 0) {
	    IPvX ipvx(family());
	    BUFFER_GET_IPVX(family(), ipvx, buffer);
	    source_addresses.insert(ipvx);
	    sources_n--;
	}

	// XXX: Skip the 'Auxiliary Data', because we don't use it
	BUFFER_GET_SKIP(aux_data_len, buffer);

	//
	// Select the appropriate set, and add the group and the sources to it
	//
	if (proto_is_igmp()) {
	    switch (record_type) {
	    case IGMP_MODE_IS_INCLUDE:
		gs_record_ptr = &mode_is_include_groups;
		break;
	    case IGMP_MODE_IS_EXCLUDE:
		gs_record_ptr = &mode_is_exclude_groups;
		break;
	    case IGMP_CHANGE_TO_INCLUDE_MODE:
		gs_record_ptr = &change_to_include_mode_groups;
		break;
	    case IGMP_CHANGE_TO_EXCLUDE_MODE:
		gs_record_ptr = &change_to_exclude_mode_groups;
		break;
	    case IGMP_ALLOW_NEW_SOURCES:
		gs_record_ptr = &allow_new_sources_groups;
		break;
	    case IGMP_BLOCK_OLD_SOURCES:
		gs_record_ptr = &block_old_sources_groups;
		break;
	    default:
		break;
	    }
	}
	if (proto_is_mld6()) {
	    switch (record_type) {
	    case MLD_MODE_IS_INCLUDE:
		gs_record_ptr = &mode_is_include_groups;
		break;
	    case MLD_MODE_IS_EXCLUDE:
		gs_record_ptr = &mode_is_exclude_groups;
		break;
	    case MLD_CHANGE_TO_INCLUDE_MODE:
		gs_record_ptr = &change_to_include_mode_groups;
		break;
	    case MLD_CHANGE_TO_EXCLUDE_MODE:
		gs_record_ptr = &change_to_exclude_mode_groups;
		break;
	    case MLD_ALLOW_NEW_SOURCES:
		gs_record_ptr = &allow_new_sources_groups;
		break;
	    case MLD_BLOCK_OLD_SOURCES:
		gs_record_ptr = &block_old_sources_groups;
		break;
	    default:
		break;
	    }
	}
	if (gs_record_ptr != NULL) {
	    gs_record_ptr->push_back(make_pair(group_address,
					       source_addresses));
	} else {
	    error_msg = c_format("RX %s from %s to %s on vif %s: "
				 "unrecognized record type %d (ignored)",
				 proto_message_type2ascii(message_type),
				 cstring(src), cstring(dst),
				 name().c_str(),
				 record_type);
	    XLOG_WARNING("%s", error_msg.c_str());
	}

	group_records_n--;
    }

    //
    // Process the records
    //
    for (gs_iter = mode_is_include_groups.begin();
	 gs_iter != mode_is_include_groups.end();
	 ++gs_iter) {
	group_records().process_mode_is_include(gs_iter->first,
						gs_iter->second,
						src);
    }
    for (gs_iter = mode_is_exclude_groups.begin();
	 gs_iter != mode_is_exclude_groups.end();
	 ++gs_iter) {
	group_records().process_mode_is_exclude(gs_iter->first,
						gs_iter->second,
						src);
    }
    for (gs_iter = change_to_include_mode_groups.begin();
	 gs_iter != change_to_include_mode_groups.end();
	 ++gs_iter) {
	group_records().process_change_to_include_mode(gs_iter->first,
						       gs_iter->second,
						       src);
    }
    for (gs_iter = change_to_exclude_mode_groups.begin();
	 gs_iter != change_to_exclude_mode_groups.end();
	 ++gs_iter) {
	group_records().process_change_to_exclude_mode(gs_iter->first,
						       gs_iter->second,
						       src);
    }
    for (gs_iter = allow_new_sources_groups.begin();
	 gs_iter != allow_new_sources_groups.end();
	 ++gs_iter) {
	group_records().process_allow_new_sources(gs_iter->first,
						  gs_iter->second,
						  src);
    }
    for (gs_iter = block_old_sources_groups.begin();
	 gs_iter != block_old_sources_groups.end();
	 ++gs_iter) {
	group_records().process_block_old_sources(gs_iter->first,
						  gs_iter->second,
						  src);
    }

    return (XORP_OK);

 rcvlen_error:
    error_msg = c_format("RX %s from %s to %s on vif %s: "
			 "some fields are too short",
			 proto_message_type2ascii(message_type),
			 cstring(src), cstring(dst),
			 name().c_str());
    XLOG_WARNING("%s", error_msg.c_str());
    return (XORP_ERROR);
}

/**
 * Mld6igmpVif::other_querier_timer_timeout:
 * 
 * Timeout: the previous querier has expired. I will become the querier.
 **/
void
Mld6igmpVif::other_querier_timer_timeout()
{
    string dummy_error_msg;

    if (primary_addr() == IPvX::ZERO(family())) {
	// XXX: the vif address is unknown; this cannot happen if the
	// vif status is UP.
	XLOG_ASSERT(! is_up());
	return;
    }
    
    set_querier_addr(primary_addr());
    set_i_am_querier(true);

    //
    // Now I am the querier. Send a general membership query.
    //
    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()),			// XXX: ANY
			no_sources,
			false,
			dummy_error_msg);
    _startup_query_count = 0;		// XXX: not a startup case
    _query_timer = mld6igmp_node().eventloop().new_oneoff_after(
	effective_query_interval(),
	callback(this, &Mld6igmpVif::query_timer_timeout));
}

/**
 * Mld6igmpVif::query_timer_timeout:
 * 
 * Timeout: time to send a membership query.
 **/
void
Mld6igmpVif::query_timer_timeout()
{
    TimeVal interval;
    string dummy_error_msg;

    if (! i_am_querier())
	return;		// I am not the querier anymore. Ignore.

    //
    // Send a general membership query
    //
    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()),			// XXX: ANY
			no_sources,
			false,
			dummy_error_msg);
    if (_startup_query_count > 0)
	_startup_query_count--;
    if (_startup_query_count > 0) {
	// "Startup Query Interval"
	interval = effective_query_interval() / 4;
    } else {
	interval = effective_query_interval();
    }

    _query_timer = mld6igmp_node().eventloop().new_oneoff_after(
	interval,
	callback(this, &Mld6igmpVif::query_timer_timeout));
}

/**
 * mld6igmp_query_version_consistency_check:
 * @src: The message source address.
 * @dst: The message destination address.
 * @message_type: The type of the MLD/IGMP message.
 * @message_version: The protocol version of the received Query message:
 * (IGMP_V1, IGMP_V2, IGMP_V3 for IGMP) or (MLD_V1, MLD_V2 for MLD).
 * 
 * Check for MLD/IGMP protocol version interface configuration consistency.
 * For example, if the received Query message was IGMPv1, a correctly
 * configured local interface must be operating in IGMPv1 mode.
 * Similarly, if the local interface is operating in IGMPv1 mode,
 * all other neighbor routers (for that interface) must be
 * operating in IGMPv1 as well.
 * 
 * Return value: %XORP_OK if consistency, otherwise %XORP_ERROR.
 **/
int
Mld6igmpVif::mld6igmp_query_version_consistency_check(const IPvX& src,
						      const IPvX& dst,
						      uint8_t message_type,
						      int message_version)
{
    string proto_name, mode_config, mode_received;

    if (message_version == proto_version())
	return (XORP_OK);

    if (proto_is_igmp())
	proto_name = "IGMP";
    if (proto_is_mld6())
	proto_name = "MLD";
    mode_config = c_format("%sv%u", proto_name.c_str(), proto_version());
    mode_received = c_format("%sv%u", proto_name.c_str(), message_version);

    // TODO: rate-limit the warning
    XLOG_WARNING("RX %s from %s to %s on vif %s: "
		 "this interface is in %s mode, but received %s message",
		 proto_message_type2ascii(message_type),
		 cstring(src), cstring(dst),
		 name().c_str(),
		 mode_config.c_str(),
		 mode_received.c_str());
    XLOG_WARNING("Please configure properly all routers on "
		 "that subnet to use same %s version",
		 proto_name.c_str());

    return (XORP_ERROR);
}

void
Mld6igmpVif::set_configured_query_interval_cb(TimeVal v)
{
    set_effective_query_interval(v);
}

void
Mld6igmpVif::set_effective_query_interval(const TimeVal& v)
{
    _effective_query_interval = v;
    recalculate_effective_query_interval();
}

void
Mld6igmpVif::recalculate_effective_query_interval()
{
    recalculate_group_membership_interval();
    recalculate_older_version_host_present_interval();
}

void
Mld6igmpVif::set_query_last_member_interval_cb(TimeVal v)
{
    UNUSED(v);
    recalculate_last_member_query_time();
}

void
Mld6igmpVif::set_query_response_interval_cb(TimeVal v)
{
    UNUSED(v);
    recalculate_group_membership_interval();
    recalculate_older_version_host_present_interval();
}

void
Mld6igmpVif::set_configured_robust_count_cb(uint32_t v)
{
    set_effective_robustness_variable(v);
}

void
Mld6igmpVif::set_effective_robustness_variable(uint32_t v)
{
    _effective_robustness_variable = v;
    recalculate_effective_robustness_variable();
}

void
Mld6igmpVif::recalculate_effective_robustness_variable()
{
    recalculate_group_membership_interval();
    recalculate_last_member_query_count();
    recalculate_older_version_host_present_interval();
}

void
Mld6igmpVif::recalculate_last_member_query_count()
{
    _last_member_query_count = effective_robustness_variable();
    recalculate_last_member_query_time();
}

void
Mld6igmpVif::recalculate_group_membership_interval()
{
    _group_membership_interval =
	effective_query_interval() * effective_robustness_variable()
	+ query_response_interval().get();
}

void
Mld6igmpVif::recalculate_last_member_query_time()
{
    _last_member_query_time = query_last_member_interval().get()
	* last_member_query_count();
}

void
Mld6igmpVif::recalculate_older_version_host_present_interval()
{
    _older_version_host_present_interval =
	effective_query_interval() * effective_robustness_variable()
	+ query_response_interval().get();
}

void
Mld6igmpVif::restore_effective_variables()
{
    // Restore the default Query Interval and Robustness Variable
    set_effective_robustness_variable(configured_robust_count().get());
    set_effective_query_interval(configured_query_interval().get());
}

void
Mld6igmpVif::decode_exp_time_code8(uint8_t code, TimeVal& timeval,
				   uint32_t timer_scale)
{
    uint32_t decoded_time = 0;

    //
    // From RFC 3376 Section 4.1.1, and RFC 3810 Section 5.1.9:
    //
    // If Code < 128, Time = Code
    //
    // If Code >= 128, Code represents a floating-point value as follows:
    //
    //     0 1 2 3 4 5 6 7
    //    +-+-+-+-+-+-+-+-+
    //    |1| exp | mant  |
    //    +-+-+-+-+-+-+-+-+
    //
    // Time = (mant | 0x10) << (exp + 3)
    //
    if (code < 128) {
	decoded_time = code;
    } else {
	uint8_t mant = code & 0xf;
	uint8_t exp = (code >> 4) & 0x7;
	decoded_time = (mant | 0x10) << (exp + 3);
    }

    timeval = TimeVal(decoded_time, 0);
    timeval = timeval / timer_scale;
}

void
Mld6igmpVif::decode_exp_time_code16(uint16_t code, TimeVal& timeval,
				    uint32_t timer_scale)
{
    uint32_t decoded_time = 0;

    //
    // From RFC 3810 Section 5.1.9:
    //
    // If Code < 32768, Time = Code
    //
    // If Code >= 32768, Code represents a floating-point value as follows:
    //
    //     0 1 2 3 4 5 6 7 8 9 A B C D E F
    //    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    //    |1| exp |          mant         |
    //    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    //
    // Time = (mant | 0x1000) << (exp + 3)
    //
    if (code < 32768) {
	decoded_time = code;
    } else {
	uint8_t mant = code & 0xfff;
	uint8_t exp = (code >> 12) & 0x7;
	decoded_time = (mant | 0x1000) << (exp + 3);
    }

    timeval = TimeVal(decoded_time, 0);
    timeval = timeval / timer_scale;
}

void
Mld6igmpVif::encode_exp_time_code8(const TimeVal& timeval,
				   uint8_t& code,
				   uint32_t timer_scale)
{
    TimeVal scaled_max_resp_time = timeval * timer_scale;
    uint32_t decoded_time = scaled_max_resp_time.sec();

    code = 0;

    //
    // From RFC 3376 Section 4.1.1, and RFC 3810 Section 5.1.9:
    //
    // If Code < 128, Time = Code
    //
    // If Code >= 128, Code represents a floating-point value as follows:
    //
    //     0 1 2 3 4 5 6 7
    //    +-+-+-+-+-+-+-+-+
    //    |1| exp | mant  |
    //    +-+-+-+-+-+-+-+-+
    //
    // Time = (mant | 0x10) << (exp + 3)
    //
    if (decoded_time < 128) {
	code = decoded_time;
    } else {
	uint8_t mant = 0;
	uint8_t exp = 0;

	// Calculate the "mant" and the "exp"
	while ((decoded_time >> (exp + 3)) > 0x1f) {
	    exp++;
	}
	mant = (decoded_time >> (exp + 3)) & 0xf;

	code = 0x80 | (exp << 4) | mant;
    }
}

void
Mld6igmpVif::encode_exp_time_code16(const TimeVal& timeval,
				    uint16_t& code,
				    uint32_t timer_scale)
{
    TimeVal scaled_max_resp_time = timeval * timer_scale;
    uint32_t decoded_time = scaled_max_resp_time.sec();

    code = 0;

    //
    // From RFC 3810 Section 5.1.9:
    //
    // If Code < 32768, Time = Code
    //
    // If Code >= 32768, Code represents a floating-point value as follows:
    //
    //     0 1 2 3 4 5 6 7 8 9 A B C D E F
    //    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    //    |1| exp |          mant         |
    //    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    //
    // Time = (mant | 0x1000) << (exp + 3)
    //
    if (decoded_time < 32768) {
	code = decoded_time;
    } else {
	uint8_t mant = 0;
	uint8_t exp = 0;

	// Calculate the "mant" and the "exp"
	while ((decoded_time >> (exp + 3)) > 0x1fff) {
	    exp++;
	}
	mant = (decoded_time >> (exp + 3)) & 0xfff;

	code = 0x8000 | (exp << 12) | mant;
    }
}