ospf_config.c

BCAST Implementation for NS2

    VlinkIterator v_iter = _vls.begin();
    while (v_iter != _vls.end()) {
	v_iter->second->activate();
	++v_iter;
    }
    
    return 0;
}

InterfaceConfig::InterfaceConfig(const string &identifier, 
				 const IPv4 &area_id,
				 int ifnum, int cost) 
    throw (ConfigError)
    : _identifier(identifier), _cost(cost)
{
    in_addr addr;
    BSDPhyInt *phyp;
    printf("SendInterface\n");

    if (!sys->parse_interface(identifier.c_str(), addr, phyp))
	throw ConfigError();

    _m.address = phyp->addr;
    _m.phyint = phyp->phyint;
    _m.mask = phyp->mask;
    _m.mtu = phyp->mtu;
    _m.IfIndex = ifnum;
    _m.area_id = ntoh32(area_id.addr());

    if ((phyp->flags & IFF_BROADCAST) != 0)
	_m.IfType = IFT_BROADCAST;
    else if ((phyp->flags & IFF_POINTOPOINT) != 0)
	_m.IfType = IFT_PP;
    else
	_m.IfType = IFT_NBMA;

    _m.dr_pri = 1;
    _m.xmt_dly = 1;
    _m.rxmt_int = 5;
    _m.hello_int = 10;
    _m.dead_int = 40;
    _m.poll_int = 120;
    _m.auth_type = 0;
    memset(_m.auth_key, 0, 8);
    _m.mc_fwd = true;
    _m.demand = false;
    _m.passive = false;
}

int
InterfaceConfig::add_neighbor(const IPv4 &address, int priority) {
    NeighborConfig *nc = new NeighborConfig(address, priority);
    _nbrs[address] = nc;
    return 0;
}

int
InterfaceConfig::add_key(int keyid, char *key, int keylen) {
    KeyConfig *kc;
    try {
	kc = new KeyConfig(_identifier, keyid, key, keylen);
    } catch (ConfigError ce) {
	fprintf(stderr, "new KeyConfig threw ConfigError\n");
	return -1;
    }
    _keys[keyid] = kc;
    return 0;
}

int 
InterfaceConfig::set_param(const ConfigParam &param) {
    string name = param.paramname();
    if (name == "mtu")
	_m.mtu = param;
    else if (name == "if_index")
	_m.IfIndex = param;
    else if (name == "nbma")
	_m.IfType = IFT_NBMA;
    else if (name == "ptmp")
	_m.IfType = IFT_P2MP;
    else if (name == "ospf_if_rtr_priority")
	_m.dr_pri = param;
    else if (name == "ospf_if_transit_delay")
	_m.xmt_dly = param;
    else if (name == "ospf_if_retrans_interval")
	_m.rxmt_int = param;
    else if (name == "ospf_if_hello_interval")
	_m.hello_int = param;
    else if (name == "ospf_if_rtr_dead_interval")
	_m.dead_int = param;
    else if (name == "ospf_if_poll_interval")
	_m.poll_int = param;
    else if (name == "ospf_if_auth_type")
	_m.auth_type = param;
    else if (name == "ospf_if_auth_key") {
	memset(_m.auth_key, 0, 8);
	strncpy((char *)(_m.auth_key), string(param).c_str(), 8);
    } else if (name == "ospf_if_multicast_forwarding")
	_m.mc_fwd = param;
    else if (name == "on-demand")
	_m.demand = param;
    else if (name == "passive")
	_m.passive = param;
    else {
	fprintf(stderr, "Unknown parameter: %s\n", name.c_str());
	return -1;
    }
    return 0;
}

int 
InterfaceConfig::set_neighbor_param(const IPv4 &address, 
				    const ConfigParam &param) {
    typedef map<IPv4,NeighborConfig*>::iterator Iterator;
    Iterator iter = _nbrs.find(address);
    if (iter == _nbrs.end()) {
	fprintf(stderr, "Attempt to find unknown neighbor: %s\n",
		string(address).c_str());
	return -1;
    }
    return iter->second->set_param(param);
}

int 
InterfaceConfig::set_key_param(int keyid, const ConfigParam &param) {
    typedef map<int,KeyConfig*>::iterator Iterator;
    Iterator iter = _keys.find(keyid);
    if (iter == _keys.end()) {
	fprintf(stderr, "Attempt to find unknown keyid: %d\n",
		keyid);
	return -1;
    }
    return iter->second->set_param(param);
}

int
InterfaceConfig::activate() {
    ospf->cfgIfc(&_m, ADD_ITEM);

    typedef map<IPv4,NeighborConfig*>::iterator NeighborIterator;
    NeighborIterator n_iter = _nbrs.begin();
    while (n_iter != _nbrs.end()) {
	n_iter->second->activate();
	++n_iter;
    }

    typedef map<int,KeyConfig*>::iterator KeyIterator;
    KeyIterator k_iter = _keys.begin();
    while (k_iter != _keys.end()) {
	k_iter->second->activate();
	++k_iter;
    }

    return 0;
}


AggregateConfig::AggregateConfig(const IPv4Net &prefix, const IPv4 &area_id) 
    throw (ConfigError)
    : _prefix(prefix)
{
    InAddr net;
    InAddr mask;

    if (get_prefix(string(prefix).c_str(), net, mask)) {
	_m.net = net;
	_m.mask = mask;
	_m.area_id = ntoh32(area_id.addr());
	_m.no_adv = 0;
    } else {
	throw ConfigError();
    }
}

int
AggregateConfig::set_param(const ConfigParam &param) {
    string name = param.paramname();
    if (name == "suppress")
	_m.no_adv = param;
    else {
	fprintf(stderr, "Unknown parameter: %s\n", name.c_str());
	return -1;
    }
    return 0;
}

int
AggregateConfig::activate() {
    ospf->cfgRnge(&_m, ADD_ITEM);
    return 0;
}

HostConfig::HostConfig(const IPv4Net &prefix, const IPv4 &area_id, int cost) 
    throw (ConfigError)
    : _prefix(prefix)
{
    InAddr net;
    InAddr mask;

    if (get_prefix(string(prefix).c_str(), net, mask)) {
	_m.net = net;
	_m.mask = mask;
	_m.area_id = ntoh32(area_id.addr());
	_m.cost = cost;
    } else {
	throw ConfigError();
    }
}

int
HostConfig::set_param(const ConfigParam &param) {
    string name = param.paramname();
    if (name == "cost")
	_m.cost = param;
    else {
	fprintf(stderr, "Unknown parameter: %s\n", name.c_str());
	return -1;
    }
    return 0;
}

int 
HostConfig::activate() {
    ospf->cfgHost(&_m, ADD_ITEM);
    return 0;
}

VlinkConfig::VlinkConfig(const IPv4 &endpoint, const IPv4 &area_id) :
    _endpoint(endpoint)
{
    _m.nbr_id = ntoh32(endpoint.addr());
    _m.transit_area = ntoh32(area_id.addr());
    _m.xmt_dly = 1;
    _m.rxmt_int = 5;
    _m.hello_int = 10;
    _m.dead_int = 40;
    _m.auth_type = 0;
    memset(_m.auth_key, 0, 8);
}

int
VlinkConfig::set_param(const ConfigParam &param) {
    string name = param.paramname();
    if (name == "ospf_virt_if_transit_delay")
	_m.xmt_dly = param;
    else if (name == "ospf_virt_if_retrans_interval")
	_m.rxmt_int = param;
    else if (name == "ospf_virt_if_hello_interval")
	_m.hello_int = param;
    else if (name == "ospf_virt_if_rtr_dead_interval")
	_m.dead_int = param;
    else if (name == "ospf_virt_if_auth_type")
	_m.auth_type = param;
    else if (name == "ospf_virt_if_auth_key") {
	memset(_m.auth_key, 0, 8);
	strncpy((char *)(_m.auth_key), string(param).c_str(), 8);
    } else {
	fprintf(stderr, "Unknown parameter: %s\n", name.c_str());
	return -1;
    }
    return 0;
}

int 
VlinkConfig::activate() {
    ospf->cfgVL(&_m, ADD_ITEM);
    return 0;
}

NeighborConfig::NeighborConfig(const IPv4 &address, int priority) :
    _address(address)
{
    _m.nbr_addr = ntoh32(address.addr());
    _m.dr_eligible = priority;
}

int
NeighborConfig::set_param(const ConfigParam &param) {
    string name = param.paramname();
    if (name == "priority")
	_m.dr_eligible = param;
    else {
	fprintf(stderr, "Unknown parameter: %s\n", name.c_str());
	return -1;
    }
    return 0;
}

int 
NeighborConfig::activate() {
    ospf->cfgNbr(&_m, ADD_ITEM);
    return 0;
}

RouteConfig::RouteConfig(const IPv4Net &prefix, const IPv4 &nexthop, 
			 int type, int cost) 
    throw (ConfigError)
    : _prefix(prefix)
{
    InAddr net;
    InMask mask;

    if (get_prefix(string(prefix).c_str(), net, mask)) {
	_m.net = net;
	_m.mask = mask;
	_m.type2 = (type == 2);
	_m.mc = 0;
	_m.direct = 0;
	_m.noadv = 0;
	_m.cost = cost;
	_m.gw = ntoh32(nexthop.addr());
	_m.phyint = sys->get_phyint(_m.gw);
	_m.tag = 0;
    } else {
	throw ConfigError();
    }
}

int 
RouteConfig::set_param(const ConfigParam &param) {
    string name = param.paramname();
    if (name == "mcsource")
	_m.mc = param;
    else if (name == "tag")
	_m.tag = param;
    else if (name == "nexthop") {
	IPv4 gw = param;
	_m.gw = ntoh32(gw.addr());
	_m.phyint = sys->get_phyint(_m.gw);
    } else if (name == "type")
	_m.type2 = (int(param) == 2);
    else if (name == "cost")
	_m.cost = param;
    else {
	fprintf(stderr, "Unknown parameter: %s\n", name.c_str());
	return -1;
    }
    return 0;
}

int 
RouteConfig::activate() {
    ospf->cfgExRt(&_m, ADD_ITEM);
    return 0;
}


KeyConfig::KeyConfig(const string &identifier, int keyid, 
		     char *key, int keylen) 
    throw (ConfigError)
{
    in_addr addr;
    BSDPhyInt *phyp;

    if ((keyid < 0) || (keyid > 255))
	fprintf(stderr, "Bad Key ID: %d\n", keyid);
    _m.key_id = keyid;
    if ((keylen < 0) || (keyid > 15)) {
	fprintf(stderr, "Bad Key Length: %d\n", keyid);
	return;
    }
    memset(_m.auth_key, 0, 16);
    memcpy(_m.auth_key, key, keylen);

    if (!sys->parse_interface(identifier.c_str(), addr, phyp))
	throw ConfigError();

    _m.address = phyp->addr;
    _m.phyint = phyp->phyint;
    _m.start_accept = 0;
    _m.start_generate = 0;
    _m.stop_generate = 0;
    _m.stop_accept = 0;
}

int 
KeyConfig::set_param(const ConfigParam &param) {
    string name = param.paramname();
    if (name == "startaccept")
	_startacc = param;
    else if (name == "startgenerate")
	_startgen = param;
    else if (name == "stopgenerate")
	_stopgen = param;
    else if (name == "stopaccept")
	_stopacc = param;
    else {
	fprintf(stderr, "Unknown parameter: %s\n", name.c_str());
	return -1;
    }
    return 0;
}

int 
KeyConfig::activate() {
    timeval now;
    tm tmstr;
    gettimeofday(&now, 0);
    if (strptime(_startacc.c_str(), "%D@%T", &tmstr))
	_m.start_accept = mktime(&tmstr) - now.tv_sec;
    if (strptime(_startgen.c_str(), "%D@%T", &tmstr))
	_m.start_generate = mktime(&tmstr) - now.tv_sec;
    if (strptime(_stopgen.c_str(), "%D@%T", &tmstr))
	_m.stop_generate = mktime(&tmstr) - now.tv_sec;
    if (strptime(_stopacc.c_str(), "%D@%T", &tmstr))
	_m.stop_accept = mktime(&tmstr) - now.tv_sec;
    ospf->cfgAuKey(&_m, ADD_ITEM);
    return 0;
}

ConfigParam::ConfigParam(const string &paramname, int value) :
    _paramname(paramname)
{
    _type = inttype;
    _intvalue = value;
}

ConfigParam::ConfigParam(const string &paramname, bool value) :
    _paramname(paramname)
{
    _type = booltype;
    _boolvalue = value;
}

ConfigParam::ConfigParam(const string &paramname, string value) :
    _paramname(paramname)
{
    _type = stringtype;
    _stringvalue = value;
}

ConfigParam::ConfigParam(const string &paramname, IPv4 value) :
    _paramname(paramname)
{
    _type = ipv4type;
    _ipv4value = value;
}

ConfigParam::ConfigParam(const XrlAtom *atom) 
    throw (ConfigError)
{
 
    XrlAtomType type = atom->type();

    _paramname = atom->name();

    if (type == xrlatom_int32) {
	_type = inttype;
	_intvalue = atom->int32();
    } else if (type == xrlatom_uint32) {
	_type = inttype;
	_intvalue = atom->uint32();
    } else if (type == xrlatom_ipv4) {
	_type = ipv4type;
	_ipv4value = atom->ipv4();
    } else if (type == xrlatom_text) {
	_type = stringtype;
	_stringvalue = atom->text();
    } else {
        XLOG_ERROR("Unknown parameter type");
	throw ConfigError();
    }
}

ConfigParam::operator int() const {
    if (_type != inttype)
	fprintf(stderr, "type mismatch\n");
    return _intvalue;
}

ConfigParam::operator uns32() const {
    if (_type != inttype)
	fprintf(stderr, "type mismatch\n");
    return _intvalue;
}

ConfigParam::operator uns16() const {
    if (_type != inttype)
	fprintf(stderr, "type mismatch\n");
    if (_intvalue < 0 || _intvalue > 65535) {
	fprintf(stderr, "type out of range\n");
	return 0;
    }
    return _intvalue;
}

ConfigParam::operator byte() const {
    if (_type != inttype)
	fprintf(stderr, "type mismatch\n");
    if (_intvalue < 0 || _intvalue > 255) {
	fprintf(stderr, "type out of range\n");
	return 0;
    }
    return _intvalue;
}

ConfigParam::operator bool() const {
    if (_type != booltype)
	fprintf(stderr, "type mismatch\n");
    return _boolvalue;
}

ConfigParam::operator string() const {
    if (_type != stringtype)
	fprintf(stderr, "type mismatch\n");
    return _stringvalue;
}

ConfigParam::operator IPv4() const {
    if (_type != ipv4type)
	fprintf(stderr, "type mismatch\n");
    return _ipv4value;
}

#endif /* OLD_CONFIG_CODE */