C / C++ / MFC

void StartServer()
{
    // run the acceptor thread and use WaitForSingleObject to wait for a suicide event
    // then set the flag for the acceptor to exit and wait for the acceptor to exit using WaitForSingleObject, then close the handle to the acceptor so its removed from memory
}

DWORD WINAPI Acceptor(void*)
{
    // loop for connections and spin them off in their own clientthread, at the same time check if the flag is set to make us exit (using select() we can check for incoming connection non-blocking)
    // If a connection is accepted store the handle of the client thread in a global vector
}

DWORD WINAPI Clientthread(void*)
{
    // Handle IO here and return when peer closes the connection or if any other error occurs
    // Cannot close handle to thread here, cause we're still in it
    // If we just return, the thread stays mapped in memory, so everytime someone disconnects memory is wasted, causing the server to run out of memory eventually
}

<br />
template < class BASE ><br />
class CBWnd : public BASE {<br />
public:<br />
CBWnd(){};<br />
CBWnd(LPCTSTR s, CWnd *p):BASE(s, p){};<br />
CBWnd(UINT n, CWnd *p):BASE(n, p){};<br />
CBWnd(LPCTSTR s):BASE(s){};<br />
CBWnd(UINT n):BASE(n){}; <br />
//...<br />
};<br />

<br />
class CMyButton : public CBWnd < CButton > {};<br />
<br />
class CMyDialog : public CBWnd < CDialog > <br />
{<br />
CMyDialog(LPCTSTR s, CWnd *p):CBWnd< CDialog >(s, p){};<br />
};<br />

#define BLOCK_SOCK_TIMEOUT 15

class CBlockingSocketFile : public CFile  
{
	DECLARE_DYNAMIC(CBlockingSocketFile)
public:
//Constructors
	CBlockingSocketFile(CBlockingSocket *pNewSocket);
	virtual ~CBlockingSocketFile();

// Implementation
public:
	CBlockingSocket * pSocket;

	virtual UINT Read(void * pBuffer, UINT nBytes);
	virtual void Write(const void* pBuffer, UINT nBytes);
	virtual void Close();

private:
// Unsupported APIs
	virtual BOOL Open(LPCTSTR lpszFileName, UINT nOpenFlags, CFileException* pError = NULL);
	virtual CFile* Duplicate() const;
	virtual DWORD GetPosition() const;
	virtual LONG Seek(LONG lOff, UINT nFrom);
	virtual void SetLength(DWORD dwNewLen);
	virtual DWORD GetLength() const;
	virtual void LockRange(DWORD dwPos, DWORD dwCount);
	virtual void UnlockRange(DWORD dwPos, DWORD dwCount);
	virtual void Flush();
	virtual void Abort();
};

IMPLEMENT_DYNAMIC(CBlockingSocketFile, CFile);

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CBlockingSocketFile::CBlockingSocketFile(CBlockingSocket *pNewSocket)
{
	if(pNewSocket == NULL) {
		DEBUG_LOG("CBlockingSocketFile constructor: NULL pointer assignment.");
		AfxThrowUserException();
	}
	pSocket = pNewSocket;
}

CBlockingSocketFile::~CBlockingSocketFile()
{

}

UINT CBlockingSocketFile::Read(void *pBuffer, UINT nBytes)
{
	return pSocket->Receive((char *)pBuffer, (const int)nBytes, BLOCK_SOCK_TIMEOUT);
}

void CBlockingSocketFile::Write(const void *pBuffer, UINT nBytes)
{
	pSocket->Write((const char*)pBuffer, (const int)nBytes, BLOCK_SOCK_TIMEOUT);
}

void CBlockingSocketFile::Close()
{
	pSocket->Close();
}

// Unsupported APIs
BOOL Open(LPCTSTR lpszFileName, UINT nOpenFlags, CFileException* pError = NULL)
{ 
	return false;
}

CFile* Duplicate(){return NULL;}
DWORD GetPosition(){return 0;}
LONG Seek(LONG lOff, UINT nFrom){return 0;}
void SetLength(DWORD dwNewLen){}
DWORD GetLength(){return 0;}
void LockRange(DWORD dwPos, DWORD dwCount){}
void UnlockRange(DWORD dwPos, DWORD dwCount){}
void Flush(){}
void Abort(){}

<br />
// workaround 1<br />
<br />
if (fp = fopen(filename, "cwt"), fp != NULL)<br />
{<br />
  // do stuff<br />
}<br />
else<br />
  perror( ... );<br />
<br />
// the inclusion of the 'c' switch caused<br />
// a)  fopen() to return NULL<br />
// b)  perror() to report "no error"<br />
<br />
// workaround 2<br />
<br />
if (h = _open(filename, _O_CREAT|_O_TRUNC|_O_WRONLY|_O_TEXT), h != -1)<br />
{<br />
  // do stuff<br />
}<br />
else<br />
  perror( ... );<br />
<br />
// resorting to raw I/O was less ambiguous ...<br />
// _open returned -1<br />
// perror() reported Permission denied for reasons which are simply beyond me<br />