[C++] Robienie wątków, przerabianie gry, czy dobrze myślę?

#include <string>
#include <fstream>
#include <sstream>
#include <iostream>
#include <windows.h>
#include <winsock2.h>

using namespace std;
fstream plik;
string str;

#define BUFOR 256
#define NO_HOST 23023
#define MAX_CONN 100

WSADATA wsaData;
SOCKET soc_serwer; //socket serwera oraz klienta
WORD wersja = MAKEWORD( 2,0  );
sockaddr_in _sin;

/******************************************************************************/
int do_int(string wartosc){
istringstream strum(wartosc);
int pom = 0;
strum >> pom;
return pom;
}

/******************************************************************************/
string do_str(int wartosc){
ostringstream strum ;
strum << wartosc;
return strum.str();
}
/******************************************************************************/

bool FileExists( const char* FileName )
{
    FILE* fp = NULL;
    fp = fopen( FileName, "rb" );
    if( fp != NULL )
    {
        fclose( fp );
        return true;
    }
    return false;
}
/******************************************************************************/

void zeruj(char *c, char l = 0){
for(int i = 0; i < BUFOR; i++)
 c[i] = l;
}
/******************************************************************************/

DWORD WINAPI obsluga_klienta(){
SOCKET soc_klient;
HANDLE hThread;
DWORD dwThreadId;
int blad;
char bufor_[BUFOR], _bufor[BUFOR];
fstream plik;
string str;

 if(listen(soc_serwer,MAX_CONN)==SOCKET_ERROR) {
        return 2;
        }
 int rozmiar = sizeof(_sin);
 soc_klient = accept(soc_serwer,(struct sockaddr *)&_sin, &rozmiar);


hThread = CreateThread( 
            NULL,
            0,
            (LPTHREAD_START_ROUTINE) obsluga_klienta,
            NULL,
            0,
            &dwThreadId);


do{
    zeruj(_bufor);
    blad = recv(soc_klient,_bufor,BUFOR,0);
    if(blad == SOCKET_ERROR || _bufor[0] == 0){
        closesocket(soc_klient);
        return 0;
        }
    
    switch(_bufor[0]){
    case 1 : plik.open(_bufor+1,ios::out);
             plik << " ";
             plik.close();
             plik.clear();
             break;
    case 6 : DeleteFile(_bufor+1);
             break;
    case 2 : zeruj(bufor_);
             bufor_[0] = FileExists((char*)_bufor+1);
             send(soc_klient,bufor_,BUFOR,0);
             break;
    case 3 : {
             plik.open(_bufor+1, ios::in);

             do{
             zeruj(bufor_);
             for(int i=0;plik.good() && (i<BUFOR);i++)
              plik.get(bufor_[i]);   
             send(soc_klient,bufor_,BUFOR,0);
             }while(bufor_[0]);

             plik.close();
             plik.clear();
             break;}
    case 4 : {
             recv(soc_klient,bufor_,BUFOR,0);
             if(bufor_[0] == 0){
              break;
              }
             
             plik.open(_bufor+1, ios::out);
             while(bufor_[0]){
             for(int i = 0; i < BUFOR && bufor_[i]; i++)
              plik.put(bufor_[i]);
             recv(soc_klient,bufor_,BUFOR,0);
             }
             
             plik.close();
             plik.clear();
             break;}
    }      

}while(true);


}

/******************************************************************************/
int main(){
     HANDLE hThread;
     DWORD dwThreadId;

     cout << "Uruchamianie modulu WinSock   ";
     int blad = WSAStartup(wersja, &wsaData );
     if( blad != 0 ) {
        cout << "[  BLAD  ]\n";
        system("pause");
        return 0;
        }
     cout << "[   OK   ]\n";
     cout << "Badanie wersji WinSock        ";
     if( LOBYTE( wsaData.wVersion ) != 2 || HIBYTE( wsaData.wVersion ) != 0 ){
        WSACleanup();
        cout << "[  BLAD  ]\n";
        system("pause");
        return 2;
        }
     cout << "[   OK   ]\n";
     cout << "Tworzenie hosta serwera       ";      
      soc_serwer = socket( AF_INET, SOCK_STREAM, 0 );
      memset( &_sin, 0, sizeof(_sin));
      _sin.sin_family = AF_INET;
      _sin.sin_addr.s_addr = INADDR_ANY;
      _sin.sin_port = htons(NO_HOST);

     cout << "[   OK   ]\n";

     cout << "Konfigaracja adresu serwera   ";      
      if(bind(soc_serwer,(struct sockaddr *)&_sin, sizeof(_sin))==SOCKET_ERROR) {
        WSACleanup();
        cout << "[  BLAD  ]\n";
        system("pause");
        return 2;
        }
     cout << "[   OK   ]\n";


hThread = CreateThread( // -> w tym miejscu następuje crash programu :P
            NULL,
            0,
            (LPTHREAD_START_ROUTINE) obsluga_klienta,
            NULL,
            0,
            &dwThreadId);

closesocket(soc_serwer);
WSACleanup();
}

for(;;);