ospf_config.c

BCAST Implementation for NS2

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

// Copyright (c) 2001-2003 International Computer Science Institute
//
// 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.

// You may also (at your option) redistribute this software and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or any later version.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

#ident "$XORP: xorp/ospfd/xorp/ospf_config.C,v 1.2 2003/05/29 17:58:33 pavlin Exp $"

#if defined(OLD_CONFIG_CODE)

#include <sys/types.h>
#include <sys/socket.h> 
#include <net/if.h> 

#include "ospf_module.h"
#include "ospfinc.h"
#include "system.h"

#include "tcppkt.h"
#include "os-instance.h"
#include "ospf_config.h"
#include "ospfd_xorp.h"

bool get_prefix(const char *prefix, InAddr &net, InMask &mask); 

GlobalConfig::GlobalConfig() {

    _m.lsdb_limit = 0;
    _m.mospf_enabled = false;
    _m.inter_area_mc = true;
    _m.ovfl_int = 300;
    _m.new_flood_rate = 200;
    _m.max_rxmt_window = 8;
    _m.max_dds = 4;
    _m.log_priority = 4;
    _m.host_mode = false;
    _m.refresh_rate = 0;
    _m.PPAdjLimit = 0;
    _m.random_refresh = false;

    _config_changed = 0;
    _config_done = 0;

    _interfaces = 0;
}

int
GlobalConfig::add_area(const IPv4 &area_id) {
    AreaConfig *ac;
    ac = new AreaConfig(area_id);
    _areas[area_id] = ac;
    _config_changed = 1;
    _config_done = 0;
    return 0;
}

AreaConfig *
GlobalConfig::find_area(const IPv4 &area_id) {
    typedef map<IPv4,AreaConfig*>::iterator Iterator;
    Iterator iter = _areas.find(area_id);
    if (iter == _areas.end()) {
	fprintf(stderr, "Attempt to find unknown area: %s\n",
		string(area_id).c_str());
	return NULL;
    }
    return iter->second;
}

int
GlobalConfig::add_route(const IPv4Net &prefix, const IPv4 &nexthop, 
	  int type, int cost) {
    RouteConfig *rc;
    try {
	rc = new RouteConfig(prefix, nexthop, type, cost);
    } catch (ConfigError ce) {
	fprintf(stderr, "new RouteConfig threw ConfigError\n");
	return -1;
    }
    _routes[prefix] = rc;
    _config_changed = 1;
    _config_done = 0;
    return 0;
}

int 
GlobalConfig::add_interface(const IPv4 &area_id, const string &identifier,
			    int cost) {
    AreaConfig *ac = find_area(area_id);
    if (ac == NULL) return -1;
    _config_changed = 1;
    _config_done = 0;
    return ac->add_interface(identifier, ++_interfaces, cost);
}

int 
GlobalConfig::add_aggregate(const IPv4 &area_id, const IPv4Net &prefix) {
    AreaConfig *ac = find_area(area_id);
    if (ac == NULL) return -1;
    _config_changed = 1;
    _config_done = 0;
    return ac->add_aggregate(prefix);
}


int 
GlobalConfig::add_host(const IPv4 &area_id, const IPv4Net &prefix, 
		       int cost) {
    AreaConfig *ac = find_area(area_id);
    if (ac == NULL) return -1;
    _config_changed = 1;
    _config_done = 0;
    return ac->add_host(prefix, cost);
}

int 
GlobalConfig::add_vlink(const IPv4 &area_id, const IPv4 &endpoint) {
    AreaConfig *ac = find_area(area_id);
    if (ac == NULL) return -1;
    _config_changed = 1;
    _config_done = 0;
    return ac->add_vlink(endpoint);
}

int 
GlobalConfig::add_neighbor(const IPv4 &area_id, const string &identifier,
			   const IPv4 &address, int priority) {
    AreaConfig *ac = find_area(area_id);
    if (ac == NULL) return -1;
    _config_changed = 1;
    _config_done = 0;
    return ac->add_neighbor(identifier, address, priority);
}

int 
GlobalConfig::add_key(const IPv4 &area_id, const string &identifier,
		      int keyid, char *key, int keylen) {
    AreaConfig *ac = find_area(area_id);
    if (ac == NULL) return -1;
    _config_changed = 1;
    _config_done = 0;
    return ac->add_key(identifier, keyid, key, keylen);
}

int 
GlobalConfig::set_param(const ConfigParam &param) {
    
    string name = param.paramname();

    debug_msg("set_param %s", name.c_str());

    _config_done = 0;

    if (name == "router_id")
	_router_id = param;
    else if (name == "ospf_ext_lsdb_limit")
	_m.lsdb_limit = param;
    else if (name == "ospf_exit_overflow_interval")
	_m.ovfl_int = param;
    else if (name == "ase_orig_rate")
	_m.new_flood_rate = param;
    else if (name == "lsu_rxmt_window")
	_m.max_rxmt_window = param;
    else if (name == "dd_sessions")
	_m.max_dds = param;
    else if (name == "log_level")
	_m.log_priority = param;
    else if (name == "refresh_rate")
	_m.refresh_rate = param;
    else if (name == "pp_adj_limit")
	_m.PPAdjLimit = param;
    else if (name == "host_mode")
	_m.host_mode = bool(param);
    else if (name == "mospf")
	_m.mospf_enabled = param;
    else if (name == "no_inter_area_mc")
	_m.inter_area_mc = !param;
    else if (name == "done") 
	_config_done = true;
    else {
	fprintf(stderr, "Unknown parameter: %s\n", name.c_str());
	return -1;
    }
    _config_changed = 1;
    return 0;
}

int 
GlobalConfig::set_area_param(const IPv4 &area_id, const ConfigParam &param) {
    AreaConfig *ac = find_area(area_id);
    if (ac == NULL) return -1;
    _config_changed = 1;
    _config_done = 0;
    return ac->set_param(param);
}

int 
GlobalConfig::set_interface_param(const IPv4 &area_id, 
				  const string &identifier, 
				  const ConfigParam &param) {
    AreaConfig *ac = find_area(area_id);
    if (ac == NULL) return -1;
    _config_changed = 1;
    _config_done = 0;
    return ac->set_interface_param(identifier, param);
}

int 
GlobalConfig::set_aggregate_param(const IPv4 &area_id, 
				  const IPv4Net &prefix,
				  const ConfigParam &param) {
    AreaConfig *ac = find_area(area_id);
    if (ac == NULL) return -1;
    _config_changed = 1;
    _config_done = 0;
    return ac->set_aggregate_param(prefix, param);
}

int 
GlobalConfig::set_host_param(const IPv4 &area_id, 
			     const IPv4Net &prefix, 
			     const ConfigParam &param) {
    AreaConfig *ac = find_area(area_id);
    if (ac == NULL) return -1;
    _config_changed = 1;
    _config_done = 0;
    return ac->set_host_param(prefix, param);
}

int 
GlobalConfig::set_vlink_param(const IPv4 &area_id, 
			      const IPv4 &endpoint,	
			      const ConfigParam &param) {
    AreaConfig *ac = find_area(area_id);
    if (ac == NULL) return -1;
    _config_changed = 1;
    _config_done = 0;
    return ac->set_vlink_param(endpoint, param);
}

int 
GlobalConfig::set_neighbor_param(const IPv4 &area_id, 
				 const string &identifier,
				 const IPv4 &address,
				 const ConfigParam &param) {
    AreaConfig *ac = find_area(area_id);
    if (ac == NULL) return -1;
    _config_changed = 1;
    _config_done = 0;
    return ac->set_neighbor_param(identifier, address.addr(), param);
}

int 
GlobalConfig::set_key_param(const IPv4 &area_id, 
			    const string &identifier,
			    int keyid,
			    const ConfigParam &param) {
    AreaConfig *ac = find_area(area_id);
    if (ac == NULL) return -1;
    _config_changed = 1;
    _config_done = 0;
    return ac->set_key_param(identifier, keyid, param);
}

int 
GlobalConfig::set_route_param(const IPv4Net &prefix,
			      const ConfigParam &param) {
    typedef map<IPv4Net,RouteConfig*>::iterator Iterator;
    Iterator iter = _routes.find(prefix);
    if (iter == _routes.end()) {
	fprintf(stderr, "Attempt to find unknown route: %s\n",
		string(prefix).c_str());
	return -1;
    }
    _config_changed = 1;
    _config_done = 0;
    return iter->second->set_param(param);
}

int GlobalConfig::activate() {
    rtid_t new_router_id = ntoh32(_router_id.addr());
    if (!ospf)
	ospf = new OSPF(new_router_id);

    ospf->cfgStart();
    
    ospf->cfgOspf(&_m);

    typedef map<IPv4,AreaConfig*>::iterator AreaIterator;
    AreaIterator a_iter = _areas.begin();
    while (a_iter != _areas.end()) {
	a_iter->second->activate();
	++a_iter;
    }

    typedef map<IPv4Net,RouteConfig*>::iterator RouteIterator;
    RouteIterator r_iter = _routes.begin();
    while (r_iter != _routes.end()) {
	r_iter->second->activate();
	++r_iter;
    }

    ospf->cfgDone();
    return 0;
}

AreaConfig::AreaConfig(const IPv4 &area_id) :
    _area_id(area_id)
{
    _m.area_id = ntoh32(area_id.addr());
    _m.stub = false;
    _m.dflt_cost = 0;
    _m.import_summs = true;
}

int 
AreaConfig::set_param(const ConfigParam &param) {
    string name = param.paramname();
    if (name == "stub")
	_m.stub = param;
    else if (name == "stub_default_cost")
	_m.dflt_cost = param;
    else if (name == "no_summaries")
	_m.import_summs = !bool(param);
    else {
	fprintf(stderr, "Unknown parameter: %s\n", name.c_str());
	return -1;
    }
    return 0;
}

int AreaConfig::add_interface(const string &identifier, 
			      int ifnum, int cost) {
    InterfaceConfig *ic;
    try {
	ic = new InterfaceConfig(identifier, _area_id, ifnum, cost);
    } catch (ConfigError ce) {
	fprintf(stderr, "new InterfaceConfig threw ConfigError\n");
	return -1;
    }
    _interfaces[identifier] = ic;
    return 0;
}

InterfaceConfig *
AreaConfig::find_interface(const string &identifier) {
    typedef map<string,InterfaceConfig*>::iterator Iterator;
    printf("AreaConfig::find_interface\n");
    Iterator iter = _interfaces.find(identifier);
    if (iter == _interfaces.end()) {
	fprintf(stderr, "Attempt to find unknown interface: %s\n",
		identifier.c_str());
	return NULL;
    }
    return iter->second;
}



int
AreaConfig::add_aggregate(const IPv4Net &prefix) {
    AggregateConfig *ac;
    try {
	ac = new AggregateConfig(prefix, _area_id);
    } catch (ConfigError ce) {
	fprintf(stderr, "new AggregateConfig threw ConfigError\n");
	return -1;
    }
    _aggregates[prefix] = ac;
    return 0;
}

int
AreaConfig::add_host(const IPv4Net &prefix, int cost) {
    HostConfig *hc;
    try {
	hc = new HostConfig(prefix, _area_id, cost);
    } catch (ConfigError ce) {
	fprintf(stderr, "new HostConfig threw ConfigError\n");
	return -1;
    }
    _hosts[prefix] = hc;
    return 0;
}

int 
AreaConfig::add_vlink(const IPv4 &endpoint) {
    VlinkConfig *vc;
    vc = new VlinkConfig(endpoint, _area_id);
    _vls[endpoint] = vc;
    return 0;
}

int 
AreaConfig::add_neighbor(const string &identifier,
			 const IPv4 &address, int priority) {
    InterfaceConfig *ic = find_interface(identifier);
    if (ic == NULL) return -1;
    return ic->add_neighbor(address, priority);
}

int 
AreaConfig::add_key(const string &identifier,
		    int keyid, char *key, int keylen) {
    InterfaceConfig *ic = find_interface(identifier);
    if (ic == NULL) return -1;
    return ic->add_key(keyid, key, keylen);
}

int 
AreaConfig::set_interface_param(const string &identifier, 
				const ConfigParam &param) {
    printf("AreaConfig::set_interface_param\n");
    InterfaceConfig *ic = find_interface(identifier);
    if (ic == NULL) return -1;
    return ic->set_param(param);
}

int 
AreaConfig::set_aggregate_param(const IPv4Net &prefix,
				const ConfigParam &param) {
    typedef map<IPv4Net,AggregateConfig*>::iterator Iterator;
    Iterator iter = _aggregates.find(prefix);
    if (iter == _aggregates.end()) {
	fprintf(stderr, "Attempt to find unknown aggregate: %s\n",
		string(prefix).c_str());
	return -1;
    }
    return iter->second->set_param(param);
}

int 
AreaConfig::set_host_param(const IPv4Net &prefix, 
			   const ConfigParam &param) {
    typedef map<IPv4Net,HostConfig*>::iterator Iterator;
    Iterator iter = _hosts.find(prefix);
    if (iter == _hosts.end()) {
	fprintf(stderr, "Attempt to find unknown host: %s\n",
		string(prefix).c_str());
	return -1;
    }
    return iter->second->set_param(param);
}

int 
AreaConfig::set_vlink_param(const IPv4 &endpoint,
			    const ConfigParam &param) {
    typedef map<IPv4,VlinkConfig*>::iterator Iterator;
    Iterator iter = _vls.find(endpoint);
    if (iter == _vls.end()) {
	fprintf(stderr, "Attempt to find unknown vlink: %s\n",
		string(endpoint).c_str());
	return -1;
    }
    return iter->second->set_param(param);
}

int 
AreaConfig::set_neighbor_param(const string &identifier,
			       const IPv4 &address, 
			       const ConfigParam &param) {
    InterfaceConfig *ic = find_interface(identifier);
    if (ic == NULL) return -1;
    return ic->set_neighbor_param(address, param);
}

int 
AreaConfig::set_key_param(const string &identifier, int keyid,
			  const ConfigParam &param) {
    InterfaceConfig *ic = find_interface(identifier);
    if (ic == NULL) return -1;
    return ic->set_key_param(keyid, param);
}

int
AreaConfig::activate() {
    ospf->cfgArea(&_m, ADD_ITEM);

    typedef map<string,InterfaceConfig*>::iterator InterfaceIterator;
    InterfaceIterator i_iter = _interfaces.begin();
    while (i_iter != _interfaces.end()) {
	i_iter->second->activate();
	++i_iter;
    }

    typedef map<IPv4Net,AggregateConfig*>::iterator AggregateIterator;
    AggregateIterator a_iter = _aggregates.begin();
    while (a_iter != _aggregates.end()) {
	a_iter->second->activate();
	++a_iter;
    }

    typedef map<IPv4Net,HostConfig*>::iterator HostIterator;
    HostIterator h_iter = _hosts.begin();
    while (h_iter != _hosts.end()) {
	h_iter->second->activate();
	++h_iter;
    }

    typedef map<IPv4,VlinkConfig*>::iterator VlinkIterator;