C / C++ / MFC

    int iSockErr = 0;
    HANDLE hnd = 0;
    WORD wVersionRequested = MAKEWORD(2, 2);
    WSADATA wsaData;
    try
    {

        //Inicializar los sockets
        if ((iSockErr = WSAStartup(wVersionRequested, &wsaData)) != 0) { throw 1; }
 
        DWORD dw;
        GUID guid = SVCID_HOSTNAME;
        struct AUX{
            WSAQUERYSET qsRestrictions;
            BYTE byte[500];
        }aux;
 
        memset(&aux.qsRestrictions, 0, sizeof(WSAQUERYSET));
        aux.qsRestrictions.dwSize = sizeof(WSAQUERYSET);
        aux.qsRestrictions.lpServiceClassId = &guid;
        if (WSALookupServiceBegin(&aux.qsRestrictions, LUP_RETURN_ADDR, &hnd)) { throw 2; }
 
        dw = sizeof(aux);
        memset(&aux, 0, sizeof(aux));
        aux.qsRestrictions.dwSize = sizeof(WSAQUERYSET);
        while ( !WSALookupServiceNext(hnd, LUP_RETURN_ADDR, &dw, &aux.qsRestrictions) )
        {

//IN WINDOWS 2003 aux.qsRestrictions.lpcsaBuffer IS ALWAYS NULL

            ptyIP->d0 = aux.qsRestrictions.lpcsaBuffer[0].RemoteAddr.lpSockaddr->sa_data[2];
            ptyIP->d1 = aux.qsRestrictions.lpcsaBuffer[0].RemoteAddr.lpSockaddr->sa_data[3];
            ptyIP->d2 = aux.qsRestrictions.lpcsaBuffer[0].RemoteAddr.lpSockaddr->sa_data[4];
            ptyIP->d3 = aux.qsRestrictions.lpcsaBuffer[0].RemoteAddr.lpSockaddr->sa_data[5];
        }

        ...

//Main.cpp (entry point of my MFC application)

#include <afxwin.h>
#include <THInc.h>

class MainWindow : public CFrameWnd
{
public:
	CButton start;
	CButton end;
	CEdit textbox;

	ThreadPool* m_threadPool;
	EventSource* m_source;
	EventReceiver* m_receiver;

	MainWindow()
	{
		Create(NULL, "MFC Window");
		start.Create("Start", WS_CHILD|WS_VISIBLE|BS_PUSHBUTTON, CRect(10,10,100,30), this, 1);
		end.Create("End", WS_CHILD|WS_VISIBLE|BS_PUSHBUTTON, CRect(10,40,100,60), this, 2);
		textbox.Create(WS_VISIBLE|ES_READONLY|ES_LEFT|ES_MULTILINE|ES_AUTOVSCROLL, CRect(10,70,100,120), this, 3);
	}
	void ButtonStart();
	void ButtonEnd();
	void OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags);
	DECLARE_MESSAGE_MAP()
};

void MainWindow::ButtonStart()
{
	m_threadPool = new ThreadPool();
	m_source = new EventSource();
	m_receiver = new EventReceiver(m_threadPool);
	m_receiver->HookThreadPool(m_source);
}

void MainWindow::ButtonEnd()
{
	if (m_threadPool)
	{
		m_receiver->ReleaseThreadPool(m_source);
		m_threadPool->Release();
		m_threadPool = 0;
	}
}

void MainWindow::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
{
	if (nChar == VK_ESCAPE)
		MessageBox("Escape button pressed");
}

BEGIN_MESSAGE_MAP(MainWindow, CFrameWnd)
	ON_BN_CLICKED(1, MainWindow::ButtonStart)
	ON_BN_CLICKED(2, MainWindow::ButtonEnd)
	ON_WM_KEYDOWN()
END_MESSAGE_MAP()

class Application : public CWinApp
{
public:
	BOOL InitInstance()
	{
		m_pMainWnd = new MainWindow();
		m_pMainWnd->ShowWindow(SW_SHOW);
		return TRUE;
	}
};

Application theApp;

//ThreadPool.cpp (main threading class)

#include "ThreadPool.h"

//Static Declarations

HANDLE ThreadPool::m_threadHandles[3];
map<int, WorkUnit*> ThreadPool::m_workQueue;
bool ThreadPool::m_terminate = false;

//Public Functions

ThreadPool::ThreadPool()
{
	InitThreads();
}

ThreadPool::~ThreadPool()
{
}

void ThreadPool::SignalTermination()
{
	HANDLE termMutex = CreateMutex(NULL, false, "TerminateThreadPool");
	WaitForSingleObject(termMutex, INFINITE);
	m_terminate = true;
	ReleaseMutex(termMutex);
}

void ThreadPool::Release()
{
	//Wait for threads to finish work before terminating
	WaitForMultipleObjects(3, m_threadHandles, true, INFINITE);
	delete this;
}

//int ThreadPool::Process(int (*ptrToFunc)(void))
//{
//	void* funcPtr = ptrToFunc;
//	return 0;
//}

//Private Functions

void ThreadPool::InitThreads()
{
	unsigned int threadID[3];

	for (int i = 0; i < 3; i++)
	{
		int* index = new int(i);
		m_threadHandles[i] = (HANDLE)_beginthreadex(0, 0, &ThreadPool::BeginThread, index, 0, &threadID[i]);
	}
}

unsigned int ThreadPool::BeginThread(void* pArgs)
{
	//Work loop
	HANDLE hWQMutex = CreateMutex(NULL, false, "WorkQueue");
	HANDLE termMutex = CreateMutex(NULL, false, "TerminateThreadPool");
	while (true)
	{
		//Search work queue for work
		WaitForSingleObject(hWQMutex, INFINITE);
		int key = -1;
		WorkUnit* value = 0;
		if (m_workQueue.size() > 0)
		{
			map<int, WorkUnit*>::iterator iter;
			for (iter = m_workQueue.begin(); iter != m_workQueue.end(); iter++)
			{
				value = (*iter).second;
				if (value->GetState() == WorkState_Queued)
				{
					key = (*iter).first;
					value = (*iter).second;
					value->SetState(WorkState_Active);
				}
				else
					continue;
			}
		}
		ReleaseMutex(hWQMutex);

		//If termination has been signaled, return thread
		WaitForSingleObject(termMutex, INFINITE);
		if (m_terminate)
			break;
		ReleaseMutex(termMutex);

		//If no key has been set, sleep thread
		if (key == -1)
			Sleep(1000);
	}

	//Thread termination
	m_threadHandles[*((int*)pArgs)] = 0;
	delete pArgs;
	return 0;
}