test_peer.cc

xorp源码hg

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

// Copyright (c) 2001-2007 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.

#ident "$XORP: xorp/bgp/harness/test_peer.cc,v 1.45 2007/02/16 22:45:26 pavlin Exp $"

// #define DEBUG_LOGGING
// #define DEBUG_PRINT_FUNCTION_NAME

#include "bgp/bgp_module.h"

#include "libxorp/xorp.h"
#include "libxorp/debug.h"
#include "libxorp/xlog.h"
#include "libxorp/status_codes.h"
#include "libxorp/xorpfd.hh"
#include "libxorp/eventloop.hh"

#ifdef HAVE_GETOPT_H
#include <getopt.h>
#endif

#include "libcomm/comm_api.h"

#include "libxipc/xrl_std_router.hh"

#include "xrl/interfaces/datain_xif.hh"

#include "bgp/socket.hh"

#include "bgppp.hh"
#include "test_peer.hh"


static const char SERVER[] = "test_peer";/* This servers name */
static const char SERVER_VERSION[] = "0.1";

#define	ZAP(s)	zap(s, #s)


/*
-------------------- XRL --------------------
*/

XrlTestPeerTarget::XrlTestPeerTarget(XrlRouter *r, TestPeer& test_peer,
				     bool trace)
    : XrlTestPeerTargetBase(r), _test_peer(test_peer), _trace(trace)
{
    debug_msg("\n");
}

XrlCmdError
XrlTestPeerTarget::common_0_1_get_target_name(string& name)
{
    debug_msg("\n");

    name = SERVER;
    return XrlCmdError::OKAY();
}

XrlCmdError
XrlTestPeerTarget::common_0_1_get_version(string& version)
{
    debug_msg("\n");

    version = SERVER_VERSION;
    return XrlCmdError::OKAY();
}

XrlCmdError
XrlTestPeerTarget::common_0_1_get_status(// Output values,
					 uint32_t& status,
					 string& reason)
{
    //XXX placeholder only
    status = PROC_READY;
    reason = "Ready";
    return XrlCmdError::OKAY();
}

XrlCmdError
XrlTestPeerTarget::common_0_1_shutdown()
{
    string error_string;
    if(!_test_peer.terminate(error_string)) {
	return XrlCmdError::COMMAND_FAILED(error_string);
    }

    return XrlCmdError::OKAY();
}


XrlCmdError
XrlTestPeerTarget::test_peer_0_1_register(const string& coordinator,
					  const uint32_t& genid)
{
    debug_msg("\n");

    if(_trace)
	printf("register(%s,%u)\n", coordinator.c_str(),
	       XORP_UINT_CAST(genid));

    _test_peer.register_coordinator(coordinator);
    _test_peer.register_genid(genid);

    return XrlCmdError::OKAY();
}

XrlCmdError
XrlTestPeerTarget::test_peer_0_1_packetisation(const string& protocol)
{
    debug_msg("\n");

    if(_trace)
	printf("packetisation(%s)\n", protocol.c_str());

    if(!_test_peer.packetisation(protocol))
	return XrlCmdError::COMMAND_FAILED(c_format("Unsupported protocol %s",
					     protocol.c_str()));

    return XrlCmdError::OKAY();
}

XrlCmdError
XrlTestPeerTarget::test_peer_0_1_connect(const string&	host,
					 const uint32_t&  port)
{
    debug_msg("\n");

    if(_trace)
	printf("connect(%s,%u)\n", host.c_str(), XORP_UINT_CAST(port));

    string error_string;
    if(!_test_peer.connect(host, port, error_string)) {
	return XrlCmdError::COMMAND_FAILED(error_string);
    }

    return XrlCmdError::OKAY();
}

XrlCmdError
XrlTestPeerTarget::test_peer_0_1_listen(const string& address,
					const uint32_t&	port)
{
    debug_msg("\n");

    if(_trace)
	printf("listen(%s,%u)\n", address.c_str(), XORP_UINT_CAST(port));

    string error_string;
    if(!_test_peer.listen(address, port, error_string)) {
	return XrlCmdError::COMMAND_FAILED(error_string);
    }

    return XrlCmdError::OKAY();
}

XrlCmdError
XrlTestPeerTarget::test_peer_0_1_bind(const string& address,
				      const uint32_t& port)
{
    debug_msg("\n");

    if(_trace)
	printf("bind(%s,%u)\n", address.c_str(), XORP_UINT_CAST(port));

    string error_string;
    if(!_test_peer.bind(address, port, error_string)) {
	return XrlCmdError::COMMAND_FAILED(error_string);
    }

    return XrlCmdError::OKAY();
}

XrlCmdError
XrlTestPeerTarget::test_peer_0_1_send(const vector<uint8_t>& data)
{
    debug_msg("\n");

    if(_trace && MESSAGETYPEOPEN == data[BGPPacket::COMMON_HEADER_LEN - 1]) {
	printf("send() - open\n");
    }

    string error_string;
    if(!_test_peer.send(data, error_string)) {
	return XrlCmdError::COMMAND_FAILED(error_string);
    }

    return XrlCmdError::OKAY();
}

XrlCmdError
XrlTestPeerTarget::test_peer_0_1_disconnect()
{
    debug_msg("\n");

    if(_trace)
	printf("disconnect()\n");

    string error_string;
    if(!_test_peer.disconnect(error_string)) {
	return XrlCmdError::COMMAND_FAILED(error_string);
    }

    return XrlCmdError::OKAY();
}

XrlCmdError
XrlTestPeerTarget::test_peer_0_1_reset()
{
    debug_msg("\n");

    if(_trace)
	printf("reset()\n");

    _test_peer.reset();

    return XrlCmdError::OKAY();
}

XrlCmdError
XrlTestPeerTarget::test_peer_0_1_terminate()
{
    debug_msg("\n");

    if(_trace)
	printf("terminate()\n");

    string error_string;
    if(!_test_peer.terminate(error_string)) {
	return XrlCmdError::COMMAND_FAILED(error_string);
    }

    return XrlCmdError::OKAY();
}

/*
-------------------- IMPLEMENTATION --------------------
*/
TestPeer::TestPeer(EventLoop& eventloop, XrlRouter& xrlrouter,
		   const char *server, bool verbose)
    : _eventloop(eventloop), _xrlrouter(xrlrouter), _server(server),
      _verbose(verbose),
     _done(false),
      _async_writer(0),
      _bgp(false),
      _flying(0),
     _bgp_bytes(0)
{
}

TestPeer::~TestPeer()
{
    delete _async_writer;
}

bool
TestPeer::done()
{
    return _done;
}

void
TestPeer::register_coordinator(const string& name)
{
    debug_msg("Test Peer: coordinator name = \"%s\"\n", name.c_str());

    _coordinator = name;
}

void
TestPeer::register_genid(const uint32_t& genid)
{
    debug_msg("Test Peer: genid = %u\n", XORP_UINT_CAST(genid));

    _genid = genid;
}

bool
TestPeer::packetisation(const string& protocol)
{
    debug_msg("\n");

    /*
    ** We only support "bgp".
    */
    if(protocol != "bgp") {
	return false;
    }

    _bgp = true;
    _bgp_bytes = 0;
    return true;
}

bool
TestPeer::connect(const string& host, const uint32_t& port,
		  string& error_string)
{
    debug_msg("\n");

    if (_listen.is_valid()) {
	error_string = "Peer is currently listening";
	return false;
    }

    if (_bind.is_valid()) {
	error_string = "Peer is currently bound";
	return false;
    }

    if (_s.is_valid()) {
	error_string = "Peer is already connected";
	return false;
    }

    struct sockaddr_storage peer;
    size_t len = sizeof(peer);
    try {
	Socket::init_sockaddr(host, port, peer, len);
    } catch(UnresolvableHost e) {
	error_string = e.why();
	return false;
    }

    XorpFd s = comm_sock_open(peer.ss_family, SOCK_STREAM, 0,
			      COMM_SOCK_NONBLOCKING);
    if (!s.is_valid()) {
	error_string = c_format("comm_sock_open failed: %s\n",
				comm_get_last_error_str());
	return false;
    }

    // XXX
    int in_progress = 0;
    (void)comm_sock_connect(s, reinterpret_cast<struct sockaddr *>(&peer),
			    COMM_SOCK_NONBLOCKING, &in_progress);

   /*
   ** If there is a coordinator then add an I/O event callback.
   */
   if (0 != _coordinator.length() &&
       !_eventloop.add_ioevent_cb(s, IOT_READ,
				callback(this, &TestPeer::receive))) {
	comm_sock_close(s);
	XLOG_WARNING("Failed to add socket %s to eventloop", s.str().c_str());
	return false;
    }

   /*
   ** Set up the async writer.
   */
    if (XORP_ERROR == comm_sock_set_blocking(s, COMM_SOCK_NONBLOCKING)) {
        XLOG_FATAL("Failed to go non-blocking: %s", comm_get_last_error_str());
    }
    delete _async_writer;
    _async_writer = new AsyncFileWriter(_eventloop, s);

    _s = s;

    return true;
}

bool
TestPeer::listen(const string& host, const uint32_t& port,
		 string& error_string)
{
    debug_msg("\n");

    if (_listen.is_valid()) {
	error_string = "Peer is already listening";
	return false;
    }

    if (_bind.is_valid()) {
	error_string = "Peer is currently bound";
	return false;
    }

    if (_s.is_valid()) {
	error_string = "Peer is currently connected";
	return false;
    }

    struct sockaddr_storage local;
    size_t len = sizeof(local);
    try {
	Socket::init_sockaddr(host, port, local, len);
    } catch(UnresolvableHost e) {
	error_string = e.why();
	return false;
    }

    XorpFd s = comm_bind_tcp(reinterpret_cast<struct sockaddr *>(&local),
			     COMM_SOCK_NONBLOCKING);
    if (!s.is_valid()) {
	error_string = c_format("comm_bind_tcp() failed: %s\n",
				comm_get_last_error_str());
	return false;
    }

    if(!_eventloop.add_ioevent_cb(s, IOT_ACCEPT,
				callback(this,
					 &TestPeer::connect_attempt))) {
	comm_sock_close(s);
	error_string = c_format("Failed to add socket %s to eventloop",
				s.str().c_str());
	return false;
    }
    _listen = s;

    return true;
}

bool
TestPeer::bind(const string& host, const uint32_t& port,
	       string& error_string)
{
    debug_msg("\n");

    if (_listen.is_valid()) {
	error_string = "Peer is currently listening";
	return false;
    }

    if (_bind.is_valid()) {
	error_string = "Peer is already bound";
	return false;
    }

    if (_s.is_valid()) {
	error_string = "Peer is currently connected";
	return false;
    }

    struct sockaddr_storage local;
    size_t len = sizeof(local);
    try {
	Socket::init_sockaddr(host, port, local, len);
    } catch(UnresolvableHost e) {
	error_string = e.why();
	return false;
    }

    XorpFd s = comm_sock_open(local.ss_family, SOCK_STREAM, 0,
			      COMM_SOCK_NONBLOCKING);
    if (!s.is_valid()) {
	error_string = c_format("comm_sock_open failed: %s",
				comm_get_last_error_str());
	return false;
    }

    if (XORP_OK != comm_set_reuseaddr(s, 1)) {