* finally, first socket test work

2 files changed, 180 insertions, 128 deletions

diff --git a/AudioManagerDaemon/test/sockethandler/sockethandlerTest.cpp b/AudioManagerDaemon/test/sockethandler/sockethandlerTest.cpp
index bb72324..69af391 100644
--- a/AudioManagerDaemon/test/sockethandler/sockethandlerTest.cpp
+++ b/AudioManagerDaemon/test/sockethandler/sockethandlerTest.cpp
@@ -12,7 +12,10 @@
 #include <sys/ioctl.h>
 #include <string.h>
 #include <netdb.h>
+#include <fcntl.h>
+#include <sys/un.h>
 
+#define SOCK_PATH "/tmp/mysock"
 
 using namespace testing;
 using namespace am;
@@ -25,56 +28,6 @@ sockethandlerTest::~sockethandlerTest()
 {
 }
 
-void fdCallBack::connectSocket(int fd, const int16_t  events,void * userData)
-{
-	std::cout<<"Socket connection received and open"<<std::endl;
-
-	//accept the connection
-	mSocketConnection = accept(fd, NULL, NULL);
-	int16_t event = 0;
-	event |=POLLIN;
-
-	shPollCallBack* buf=&pSocketDataCallback;
-	//add new socketConnection to the handler
-	mSocketHandler->addFDPoll(mSocketConnection,event,buf,NULL);
-}
-
-
-
-
-fdCallBack::fdCallBack(SocketHandler *SocketHandler)
-:mSocketConnection(0),
- mSocketHandler(SocketHandler),
- pSocketDataCallback(this, &fdCallBack::handleSocketData),
- pSocketConnectionCallback(this, &fdCallBack::connectSocket)
-{
-}
-
-
-
-void am::fdCallBack::handleSocketData(int fd, const int16_t  events, void* userdata)
-{
-	char buffer[3000];
-	std::string msg;
-
-	//there is something for us, read it
-	int read=recv(mSocketConnection,buffer,sizeof(buffer),NULL);
-	msg=std::string(buffer,read);
-	if (msg.compare("stopit")==0)
-	{
-		mSocketHandler->stop_listening();
-	}
-	else if (msg.compare("answer")==0)
-	{
-		std::string answer="myAnswer";
-		send(mSocketConnection,answer.c_str(),answer.size(),NULL);
-	}
-}
-
-fdCallBack::~fdCallBack()
-{
-}
-
 am::timerCallBack::timerCallBack(SocketHandler *myHandler)
  :pTimer1Callback(this, &timerCallBack::timer1Callback),
   pTimer2Callback(this, &timerCallBack::timer2Callback),
@@ -93,71 +46,46 @@ am::timerCallBack::~timerCallBack()
 
 
 
-void am::timerCallBack::timer1Callback(SocketHandler::sh_timerHandle_t handle, void* userData)
+void am::timerCallBack::timer1Callback(sh_timerHandle_t handle, void* userData)
 {
 	std::cout<<"callback1 called"<<std::endl;
 	timespec timeout;
 	timeout.tv_nsec=0;
 	timeout.tv_sec=1;
-	TBasicTimerCallback *buf=&pTimer1Callback;
-	SocketHandler::sh_timerHandle_t handle_;
+	shTimerCallBack *buf=&pTimer1Callback;
+	sh_timerHandle_t handle_;
 	mSocketHandler->addTimer(timeout,buf,handle_,NULL);
 }
 
 
 
-void am::timerCallBack::timer2Callback(SocketHandler::sh_timerHandle_t handle, void* userData)
+void am::timerCallBack::timer2Callback(sh_timerHandle_t handle, void* userData)
 {
 	std::cout<<"callback2 called"<<std::endl;
 	timespec timeout;
 	timeout.tv_nsec=0;
 	timeout.tv_sec=1;
-	TBasicTimerCallback *buf=&pTimer2Callback;
-	SocketHandler::sh_timerHandle_t handle_;
+	shTimerCallBack *buf=&pTimer2Callback;
+	sh_timerHandle_t handle_;
 	mSocketHandler->addTimer(timeout,buf,handle_,NULL);
 }
 
-void am::timerCallBack::timer3Callback(SocketHandler::sh_timerHandle_t handle, void* userData)
+void am::timerCallBack::timer3Callback(sh_timerHandle_t, void* userData)
 {
 	std::cout<<"callback3 called"<<std::endl;
 }
 
-void am::timerCallBack::timer4Callback(SocketHandler::sh_timerHandle_t handle, void* userData)
+void am::timerCallBack::timer4Callback(sh_timerHandle_t, void* userData)
 {
 	std::cout<<"callback4 called"<<std::endl;
+	mSocketHandler->stop_listening();
 }
 
 void* playWithSocketServer(void* data)
 {
-	int yes = 1;
-
-	//get a SocketHandler
 	SocketHandler myHandler;
-
-	//get a class that handles the callbacks from the handler
-	fdCallBack testCallback(&myHandler);
-
-	//prepare the socket, bind etc...
-	struct sockaddr_in servAddr;
-	int socketHandle = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
-	setsockopt(socketHandle, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int));
-	servAddr.sin_family      = AF_INET;
-	servAddr.sin_addr.s_addr = htonl(INADDR_ANY);
-	servAddr.sin_port = htons(6060);
-	bind(socketHandle, (struct sockaddr*)(&servAddr), sizeof (servAddr));
-	listen(socketHandle, 3);
-
-	//prepare the event (we want POLLIN because we need to listen)
-	int16_t event = 0;
-	event |=POLLIN;
-
-	shPollCallBack* buf=&testCallback.pSocketConnectionCallback;
-	//add the callback to the Sockethandler
-	myHandler.addFDPoll(socketHandle, event, buf, NULL);
-
-	//start the mainloop
+	SamplePlugin myplugin(&myHandler);
 	myHandler.start_listenting();
-	close(socketHandle);
 }
 
 
@@ -166,36 +94,45 @@ TEST(sockethandlerTest,playWithSockets)
 {
 	pthread_t serverThread;
 	char buffer[3000];
+	struct sockaddr_in servAddr;
+	unsigned short servPort = 6060;
+	struct hostent *host;
+	int socket_;
 
 	//creates a thread that handles the serverpart
 	pthread_create(&serverThread,NULL,playWithSocketServer,NULL);
 
-	sleep(1); //give a little time to settle everything
-	//make everything ready to send data
-	struct sockaddr_in servAddr;
-	int socketHandle = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
-	struct hostent *host;
-	host = (struct hostent*) gethostbyname("localhost");
+	sleep(1); //we need that here because the port needs to be opened
+    if ((socket_ = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
+    {
+    	std::cout<<"socket problem"<<std::endl;
+
+    }
 
-	memset(&servAddr, 0, sizeof(servAddr));
-	memcpy(&servAddr.sin_addr, host->h_addr_list[0], host->h_length);
-	servAddr.sin_family      = AF_INET;
-	servAddr.sin_port = htons(6060);
+    if ((host = (struct hostent*) gethostbyname("localhost")) == 0)
+    {
+    	std::cout<<"ERROR: gethostbyname() failed\n"<<std::endl;
 
-	//connect to the socket
-	int k =connect(socketHandle,(struct sockaddr *) &servAddr, sizeof(servAddr));
+    }
 
-	std::string msg="answer";
+    memset(&servAddr, 0, sizeof(servAddr));
+    servAddr.sin_family      = AF_INET;
+    servAddr.sin_addr.s_addr = inet_addr(inet_ntoa(*( struct in_addr*)( host -> h_addr_list[0])));
+    servAddr.sin_port        = htons(servPort);
 
-	//send first the answer message and wait for the reply
-	int p=send(socketHandle,msg.c_str(),msg.size(),NULL);
-	int read=recv(socketHandle,buffer,sizeof(buffer),NULL);
-	msg=std::string(buffer,read);
-	ASSERT_TRUE(msg.compare("myAnswer")==0);
+    if (connect(socket_, (struct sockaddr *) &servAddr, sizeof(servAddr)) < 0)
+    {
+     	std::cout<<"ERROR: connect() failed\n"<<std::endl;
+    }
+
+	for (int i=0;i<=1000;i++)
+	{
+		std::string string("Got It?");
+		send(socket_,string.c_str(),string.size(),0);
+	}
+	std::string string("finish!");
+	send(socket_,string.c_str(),string.size(),0);
 
-	msg="stopit";
-	//now send a message causing the handler to stop and end the loop
-	p=send(socketHandle,msg.c_str(),msg.size(),NULL);
 	pthread_join(serverThread,NULL);
 }
 
@@ -211,12 +148,12 @@ TEST(sockethandlerTest,playWithTimers)
 	timeout3.tv_nsec=000000000;
 	timeout3.tv_sec=2;
 	timeout4.tv_nsec=0;
-	timeout4.tv_sec=30;
-	TBasicTimerCallback* buf=&testCallback.pTimer1Callback;
-	TBasicTimerCallback* buf2=&testCallback.pTimer2Callback;
-	TBasicTimerCallback* buf3=&testCallback.pTimer3Callback;
-	TBasicTimerCallback* buf4=&testCallback.pTimer4Callback;
-	SocketHandler::sh_timerHandle_t handle;
+	timeout4.tv_sec=13;
+	shTimerCallBack* buf=&testCallback.pTimer1Callback;
+	shTimerCallBack* buf2=&testCallback.pTimer2Callback;
+	shTimerCallBack* buf3=&testCallback.pTimer3Callback;
+	shTimerCallBack* buf4=&testCallback.pTimer4Callback;
+	sh_timerHandle_t handle;
 	myHandler.addTimer(timeoutTime,buf,handle,NULL);
 	myHandler.addTimer(timeout2,buf2,handle,NULL);
 	myHandler.addTimer(timeout3,buf3,handle,NULL);
@@ -239,6 +176,114 @@ int main(int argc, char **argv)
 	return RUN_ALL_TESTS();
 }
 
+am::SamplePlugin::SamplePlugin(SocketHandler *mySocketHandler)
+	:connectFiredCB(this,&SamplePlugin::connectSocket),
+	 receiveFiredCB(this,&SamplePlugin::receiveData),
+	 sampleDispatchCB(this,&SamplePlugin::dispatchData),
+	 sampleCheckCB(this,&SamplePlugin::check),
+	 mSocketHandler(mySocketHandler),
+	 mConnecthandle(),
+	 mReceiveHandle(),
+	 msgList()
+{
+	int ret;
+	int yes = 1;
+
+	struct sockaddr_in servAddr;
+	unsigned int servPort = 6060;
+	int socketHandle = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
+    setsockopt(socketHandle, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int));
+    memset(&servAddr, 0, sizeof(servAddr));
+    servAddr.sin_family      = AF_INET;
+    servAddr.sin_addr.s_addr = INADDR_ANY;
+    servAddr.sin_port        = htons(servPort);
+
+    if (bind(socketHandle, (struct sockaddr *) &servAddr, sizeof(servAddr)) < 0)
+    {
+    	std::cout<<"bind ok"<<std::endl;
+    } /* if */
+
+    if (listen(socketHandle, 3) < 0)
+    {
+    	std::cout<<"listen ok"<<std::endl;
+    } /* if */
+
+    int a=1;
+    ioctl (socketHandle, FIONBIO, (char *) &a);
+    setsockopt (socketHandle, SOL_SOCKET, SO_KEEPALIVE, (char *) &a, sizeof (a));
+
+	short events=0;
+	events |= POLLIN;
+	mySocketHandler->addFDPoll(socketHandle,events,NULL,&connectFiredCB,NULL,NULL,NULL,mConnecthandle);
+	std::cout<<"setup server - listening"<<std::endl;
+}
+
+
+
+void am::SamplePlugin::connectSocket(const pollfd pollfd1, const sh_pollHandle_t handle, void *userData)
+{
+	//first, accept the connection, create a new filedescriptor
+	std::cout<<"Got a connection request !"<<std::endl;
+	struct sockaddr answer;
+	socklen_t len=sizeof(answer);
+	int receiveFD = accept(pollfd1.fd, (struct sockaddr*)&answer, &len);
+
+	//set the correct event:
+	short event = 0;
+	event |=POLLIN;
+
+	//aded the filedescriptor to the sockethandler and register the callbacks for receiving the data
+	mSocketHandler->addFDPoll(receiveFD,event,NULL,&receiveFiredCB,&sampleCheckCB,&sampleDispatchCB,NULL,mReceiveHandle);
+
+}
+
+
+
+void am::SamplePlugin::receiveData(const pollfd pollfd, const sh_pollHandle_t handle, void *userData)
+{
+	//initialize buffer
+	char buffer[10];
+	//read until buffer is full or no more data is there
+	int read=recv(pollfd.fd,buffer,7,NULL);
+	if (read>1)
+	{
+		//read the message and store it in a queue
+		std::string msg=std::string(buffer,read);
+		msgList.push(msg);
+		std::cout<<"Got a message !"<<std::endl;
+	}
+}
+
+
+
+bool am::SamplePlugin::dispatchData(const sh_pollHandle_t handle, void *userData)
+{
+	//read data from the queue
+	std::cout<<"Data:"<<msgList.front()<<std::endl;
+
+	//if the message was our finish message, we quit the poll loop
+	if (msgList.front().compare("finish!")==0)
+	{
+		mSocketHandler->stop_listening();
+	}
+	//remove the message from the queue and return false if there is no more message to read.
+	msgList.pop();
+	if (msgList.size()!=0) return true;
+	return false;
+}
+
+bool am::SamplePlugin::check(const sh_pollHandle_t handle, void *userData)
+{
+	//checks if there is data to dispatch
+	std::cout<<"check!:"<<std::endl;
+	if (msgList.size()!=0) return true;
+	return false;
+}
+
+
+
+
+
 
 
 
diff --git a/AudioManagerDaemon/test/sockethandler/sockethandlerTest.h b/AudioManagerDaemon/test/sockethandler/sockethandlerTest.h
index 85e2dca..d58c46f 100644
--- a/AudioManagerDaemon/test/sockethandler/sockethandlerTest.h
+++ b/AudioManagerDaemon/test/sockethandler/sockethandlerTest.h
@@ -9,37 +9,44 @@
 #define SOCKETHANDLERTEST_H_
 
 #include <gtest/gtest.h>
+#include <queue>
 #include "SocketHandler.h"
 
 namespace am {
 
-class fdCallBack
+class SamplePlugin
 {
 public:
-	fdCallBack(SocketHandler *SocketHandler);
-	virtual ~fdCallBack();
-	void connectSocket(int fd,const int16_t events,void * userData);
-	void handleSocketData(int fd,const int16_t events,void * userData);
-	TSpecificPollCallback<fdCallBack> pSocketDataCallback;
-	TSpecificPollCallback<fdCallBack> pSocketConnectionCallback;
+	SamplePlugin(SocketHandler *mySocketHandler);
+	virtual ~SamplePlugin() {};
+	void connectSocket(const pollfd pollfd,const sh_pollHandle_t handle, void* userData);
+	void receiveData(const pollfd pollfd,const sh_pollHandle_t handle, void* userData);
+	bool dispatchData(const sh_pollHandle_t handle, void* userData);
+	bool check(const sh_pollHandle_t handle, void* userData);
+	shPollFired_T<SamplePlugin> connectFiredCB;
+	shPollFired_T<SamplePlugin> receiveFiredCB;
+	shPollDispatch_T<SamplePlugin> sampleDispatchCB;
+	shPollCheck_T<SamplePlugin> sampleCheckCB;
 private:
-	int mSocketConnection;
 	SocketHandler *mSocketHandler;
+	sh_pollHandle_t mConnecthandle,mReceiveHandle;
+	std::queue<std::string> msgList;
 };
 
+
 class timerCallBack
 {
 public:
 	timerCallBack(SocketHandler *SocketHandler);
 	virtual ~timerCallBack();
-	void timer1Callback(SocketHandler::sh_timerHandle_t handle,void * userData);
-	void timer2Callback(SocketHandler::sh_timerHandle_t handle,void * userData);
-	void timer3Callback(SocketHandler::sh_timerHandle_t handle,void * userData);
-	void timer4Callback(SocketHandler::sh_timerHandle_t handle,void * userData);
-	TSpecificTimerCallback<timerCallBack> pTimer1Callback;
-	TSpecificTimerCallback<timerCallBack> pTimer2Callback;
-	TSpecificTimerCallback<timerCallBack> pTimer3Callback;
-	TSpecificTimerCallback<timerCallBack> pTimer4Callback;
+	void timer1Callback(sh_timerHandle_t handle,void * userData);
+	void timer2Callback(sh_timerHandle_t handle,void * userData);
+	void timer3Callback(sh_timerHandle_t handle,void * userData);
+	void timer4Callback(sh_timerHandle_t handle,void * userData);
+	shTimerCallBack_T<timerCallBack> pTimer1Callback;
+	shTimerCallBack_T<timerCallBack> pTimer2Callback;
+	shTimerCallBack_T<timerCallBack> pTimer3Callback;
+	shTimerCallBack_T<timerCallBack> pTimer4Callback;
 	SocketHandler *mSocketHandler;
 };