int
Peer_Factory::info (ACE_TCHAR **strp, size_t length) const
{
ACE_TCHAR buf[BUFSIZ];
ACE_TCHAR consumer_addr_str[BUFSIZ];
ACE_TCHAR supplier_addr_str[BUFSIZ];
ACE_INET_Addr addr;
if (this->consumer_acceptor_.acceptor ().get_local_addr (addr) == -1)
return -1;
else if (addr.addr_to_string (consumer_addr_str,
sizeof addr) == -1)
return -1;
else if (this->supplier_acceptor_.acceptor ().get_local_addr (addr) == -1)
return -1;
else if (addr.addr_to_string (supplier_addr_str,
sizeof addr) == -1)
return -1;
ACE_OS::strcpy (buf, ACE_TEXT ("peerd\t C:"));
ACE_OS::strcat (buf, consumer_addr_str);
ACE_OS::strcat (buf, ACE_TEXT ("|S:"));
ACE_OS::strcat (buf, supplier_addr_str);
ACE_OS::strcat
(buf, ACE_TEXT ("/tcp # Gateway traffic generator and data sink\n"));
if (*strp == 0 && (*strp = ACE_OS::strdup (buf)) == 0)
return -1;
else
ACE_OS::strncpy (*strp, buf, length);
return ACE_OS::strlen (buf);
}
int
Connection_Handler::open (void*)
{
if (this->box_ != 0)
{
ACE_INET_Addr from;
this->peer ().get_remote_addr (from);
const int bufsiz = 128;
char buf[bufsiz];
from.addr_to_string (buf, bufsiz, 0);
static char msg[256];
ACE_OS::sprintf (msg, "connection from <%s>\n", buf);
this->box_->label (msg);
this->box_->redraw ();
}
if (this->w_ != 0)
{
this->w_->incr_sides ();
}
return this->peer ().enable (ACE_NONBLOCK);
}
// Open a RAPI QoS session [dest IP, dest port, Protocol ID].
int
ACE_RAPI_Session::open (ACE_INET_Addr dest_addr,
ACE_Protocol_ID protocol_id)
{
char buf [BUFSIZ];
dest_addr.addr_to_string (buf,
BUFSIZ);
ACELIB_DEBUG ((LM_DEBUG,
"In RAPI SESSION OPEN %s\n",
buf));
this->dest_addr_ = dest_addr;
this->protocol_id_ = protocol_id;
// Open a RAPI session. Note "this" is being passed as an argument to
// the callback function. The callback function uses this argument to
// update the QoS of this session based on the RSVP event it receives.
if ((this->session_id_ = rapi_session((struct sockaddr *) dest_addr.get_addr (),
protocol_id,
0,
rsvp_callback,
(void *) this,
&rsvp_error)) == NULL_SID)
ACELIB_ERROR_RETURN ((LM_ERROR,
"rapi_session () call fails. Error\n"),
-1);
else
ACELIB_DEBUG ((LM_DEBUG,
"rapi_session () call succeeds. "
"Session ID = %d\n",
this->session_id_));
return 0;
}
ssize_t
RtpsUdpSendStrategy::send_single_i(const iovec iov[], int n,
const ACE_INET_Addr& addr)
{
#ifdef ACE_HAS_IPV6
ACE_SOCK_Dgram& sock = link_->socket_for(addr.get_type());
#define USE_SOCKET sock
#else
#define USE_SOCKET link_->unicast_socket()
#endif
#ifdef ACE_LACKS_SENDMSG
char buffer[UDP_MAX_MESSAGE_SIZE];
char *iter = buffer;
for (int i = 0; i < n; ++i) {
if (iter - buffer + iov[i].iov_len > UDP_MAX_MESSAGE_SIZE) {
ACE_ERROR((LM_ERROR, "(%P|%t) RtpsUdpSendStrategy::send_single_i() - "
"message too large at index %d size %d\n", i, iov[i].iov_len));
return -1;
}
std::memcpy(iter, iov[i].iov_base, iov[i].iov_len);
iter += iov[i].iov_len;
}
const ssize_t result = USE_SOCKET.send(buffer, iter - buffer, addr);
#else
const ssize_t result = USE_SOCKET.send(iov, n, addr);
#endif
if (result < 0) {
ACE_TCHAR addr_buff[256] = {};
addr.addr_to_string(addr_buff, 256, 0);
ACE_ERROR((LM_ERROR, "(%P|%t) RtpsUdpSendStrategy::send_single_i() - "
"destination %s failed %p\n", addr_buff, ACE_TEXT("send")));
}
return result;
}
int run_main (int argc, ACE_TCHAR *argv[])
{
ACE_START_TEST (ACE_TEXT ("FlReactor_Test"));
Fl_Window window (300, 370);
Test_Window tw (10, 75, window.w () - 20, window.h ()-90);
window.resizable (&tw);
Fl_Hor_Slider slider (60, 5, window.w () - 70, 30, "Sides:");
slider.align (FL_ALIGN_LEFT);
slider.callback (sides_cb, &tw);
slider.value (tw.sides ());
slider.step (1);
slider.bounds (3, 10);
ACE_FlReactor reactor;
ACE_Reactor r (&reactor);
Fl_Box *box = new Fl_Box (FL_UP_BOX, 10, 40,
window.w () - 20, 30,
"Setting up");
box->labelfont (FL_BOLD);
Acceptor acceptor (&tw, box);
ACE_INET_Addr address;
if (acceptor.open (address, &r) == -1)
ACE_ERROR_RETURN ((LM_ERROR,
"%p\n",
"open acceptor"),
-1);
acceptor.acceptor ().get_local_addr (address);
const int bufsiz = 128;
char buf[bufsiz];
address.addr_to_string (buf, bufsiz, 0);
char msg[2 * bufsiz];
ACE_OS::sprintf (msg, "Listening on <%s>\n", buf);
box->label (msg);
box->redraw ();
window.end ();
window.show (argc, argv);
tw.show ();
return Fl::run ();
ACE_END_TEST;
}
void
PSession::addresses (const ACE_INET_Addr& peer, const ACE_INET_Addr& local)
{
ACE_TCHAR str_peer [256];
ACE_TCHAR str_local[256];
if (0 != peer.addr_to_string (str_peer, sizeof (str_peer)/sizeof (ACE_TCHAR)))
ACE_OS::strcpy (str_peer, ACE_TEXT("????"));
if (0 != local.addr_to_string (str_local, sizeof (str_local)/sizeof (ACE_TCHAR)))
ACE_OS::strcpy (str_peer, ACE_TEXT("????"));
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%t) %s=%d Remote=%s Local=%s\n"),
this->get_name(),
this->index(),
str_peer,
str_local));
return;
}
// Registers the new ClientService instance with the reactor
//
// We try to print a log message stating which host connected, then call ACE_Reactor::register_handler()
// to register for input events with the reactor. We return the return value of register_handler(),
// which is 0 for success and �for failure. This value is passed back to the ClientAcceptor::handle_input() method,
// and handle_input() also will return �for error and 0 for success.
// If ClientAcceptor::handle_input() returns �we will have to close the handle.
//
int ClientService::open()
{
ACE_TCHAR peerName[MAXHOSTNAMELEN];
ACE_INET_Addr peerAddress;
if (this->m_socket.get_remote_addr(peerAddress) == 0 && peerAddress.addr_to_string(peerName, MAXHOSTNAMELEN) == 0)
{
ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) Connection from %s\n"), peerName));
}
return this->reactor()->register_handler(this, ACE_Event_Handler::READ_MASK);
}
int
TAO_AV_TCP_Flow_Handler::open (void * /*arg*/)
{
#if defined (TCP_NODELAY)
int nodelay = 1;
if (this->peer ().set_option (IPPROTO_TCP,
TCP_NODELAY,
(void *) &nodelay,
sizeof (nodelay)) == -1)
ORBSVCS_ERROR_RETURN ((LM_ERROR,
"NODELAY failed\n"),
-1);
#endif /* TCP_NODELAY */
int buf_size = BUFSIZ;
int s = sizeof (buf_size);
if (this->peer ().get_option (SOL_SOCKET, /*IPPROTO_TCP,*/
SO_RCVBUF,
(void *) &buf_size, &s) == -1)
buf_size = BUFSIZ;
((TAO_AV_TCP_Object*)(this->protocol_object_))->frame_.size (buf_size);
// Called by the <Strategy_Acceptor> when the handler is completely
// connected.
ACE_INET_Addr addr;
if (this->peer ().get_remote_addr (addr) == -1)
return -1;
ACE_TCHAR server[MAXHOSTNAMELEN + 16];
(void) addr.addr_to_string (server, sizeof (server));
if (TAO_debug_level > 0)
if (TAO_debug_level > 0) ORBSVCS_DEBUG ((LM_DEBUG,
"(%P|%t) connection to server <%s> on %d\n",
server, this->peer ().get_handle ()));
this->peer ().enable (ACE_NONBLOCK);
// Register the handler with the reactor.
if (this->reactor ()
&& this->reactor ()->register_handler
(this,
ACE_Event_Handler::READ_MASK) == -1)
ORBSVCS_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("unable to register client handler")),
-1);
return 0;
}
string chromatic_handler::client_addr()
{
ACE_INET_Addr addr;
char addrstr[MAXHOSTNAMELEN + 1];
peer().get_remote_addr( addr );
addr.addr_to_string( addrstr , sizeof( addrstr ) );
string strTemp( addrstr );
return ( strTemp );
}
static void addr_to_string (const ACE_INET_Addr &ip_addr,
ACE_TCHAR *ret_string, // results here.
size_t len,
int clip_portnum) // clip port# info?
{
if (ip_addr.addr_to_string (ret_string, len, 1) == -1)
ACE_OS::strcpy (ret_string, ACE_TEXT ("<?>"));
else
{
ACE_TCHAR *pc = ACE_OS::strrchr (ret_string, ACE_TEXT (':'));
if (clip_portnum && pc)
*pc = ACE_TEXT ('\0'); // clip port# info.
}
}
int
TAO_AV_SCTP_SEQ_Acceptor::open_default (TAO_Base_StreamEndPoint *endpoint,
TAO_AV_Core *av_core,
TAO_FlowSpec_Entry *entry,
TAO_AV_Flow_Protocol_Factory *factory,
TAO_AV_Core::Flow_Component flow_comp)
{
this->flow_protocol_factory_ = factory;
this->av_core_ = av_core;
this->endpoint_ = endpoint;
this->entry_ = entry;
if (flow_comp == TAO_AV_Core::TAO_AV_CONTROL)
this->flowname_ = TAO_AV_Core::get_control_flowname (entry->flowname());
else
this->flowname_ = entry->flowname ();
ACE_INET_Addr *address;
ACE_NEW_RETURN (address,
ACE_INET_Addr ("0"),
-1);
int result = this->acceptor_.acceptor_open (this,
av_core->reactor (),
*address,
entry);
if (result < 0)
ORBSVCS_ERROR_RETURN ((LM_ERROR,
"TAO_AV_SCTP_SEQ_Acceptor::open failed"),
-1);
this->acceptor_.acceptor ().get_local_addr (*address);
address->set (address->get_port_number (),
address->get_host_name ());
char buf[BUFSIZ];
address->addr_to_string (buf,BUFSIZ);
if (TAO_debug_level > 0)
ORBSVCS_DEBUG ((LM_DEBUG,
"TAO_AV_SCTP_SEQ_Acceptor::open_default: %s\n",
buf));
entry->set_local_addr (address);
return 0;
}
static bool test_multiple (void)
{
bool success = true;
// Check the behavior when there are multiple addresses assigned to a name.
// The NTP pool should always return multiples, though always different.
ACE_INET_Addr ntp;
if (ntp.set (123, ACE_TEXT ("pool.ntp.org")) == -1)
{
// This is just a warning to prevent fails on lookups on hosts with no
// DNS service. The real value of this test is to accurately get
// multiples from the result.
ACE_ERROR ((LM_WARNING, ACE_TEXT ("%p\n"), ACE_TEXT ("pool.ntp.org")));
return true;
}
size_t count = 0;
ACE_TCHAR addr_string[256];
do
{
++count; // If lookup succeeded, there's at least one
ntp.addr_to_string (addr_string, sizeof (addr_string));
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("IPv4 %B: %s\n"), count, addr_string));
}
while (ntp.next ());
success = count > 1;
#if defined (ACE_HAS_IPV6)
ACE_INET_Addr ntp6;
if (ntp6.set (123, ACE_TEXT ("2.pool.ntp.org"), 1, AF_INET6) == -1)
{
ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("2.pool.ntp.org")));
return false;
}
count = 0;
do
{
++count; // If lookup succeeded, there's at least one
ntp6.addr_to_string (addr_string, sizeof (addr_string));
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("IPv6 %B: %s\n"), count, addr_string));
}
while (ntp6.next ());
if (count <= 1)
success = false;
#endif /* ACE_HAS_IPV6 */
return success;
}
int
ACE_TMAIN (int argc, ACE_TCHAR * argv[])
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) Server: ")
ACE_TEXT ("At start of main\n")));
ACE_OS::socket_init (ACE_WSOCK_VERSION);
if (parse_args (argc, argv) != 0)
return 1;
ACE_TCHAR host[MAXHOSTNAMELEN+1];
if (ACE_OS::hostname (host, MAXHOSTNAMELEN) != 0)
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("(%P|%t) Server failure: %p\n"),
ACE_TEXT ("hostname")),
1);
ACE_INET_Addr local (port, host);
local.addr_to_string (host, MAXHOSTNAMELEN);
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) Server: ")
ACE_TEXT ("listening at %s\n"),
host));
ACE_SOCK_Acceptor acc (local, 1);
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) Server: ")
ACE_TEXT ("opened listener\n")));
Accept_Handler handler (acc);
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) Server: ")
ACE_TEXT ("server is ready\n")));
if (notifier_file != 0)
{
FILE *f = ACE_OS::fopen (notifier_file,ACE_TEXT("w+"));
const char *msg = "server ready";
ACE_OS::fwrite (msg,ACE_OS::strlen(msg),1,f);
ACE_OS::fclose (f);
}
ACE_Reactor::instance()->run_reactor_event_loop();
return 0;
}
void RealmList::UpdateRealm(uint32 ID, const std::string& name, ACE_INET_Addr const& address, uint8 icon, RealmFlags flag, uint8 timezone, AccountTypes allowedSecurityLevel, float popu, uint32 build)
{
// Create new if not exist or update existed
Realm& realm = m_realms[name];
realm.m_ID = ID;
realm.name = name;
realm.icon = icon;
realm.flag = flag;
realm.timezone = timezone;
realm.allowedSecurityLevel = allowedSecurityLevel;
realm.populationLevel = popu;
// Append port to IP address.
address.addr_to_string(realm.address, ACE_MAX_FULLY_QUALIFIED_NAME_LEN + 16);
realm.gamebuild = build;
}
void
RPG_Net_Client_AsynchConnector::connect(const ACE_INET_Addr& peer_address)
{
RPG_TRACE(ACE_TEXT("RPG_Net_Client_AsynchConnector::connect"));
int result =
inherited::connect(peer_address, // remote SAP
ACE_sap_any_cast(const ACE_INET_Addr&), // local SAP
1, // re-use address (SO_REUSEADDR) ?
NULL); // ACT
if (result == -1)
{
ACE_TCHAR buffer[RPG_COMMON_BUFSIZE];
ACE_OS::memset(buffer, 0, sizeof(buffer));
if (peer_address.addr_to_string(buffer,
sizeof(buffer)) == -1)
ACE_DEBUG((LM_ERROR,
ACE_TEXT("failed to ACE_INET_Addr::addr_to_string(): \"%m\", continuing\n")));
ACE_DEBUG((LM_ERROR,
ACE_TEXT("failed to ACE_Asynch_Connector::connect(\"%s\"): \"%m\", aborting\n"),
buffer));
} // end IF
}
int
RPG_Net_Client_AsynchConnector::validate_connection(const ACE_Asynch_Connect::Result& result_in,
const ACE_INET_Addr& remoteSAP_in,
const ACE_INET_Addr& localSAP_in)
{
RPG_TRACE(ACE_TEXT("RPG_Net_Client_AsynchConnector::validate_connection"));
// success ?
if (result_in.success() == 0)
{
// debug info
ACE_TCHAR buffer[RPG_COMMON_BUFSIZE];
ACE_OS::memset(buffer, 0, sizeof(buffer));
if (remoteSAP_in.addr_to_string(buffer, sizeof(buffer)) == -1)
ACE_DEBUG((LM_ERROR,
ACE_TEXT("failed to ACE_INET_Addr::addr_to_string(): \"%m\", continuing\n")));
ACE_DEBUG((LM_ERROR,
ACE_TEXT("failed to RPG_Net_Client_AsynchConnector::connect(\"%s\"): \"%s\", aborting\n"),
buffer,
ACE_OS::strerror(result_in.error())));
} // end IF
return ((result_in.success() == 1) ? 0 : -1);
}
int
ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
ACE_OS::socket_init (ACE_WSOCK_VERSION);
if (parse_args(argc, argv) != 0)
return 1;
if (remote_host == 0)
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("Client: No remote host specified\n")),1);
ACE::HTBP::Environment env;
if (config_file != 0)
env.import_config (config_file);
ACE::HTBP::ID_Requestor req (&env);
ACE::HTBP::Addr local (ACE_TEXT_ALWAYS_CHAR(req.get_HTID()));
unsigned proxy_port = 0;
ACE_TString proxy_host;
if (env.get_proxy_port(proxy_port) != 0 ||
env.get_proxy_host(proxy_host) != 0)
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) Client: ")
ACE_TEXT("no proxy address in ")
ACE_TEXT("config, using direct connect\n")));
proxy_port = remote_port;
proxy_host = remote_host;
}
ACE_INET_Addr proxy (proxy_port, proxy_host.c_str ());
ACE::HTBP::Addr remote (remote_port, ACE_TEXT_ALWAYS_CHAR (remote_host));
ACE_TCHAR local_s[512], remote_s[512], proxy_s[512];
remote.addr_to_string (remote_s, 512);
local.addr_to_string (local_s, 512);
proxy.addr_to_string (proxy_s, 512);
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) Client starting session for ")
ACE_TEXT ("remote %s, local %s, proxy %s\n"),
remote_s,
local_s,
proxy_s));
ACE::HTBP::Session session (remote,
local,
ACE::HTBP::Session::next_session_id(),
&proxy);
ACE::HTBP::Stream stream (&session);
char buffer[1000];
ssize_t n = 0;
int retrycount = 10;
for (int i = 0; i < 3; i++)
{
ACE::HTBP::Channel *ch = session.outbound();
ACE_OS::sprintf (buffer,"Do you hear me? %d",i);
n = stream.send (buffer,ACE_OS::strlen(buffer)+1);
if (n == -1)
ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT("%p\n"),
ACE_TEXT("stream send")),-1);
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) Client: ")
ACE_TEXT("send returned %d\n"),n));
retrycount = 10;
while ((n = ch->recv_ack()) == -1
&& (errno == EWOULDBLOCK || errno == ETIME)
&& retrycount > 0)
{
retrycount--;
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) Client: ")
ACE_TEXT("waiting for ack, %d tries left\n"),
retrycount));
ACE_OS::sleep (1);
}
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) Client: ")
ACE_TEXT("After wait for ack, n = %d, retry = %d\n"),
n,retrycount,ACE_ERRNO_GET));
retrycount = 10;
while ((n = stream.recv(buffer,1000)) == -1
&& (errno == EWOULDBLOCK || errno == ETIME)
&& retrycount > 0)
{
retrycount--;
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) Client: ")
ACE_TEXT("waiting for inbound data, %d tries left\n"),
retrycount));
ACE_OS::sleep(1);
}
if (retrycount == 0 || n < 0)
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) Client: ")
ACE_TEXT("bailing after wait, %p\n"),
ACE_TEXT("recv")));
break;
}
buffer[n] = 0;
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) Client: ")
ACE_TEXT("Got: \"%s\"\n"),
buffer));
}
ACE::HTBP::Channel *ch = session.outbound();
if (ch == 0)
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("(%P|%t) Client: ")
ACE_TEXT("session's outbound channel is null!\n")),1);
n = stream.send ("goodbye",7);
if (n == -1)
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("(%P|%t) Client: ")
ACE_TEXT("%p\n"),
ACE_TEXT("stream send")),-1);
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) Client: ")
ACE_TEXT("send returned %d\n"),n));
retrycount = 10;
while (ch &&
(n = ch->recv_ack()) == -1
&& (errno == EWOULDBLOCK || errno == ETIME)
&& retrycount > 0)
{
retrycount--;
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) Client: ")
ACE_TEXT("waiting for ack, %d tries left\n"),
retrycount));
ACE_OS::sleep (1);
}
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) Client: ")
ACE_TEXT("After wait for ack, n = %d, retry = %d\n"),
n,retrycount,ACE_ERRNO_GET));
return 0;
}
std::string GetAddressString(ACE_INET_Addr const& addr)
{
char buf[ACE_MAX_FULLY_QUALIFIED_NAME_LEN + 16];
addr.addr_to_string(buf, ACE_MAX_FULLY_QUALIFIED_NAME_LEN + 16);
return buf;
}
bool TheEthManager::createSocket(ACE_INET_Addr local_addr)
{
yTrace();
managerMutex.wait();
// if(NULL == handle)
// {
// yError() << "Called createSocket while EthManager is not instantiated";
// handle = TheEthManager::instance();
// }
if(!UDP_initted)
{
UDP_socket = new ACE_SOCK_Dgram();
char tmp[64];
if(-1 == UDP_socket->open(local_addr))
{
local_addr.addr_to_string(tmp, 64);
yError() << "\n/---------------------------------------------------\\"
<< "\n| Unable to bind to local IP address " << tmp
<< "\n\\---------------------------------------------------/";
delete UDP_socket;
UDP_socket = NULL;
UDP_initted = false;
}
else
{
UDP_initted = true;
sender = new EthSender();
receiver = new EthReceiver();
//managerMutex.post();
sender->config(UDP_socket, this);
receiver->config(UDP_socket, this);
/* Start the threads sending to and receiving messages from the boards.
* It will execute the threadInit and pass its return value to the following calls
* afterStart to check if they started correctly.
*/
bool ret1, ret2;
ret1 = sender->start();
ret2 = receiver->start();
//managerMutex.wait();
if(!ret1 || !ret2)
{
yError() << "EthManager: issue while starting threads for UDP communication with EMSs";
// stop threads
stopThreads();
delete UDP_socket;
UDP_initted = false;
return false;
}
else
{
yTrace() << "Both sending and Receiving thread started correctly!";
}
}
}
managerMutex.post();
return UDP_initted;
}
template <class HANDLER> void
ACE_Asynch_Connector<HANDLER>::parse_address (const ACE_Asynch_Connect::Result &result,
ACE_INET_Addr &remote_address,
ACE_INET_Addr &local_address)
{
#if defined (ACE_HAS_IPV6)
// Getting the addresses.
sockaddr_in6 local_addr;
sockaddr_in6 remote_addr;
#else
// Getting the addresses.
sockaddr_in local_addr;
sockaddr_in remote_addr;
#endif /* ACE_HAS_IPV6 */
// Get the length.
int local_size = sizeof (local_addr);
int remote_size = sizeof (remote_addr);
// Get the local address.
if (ACE_OS::getsockname (result.connect_handle (),
reinterpret_cast<sockaddr *> (&local_addr),
&local_size) < 0)
ACE_ERROR ((LM_ERROR,
ACE_TEXT("%p\n"),
ACE_TEXT("ACE_Asynch_Connector::<getsockname> failed")));
// Get the remote address.
if (ACE_OS::getpeername (result.connect_handle (),
reinterpret_cast<sockaddr *> (&remote_addr),
&remote_size) < 0)
ACE_ERROR ((LM_ERROR,
ACE_TEXT("%p\n"),
ACE_TEXT("ACE_Asynch_Connector::<getpeername> failed")));
// Set the addresses.
local_address.set (reinterpret_cast<sockaddr_in *> (&local_addr),
local_size);
remote_address.set (reinterpret_cast<sockaddr_in *> (&remote_addr),
remote_size);
#if 0
// @@ Just debugging.
char local_address_buf [BUFSIZ];
char remote_address_buf [BUFSIZ];
if (local_address.addr_to_string (local_address_buf,
sizeof local_address_buf) == -1)
ACE_ERROR ((LM_ERROR,
"Error:%m:can't obtain local_address's address string"));
ACE_DEBUG ((LM_DEBUG,
"ACE_Asynch_Connector<HANDLER>::parse_address : "
"Local address %s\n",
local_address_buf));
if (remote_address.addr_to_string (remote_address_buf,
sizeof remote_address_buf) == -1)
ACE_ERROR ((LM_ERROR,
"Error:%m:can't obtain remote_address's address string"));
ACE_DEBUG ((LM_DEBUG,
"ACE_Asynch_Connector<HANDLER>::parse_address : "
"Remote address %s\n",
remote_address_buf));
#endif /* 0 */
return;
}
int
TAO_SHMIOP_Connection_Handler::open (void*)
{
if (this->shared_open() == -1)
return -1;
TAO_SHMIOP_Protocol_Properties protocol_properties;
// Initialize values from ORB params.
protocol_properties.send_buffer_size_ =
this->orb_core ()->orb_params ()->sock_sndbuf_size ();
protocol_properties.recv_buffer_size_ =
this->orb_core ()->orb_params ()->sock_rcvbuf_size ();
protocol_properties.no_delay_ =
this->orb_core ()->orb_params ()->nodelay ();
TAO_Protocols_Hooks *tph = this->orb_core ()->get_protocols_hooks ();
if (tph != 0)
{
try
{
if (this->transport ()->opened_as () == TAO::TAO_CLIENT_ROLE)
{
tph->client_protocol_properties_at_orb_level (protocol_properties);
}
else
{
tph->server_protocol_properties_at_orb_level (protocol_properties);
}
}
catch (const ::CORBA::Exception&)
{
return -1;
}
}
if (this->set_socket_option (this->peer (),
protocol_properties.send_buffer_size_,
protocol_properties.recv_buffer_size_) == -1)
return -1;
#if !defined (ACE_LACKS_TCP_NODELAY)
if (this->peer ().set_option (ACE_IPPROTO_TCP,
TCP_NODELAY,
(void *) &protocol_properties.no_delay_,
sizeof (protocol_properties.no_delay_)) == -1)
return -1;
#endif /* ! ACE_LACKS_TCP_NODELAY */
if (this->transport ()->wait_strategy ()->non_blocking ())
{
if (this->peer ().enable (ACE_NONBLOCK) == -1)
return -1;
}
// Called by the <Strategy_Acceptor> when the handler is
// completely connected.
ACE_INET_Addr addr;
ACE_TCHAR local_as_string[MAXHOSTNAMELEN + 16];
// Get the peername.
if (this->peer ().get_remote_addr (addr) == -1)
return -1;
// Verify that we can resolve the peer hostname.
else if (addr.addr_to_string (local_as_string, sizeof (local_as_string)) == -1)
return -1;
if (TAO_debug_level > 0)
{
TAOLIB_DEBUG ((LM_DEBUG,
ACE_TEXT ("TAO (%P|%t) - SHMIOP connection from client")
ACE_TEXT ("<%s> on %d\n"),
local_as_string, this->peer ().get_handle ()));
}
// Set that the transport is now connected, if fails we return -1
// Use C-style cast b/c otherwise we get warnings on lots of
// compilers
if (!this->transport ()->post_open ((size_t) this->get_handle ()))
return -1;
// Not needed, anyway
this->state_changed (TAO_LF_Event::LFS_SUCCESS,
this->orb_core ()->leader_follower ());
return 0;
}
int
ACE_TMAIN (int argc , ACE_TCHAR *argv[])
{
char buffer[1000];
ssize_t n = 0;
ACE_OS::socket_init (ACE_WSOCK_VERSION);
if (parse_args(argc, argv) != 0)
return 1;
ACE_TCHAR host[MAXHOSTNAMELEN+1];
if (ACE_OS::hostname (host, MAXHOSTNAMELEN) != 0)
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("(%P|%t) Server failure: %p\n"),
ACE_TEXT ("hostname")),
1);
ACE_INET_Addr local (port, host);
ACE_SOCK_Stream sock[2];
ACE_SOCK_Acceptor acc(local, 1);
local.addr_to_string (host, MAXHOSTNAMELEN);
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) Server is ready on %s\n"),
host));
if (notifier_file != 0)
{
FILE *f = ACE_OS::fopen (notifier_file,ACE_TEXT("w+"));
const char *msg = "server ready";
ACE_OS::fwrite (msg,ACE_OS::strlen(msg),1,f);
ACE_OS::fclose (f);
}
acc.accept (sock[0]);
ACE::HTBP::Channel channel1(sock[0]);
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) Server: ")
ACE_TEXT ("Got sock[0], handle = %d\n"),
sock[0].get_handle()));
acc.accept (sock[1]);
ACE::HTBP::Channel channel2 (sock[1]);
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) Server: ")
ACE_TEXT ("Got sock[1], handle = %d\n"),
sock[1].get_handle()));
int res = 0;
while ((res = channel1.pre_recv ()) != 0)
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) Server: ")
ACE_TEXT ("res = %d. waiting 1 sec. %p\n"),
res,
ACE_TEXT ("stream.pre_recv()")));
ACE_OS::sleep (1);
}
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Read from channel2\n")));
while ((res = channel2.pre_recv()) != 0)
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) Server: ")
ACE_TEXT ("res = %d, waiting 1 sec. %p\n"),
res,
ACE_TEXT ("stream2.pre_recv()")));
ACE_OS::sleep (1);
}
ACE::HTBP::Session *session = channel1.session();
ACE::HTBP::Stream stream (session);
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) Server: ")
ACE_TEXT ("using streams %d, %d. Got session = %@\n"),
sock[0].get_handle(),
sock[1].get_handle(),
session));
for (int i = 0; i >= 0; i++)
{
int retrycount = 10;
while ((n = stream.recv(buffer,1000)) == -1
&& (errno == EWOULDBLOCK || errno == ETIME)
&& retrycount > 0)
{
retrycount--;
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) Server: ")
ACE_TEXT ("waiting for inbound data, %d tries left\n"),
retrycount));
ACE_OS::sleep(1);
}
if (retrycount == 0 || n < 0)
break;
buffer[n] = 0;
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) Server: ")
ACE_TEXT ("Got: \"%C\"\n"), buffer));
if (ACE_OS::strstr (buffer,"goodbye") != 0)
break;
ACE_OS::sprintf (buffer,"I hear you %d",i);
n = stream.send (buffer,ACE_OS::strlen(buffer)+1);
if (n == -1)
ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("%p\n"),
ACE_TEXT ("stream.send")),
-1);
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) Server: Send returned %d\n"), n));
int got[2] = {-1,-1};
while (got[0] == -1 || got[1] == -1)
{
if (got[0] == -1)
{
if ((got[0] = (res =channel1.pre_recv())) == -1)
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) Server: ")
ACE_TEXT ("res = %d, waiting 1 sec. %p\n"),
got[0],
ACE_TEXT ("channel1.pre_recv()")));
}
if (got[1] == -1)
{
if ((got[1] = (res =channel2.pre_recv())) == -1)
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) Server: ")
ACE_TEXT ("res = %d, waiting 1 sec. %p\n"),
got[1],
ACE_TEXT ("channel2.pre_recv()")));
}
if (got[0] == -1 || got[1] == -1)
ACE_OS::sleep (1);
}
}
ACE_OS::sleep(1); // prevent test failure on windows when the connection
// closes too fast.
stream.close();
acc.close();
return 0;
}
/*
* The set of readers and the writer will operate in a staggered sequence
* of acquiring and releasing the lock. The sequence is designed to exercise
* waiting behavior of both readers and writer, as well as allowing multiple
* readers in, without getting tripped up by any differences in ordering
* on different platforms which may favor writers, or vice-versa.
* In this timeline, time on seconds is on the left, time holding the lock
* is solid, time waiting is dots, acquire/release point is a dash, and
* time without the lock is blank.
*
* TIME WRITER READER1 READER2 READER3
* 0 |
* |
* 1 | .
* | .
* 2 - - -
* | |
* 3 | | -
* | | |
* 4 - | |
* | |
* 5 - |
* |
* 6 - -
* |
* 7 | . . .
* | . . .
* 8 - - - -
* | | |
* 9 | | |
*
* A file is used to test the sequencing. When the writer first gets the
* lock, it will ensure the file is not present. At the end of its time
* holding the lock the first time, it will write a "writer 1" string to
* the file. When it gets the lock the second time, it will write a
* different string to the file, and just before releasing the second time
* write a "writer 2" string to the file. The readers all check to be sure
* that the file is present and says "writer 1" at the start and end of
* their periods of holding the reader lock and, similarly, check for
* "writer 2" the second time they hold the lock.
*/
static void
reader (int num)
{
// Let the writer get there first.
ACE_OS::sleep (1);
ACE_SOCK_Dgram sock;
ACE_INET_Addr parent;
parent.set (reporting_port, ACE_LOCALHOST, 1, AF_INET);
ACE_TCHAR me_str[80];
parent.addr_to_string (me_str, 80);
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Sending reports to %s\n"), me_str));
if (sock.open (ACE_Addr::sap_any, PF_INET) == -1)
ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("UDP open")));
Range_Report report;
report.child_ = num;
ACE_Time_Value start (ACE_Time_Value::zero), stop (ACE_Time_Value::zero);
ACE_RW_Process_Mutex mutex (mutex_name.c_str ());
// Make sure the constructor succeeded
if (ACE_LOG_MSG->op_status () != 0)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Reader %d, mutex %s %p\n"),
num,
mutex_name.c_str (),
ACE_TEXT ("ctor")));
return;
}
ACE_OS::sleep (num);
// Grab the lock
if (-1 == mutex.acquire_read ())
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Reader %d %p\n"),
num,
ACE_TEXT ("first acquire_read")));
else
{
start = ACE_OS::gettimeofday ();
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("Reader %d acquired first time\n"),
num));
}
// Wait a bit, then release and report the range held.
ACE_OS::sleep (num);
// Release the lock then wait; in the interim, the writer should change
// the file.
stop = ACE_OS::gettimeofday ();
if (-1 == mutex.release ())
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Reader %d %p\n"),
num,
ACE_TEXT ("first release")));
else
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Reader %d released first time\n"), num));
report.range_.set (start, stop);
ssize_t bytes = sock.send (&report, sizeof (report), parent);
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("Reader %d sent %b byte report\n"),
num,
bytes));
ACE_OS::sleep (4 - num);
start = stop = ACE_Time_Value::zero;
if (-1 == mutex.acquire_read ())
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Reader %d %p\n"),
num,
ACE_TEXT ("second acquire_read")));
else
{
start = ACE_OS::gettimeofday ();
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("Reader %d acquired second time\n"),
num));
}
// Done; small delay, release, report, and return.
ACE_OS::sleep (1);
stop = ACE_OS::gettimeofday ();
if (-1 == mutex.release ())
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Reader %d %p\n"),
num,
ACE_TEXT ("second release")));
else
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("Reader %d released second time; done\n"),
num));
report.range_.set (start, stop);
bytes = sock.send (&report, sizeof (report), parent);
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("Reader %d sent %b byte report\n"),
num,
bytes));
sock.close ();
return;
}
static void
writer (void)
{
ACE_RW_Process_Mutex mutex (mutex_name.c_str ());
// Make sure the constructor succeeded
if (ACE_LOG_MSG->op_status () != 0)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Writer, mutex %s %p\n"),
mutex_name.c_str (),
ACE_TEXT ("ctor")));
return;
}
ACE_SOCK_Dgram sock;
ACE_INET_Addr parent;
parent.set (reporting_port, ACE_LOCALHOST, 1, AF_INET);
ACE_TCHAR me_str[80];
parent.addr_to_string (me_str, 80);
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Sending reports to %s\n"), me_str));
if (sock.open (ACE_Addr::sap_any, PF_INET) == -1)
ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("UDP open")));
Range_Report report;
report.child_ = 0; // We're the writer
ACE_Time_Value start (ACE_Time_Value::zero), stop (ACE_Time_Value::zero);
// Grab the lock
if (-1 == mutex.acquire_write ())
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Writer first %p\n"),
ACE_TEXT ("acquire_write")));
else
{
start = ACE_OS::gettimeofday ();
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Writer acquired first time\n")));
}
// Now sleep, making the readers wait for the lock. Then release the lock,
// sleep, and reacquire the lock.
ACE_OS::sleep (2);
stop = ACE_OS::gettimeofday ();
if (-1 == mutex.release ())
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Writer %p\n"),
ACE_TEXT ("first release")));
else
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("Writer released first time\n")));
report.range_.set (start, stop);
ssize_t bytes = sock.send (&report, sizeof (report), parent);
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Writer sent %b byte report\n"), bytes));
ACE_OS::sleep (1); // Ensure we don't immediately grab the lock back
start = stop = ACE_Time_Value::zero;
if (-1 == mutex.acquire_write ())
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Writer second %p\n"),
ACE_TEXT ("acquire_write")));
else
{
start = ACE_OS::gettimeofday ();
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Writer acquired second time\n")));
}
ACE_OS::sleep (2);
stop = ACE_OS::gettimeofday ();
if (-1 == mutex.release ())
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Writer %p\n"),
ACE_TEXT ("second release")));
else
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("Writer released second time\n")));
report.range_.set (start, stop);
bytes = sock.send (&report, sizeof (report), parent);
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Writer sent %b byte report\n"), bytes));
sock.close ();
return;
}
int
run_main (int argc, ACE_TCHAR *argv[])
{
parse_args (argc, argv);
// Child process code.
if (child_nr >= 0)
{
ACE_TCHAR lognm[MAXPATHLEN];
int mypid (ACE_OS::getpid ());
ACE_OS::sprintf(lognm,
ACE_TEXT ("RW_Process_Mutex_Test-child-%d"),
(int)mypid);
ACE_START_TEST (lognm);
if (child_nr == 0)
writer ();
else
reader (child_nr);
ACE_END_LOG;
}
else
{
ACE_START_TEST (ACE_TEXT ("RW_Process_Mutex_Test"));
// Although it should be safe for each process to construct and
// destruct the rw lock, this can disturb other process still
// using the lock. This is not really correct, and should be
// looked at, but it gets things moving.
// Also see Process_Mutex_Test.cpp for similar issue.
ACE_RW_Process_Mutex mutex (mutex_name.c_str ());
// Make sure the constructor succeeded
if (ACE_LOG_MSG->op_status () != 0)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Parent, mutex %s %p\n"),
mutex_name.c_str (),
ACE_TEXT ("ctor")));
}
#if !defined (ACE_WIN32) && defined (ACE_USES_WCHAR)
static const ACE_TCHAR* format = ACE_TEXT ("%ls -c %d -p %u -n %ls");
#else
static const ACE_TCHAR* format = ACE_TEXT ("%s -c %d -p %u -n %s");
#endif /* !ACE_WIN32 && ACE_USES_WCHAR */
// The parent process reads time ranges sent from the children via
// UDP. Grab an unused UDP port to tell the children to send to.
ACE_INET_Addr me;
ACE_SOCK_Dgram sock;
if (sock.open (ACE_Addr::sap_any, PF_INET) == -1)
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("Socket %p\n"),
ACE_TEXT ("open")),
-1);
sock.get_local_addr (me);
ACE_TCHAR me_str[80];
me.addr_to_string (me_str, 80);
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Receiving on %s\n"), me_str));
// Spawn 1 writer and 3 reader processes that will contend for the
// lock.
Child writer;
Child readers[Nr_Processes - 1];
int i;
for (i = 0; i < Nr_Processes; i++)
{
Child *child = (i == 0 ? &writer : &readers[i-1]);
ACE_Process_Options options;
options.command_line (format,
argc > 0 ? argv[0] : ACE_TEXT ("RW_Process_Mutex_Test"),
i,
(unsigned int)me.get_port_number (),
mutex_name.c_str ());
if (child->spawn (options) == -1)
{
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("spawn of child %d %p\n"),
i,
ACE_TEXT ("failed")),
-1);
}
else
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("Child process %d has pid = %d.\n"),
i,
(int)(child->getpid ())));
}
}
// Keep reading time ranges reported from the children until all the
// children have exited. Alternate between checking for a range and
// checking for exits.
int processes = Nr_Processes;
Child *children[Nr_Processes];
for (i = 0; i < Nr_Processes; i++)
children[i] = (i == 0 ? &writer : &readers[i-1]);
Range_Report report;
ACE_Time_Value poll (0);
ACE_INET_Addr from;
ssize_t bytes;
while (processes > 0)
{
ACE_Time_Value limit (10);
bytes = sock.recv (&report, sizeof (report), from, 0, &limit);
if (bytes > 0)
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("Report from child %d; %b bytes\n"),
report.child_, bytes));
if (report.child_ == 0)
writer.add_range (report.range_);
else
{
if (report.child_ >= 1 && report.child_ < Nr_Processes)
readers[report.child_ - 1].add_range (report.range_);
else
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Report from out-of-range child #%d\n"),
report.child_));
}
}
else
{
if (errno == ETIME)
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("UDP time out; check child exits\n")));
else
ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("UDP recv")));
}
for (i = 0; i < Nr_Processes; i++)
{
if (children[i] == 0)
continue;
ACE_exitcode child_status;
// See if the child has exited.
int wait_result = children[i]->wait (poll, &child_status);
if (wait_result == -1)
ACE_ERROR ((LM_ERROR, ACE_TEXT ("Wait for child %d, %p\n"),
i, ACE_TEXT ("error")));
else if (wait_result != 0)
{
if (child_status == 0)
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("Child %d finished ok\n"),
(int)(children[i]->getpid ())));
else
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Child %d finished with status %d\n"),
(int)(children[i]->getpid ()), child_status));
children[i] = 0;
--processes;
}
}
}
sock.close ();
if (0 != mutex.remove ())
ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("mutex remove")));
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Comparing time ranges...\n")));
// The writer should never overlap any readers
bool writer_overlap = false;
for (i = 0; i < Nr_Processes - 1; ++i)
{
if (writer.any_overlaps (readers[i]))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Writer overlaps reader %d\n"),
i+1));
writer_overlap = true;
}
}
if (!writer_overlap)
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("Writer does not overlap with readers; Ok\n")));
// And there should be some overlap between readers.
bool reader_overlap = false;
for (i = 0; i < Nr_Processes - 1; ++i)
{
// Just compare to those higher, else it compares the same ones,
// only in reverse.
for (int j = i + 1; j < Nr_Processes - 1; ++j)
{
if (readers[i].any_overlaps (readers[j]))
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("Reader %d overlaps reader %d; Ok\n"),
i + 1, j + 1));
reader_overlap = true;
}
}
}
if (!reader_overlap)
ACE_ERROR ((LM_ERROR, ACE_TEXT ("No readers overlapped!\n")));
ACE_END_TEST;
}
return 0;
}
int
Echo_Handler::handle_input (ACE_HANDLE)
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) Echo_Handler::handle_input - ")
ACE_TEXT ("activity occurred on handle %d!\n"),
this->ping_socket ().get_handle ()));
ACE_TCHAR buf[BUFSIZ];
ACE_OS::memset (buf, 0, sizeof buf);
ACE_INET_Addr addr;
int rval_recv = -1;
// Receive an <n> byte <buf> from the datagram socket
// (uses<recvfrom(3)>).
rval_recv =
this->ping_socket ().recv (this->ping_socket ().icmp_recv_buff (),
ACE_Ping_Socket::PING_BUFFER_SIZE,
addr);
switch (rval_recv)
{
case -1:
// Complain and leave, but keep registered, returning 0.
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("(%P|%t) Echo_Handler::handle_input - ")
ACE_TEXT ("%p: bad read\n"),
ACE_TEXT ("client")),
0);
// NOTREACHED
case 0:
// Complain and leave
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("(%P|%t) Echo_Handler::handle_input - ")
ACE_TEXT ("closing daemon (fd = %d)\n"),
this->get_handle ()),
0);
// NOTREACHED
default:
ACE_DEBUG ((LM_INFO,
ACE_TEXT ("(%P|%t) Echo_Handler::handle_input - ")
ACE_TEXT ("message from %d bytes received.\n"),
rval_recv));
if (! this->ping_socket ().process_incoming_dgram (
this->ping_socket ().icmp_recv_buff (),
rval_recv))
{
for (size_t k = 0; k <this->number_remotes_; ++k)
{
if (addr.is_ip_equal (this->remote_addrs_[k]))
{
if (addr.addr_to_string (buf, sizeof buf) == -1)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("can't obtain peer's address")));
}
else
{
ACE_DEBUG
((LM_INFO,
ACE_TEXT ("(%P|%t) Echo_Handler::handle_input - ")
ACE_TEXT ("ECHO_REPLY received ")
ACE_TEXT ("from %s; marking this peer alive\n"),
buf));
}
// mark as successful
this->success_status_[k] = 0;
break;
}
}
}
break;
}
return 0;
}
int ACE_TMAIN (int, ACE_TCHAR *[])
{
/*
* Here we will use the default ctor and the set()
* method to configure it. After each set() we will
* display the address as a string and then connect
* to each respective server. We can reuse the addr
* instance once connection has been established.
*
// Listing 1 code/ch06
ACE_INET_Addr addr;
...
addr.set ("HAStatus", ACE_LOCALHOST);
...
addr.set ("HALog", ACE_LOCALHOST);
// Listing 1
*
*/
ACE_INET_Addr addr;
ACE_TCHAR peerAddress[64];
// Listing 2 code/ch06
addr.set (ACE_TEXT("HAStatus"), ACE_LOCALHOST);
if (addr.addr_to_string (peerAddress,
sizeof(peerAddress), 0) == 0)
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) Connecting to %s\n"),
peerAddress));
}
// Listing 2
// Listing 3 code/ch06
ACE_SOCK_Stream status;
ACE_OS::last_error(0);
ACE_SOCK_Connector statusConnector (status, addr);
if (ACE_OS::last_error())
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("status")), 100);
// Listing 3
addr.set (ACE_TEXT("HALog"), ACE_LOCALHOST);
if (addr.addr_to_string (peerAddress,
sizeof(peerAddress), 0) == 0)
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) Connecting to %s\n"),
peerAddress ));
}
// Listing 4 code/ch06
ACE_SOCK_Connector logConnector;
ACE_Time_Value timeout (10);
ACE_SOCK_Stream log;
if (logConnector.connect (log, addr, &timeout) == -1)
{
if (ACE_OS::last_error() == ETIME)
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) Timeout while ")
ACE_TEXT ("connecting to log server\n")));
}
else
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("log")));
}
return (101);
}
// Listing 4
/*
* We generally let the OS pick our local port number but
* if you want, you can choose that also:
// Listing 5 code/ch06
ACE_SOCK_Connector logConnector;
ACE_INET_Addr local (4200, ACE_LOCALHOST);
if (logConnector.connect (log, addr, 0, local) == -1)
{
...
// Listing 5
}
*/
char buf[64];
// Listing 6 code/ch06
ACE_Time_Value sendTimeout (0, 5);
if (status.send_n ("uptime\n", 7, &sendTimeout) == -1)
{
if (ACE_OS::last_error() == ETIME)
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) Timeout while sending ")
ACE_TEXT ("query to status server\n")));
}
// Listing 6
else
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("send_n")));
}
return (102);
}
// Listing 7 code/ch06
ssize_t bc ;
ACE_Time_Value recvTimeout (0, 1);
if ((bc = status.recv (buf, sizeof(buf), &recvTimeout)) == -1)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("recv")));
return (103);
}
log.send_n (buf, bc);
// Listing 7
status.close ();
log.close ();
return (0);
}
ACE_TString InetAddrToString(const ACE_INET_Addr& addr)
{
ACE_TCHAR buf[MAX_STRING_LENGTH+1] = {};
addr.addr_to_string(buf, MAX_STRING_LENGTH);
return buf;
}
