jni/commoncpp2-1.8.1-android/demo/tcpservice.cpp - jami-client-android - Gitiles

 //
 // tcpservice.cpp
 //
 //  Copyright 2000 - Gianni Mariani <gianni@mariani.ws>
 //
 //  An example of a simple chatty server using CommonC++.
 //
 //  This simple application basically operates as a
 //  very simple chat system. From a telnet session
 //  on localhost:3999 , any messages typed from a telnet
 //  client are written to all participating sessions.
 //
 //  This is free software licensed under the terms of the GNU
 //  Public License
 //
 //  This example:
 //
 //  This demostrates a simple threaded server, actually,
 //  the sessions are not all threaded though they could be
 //  if that's what you wanted.	Basically it demonstrates the
 //  use of SocketService, SocketPorts and Threads.
 //
 //  For those familiar with Unix network programming, SocketService
 //  basically encapsulates all the work to communicate with
 //  the select() or poll() system calls.  SocketPorts are
 //  basically encapsulations of sessions or open file descriptors.
 //
 //  Anyhow, this example is a very simple echo server but
 //  it echos to all connected clients.	So it's a poor man's
 //  IRC !  You connect via telnet to localhost port 3999 and
 //  it will echo to all other connected clients what you type in !
 //

 #include <cc++/socketport.h>

 #include <iostream>

 // For starters, we need a thread safe list, we'll make one
 // out of the STL list<> template -
 //  http://www.sgi.com/Technology/STL/index.html
 //
 // Thread safe list class
 //
 #include <list>

 #ifdef	CCXX_NAMESPACES
 using namespace std;
 using namespace ost;
 #endif

 class ts_list_item;
 typedef list<ts_list_item *> ts_list;

 // a list head - containing a list and a Mutex.
 // It would be really nice to teach stl to do this.

 class ts_list_head {
 public:

 	// No point inheriting, I'd have to implement
 	// alot of code. We'll hold off on that exercise.

 	// Using the CommonC++ Mutex class.
 	Mutex		    linkmutex;
 	// And the STL template.
 	ts_list		    list_o_items;

 	// Not nessasary, but nice to be explicit.
 	ts_list_head()
 	: linkmutex(), list_o_items() {
 	}

 	// This thing knows how to remove and insert items.
 	void RemoveListItem( ts_list_item * li );
 	void InsertListItem( ts_list_item * li );

 	// And it knows how to notify that it became empty
 	// or an element was deleted and it was the last one.
 	virtual void ListDepleted() {
 	}

 	virtual ~ts_list_head() {
 	}
 };


 // This item knows how to remove itself from the
 // list it belongs to.
 class ts_list_item {
 public:
 	ts_list::iterator	   linkpoint;
 	ts_list_head	  * listhead;

 	virtual ~ts_list_item() {
 	listhead->RemoveListItem( this );
 	}

 	ts_list_item( ts_list_head * head ) {
 	listhead = head;
 	head->InsertListItem( this );
 	}
 };

 void ts_list_head::RemoveListItem( ts_list_item * li )
 {
 	bool    is_empty;
 	linkmutex.enterMutex();
 	list_o_items.erase( li->linkpoint );
 	is_empty = list_o_items.empty();
 	linkmutex.leaveMutex();

 	// There is a slim possibility that at this time
 	// we recieve a connection.
 	if ( is_empty ) {
 	ListDepleted();
 	}
 }

 void ts_list_head::InsertListItem( ts_list_item * li )
 {
 	linkmutex.enterMutex();
 	list_o_items.push_front( li );
 	li->linkpoint = list_o_items.begin();
 	linkmutex.leaveMutex();
 }

 // ChatterSession operates on the individual connections
 // from clients as are managed by the SocketService
 // contained in CCExec.  ChatterThread simply waits in
 // a loop to create these, listening forever.
 //
 // Even though the SocketService contains a list of
 // clients it serves, it may actually serve more than
 // one type of session so we create our own list by
 // inheriting the ts_list_item.
 //

 class ChatterSession :
 	public virtual SocketPort,
 	public virtual ts_list_item {
 public:

 	enum { size_o_buf = 2048 };

 	// Nothing special to do here, it's all handled
 	// by SocketPort and ts_list_item

 	virtual ~ChatterSession() {
 	cerr << "ChatterSession deleted !\n";
 	}

 	// When you create a ChatterSession it waits to accept a
 	// connection.  This is done by it's own
 	ChatterSession(
 	TCPSocket      & server,
 	SocketService	* svc,
 	ts_list_head	* head
 	) :
 	SocketPort( NULL, server ),
 	ts_list_item( head ) {
 	cerr << "ChatterSession Created\n";

 	tpport_t port;
 	InetHostAddress ia = getPeer( & port );

 	cerr << "connecting from " << ia.getHostname() <<
 	":" << port << endl;

 	// Set up non-blocking reads
 	setCompletion( false );

 	// Set yerself to time out in 10 seconds
 	setTimer( 100000 );
 	attach(svc);
 	}

 	//
 	// This is called by the SocketService thread when it the
 	// object has expired.
 	//

 	virtual void expired() {
 	// Get outa here - this guy is a LOOSER - type or terminate
 	cerr << "ChatterSession Expired\n";
 	delete this;
 	}

 	//
 	// This is called by the SocketService thread when it detects
 	// that there is somthing to read on this connection.
 	//

 	virtual void pending() {
 	// Implement the echo

 	cerr << "Pending called\n";

 	// reset the timer
 	setTimer( 100000 );
 	try {
 	    int    len;
 	    unsigned int total = 0;
 	    char    buf[ size_o_buf ];

 	    while ( (len = receive(buf, sizeof(buf) )) > 0 ) {
 		total += len;
 		cerr << "Read '";
 		cerr.write( buf, len );
 		cerr << "'\n";

 		// Send it to all the sessions.
 		// We probably don't really want to lock the
 		// entire list for the entire time.
 		// The best way to do this would be to place the
 		// message somewhere and use the service function.
 		// But what are examples for ?

 		bool sent = false;
 		listhead->linkmutex.enterMutex();
 		for (
 		   ts_list::iterator iter = listhead->list_o_items.begin();
 		   iter != listhead->list_o_items.end();
 		   iter ++
 		) {
 		   ChatterSession * sess =
 		    dynamic_cast< ChatterSession * >( * iter );
 		   if ( sess != this ) {
 		    sess->send( buf, len );
 		    sent = true;
 		   }
 		}
 		listhead->linkmutex.leaveMutex();

 		if ( ! sent ) {
 		   send(
 		    ( void * ) "No one else listening\n",
 		    sizeof( "No one else listening\n" ) - 1
 		   );

 		   send( buf, len );
 		}
 	    }
 	    if (total == 0) {
 		cerr << "Broken connection!\n" << endl;
 		delete this;
 	    }
 	}
 	catch ( ... ) {
 	    // somthing wrong happened here !
 	    cerr << "Socket port write sent an exception !\n";
 	}

 	}

 	virtual void disconnect() {
 	// Called by the SocketService thread when the client
 	// hangs up.
 	cerr << "ChatterSession disconnected!\n";

 	delete this;
 	}

 };

 class ChatterThread;

 //
 // This is the main application object containing all the
 // state for the application.  It uses a SocketService object
 // (and thread) to do all the work, however, that object could
 // theoretically be use by more than one main application.
 //
 // It creates a ChatterThread to sit and wait for connections
 // from clients.

 class CCExec : public virtual ts_list_head {
 public:

 	SocketService	    * service;
 	ChatterThread	       * my_Chatter;
 	Semaphore		      mainsem[1];

 	CCExec():my_Chatter(NULL) {
 	service = new SocketService( 0 );
 	}

 	virtual void ListDepleted();

 	// These methods defined later.
 	virtual ~CCExec();
 	int RunApp( char * hn = (char *)"localhost" );

 };

 //
 // ChatterThread simply creates ChatterSession all the time until
 // it has an error.  I suspect you could create as many of these
 // as the OS could take.
 //

 class ChatterThread : public virtual TCPSocket, public virtual Thread {
 public:

 	CCExec		* exec;

 	void run () {
 	while ( 1 ) {
 	    try {
 		// new does all the work to accept a new connection
 		// attach itself to the SocketService AND include
 		// itself in the CCExec list of sessions.
 		new ChatterSession(
 		   * ( TCPSocket * ) this,
 		   exec->service,
 		   exec
 		);
 	    }
 	    catch ( ... ) {
 		// Bummer - there was an error.
 		cerr << "ChatterSession create failed\n";
 		exit();
 	    }
 	}
 	}

 	ChatterThread(
 	InetHostAddress & machine,
 	int	      port,
 	CCExec	       * inexec

 	) : TCPSocket( machine, port ),
 	Thread(),
 	exec( inexec ) {
 	    start();
 	}


 };

 //
 // Bug here, this should go ahead and shut down all sessions
 // for application.  An exercise left to the reader.

 CCExec::~CCExec()
 {
 	// MUST delete my_Chatter first or it may end up using
 	// a deleted service.
 	if ( my_Chatter ) delete my_Chatter;

 	// Delete whatever is left.
 	delete service;
 }

 //
 // Run App would normally read some config file or take some
 // parameters about which port to connect to and then
 // do that !
 int CCExec::RunApp( char * hn )
 {
 	// which port ?

 	InetHostAddress machine( hn );

 	if ( machine.isInetAddress() == false ) {
 	cerr << "machine is not address" << endl;
 	}

 	cerr << "machine is " << machine.getHostname() << endl;

 	// Start accepting connections - this will bind to the
 	// port as well.
 	try {
 	my_Chatter = new ChatterThread(
 	    machine,
 	    3999,
 	    this
 	);
 	}
 	catch ( ... ) {
 	cerr << "Failed to bind\n";
 	return false;
 	}

 	return true;
 }

 // When there is no one else connected - terminate !
 void CCExec::ListDepleted()
 {
 	mainsem->post();
 }


 int main( int argc, char ** argv )
 {
 	CCExec	* server;

 	server = new CCExec();

 	// take the first command line option as a hostname
 	// to listen to.
 	if ( argc > 1 ) {
 		server->RunApp( argv[ 1 ] );
 	} else {
 		server->RunApp();
 	}

 	server->mainsem->wait();

 	delete server;

 	return 0;
 }
	//
	// tcpservice.cpp
	//
	// Copyright 2000 - Gianni Mariani <gianni@mariani.ws>
	//
	// An example of a simple chatty server using CommonC++.
	//
	// This simple application basically operates as a
	// very simple chat system. From a telnet session
	// on localhost:3999 , any messages typed from a telnet
	// client are written to all participating sessions.
	//
	// This is free software licensed under the terms of the GNU
	// Public License
	//
	// This example:
	//
	// This demostrates a simple threaded server, actually,
	// the sessions are not all threaded though they could be
	// if that's what you wanted. Basically it demonstrates the
	// use of SocketService, SocketPorts and Threads.
	//
	// For those familiar with Unix network programming, SocketService
	// basically encapsulates all the work to communicate with
	// the select() or poll() system calls. SocketPorts are
	// basically encapsulations of sessions or open file descriptors.
	//
	// Anyhow, this example is a very simple echo server but
	// it echos to all connected clients. So it's a poor man's
	// IRC ! You connect via telnet to localhost port 3999 and
	// it will echo to all other connected clients what you type in !
	//

	#include <cc++/socketport.h>

	#include <iostream>

	// For starters, we need a thread safe list, we'll make one
	// out of the STL list<> template -
	// http://www.sgi.com/Technology/STL/index.html
	//
	// Thread safe list class
	//
	#include <list>

	#ifdef CCXX_NAMESPACES
	using namespace std;
	using namespace ost;
	#endif

	class ts_list_item;
	typedef list<ts_list_item *> ts_list;

	// a list head - containing a list and a Mutex.
	// It would be really nice to teach stl to do this.

	class ts_list_head {
	public:

	// No point inheriting, I'd have to implement
	// alot of code. We'll hold off on that exercise.

	// Using the CommonC++ Mutex class.
	Mutex linkmutex;
	// And the STL template.
	ts_list list_o_items;

	// Not nessasary, but nice to be explicit.
	ts_list_head()
	: linkmutex(), list_o_items() {
	}

	// This thing knows how to remove and insert items.
	void RemoveListItem( ts_list_item * li );
	void InsertListItem( ts_list_item * li );

	// And it knows how to notify that it became empty
	// or an element was deleted and it was the last one.
	virtual void ListDepleted() {
	}

	virtual ~ts_list_head() {
	}
	};


	// This item knows how to remove itself from the
	// list it belongs to.
	class ts_list_item {
	public:
	ts_list::iterator linkpoint;
	ts_list_head * listhead;

	virtual ~ts_list_item() {
	listhead->RemoveListItem( this );
	}

	ts_list_item( ts_list_head * head ) {
	listhead = head;
	head->InsertListItem( this );
	}
	};

	void ts_list_head::RemoveListItem( ts_list_item * li )
	{
	bool is_empty;
	linkmutex.enterMutex();
	list_o_items.erase( li->linkpoint );
	is_empty = list_o_items.empty();
	linkmutex.leaveMutex();

	// There is a slim possibility that at this time
	// we recieve a connection.
	if ( is_empty ) {
	ListDepleted();
	}
	}

	void ts_list_head::InsertListItem( ts_list_item * li )
	{
	linkmutex.enterMutex();
	list_o_items.push_front( li );
	li->linkpoint = list_o_items.begin();
	linkmutex.leaveMutex();
	}

	// ChatterSession operates on the individual connections
	// from clients as are managed by the SocketService
	// contained in CCExec. ChatterThread simply waits in
	// a loop to create these, listening forever.
	//
	// Even though the SocketService contains a list of
	// clients it serves, it may actually serve more than
	// one type of session so we create our own list by
	// inheriting the ts_list_item.
	//

	class ChatterSession :
	public virtual SocketPort,
	public virtual ts_list_item {
	public:

	enum { size_o_buf = 2048 };

	// Nothing special to do here, it's all handled
	// by SocketPort and ts_list_item

	virtual ~ChatterSession() {
	cerr << "ChatterSession deleted !\n";
	}

	// When you create a ChatterSession it waits to accept a
	// connection. This is done by it's own
	ChatterSession(
	TCPSocket & server,
	SocketService * svc,
	ts_list_head * head
	) :
	SocketPort( NULL, server ),
	ts_list_item( head ) {
	cerr << "ChatterSession Created\n";

	tpport_t port;
	InetHostAddress ia = getPeer( & port );

	cerr << "connecting from " << ia.getHostname() <<
	":" << port << endl;

	// Set up non-blocking reads
	setCompletion( false );

	// Set yerself to time out in 10 seconds
	setTimer( 100000 );
	attach(svc);
	}

	//
	// This is called by the SocketService thread when it the
	// object has expired.
	//

	virtual void expired() {
	// Get outa here - this guy is a LOOSER - type or terminate
	cerr << "ChatterSession Expired\n";
	delete this;
	}

	//
	// This is called by the SocketService thread when it detects
	// that there is somthing to read on this connection.
	//

	virtual void pending() {
	// Implement the echo

	cerr << "Pending called\n";

	// reset the timer
	setTimer( 100000 );
	try {
	int len;
	unsigned int total = 0;
	char buf[ size_o_buf ];

	while ( (len = receive(buf, sizeof(buf) )) > 0 ) {
	total += len;
	cerr << "Read '";
	cerr.write( buf, len );
	cerr << "'\n";

	// Send it to all the sessions.
	// We probably don't really want to lock the
	// entire list for the entire time.
	// The best way to do this would be to place the
	// message somewhere and use the service function.
	// But what are examples for ?

	bool sent = false;
	listhead->linkmutex.enterMutex();
	for (
	ts_list::iterator iter = listhead->list_o_items.begin();
	iter != listhead->list_o_items.end();
	iter ++
	) {
	ChatterSession * sess =
	dynamic_cast< ChatterSession * >( * iter );
	if ( sess != this ) {
	sess->send( buf, len );
	sent = true;
	}
	}
	listhead->linkmutex.leaveMutex();

	if ( ! sent ) {
	send(
	( void * ) "No one else listening\n",
	sizeof( "No one else listening\n" ) - 1
	);

	send( buf, len );
	}
	}
	if (total == 0) {
	cerr << "Broken connection!\n" << endl;
	delete this;
	}
	}
	catch ( ... ) {
	// somthing wrong happened here !
	cerr << "Socket port write sent an exception !\n";
	}

	}

	virtual void disconnect() {
	// Called by the SocketService thread when the client
	// hangs up.
	cerr << "ChatterSession disconnected!\n";

	delete this;
	}

	};

	class ChatterThread;

	//
	// This is the main application object containing all the
	// state for the application. It uses a SocketService object
	// (and thread) to do all the work, however, that object could
	// theoretically be use by more than one main application.
	//
	// It creates a ChatterThread to sit and wait for connections
	// from clients.

	class CCExec : public virtual ts_list_head {
	public:

	SocketService * service;
	ChatterThread * my_Chatter;
	Semaphore mainsem[1];

	CCExec():my_Chatter(NULL) {
	service = new SocketService( 0 );
	}

	virtual void ListDepleted();

	// These methods defined later.
	virtual ~CCExec();
	int RunApp( char * hn = (char *)"localhost" );

	};

	//
	// ChatterThread simply creates ChatterSession all the time until
	// it has an error. I suspect you could create as many of these
	// as the OS could take.
	//

	class ChatterThread : public virtual TCPSocket, public virtual Thread {
	public:

	CCExec * exec;

	void run () {
	while ( 1 ) {
	try {
	// new does all the work to accept a new connection
	// attach itself to the SocketService AND include
	// itself in the CCExec list of sessions.
	new ChatterSession(
	* ( TCPSocket * ) this,
	exec->service,
	exec
	);
	}
	catch ( ... ) {
	// Bummer - there was an error.
	cerr << "ChatterSession create failed\n";
	exit();
	}
	}
	}

	ChatterThread(
	InetHostAddress & machine,
	int port,
	CCExec * inexec

	) : TCPSocket( machine, port ),
	Thread(),
	exec( inexec ) {
	start();
	}


	};

	//
	// Bug here, this should go ahead and shut down all sessions
	// for application. An exercise left to the reader.

	CCExec::~CCExec()
	{
	// MUST delete my_Chatter first or it may end up using
	// a deleted service.
	if ( my_Chatter ) delete my_Chatter;

	// Delete whatever is left.
	delete service;
	}

	//
	// Run App would normally read some config file or take some
	// parameters about which port to connect to and then
	// do that !
	int CCExec::RunApp( char * hn )
	{
	// which port ?

	InetHostAddress machine( hn );

	if ( machine.isInetAddress() == false ) {
	cerr << "machine is not address" << endl;
	}

	cerr << "machine is " << machine.getHostname() << endl;

	// Start accepting connections - this will bind to the
	// port as well.
	try {
	my_Chatter = new ChatterThread(
	machine,
	3999,
	this
	);
	}
	catch ( ... ) {
	cerr << "Failed to bind\n";
	return false;
	}

	return true;
	}

	// When there is no one else connected - terminate !
	void CCExec::ListDepleted()
	{
	mainsem->post();
	}


	int main( int argc, char ** argv )
	{
	CCExec * server;

	server = new CCExec();

	// take the first command line option as a hostname
	// to listen to.
	if ( argc > 1 ) {
	server->RunApp( argv[ 1 ] );
	} else {
	server->RunApp();
	}

	server->mainsem->wait();

	delete server;

	return 0;
	}