xrl_target.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/xrl_target.C,v 1.6 2003/05/29 23:24:52 mjh Exp $"

#include <time.h>
#include <vector>

#include "ospf_module.h"
#include "libxorp/xorp.h"
#include "libxorp/xlog.h"
#include "libxorp/status_codes.h"

#include "ospfinc.h"
#include "tcppkt.h"
#include "system.h"
#include "os-instance.h"
#include "ospfd_xorp.h"
#include "xrl_target.h"

// ----------------------------------------------------------------------------
// Utility methods for handling named enumerations

struct NamedEnumItem {
public:
    NamedEnumItem(const char* n, int32_t v) : _name(n), _value(v) {}
    inline const char* name() const { return _name; }
    inline int32_t value() const { return _value; }
protected:
    const char* 	_name;
    int32_t	 	_value;
};

class NamedEnumBase {
public:
    NamedEnumBase() {}
    virtual ~NamedEnumBase() {}
    const NamedEnumItem* item_by_name(const char* name) const {
	for (uint32_t i = 0; i < _items.size(); i++) {
	    if (strcasecmp(name, _items[i].name()) == 0) {
		return &_items[i];
	    }
	}
	return 0;
    }
    const uint32_t item_count() const { 
	return _items.size();
    }
    const NamedEnumItem* item(uint32_t index) const {
	if (index < _items.size()) {
	    return &_items[index];
	}
	return 0;
    }
    uint32_t index_by_name(const char* name) const {
	const NamedEnumItem* r = item_by_name(name);
	if (0 == r) {
	    return _items.size();
	}
	return r - &_items[0];
    }
    string names() const {
	string s = c_format("\"%s\"", item(0)->name());
	for (uint32_t i = 1; i < item_count(); i++) {
	    s += c_format(", \"%s\"", item(i)->name());
	}
	return s;
    }
    string values() const {
	string s = c_format("\"%d\"", item(0)->value());
	for (uint32_t i = 1; i < item_count(); i++) {
	    s += c_format(", \"%d\"", item(i)->value());
	}
	return s;
    }
protected:
    vector<NamedEnumItem> _items;
};

static struct CryptEnum : public NamedEnumBase {
    CryptEnum() {
	_items.push_back(NamedEnumItem("none", AUT_NONE));
	_items.push_back(NamedEnumItem("cleartext", AUT_PASSWD));
	_items.push_back(NamedEnumItem("md5", AUT_CRYPT));
    }
} crypt_enum;

static struct InterfaceCryptEnum : public NamedEnumBase {
    InterfaceCryptEnum() {
	_items.push_back(NamedEnumItem("none", AUT_NONE));
	_items.push_back(NamedEnumItem("cleartext", AUT_PASSWD));
    }
} if_crypt_enum;

static struct IfTypeEnum : public NamedEnumBase {
    IfTypeEnum() {
	_items.push_back(NamedEnumItem("broadcast", IFT_BROADCAST));
	_items.push_back(NamedEnumItem("pp", IFT_PP));
	_items.push_back(NamedEnumItem("nbma", IFT_NBMA));
	_items.push_back(NamedEnumItem("p2mp", IFT_P2MP));
	_items.push_back(NamedEnumItem("vl", IFT_VL));
	_items.push_back(NamedEnumItem("loopback", IFT_LOOPBK));
    }
} if_type_enum;

static struct MulticastForwardingEnum : public NamedEnumBase {
    MulticastForwardingEnum() {
	_items.push_back(NamedEnumItem("blocked", IF_MCFWD_BLOCKED));
	_items.push_back(NamedEnumItem("multicast", IF_MCFWD_MC));
	_items.push_back(NamedEnumItem("unicast", IF_MCFWD_UNI));
    }
} if_multicast_enum;

// ----------------------------------------------------------------------------
// Common Interface Methods 

XrlCmdError 
XrlOspfTarget::common_0_1_get_target_name(
					  // Output values, 
					  string& name)
{
    name = XrlOspfTargetBase::name();
    return XrlCmdError::OKAY();
}

XrlCmdError
XrlOspfTarget::common_0_1_get_version(
				      // Output values, 
				      string& version)
{
    version = c_format("OSPFD v%d.%d", OSPF::vmajor, OSPF::vminor);
    return XrlCmdError::OKAY();
}

XrlCmdError
XrlOspfTarget::common_0_1_get_status(// Output values, 
				     uint32_t& status,
				     string& reason)
{
    if (ospf()->shutting_down()) {
	status = PROC_SHUTDOWN;
	reason = "Shutting down";
    } else {
	status = PROC_READY;
	reason = "Ready";
    }
    return XrlCmdError::OKAY();
}

XrlCmdError
XrlOspfTarget::common_0_1_shutdown()
{
    //give ospf 30 seconds to shut down
    ospf()->shutdown(30);
    return XrlCmdError::OKAY();
}


// ----------------------------------------------------------------------------
// Macros to help OSPF Global Config Methods

#define FAST_FAIL_ON_NO_OSPF() 						\
   if (ospf_ready() == false)						\
	return XrlCmdError::COMMAND_FAILED("Awaiting router id.");

#define OSPF_GLOBAL_SET_FIELD(field, val)				\
    CfgGen cg; 								\
    ospf()->qryOspf(cg); 				/* Get */	\
    cg.field = val;		 			/* Modify */	\
    ospf()->cfgOspf(&cg); 				/* Set */	\
    CfgGen cg_after;							\
    ospf()->qryOspf(cg_after); 				/* Get again */	\
    if (cg.field != cg_after.field)			/* Verify */	\
	return XrlCmdError::COMMAND_FAILED("Set failed.");	

#define OSPF_GLOBAL_GET_FIELD(var, field) 				\
    CfgGen cg; 								\
    ospf()->qryOspf(cg); 						\
    const CfgGen& ccg = cg;						\
    var = ccg.field;		 					

// ----------------------------------------------------------------------------
// OSPF Global Config Methods

XrlCmdError 
XrlOspfTarget::ospf_0_1_set_router_id(
				      // Output values,
				      const uint32_t& id)
{
    if (ospf() && ospf()->my_id() == id) {
	// Nothing to be done
	string reason = c_format("Router ID already set to %u.", id); 

	return XrlCmdError::COMMAND_FAILED(reason);
    }

    // This is the only place we deal with _pp_ospf.  Everything else
    // in this file uses XrlOspfTarget::opsf() to get a pointer to the
    // OSPF object. (NB ospf() == *_pp_ospf).
    delete *_pp_ospf;
    *_pp_ospf = new OSPF(id, sys_etime);

    // Set defaults
    CfgGen initial_config;
    initial_config.set_defaults();
    ospf()->cfgOspf(&initial_config);

    return XrlCmdError::OKAY(); 
}

XrlCmdError
XrlOspfTarget::ospf_0_1_get_router_id(
				      // Output values, 
				      uint32_t&	id)
{
    FAST_FAIL_ON_NO_OSPF();
    id = ospf()->my_id();
    return XrlCmdError::OKAY();
}

XrlCmdError 
XrlOspfTarget::ospf_0_1_set_lsdb_limit(
				       // Output values, 
				       const int32_t& limit)
{
    FAST_FAIL_ON_NO_OSPF();
    OSPF_GLOBAL_SET_FIELD(lsdb_limit, limit);
    return XrlCmdError::OKAY();
}

XrlCmdError 
XrlOspfTarget::ospf_0_1_get_lsdb_limit(
				       // Output values, 
				       int32_t&	limit)
{
    FAST_FAIL_ON_NO_OSPF();
    OSPF_GLOBAL_GET_FIELD(limit, lsdb_limit);
    return XrlCmdError::OKAY();
}

XrlCmdError 
XrlOspfTarget::ospf_0_1_set_mospf(
				  // Input values, 
				  const bool&	enabled)
{
    FAST_FAIL_ON_NO_OSPF();
    OSPF_GLOBAL_SET_FIELD(mospf_enabled, enabled);
    return XrlCmdError::OKAY();
}

XrlCmdError 
XrlOspfTarget::ospf_0_1_get_mospf(
				  // Input values, 
				  bool& enabled)
{
    FAST_FAIL_ON_NO_OSPF();
    OSPF_GLOBAL_GET_FIELD(enabled, mospf_enabled);
    return XrlCmdError::OKAY();
}

XrlCmdError
XrlOspfTarget::ospf_0_1_set_interarea_mc(
					 // Input values, 
					 const bool&	enabled)
{
    FAST_FAIL_ON_NO_OSPF();
    OSPF_GLOBAL_SET_FIELD(inter_area_mc, enabled);
    return XrlCmdError::OKAY();
}

XrlCmdError
XrlOspfTarget::ospf_0_1_get_interarea_mc(
					 // Output values, 
					 bool&	enabled)
{
    FAST_FAIL_ON_NO_OSPF();
    OSPF_GLOBAL_GET_FIELD(enabled, inter_area_mc);
    return XrlCmdError::OKAY();
}

XrlCmdError
XrlOspfTarget::ospf_0_1_set_overflow_interval(
					      // Input values, 
					      const int32_t&	ovfl_int)
{
    FAST_FAIL_ON_NO_OSPF();
    OSPF_GLOBAL_SET_FIELD(ovfl_int, ovfl_int);
    return XrlCmdError::OKAY();
}

XrlCmdError
XrlOspfTarget::ospf_0_1_get_overflow_interval(
					      // Output values, 
					      int32_t&	ovfl_int)
{
    FAST_FAIL_ON_NO_OSPF();
    OSPF_GLOBAL_GET_FIELD(ovfl_int, ovfl_int);
    return XrlCmdError::OKAY();
}

XrlCmdError
XrlOspfTarget::ospf_0_1_set_flood_rate(
				       // Input values, 
				       const int32_t&	rate)
{
    FAST_FAIL_ON_NO_OSPF();
    OSPF_GLOBAL_SET_FIELD(new_flood_rate, rate);
    return XrlCmdError::OKAY();
}

XrlCmdError
XrlOspfTarget::ospf_0_1_get_flood_rate(
				       // Output values, 
				       int32_t&	rate)
{
    FAST_FAIL_ON_NO_OSPF();
    OSPF_GLOBAL_GET_FIELD(rate, new_flood_rate);
    return XrlCmdError::OKAY();
}

XrlCmdError
XrlOspfTarget::ospf_0_1_set_max_rxmt_window(
					    // Input values, 
					    const uint32_t&	window)
{
    FAST_FAIL_ON_NO_OSPF();
    OSPF_GLOBAL_SET_FIELD(max_rxmt_window, window);
    return XrlCmdError::OKAY();
}

XrlCmdError
XrlOspfTarget::ospf_0_1_get_max_rxmt_window(
					    // Output values, 
					    uint32_t&	window)
{
    FAST_FAIL_ON_NO_OSPF();
    OSPF_GLOBAL_GET_FIELD(window, max_rxmt_window);
    return XrlCmdError::OKAY();
}

XrlCmdError
XrlOspfTarget::ospf_0_1_set_max_dds(
				    // Input values, 
				    const uint32_t&	max_dds)
{
    FAST_FAIL_ON_NO_OSPF();
    OSPF_GLOBAL_SET_FIELD(max_dds, max_dds);
    return XrlCmdError::OKAY();
}

XrlCmdError
XrlOspfTarget::ospf_0_1_get_max_dds(
				    // Output values, 
				    uint32_t&	max_dds)
{
    FAST_FAIL_ON_NO_OSPF();
    OSPF_GLOBAL_GET_FIELD(max_dds, max_dds);
    return XrlCmdError::OKAY();
}

XrlCmdError
XrlOspfTarget::ospf_0_1_set_lsa_refresh_rate(
					     // Input values, 
					     const uint32_t&	rate)
{
    FAST_FAIL_ON_NO_OSPF();
    OSPF_GLOBAL_SET_FIELD(refresh_rate, rate);
    return XrlCmdError::OKAY();
}

XrlCmdError
XrlOspfTarget::ospf_0_1_get_lsa_refresh_rate(
					     // Output values, 
					     uint32_t&	rate)
{
    FAST_FAIL_ON_NO_OSPF();
    OSPF_GLOBAL_GET_FIELD(rate, refresh_rate);
    return XrlCmdError::OKAY();
}

XrlCmdError
XrlOspfTarget::ospf_0_1_set_p2p_adj_limit(
					  // Input values, 
					  const uint32_t&	max_adj)
{
    FAST_FAIL_ON_NO_OSPF();
    OSPF_GLOBAL_SET_FIELD(PPAdjLimit, max_adj);
    return XrlCmdError::OKAY();
}

XrlCmdError
XrlOspfTarget::ospf_0_1_get_p2p_adj_limit(
					  // Output values, 
					  uint32_t&	max_adj)
{
    FAST_FAIL_ON_NO_OSPF();
    OSPF_GLOBAL_GET_FIELD(max_adj, PPAdjLimit);
    return XrlCmdError::OKAY();
}

XrlCmdError
XrlOspfTarget::ospf_0_1_set_random_refresh(
					   // Input values, 
					   const bool&	enabled)
{
    FAST_FAIL_ON_NO_OSPF();
    OSPF_GLOBAL_SET_FIELD(random_refresh, enabled);
    return XrlCmdError::OKAY();
}

XrlCmdError
XrlOspfTarget::ospf_0_1_get_random_refresh(
					   // Output values, 
					   bool&	enabled)
{
    FAST_FAIL_ON_NO_OSPF();
    OSPF_GLOBAL_GET_FIELD(enabled, random_refresh);
    return XrlCmdError::OKAY();
}

// ----------------------------------------------------------------------------
// Area configuration methods

XrlCmdError
XrlOspfTarget::ospf_0_1_add_or_configure_area(
					      // Input values, 
					      const uint32_t&	area_id, 
					      const bool&	is_stub, 
					      const uint32_t&	default_cost, 
					      const bool&	import_summary_routes) 
{
    FAST_FAIL_ON_NO_OSPF();
    CfgArea ca;
    ca.area_id		= area_id;
    ca.stub 		= is_stub;
    ca.dflt_cost 	= default_cost;
    ca.import_summs	= import_summary_routes;
    ospf()->cfgArea(&ca, ADD_ITEM);

    CfgArea sca;
    ospf()->qryArea(sca, area_id);