Question

i have implemented my ClientSocket class from CAsyncSocket:

class ClientSocket : public CAsyncSocket
{
    // this socket sends data back to "backSocket" which points to this only for 
    // testing but it can send data to other sockets like that too.
ClientSocket * backSocket;

    // store some data in backupData untill connection is established.
    StringBuilder * backupData;

public:

virtual void OnClose(int);
virtual void OnReceive(int);
ClientSocket(void);
bool ConnectToBACK();
virtual ~ClientSocket(void);
};

ClientSocket::ClientSocket(void)
{
// DONOT run to back !!! recursive calls otherwise.
backSocket = NULL;
backupData = NULL;
}

bool ClientSocket::ConnectToBACK()
{
if(this->backSocket != NULL)
    return true;

// just for debugging :)
this->backSocket = this;
return true;
}

ClientSocket::~ClientSocket(void)
{
this->Close();
if(this->backSocket)
{
    this->backSocket->Close();
    delete this->backSocket;
    this->backSocket = NULL;
}
}

void ClientSocket::OnClose(int nErrorCode)
{
if(this->backSocket != NULL)
{
    this->backSocket->Close();
}

CAsyncSocket::OnClose(nErrorCode);
}

void ClientSocket::OnReceive(int nErrorCode)
{
if(nErrorCode == 0)
{
    char *buffer = new char[2049];
    int bufLen = sizeof(buffer)/sizeof(buffer[0]);

    int received = this->Receive(buffer, bufLen-1, 0);
    if(received == SOCKET_ERROR)
    {
        return ;
    }

    if(this->ConnectToback())
    {
        if(backupData)
        {
            int backupLen;
            char *backup = backupData->ToString(&backupLen);
            this->backSocket->Send(backup, backupLen);
            delete backupData;
            delete [] backup;
            backupData = NULL;
        }

        this->backSocket->Send(buffer, received);
        delete buffer;
    }
    else
    {
        if(backupData == NULL)
        {
            backupData = new StringBuilder();
        }
        backupData->Insert(buffer, received);
    }
}

CAsyncSocket::OnReceive(nErrorCode);
 }

I have not associated any GUI to this as i thought that it would be good for no overheads.
I donot require it. I have also done AfxSocketIback() in main and from a thread started another ListeningSocket .

netstat -a shows proper binding at the port of ListeningSocket and status as Listening

// ListeningSocket inherits public CAsyncSocket

 void ListeningSocket::OnAccept(int nErrorCode)
 {
 #ifdef DEBUG
std::cout << "\nOnAccepting Proxy Server :)";
 #endif
if(nErrorCode == 0)
{
    ClientSocket *FromCliet = new ClientSocket();
    FromCliet->value = 100;
    if(this->Accept(*FromCliet, NULL, NULL))
    {
                    // Connection just has ClientSocket * client
        Connection * connection = new Connection(FromCliet);
        // a list<Connection *> is stored in ListeningSocket
                    this->clients.push_front(connection);
    }
    else
    {
        std::cerr << "\nFailed to accept connection from Client";
    }
}

CAsyncSocket::OnAccept(nErrorCode);
 }

When putting brakepoints in ListenSocket::OnAccept, it never comes here.

EDIT:

 static DWORD WINAPI StartListening(LPVOID param)
 {
       ListeningSocket *app = (ListeningSocket *)param;
   if(false == app->Create(7897, SOCK_STREAM, 31, "127.0.0.1"))
   {
     std::cerr << "\nCould not create\bind to port";
     delete app;
     return -1;
   }
   if(false == app->Listen())
   {
          std::cerr << "\nCould not listen";
      app->Close();
      delete app;
      return -1;
   }
   return 0;
 }

 int ListeningSocket::Start()
 {
      if(NULL == CreateThread(NULL,0, StartListening, (LPVOID)this,0, NULL))
   {
    return -1;
   }

  return 0;
 }

I have NOT made it like MFC Wizard solution. I have simple project and main().

 My ListeningSocket Class is Singletone Class:  
 class ListeningSocket : public CAsyncSocket
 {

    private:
static ListeningSocket * ListeningSocket;
std::list<Connection *> clients;
ListeningSocket(void);

    public:
// overrides
virtual void OnAccept(int);
virtual void OnClose(int);
static ListeningSocket * GetListeningSocket();
virtual ~ListeningSocket(void);
virtual void Close();
int Start(void);
    };

Answer 1

CAsyncSocket class internally uses Windows messages for firing events. You need to create CAsyncSocket-derived class in a thread with message loop. In this case events will be called. Pseudo-code:

// This function runs in the context of worker thread
void MyClass::ThreadFunction()
{
    mySocket.Create(...);    // creating CAsyncSocket-derived class

    // Run message loop.
    BOOL bRes = FALSE;
    MSG msg;

    while((bRes = GetMessage( &msg, NULL, 0, 0 )) != 0)
    { 
        if (bRes == -1)
        {
            break;
        }
        else
        {
            TranslateMessage(&msg); 
            DispatchMessage(&msg); 
        }
    }
}

To stop this thread, use PostQuitMessage function.

Edit.
I didn’t post all multi-threading details, assuming that you are familiar with them. Generally, CreateThread requires global function as parameter (or class static function). To call regular class method, use “this” as CreateThread parameter, which is passed as void* to global thread function. Cast it back to the class pointer and call regular class method.