bcast_xifs.cc

来自「BCAST Implementation for NS2」· CC 代码 · 共 195 行

/*******************************************************************
 Copyright (C) 2004 Thomas Kunz, CRC Canada, BCAST for IPv4.
 DISTRIBUTED WITH NO WARRANTY, EXPRESS OR IMPLIED.
 See the GNU Library General Public License (file COPYING in
 directory application) for conditions of use and redistribution.
*********************************************************************/

// Simple client-side code for invoking all methods on the BCAST target

#include "bcast_module.h"

#include "xrl/interfaces/common_xif.hh"
#include "xrl/interfaces/bcast_xif.hh"

#include "bcast_xifs.hh"

/* ------------------------------------------------------------------------- */

/**
 * Xrl dispatch failure check method.  Exits if e indicates a failure.
 */
static void 
fail_xrl_error(const XrlError& e, const char* file, int line)
{
    if (e != XrlError::OKAY()) {
	cerr << "Error from " << file << " line " << line << endl;
	cerr << "Xrl failed: \n" << e.str().c_str() << endl;
	exit(-1);
    }
}

/**
 * Time out callback
 */
static void
timed_out(const char* task)
{
    cerr << "Timed out on " << task <<endl;
    exit(-1);
}

/* ------------------------------------------------------------------------- */

/**
 * Callback for common xif interface methods returning a string
 */
static void
common_xif_string_cb(const XrlError& e, const string *val,
		     const char* eventname, bool* done_flag)
{
    fail_xrl_error(e, __FILE__, __LINE__);
    cout << eventname << "\t" << val->c_str() << endl;
    *done_flag = true;
}

void
try_common_xif_methods(EventLoop* e, XrlRouter* r, const char* target_name)
{
    XrlCommonV0p1Client client(r);
    bool done_name, done_version;

    // Timer will cause program to exit if it expires
    XorpTimer t = e->new_oneoff_after_ms(3000, callback(&timed_out, 
							"testing common_xif"));

    done_name = false;
    client.send_get_target_name(target_name,
				callback(&common_xif_string_cb, 
					 "Target Name", &done_name));

    done_version = false;
    client.send_get_version(target_name,
			    callback(&common_xif_string_cb, 
				     "Target Version", &done_version));

    while (false == done_name || false == done_version) {
	e->run();
    }
    t.unschedule();
}

/* ------------------------------------------------------------------------- */

void
bcast_set_cb(const XrlError& e, const char* cb_reason, bool* done_flag)
{
    fail_xrl_error(e, __FILE__, __LINE__);
    cout << "Callback for " << cb_reason << endl;
    *done_flag = true;
}

void
bcast_gethello_cb(const XrlError& e, const int32_t* rval, int32_t* lval)
{
    fail_xrl_error(e, __FILE__, __LINE__);
    cout << "Get hello interval count " << *rval << endl;
    assert(*rval >= 0);
    *lval = *rval;
}

void
bcast_getbuffer_cb(const XrlError& e, const int32_t* rval, int32_t* lval)
{
    fail_xrl_error(e, __FILE__, __LINE__);
    cout << "Get buffer size " << *rval << endl;
    assert(*rval >= 0);
    *lval = *rval;
}

void
bcast_getreliability_cb(const XrlError& e, const bool* rval, bool* lval)
{
    fail_xrl_error(e, __FILE__, __LINE__);
    cout << "Get reliability level " << *rval << endl;
    *lval = *rval;
}

void
bcast_getinterface_cb(const XrlError& e, const string* rval, string* lval)
{
    fail_xrl_error(e, __FILE__, __LINE__);
    cout << "Get BCAST interface (" << *rval << ")" << endl;
    *lval = *rval;
}

void
activate_bcast_cb(const XrlError& e, const char* cb_reason, bool *done_flag)
{
    fail_xrl_error(e, __FILE__, __LINE__);
    cout << "Callback for " << cb_reason << endl;
    *done_flag = true;
}

void
try_bcast_xif_methods(EventLoop* e, XrlRouter* r, const char* target_name)
{
    XrlBcastV1p0Client client(r);
    bool done_sethello, done_setbuffer, done_setreliability;
    bool done_setinterface, done_activate, reliability;
    string interface;
    int32_t hello_count, buffer_count;
    const int32_t new_hello = 2;
    const int32_t new_buffer = 22;
    const bool new_reliability = true;
    const string new_interface = "Eth0 or so";

    // Timer will cause program to exit if it expires
    XorpTimer t = e->new_oneoff_after_ms(5000, callback(&timed_out,
							"testing bcast_xif"));

    done_sethello = false;
    client.send_set_hello_interval(target_name, new_hello,
	callback(&bcast_set_cb, "set hello interval", &done_sethello));

    done_setbuffer = false;
    client.send_set_buffer_size(target_name, new_buffer,
	callback(&bcast_set_cb, "set buffer size", &done_setbuffer));

    done_setreliability = false;
    client.send_set_reliability(target_name, new_reliability,
	callback(&bcast_set_cb, "set reliability level", &done_setreliability));

    done_setinterface = false;
    client.send_set_interface(target_name, new_interface,
	callback(&bcast_set_cb, "set interface", &done_setinterface));

    hello_count = -1;
    client.send_get_hello_interval(target_name, 
	callback(&bcast_gethello_cb, &hello_count));

    buffer_count = -1;
    client.send_get_buffer_size(target_name,
	callback(&bcast_getbuffer_cb, &buffer_count));

    reliability = !new_reliability;
    client.send_get_reliability(target_name,
	callback(&bcast_getreliability_cb, &reliability));

    interface = "not quite there";
    client.send_get_interface(target_name,
	callback(&bcast_getinterface_cb, &interface));

    done_activate = false;
    client.send_activate_bcast(target_name, callback(&activate_bcast_cb,
	"activate BCAST", &done_activate));

    while (false == done_sethello || false == done_setbuffer || 
           false == done_setreliability || false == done_setinterface ||
	   false == done_activate || -1 == hello_count || 
           reliability != new_reliability || interface != new_interface ||
	   -1 == buffer_count ) {
	e->run();
    }
}