xrl_target.c

BCAST Implementation for NS2

XrlCmdError 
XrlOspfTarget::ospf_0_1_interface_set_poll_interval(
	// Input values, 
	const string&	identifier, 
	const uint32_t&	interval_secs)
{
    FAST_FAIL_ON_NO_OSPF();
    FAST_FAIL_ON_UNKNOWN_INTERFACE(identifier, addr, phyp);
    OSPF_INTERFACE_SET_FIELD(phyp, poll_int, interval_secs);
    return XrlCmdError::OKAY();
}

XrlCmdError 
XrlOspfTarget::ospf_0_1_interface_get_poll_interval(
	// Input values, 
	const string&	identifier, 
	// Output values, 
	uint32_t&	interval_secs)
{
    FAST_FAIL_ON_NO_OSPF();
    FAST_FAIL_ON_UNKNOWN_INTERFACE(identifier, addr, phyp);
    OSPF_INTERFACE_GET_FIELD(phyp, interval_secs, poll_int);
    return XrlCmdError::OKAY();
}

XrlCmdError 
XrlOspfTarget::ospf_0_1_interface_set_authentication(
	// Input values, 
	const string&	identifier, 
	const string&	type, 
	const string&	key)
{
    FAST_FAIL_ON_NO_OSPF();
    FAST_FAIL_ON_UNKNOWN_INTERFACE(identifier, addr, phyp);

    const NamedEnumItem* nei = if_crypt_enum.item_by_name(type.c_str());
    if (0 == nei) {
	string oi = "Authentication type should be either ";	
	oi += if_crypt_enum.names();
	return XrlCmdError::COMMAND_FAILED(oi);
    }

    CfgIfc m;  
    if (!ospf()->qryIfc(m, phyp->get_addr(), phyp->get_phyint())) {
	return XrlCmdError::COMMAND_FAILED("Failed to get config");
    }
    m.auth_type = nei->value();
    for (uint32_t i = 0; i < sizeof(m.auth_key); i++) {
	m.auth_key[i] = (i < key.size()) ? key[i] : 0;
    }
    ospf()->cfgIfc(&m, ADD_ITEM);

    return XrlCmdError::OKAY();
}

XrlCmdError 
XrlOspfTarget::ospf_0_1_interface_get_authentication(
	// Input values, 
	const string&	identifier, 
	// Output values, 
	string&	type, 
	string&	key)
{
    FAST_FAIL_ON_NO_OSPF();
    FAST_FAIL_ON_UNKNOWN_INTERFACE(identifier, addr, phyp);

    CfgIfc m;  
    if (!ospf()->qryIfc(m, phyp->get_addr(), phyp->get_phyint())) {
	return XrlCmdError::COMMAND_FAILED("Failed to get config");
    }
    const NamedEnumItem* nei = if_crypt_enum.item(m.auth_type);
    if (0 == nei) {
	string oops = c_format("Internal value \"%d\" is not in known "
			       "enumerated values ", m.auth_type);
	oops += if_crypt_enum.values();
	return XrlCmdError::COMMAND_FAILED(oops);
    }
    type = nei->name();

    char s[sizeof(m.auth_key) + 1];
    memcpy(s, m.auth_key, sizeof(m.auth_key));
    s[sizeof(m.auth_key)] = 0;
    key = s;

    return XrlCmdError::OKAY();
}

XrlCmdError 
XrlOspfTarget::ospf_0_1_interface_set_multicast_forwarding(
	// Input values, 
	const string&	identifier, 
	const string&	type)
{
    FAST_FAIL_ON_NO_OSPF();
    FAST_FAIL_ON_UNKNOWN_INTERFACE(identifier, addr, phyp);

    const NamedEnumItem* nei = if_multicast_enum.item_by_name(type.c_str());
    if (0 == nei) {
	string oi = "Multicast forwarding type should be either ";	
	oi += if_multicast_enum.names();
	return XrlCmdError::COMMAND_FAILED(oi);
    }    

    CfgIfc m;  
    if (!ospf()->qryIfc(m, phyp->get_addr(), phyp->get_phyint())) {
	return XrlCmdError::COMMAND_FAILED("Failed to get config");
    }
    m.mc_fwd = nei->value();
    ospf()->cfgIfc(&m, ADD_ITEM);

    return XrlCmdError::OKAY();
}

XrlCmdError 
XrlOspfTarget::ospf_0_1_interface_get_multicast_forwarding(
	// Input values, 
	const string&	identifier, 
	// Output values, 
	string&		type)
{
    FAST_FAIL_ON_NO_OSPF();
    FAST_FAIL_ON_UNKNOWN_INTERFACE(identifier, addr, phyp);

    CfgIfc m;  
    if (!ospf()->qryIfc(m, phyp->get_addr(), phyp->get_phyint())) {
	return XrlCmdError::COMMAND_FAILED("Failed to get config");
    }
    const NamedEnumItem* nei = if_multicast_enum.item(m.mc_fwd);
    if (0 == nei) {
	string oops = c_format("Internal value \"%d\" is not in known "
			       "enumerated values ", m.mc_fwd);
	oops += if_multicast_enum.values();
	return XrlCmdError::COMMAND_FAILED(oops);
    }
    type = nei->name();
    return XrlCmdError::OKAY();
}

XrlCmdError 
XrlOspfTarget::ospf_0_1_interface_set_on_demand(
	// Input values, 
	const string&	identifier, 
	const bool&	on_demand)
{
    FAST_FAIL_ON_NO_OSPF();
    FAST_FAIL_ON_UNKNOWN_INTERFACE(identifier, addr, phyp);
    OSPF_INTERFACE_SET_FIELD(phyp, demand, on_demand);
    return XrlCmdError::OKAY();
}

XrlCmdError 
XrlOspfTarget::ospf_0_1_interface_get_on_demand(
	// Input values, 
	const string&	identifier, 
	// Output values, 
	bool&	on_demand)
{
    FAST_FAIL_ON_NO_OSPF();
    FAST_FAIL_ON_UNKNOWN_INTERFACE(identifier, addr, phyp);
    OSPF_INTERFACE_GET_FIELD(phyp, on_demand, demand);
    return XrlCmdError::OKAY();
}

XrlCmdError 
XrlOspfTarget::ospf_0_1_interface_set_passive(
	// Input values, 
	const string&	identifier, 
	const bool&	passive)
{
    FAST_FAIL_ON_NO_OSPF();
    FAST_FAIL_ON_UNKNOWN_INTERFACE(identifier, addr, phyp);
    OSPF_INTERFACE_SET_FIELD(phyp, passive, passive);
    return XrlCmdError::OKAY();
}

XrlCmdError 
XrlOspfTarget::ospf_0_1_interface_get_passive(
	// Input values, 
	const string&	identifier, 
	// Output values, 
	bool&	passive)
{
    FAST_FAIL_ON_NO_OSPF();
    FAST_FAIL_ON_UNKNOWN_INTERFACE(identifier, addr, phyp);
    OSPF_INTERFACE_GET_FIELD(phyp, passive, passive);
    return XrlCmdError::OKAY();
}

XrlCmdError 
XrlOspfTarget::ospf_0_1_interface_set_igmp(
	// Input values, 
	const string&	identifier, 
	const bool&	enabled)
{
    FAST_FAIL_ON_NO_OSPF();
    FAST_FAIL_ON_UNKNOWN_INTERFACE(identifier, addr, phyp);
    OSPF_INTERFACE_SET_FIELD(phyp, igmp, enabled);
    return XrlCmdError::OKAY();
}

XrlCmdError 
XrlOspfTarget::ospf_0_1_interface_get_igmp(
	// Input values, 
	const string&	identifier, 
	// Output values, 
	bool&	enabled)
{
    FAST_FAIL_ON_NO_OSPF();
    FAST_FAIL_ON_UNKNOWN_INTERFACE(identifier, addr, phyp);
    OSPF_INTERFACE_GET_FIELD(phyp, enabled, igmp);
    return XrlCmdError::OKAY();
}

XrlCmdError 
XrlOspfTarget::ospf_0_1_delete_interface(
	// Input values, 
	const string&	identifier)
{
    FAST_FAIL_ON_NO_OSPF();
    FAST_FAIL_ON_UNKNOWN_INTERFACE(identifier, addr, phyp);

    CfgIfc m;  
    if (!ospf()->qryIfc(m, phyp->get_addr(), phyp->get_phyint())) {
	return XrlCmdError::COMMAND_FAILED("Failed to get config");
    }
    ospf()->cfgIfc(&m, DELETE_ITEM);

    return XrlCmdError::OKAY();
}

XrlCmdError 
XrlOspfTarget::ospf_0_1_list_interfaces(
	// Output values, 
	XrlAtomList&	identifiers)
{
    FAST_FAIL_ON_NO_OSPF();

    list<CfgIfc> lci;
    ospf()->getIfcs(lci);
    for (list<CfgIfc>::const_iterator i = lci.begin(); i != lci.end(); i++) {
	identifiers.append(XrlAtom(IPv4(i->address)));
    }

    return XrlCmdError::OKAY();
}

// ----------------------------------------------------------------------------
// Interface MD5 Key configuration

static const char OSPF_TIME_DATE_FMT[] = "%Y-%m-%d %H:%M:%S";

static inline bool
parse_start_time(const string& trep, SPFtime& spf)
{
    tm tmstr;
    if (strptime(trep.c_str(), OSPF_TIME_DATE_FMT, &tmstr)) {
	spf = SPFtime(mktime(&tmstr), 0);
	return true;
    } else {
	timeval now;
	gettimeofday(&now, 0);
	spf = SPFtime(now);
	return false;
    }
}

static inline bool
parse_stop_time(const string& trep, SPFtime& spf, bool& time_set_flag)
{
    tm tmstr;
    if (strptime(trep.c_str(), OSPF_TIME_DATE_FMT, &tmstr)) {
	spf = SPFtime(mktime(&tmstr), 0);
	time_set_flag = true;
	return true;
    } else {
	time_set_flag = false;
	return false;
    }
}

string format_spftime(const SPFtime& spf, bool is_specified)
{
    if (is_specified == false) {
	return "Never";
    } else {
	char s[128];
	time_t t = spf.sec;
	struct tm* lt = localtime(&t);
	strftime(s, sizeof(s), OSPF_TIME_DATE_FMT, lt);
	return s;
    }
}

XrlCmdError 
XrlOspfTarget::ospf_0_1_interface_add_md5_key(
	// Input values, 
	const string&	identifier, 
	const uint32_t&	key_id, 
	const string&	md5key, 
	const string&	start_receive, 
	const string&	stop_receive, 
	const string&	start_transmit, 
	const string&	stop_transmit)
{
    FAST_FAIL_ON_NO_OSPF();
    FAST_FAIL_ON_UNKNOWN_INTERFACE(identifier, addr, phyp);

    if (key_id > 255) {
	return XrlCmdError::COMMAND_FAILED("Key id must be between 0 and "
					   "255.");
    }

    CfgAuKey k;
    memset(&k, 0, sizeof(k));
    k.address = phyp->get_addr();
    k.phyint  = phyp->get_phyint();
    k.key_id  = key_id;
    for (size_t i = 0; i < sizeof(k.auth_key); i++)
	k.auth_key[i] = (i < md5key.size()) ? md5key[i] : '0';
    parse_start_time(start_receive, k.start_accept);
    parse_stop_time(stop_receive, k.stop_accept, k.stop_accept_specified);
    parse_start_time(start_transmit, k.start_generate);
    parse_stop_time(stop_transmit, k.stop_generate, k.stop_generate_specified);
    
    ospf()->cfgAuKey(&k, ADD_ITEM);
    return XrlCmdError::OKAY();
}

XrlCmdError 
XrlOspfTarget::ospf_0_1_interface_get_md5_key(
	// Input values, 
	const string&	identifier, 
	const uint32_t&	key_id, 
	// Output values, 
	string&	md5key, 
	string&	start_receive, 
	string&	stop_receive, 
	string&	start_transmit, 
	string&	stop_transmit)
{
    FAST_FAIL_ON_NO_OSPF();
    FAST_FAIL_ON_UNKNOWN_INTERFACE(identifier, addr, phyp);

    if (key_id > 255) {
	return XrlCmdError::COMMAND_FAILED("Key id must be between 0 and "
					   "255.");
    }
    CfgAuKey k;
    if (ospf()->qryAuKey(k, key_id, phyp->get_addr(), 
			 phyp->get_phyint()) == false) {
	return XrlCmdError::COMMAND_FAILED("Unknown key requested.");
    }
    md5key = string((const char*)k.auth_key, sizeof(k.auth_key));
    start_receive = format_spftime(k.start_accept, true);
    stop_receive = format_spftime(k.stop_accept, k.stop_accept_specified);
    start_transmit = format_spftime(k.start_generate, true);
    stop_transmit = format_spftime(k.stop_generate, k.stop_generate_specified);
    return XrlCmdError::OKAY();
}

XrlCmdError 
XrlOspfTarget::ospf_0_1_interface_delete_md5_key(
	// Input values, 
	const string&	identifier, 
	const uint32_t&	key_id)
{
    FAST_FAIL_ON_NO_OSPF();
    FAST_FAIL_ON_UNKNOWN_INTERFACE(identifier, addr, phyp);

    if (key_id > 255) {
	return XrlCmdError::COMMAND_FAILED("Key id must be between 0 and "
					   "255.");
    }
    CfgAuKey k;
    memset(&k, 0, sizeof(k));
    k.address = phyp->get_addr();
    k.phyint  = phyp->get_phyint();
    k.key_id  = key_id;

    ospf()->cfgAuKey(&k, DELETE_ITEM);
    return XrlCmdError::OKAY();
}

XrlCmdError 
XrlOspfTarget::ospf_0_1_interface_list_md5_keys(
	// Input values, 
	const string&	identifier, 
	// Output values, 
	XrlAtomList&	key_ids)
{
    FAST_FAIL_ON_NO_OSPF();
    FAST_FAIL_ON_UNKNOWN_INTERFACE(identifier, addr, phyp);

    list<CfgAuKey> keys;
    ospf()->getAuKeys(keys, phyp->get_addr(), phyp->get_phyint());
    for(list<CfgAuKey>::const_iterator k = keys.begin();
	k != keys.end(); k++) {
	key_ids.append(XrlAtom(k->key_id));
    }

    return XrlCmdError::OKAY();
}

// ----------------------------------------------------------------------------
// Static neighbor related

XrlCmdError 
XrlOspfTarget::ospf_0_1_add_neighbor(
	// Input values, 
	const IPv4&	nbr_addr, 
	const bool&	dr_eligible)
{
    FAST_FAIL_ON_NO_OSPF();
    CfgNbr cn;
    cn.nbr_addr	   = nbr_addr.addr();
    cn.dr_eligible = dr_eligible;
    ospf()->cfgNbr(&cn, ADD_ITEM);
    return XrlCmdError::OKAY();
}

XrlCmdError 
XrlOspfTarget::ospf_0_1_get_neighbor(
	// Input values, 
	const IPv4&	nbr_addr, 
	// Output values, 
	bool&	dr_eligible)
{
    FAST_FAIL_ON_NO_OSPF();
    CfgNbr cn;
    ospf()->qryNbr(cn, nbr_addr.addr());
    dr_eligible = cn.dr_eligible;
    return XrlCmdError::OKAY();
}

XrlCmdError 
XrlOspfTarget::ospf_0_1_delete_neighbor(
	// Input values, 
	const IPv4&	nbr_addr)
{
    FAST_FAIL_ON_NO_OSPF();
    CfgNbr cn;
    cn.nbr_addr	   = nbr_addr.addr();
    ospf()->cfgNbr(&cn, DELETE_ITEM);
    return XrlCmdError::OKAY();
}

XrlCmdError 
XrlOspfTarget::ospf_0_1_list_neighbors(
	// Output values, 
	XrlAtomList&	nbr_addrs)
{
    FAST_FAIL_ON_NO_OSPF();
    list<CfgNbr> lcn;
    ospf()->getNbrs(lcn);
    for(list<CfgNbr>::const_iterator i = lcn.begin(); i != lcn.end(); i++) {
	nbr_addrs.append(XrlAtom(IPv4(i->nbr_addr)));
    }
    return XrlCmdError::OKAY();
}