/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//// This example is from the ACE Programmers Guide.
//// Chapter: "The Acceptor/Connector" (Connection Initialization)
//// For details please see the guide at
//// http://www.cs.wustl.edu/~schmidt/ACE.html
//// AUTHOR: Umar Syyid (usyyid@hns.com)
//// and Ambreen Ilyas (ambreen@bitsmart.com)
/////////////////////////////////////////////////////////////////////////////////////////////////////////////

//Example 7
#include "ace/Reactor.h"
#include "ace/Svc_Handler.h"
#include "ace/Acceptor.h"
#include "ace/Synch.h"
#include "ace/SOCK_Acceptor.h"
#include "ace/Thread.h"
#define NETWORK_SPEED 3
class MyServiceHandler; //forward declaration
typedef ACE_Singleton<ACE_Reactor,ACE_Null_Mutex> Reactor;
typedef ACE_Acceptor<MyServiceHandler,ACE_SOCK_ACCEPTOR> Acceptor;

class MyServiceHandler:
public ACE_Svc_Handler<ACE_SOCK_STREAM,ACE_MT_SYNCH>{
// The message sender and creator threads are handled here.
ACE_thread_t thread_names[2];

public:
int open(void*){
ACE_DEBUG((LM_DEBUG, "Acceptor: received new connection \n"));

//Register with the reactor to remember this handler..
Reactor::instance() ->register_handler(this,ACE_Event_Handler::READ_MASK);
ACE_DEBUG((LM_DEBUG,"Acceptor: ThreadID:(%t) open\n"));

//Create two new threads to create and send messages to the
//remote machine.
activate(THR_NEW_LWP,
2, //2 new threads
0,
ACE_DEFAULT_THREAD_PRIORITY,
-1,
this,
0,
0,
0,
thread_names); // identifiers in thread_handles
//keep the service handler registered with the acceptor.
return 0;
}

void send_message(void){
//Dequeue the message and send it off
ACE_DEBUG((LM_DEBUG,"(%t)Sending message >>"));

//dequeue the message from the message queue
ACE_Message_Block *mb;
ACE_ASSERT(this->getq(mb)!=-1);
int length=mb->length();
char *data =mb->rd_ptr();

//Send the data to the remote peer
ACE_DEBUG((LM_DEBUG,"%s \n",data,length));
peer().send_n(data,length);

//Simulate very SLOW network.
ACE_OS::sleep(NETWORK_SPEED);

//release the message block
mb->release();
} //end send_message

int construct_message(void){
// A very fast message creation algorithm
// would lead to the need for queuing messages..
// here. These messages are created and then sent
// using the SLOW send_message() routine which is
// running in a different thread so that the message
//construction thread isn?t blocked.
ACE_DEBUG((LM_DEBUG,"(%t)Constructing message >> "));

// Create a new message to send
ACE_Message_Block *mb;
char *data="Hello Connector";
ACE_NEW_RETURN (mb,ACE_Message_Block (16,//Message 16 bytes long
ACE_Message_Block::MB_DATA,//Set header to data
0,//No continuations.
data//The data we want to send
), 0);
mb->wr_ptr(16); //Set the write pointer.
// Enqueue the message into the message queue
// we COULD have done a timed wait for enqueuing in case
// someone else holds the lock to the queue so it doesn?t block
//forever..
ACE_ASSERT(this->putq(mb)!=-1);
ACE_DEBUG((LM_DEBUG,"Enqueued msg successfully\n"));
}
int svc(void){
ACE_DEBUG( (LM_DEBUG,?(%t) Svc thread \n?));
//call the message creator thread
if(ACE_Thread::self()== thread_names[0])
while(1) construct_message(); //create messages forever
else
while(1) send_message(); //send messages forever
return 0; // keep the compiler happy.
}
int handle_input(ACE_HANDLE){
ACE_DEBUG((LM_DEBUG,"(%t) handle_input "));
char* data= new char[13];
//Check if peer aborted the connection
if(peer().recv_n(data,12)==0){
ACE_OS::printf("Peer probably aborted connection");
return -1; //de-register from the Reactor.
}
//Show what you got..
ACE_OS::printf("<< %s\n",data);
//keep yourself registered
return 0;
}
};

int main(int argc, char* argv[]){
ACE_INET_Addr addr(10101);
ACE_DEBUG((LM_DEBUG,"Thread: (%t) main\n"));

//Prepare to accept connections
Acceptor myacceptor(addr,Reactor::instance());

// wait for something to happen.
while(1)
Reactor::instance()->handle_events();
return 0;
}

Next Example