Re: Passing a GUI handle to a socket and Postmessage back to GUI

First I have a question, does your program only accept one connection?
Because if the socket object that you are using in your OnAccept is declared
somewhere it will lose its connection once you call accept with it again
(actually I don't know if it will lose its connection, or a runtime error or
an assert will popup).

When I do this I take a different approach.

In a nutshell, I pass a pointer to a class that will handle new connections
to my listen socket. When the OnAccept gets called, I accept the socket and
then call the handler method of the class that was passed in. There it can
create whatever type socket class it needs (passing whatever it needs to it)
and attach the handle to it.

here is an example
I have an abstract class that handler new connections and for data received
notifications, but it can be broken apart into two different classes.
With this design you can have multiple listen sockets on different ports all
reporting to the same handler method, which creates different type sockets
for the different ports. (in my case teachers vs students)

class CMsgReceiver
{
public:
   CMsgReceiver(void);
   virtual ~CMsgReceiver(void);

   virtual void ProcessMsg(LSMessage *,SOCKET hSocket) = NULL;
   virtual void SocketClosed(SOCKET hSocket) = NULL;
   virtual void NewUser(UINT Port,SOCKET hSocker) { ASSERT(FALSE); }
}

now my listen socket takes a pointer to a class that is derived from
LSMsgReceiver.
// CListenSocket member functions
BOOL CListenSocket::Listen(UINT Port, CMsgReceiver *Parent,DWORD &Error)
{
   m_Parent = Parent;
   m_Port = Port;
   if (CSocket::Create(Port))
   {
      if (CSocket::Listen())
      {
         return TRUE;
      }
   }

   Error = MAKELONG(1,GetLastError());
   return FALSE;
}

//when I accept the connection I accept it with a CAcyncSocket class, but
then detach it and pass the handle to the CMsgReceiver class
void CListenSocket::OnAccept(int nErrorCode)
{
   if (m_Parent)
   {
      CAsyncSocket Socket;
      if (Accept(Socket))
      {
         SOCKET hSocket = Socket.Detach();
         m_Parent->NewUser(m_Port,hSocket);
      }
   }

   CSocket::OnAccept(nErrorCode);
}

And example of the NewUser method can look like this
void CMainThread::NewUser(UINT Port,SOCKET hSocket)
{
   if (Port == STUD_DIR_PORT)
   {
      NewStudent(hSocket);
   }
   else if (Port == TEACH_DIR_PORT)
   {
      NewTeacher(hSocket);
   }
   else
   {
      ASSERT(FALSE);
   }
}

//here CStudent and CTeacher are both derived from CMsgReceiver, and contain
a CAsyncSocket derived object, which they attach the hSocket to. This way
when the socket object is created CStudent will pass itself to the socket as
the message handler class, and CTeacher will do the same. In the
CAsyncSocket derived class, I store a CMsgReceiver class pointer which is
the handler, and in the OnReceive of the socket class I call
CMsgReceiver::ProcessMsg.

void CMainThread::NewStudent(SOCKET hSocket)
{
   CStudent *pStud = new CStudent(hSocket,this);

   m_Studs.SetAt(pStud,pStud);
}

void CMainThread::NewTeacher(SOCKET hSocket)
{
   CTeacher *pTeacher= new CTeacher(hSocket,this);

   m_Teachers.SetAt(pTeacher,pTeacher);
}

AliR.

"KW" <KW@there.com> wrote in message
news:OZcqxPmoJHA.1252@TK2MSFTNGP03.phx.gbl...