* finally, first socket test work

diff --git a/AudioManagerDaemon/test/sockethandler/sockethandlerTest.cpp b/AudioManagerDaemon/test/sockethandler/sockethandlerTest.cpp
index bb72324..69af391 100644 (file)
--- 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 (file)
--- 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;
 };