Your problem is in this code:
thread_arg arg;
loop(...)
{
arg = ...;
handleThread = CreateThread(..., &arg, ...);
}
Every thread started here receives the address of the same thread_arg instance. Then, for starting the next thread, you again modify that instance under the feet of the previously started thread. As a remedy, create a structure that holds the necessary arguments (host, port, this) and the HANDLE to the thread. Store this structure in a std::list and then pass the address of the according element to CreateThread().
There is another problem in your code, you should check returnvalues. It's much nicer to ask for help on some code if you know that all obvious errors have been detected. For that, it's easiest to use exceptions. After CreateThread(), which should possibly be beginthread() instead, add these lines:
if(handleThread == NULL)
throw std::runtime_error("CreateThread() failed");
In a second step, create a dedicated exception class, derived from runtime_error, which holds the win32 error code (see GetLastError()) and includes the textual error description in the exception message (see FormatString()). This might sound like a lot of code for nothing, but you only write this once and you can reuse it in many places.
Lastly, your quitter() has two problems. The first is an infinite loop. Assuming you don't need the handles after closing them, try this instead:
for(; listeThread_.empty(); listeTread_.pop_back())
{
TerminateThread(listeThread_.back(), EXIT_SUCCESS);
CloseHandle(listeThread_.back());
}
You can write this as while-loop, too, but I personally prefer a for-loop if the number of iterations is essentially fixed. Of course, you still need to check the returnvalues of TerminateThread() and CloseHandle(). The second issue is that TerminateThread() is a bad idea, because you might be terminating the thread in the middle of something that remains half-done. Search the web for "terminatethread harmful". At this point here, all you can do is to wait for it to end using WaitForSingleObject().