// ------------------------------- Poll -----------------------------------
//
void CDDKSrvSocket::Poll(CHAR * debugStr)
{
CHAR *      msgPtr = m_buffer; //rxMessage;
CHAR *      debugStrPtr = debugStr;
BOOL        incommingMsgOK = FALSE;
BOOL        outgoingMsgOK = FALSE;
// Socket "notification" setup variables
u_int       retCode; 
int         errorCode;
BOOL        exitFlag;
sockaddr    acceptedAsyncSocketAddr, ackSocketAddr;
int         addrlength;
unsigned long  numBytes=0;
CString        debuggerString;
LONG           numIdleLoops = MAX_IDLE_LOOPS;

   m_debuggerStep = 0;
   accepted = FALSE;
   exitFlag = false;
   *debugStr = NULL;//zero string

   if (SOCKET_EX_TERMINATE == m_listenThreadStatus) //termination routine 
   {
      sprintf(debugStr, "EX_TERMINATE recieved, terminating!");
      OutputDebugString(debugStr);
      exitFlag = true;
   }
   AcceptedAsyncSocket = INVALID_SOCKET;

   // We want to read the asynchronous data responses
   // ..........Thread Control Loop
   while ( (SOCKET_EX_RUNNING == m_listenThreadStatus) 
            && (false == exitFlag)
         )
   {
      exitFlag = false;
      m_debuggerStep = 1;

      if (SOCKET_EX_TERMINATE == m_listenThreadStatus) //termination routine 
      {
         exitFlag = true;
         break;
      }

      if (!accepted)
      {
         m_debuggerStep = 2;
         numIdleLoops = MAX_IDLE_LOOPS;
         SockStateChanged(SOCKETCURRENTLY_LISTENING);
         debuggerString.Format("%4d Listen for connection...\n", GetCurrentThreadId());
         OutputDebugString(debuggerString);
         // Send to debugger list-box
         SockDataMessage(debuggerString);

         errorCode = listen(*m_pSocket, SOMAXCONN); //listen with backlog maximum reasonable
      
         if (SOCKET_ERROR == errorCode)
         {
            sprintf(debugStr, "Listen returned with a socket error : %s\n", sys_wsaerrlist[wsaerrno]);
            OutputDebugString(debugStr);
            exitFlag = true;
         }
         //now listening - no error !!!!

         addrlength = sizeof(acceptedAsyncSocketAddr);//for now
         WSASetLastError(0);
         if (AcceptedAsyncSocket == INVALID_SOCKET)
            accepted = FALSE;

         //------------------------- Listen Control Loop -------------------//
         do  
         {
            m_debuggerStep = 3;
             //Beep(3000,50);
            debuggerString.Format("%4d Accept connection...\n", GetCurrentThreadId());
            OutputDebugString(debuggerString);
            AcceptedAsyncSocket = accept(*m_pSocket,  //listen away returns immediatly
                                          &acceptedAsyncSocketAddr,
                                          &addrlength
                                         );
            if (INVALID_SOCKET !=AcceptedAsyncSocket)
            {
               m_debuggerStep = 4;
               debuggerString.Format("%4d Connection accepted.\n", GetCurrentThreadId());
               OutputDebugString(debuggerString);
               SockDataMessage(debuggerString);
                // copy the IP address
               memcpy(&ackSocketAddr, &acceptedAsyncSocketAddr, sizeof(acceptedAsyncSocketAddr));
               int test = h_errno;
               if ( (INVALID_SOCKET == AcceptedAsyncSocket) //check for fails
                      && (h_errno != WSAEWOULDBLOCK) //no connection avail to be accepted
                   ) 
               {
                   m_debuggerStep = 5;
                   sprintf(debugStr, "Listen Accept returned with a socket error : %s\n",sys_wsaerrlist[wsaerrno]);
                   OutputDebugString(debugStr);                    
                   exitFlag = true;
                   continue;   //skip the rest of this loopy
               }
               accepted = TRUE;   
            }
            else
            {
            LONG temp;
               
               // get the error.
               m_debuggerStep = 6;
               temp = wsaerrno;
               (temp >= 0) ? (sprintf(debugStrPtr, "Accept() Error on Listen socket : %s\n",sys_wsaerrlist[temp]))
                              : (sprintf(debugStrPtr, "Unknown Accept() error on Listen socket\n"));
               OutputDebugString(debugStrPtr);
               SockDataMessage(debugStrPtr);
               WSASetLastError(0);
            }
         }//Listen
         while ( (SOCKET_EX_RUNNING == m_listenThreadStatus) 
                  && (false == exitFlag)
                  && (AcceptedAsyncSocket == INVALID_SOCKET)
                  && (h_errno == WSAEWOULDBLOCK)
               );
      }
      if (INVALID_SOCKET !=AcceptedAsyncSocket)
      {
         m_debuggerStep = 7;
         debuggerString.Format("%4d Currently connected.\n", GetCurrentThreadId());
         OutputDebugString(debuggerString);
         //Beep(1000,100);
         DWORD initialTicks = GetTickCount();
         do
         {
            m_debuggerStep = 8;
            retCode = ioctlsocket(AcceptedAsyncSocket, FIONREAD, &numBytes);
            if (0==numBytes)
               Sleep(1);
            else
               SockStateChanged(SOCKETCURRENTLY_READING);

            if ((GetTickCount() - initialTicks) > 10000)
            {
               break;   // time out
            }
            if (SOCKET_EX_TERMINATE == m_listenThreadStatus) //termination routine 
            {
               exitFlag = true;
               break;
            }
         }
         while (0 == numBytes); //delay until an actual data bearing packet is brought in
                                //remembering only 1 packet per transaction allways

         if ( (SOCKET_ERROR != retCode)
               && (0 != numBytes)
            )
         { //Yup got a message
            m_debuggerStep = 9;
            numIdleLoops = MAX_IDLE_LOOPS;
            debuggerString.Format("%4d Server socket thread reading.\n", GetCurrentThreadId());
            OutputDebugString(debuggerString);
            incommingMsgOK = (Recieve(AcceptedAsyncSocket, numBytes, msgPtr, debugStrPtr)==(LONG)numBytes);
            m_debuggerStep = 10;
            if (SOCKET_EX_RUNNING != m_listenThreadStatus) //termination routine 
            {
               //exitFlag = true;
               break;
            }

            // process this message as valid data from a PLC
            if (incommingMsgOK)
            {
            DWORD bufSize;

               m_debuggerStep = 11;
               bufSize = numBytes; //ok so all bytes were read
               msgPtr[bufSize] = '\0'; // append a null for neatness
               m_debuggerStep = 12;
               if (FALSE == ProcessData(AcceptedAsyncSocket, msgPtr, bufSize))
               {
                  m_debuggerStep = 13;
                  
                  // close the server socket
                  closesocket(AcceptedAsyncSocket); //kill accepted instance immediatly
                  accepted = FALSE;
                  OutputDebugString("Closing socket normally.\n");
                  SockStateChanged(SOCKETCURRENTLY_CLOSING);
                  SockDataMessage(debuggerString);
                  // 13 Rembrandt st Petervale
               }
               m_debuggerStep = 14;
            }
         }
         else
         { //We may have a problem please be a patient
            if (SOCKET_ERROR == retCode)
            {
               sprintf(debugStr, "Listen Poll Failed on rx, BytesRx'd : %d\n",numBytes);
               OutputDebugString(debugStr);
               // close this PLC connection so that new data still comes in
               closesocket(AcceptedAsyncSocket); //kill accepted instance immediatly
               accepted = FALSE;
               OutputDebugString("Closing socket after error.\n");
               SockStateChanged(SOCKETCURRENTLY_CLOSING);
            }
            else
            {  // no problem at all, socket was just idle.
               numIdleLoops--;
               if (numIdleLoops > 0)
               {
                  debuggerString.Format("%4d Listen Poll idle.\n", GetCurrentThreadId());
                  OutputDebugString(debuggerString);
                  SockStateChanged(SOCKETCURRENTLY_IDLE);
               }
               else
               {
                  debuggerString.Format("%4d Closing socket idle for too long.\n", GetCurrentThreadId());
                  OutputDebugString(debuggerString);
                  SockDataMessage(debuggerString);

                  closesocket(AcceptedAsyncSocket); //kill accepted instance immediatly
                  accepted = FALSE;
                  SockStateChanged(SOCKETCURRENTLY_CLOSING);
               }
            }
         }
      }
   } //Thread
       
   //This is where we go to Terminate the Thread.

   m_listenThreadStatus = SOCKET_EX_TERMINATED;
} // Poll