Threads in C++ Builder 6

Check out this:
Its an example I downloaded and helped me some years ago...

The header:
//---------------------------------------------------------------------------
#ifndef Unit1H
#define Unit1H
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
#include <ScktComp.hpp>
#include <ExtCtrls.hpp>
//---------------------------------------------------------------------------
class TForm1 : public TForm
{
__published:      // IDE-managed Components
    TServerSocket *Server;
    TMemo *Memo1;
    TButton *cmdClose;
    TTimer *Timer1;
    TLabel *Label1;
    TLabel *Label2;
    TLabel *Label3;
    TBevel *Bevel1;
    TButton *Button1;
    TEdit *Edit1;
    TLabel *Label4;
    TEdit *txtPort;
    TButton *cmdChangePort;
    void __fastcall cmdCloseClick(TObject *Sender);
    void __fastcall ServerAccept(TObject *Sender,
          TCustomWinSocket *Socket);
    void __fastcall ServerClientDisconnect(TObject *Sender,
          TCustomWinSocket *Socket);
    void __fastcall ServerClientError(TObject *Sender,
          TCustomWinSocket *Socket, TErrorEvent ErrorEvent,
          int &ErrorCode);
    void __fastcall ServerClientRead(TObject *Sender,
          TCustomWinSocket *Socket);
    void __fastcall ServerClientWrite(TObject *Sender,
          TCustomWinSocket *Socket);
    void __fastcall ServerGetSocket(TObject *Sender, int Socket,
          TServerClientWinSocket *&ClientSocket);
    void __fastcall ServerListen(TObject *Sender,
          TCustomWinSocket *Socket);
    void __fastcall FormActivate(TObject *Sender);
    void __fastcall ServerGetThread(TObject *Sender,
          TServerClientWinSocket *ClientSocket,
          TServerClientThread *&SocketThread);
    void __fastcall ServerThreadStart(TObject *Sender,
          TServerClientThread *Thread);
    void __fastcall ServerThreadEnd(TObject *Sender,
          TServerClientThread *Thread);
    void __fastcall Timer1Timer(TObject *Sender);
    void __fastcall Button1Click(TObject *Sender);
    void __fastcall ServerClientConnect(TObject *Sender,
          TCustomWinSocket *Socket);
    void __fastcall cmdChangePortClick(TObject *Sender);

private:      // User declarations
public:            // User declarations
    __fastcall TForm1(TComponent* Owner);
};
//---------------------------------------------------------------------------
extern PACKAGE TForm1 *Form1;
//---------------------------------------------------------------------------
#endif

Source File:
/*******************************************************
This is an example of how to set up a server listening
to incomming Telnet connections. I've tried to make it
as well structured as possible with the possibility to,
without any major modifications, build up a fully
functional telnet server for whatever use there might be.
I have commented it heavily, but if there still are any
questions (or suggestions) mail them to karlpest@home.se

Please visit KTRK's webpage at http://www.ktrk.net or
http://ktrk.tripod.com

Coded by Karl Tillstr&#966;m 2000-10-11

*******************************************************/

//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"

//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;



const Max_Connections = 30;  //Set how many sockets you wish to have open

struct Connected_User
{
    int SocketHandle;   //The Socket the user is connected to
    AnsiString Name;    //If you want to attatch a name to the user
    AnsiString Data;    //To get whole lines (look into ClientRead())
    AnsiString IP;      //The clients IP
    //Add more if needed, like TimeOut, PasswordAccepted, AccessLevel etc...
};

Connected_User User[Max_Connections];   //Handles the connected users
int ConnectionCount;    //Index used by User[]

void RemoveUser(TCustomWinSocket *Socket);      //Removes a user from a socket
int GetConnectionNo(int SocketHandle);  //Finds which User[] that represents the SocketHandle
void ClearUser(int SocketHandle);   //Clears the User[] for the specific user
void BroadCastMessage(AnsiString Message, int SkipUser);  //Use this to send a message to all connected users except SkipUser (SocketHandle)

//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
    : TForm(Owner)
{

}
//---------------------------------------------------------------------------

void __fastcall TForm1::cmdCloseClick(TObject *Sender)
{
//Closes the Server Socket
Server->Active = false;
Memo1->Lines->Add("Server shut down!");
}
//---------------------------------------------------------------------------

void __fastcall TForm1::ServerAccept(TObject *Sender,
      TCustomWinSocket *Socket)
{
if (Server->Socket->ActiveConnections-1  == Max_Connections)
    {
        //The server is full!
        Socket->SendText("Too many users!");
        Memo1->Lines->Add("OnAccept: Too many users");
        delete Socket;  //Free memory
        return;
    }



while (User[ConnectionCount].SocketHandle)    //Find free entrypoint
{
    ConnectionCount++;  //Unique indexes for the Connected users!
    if (ConnectionCount > Max_Connections)
        {
            ConnectionCount = 0;
        }
}

//Attatches the SocketHandle to the User[] in use
User[ConnectionCount].SocketHandle = Socket->SocketHandle;
//This is not how it's done when you are really naming the users
User[ConnectionCount].Name = "Guest" + IntToStr(Socket->SocketHandle);
Memo1->Lines->Add("OnAccept");



User[ConnectionCount].IP = Socket->RemoteAddress;
Memo1->Lines->Add(User[ConnectionCount].IP + " connected!");


}
//---------------------------------------------------------------------------


void __fastcall TForm1::ServerClientDisconnect(TObject *Sender,
      TCustomWinSocket *Socket)
{

ClearUser(Socket->SocketHandle);
Memo1->Lines->Add("ClientDisconnected " + IntToStr(Socket->SocketHandle));
//delete Socket;  //free memory (dunno if it's needed here...)
}
//---------------------------------------------------------------------------
void __fastcall TForm1::ServerClientError(TObject *Sender,
      TCustomWinSocket *Socket, TErrorEvent ErrorEvent, int &ErrorCode)
{

switch (ErrorCode)
{
    case 10054 :
        //Client closed the connection
        RemoveUser(Socket);   //Removes the user
        Memo1->Lines->Add("Client closed connection");
        break;
    //add more error handlers as they are needed (e.g case <ErrorCode>)
    default :
        RemoveUser(Socket);
}

ErrorCode = 0;  //Prevents an error raise
}
//---------------------------------------------------------------------------
void __fastcall TForm1::ServerClientRead(TObject *Sender,
      TCustomWinSocket *Socket)
{
//Occurs when a connected user sends some text to the server!

AnsiString Data = Socket->ReceiveText();    //Get the sent data!
int UserNo = GetConnectionNo(Socket->SocketHandle); //Finds out who sent it
if (UserNo == -1)
{
    //This shouldn't happen ever, but if it does you'll at least know about it
    ShowMessage("User cannot be found!");
    return;
}

/* Telnet users doesn't send complete lines at once,
therefore this will store all data in a temporary
AnsiString until a CRLF is received (\r\n)*/

User[UserNo].Data += Data;
if (User[UserNo].Data.AnsiPos("\r\n") == 0)
{
    //Not a complete line sent!
    return;
}
else
{
    //A complete Line sent!
    //SubString removes the ending CRLF ("\n\r") since we don't want them when we Parse out data!
    Memo1->Lines->Add("<" + User[UserNo].Name + "> " + User[UserNo].Data.SubString(1, User[UserNo].Data.Length() -2));
    //An example of how to use the BroadCastMessage function
    BroadCastMessage(User[UserNo].Data.SubString(1, User[UserNo].Data.Length() -2), Socket->SocketHandle);
    User[UserNo].Data = "";
}
       
}
//---------------------------------------------------------------------------
void __fastcall TForm1::ServerClientWrite(TObject *Sender,
      TCustomWinSocket *Socket)
{
        Memo1->Lines->Add("ClientWrite");

}
//---------------------------------------------------------------------------
void __fastcall TForm1::ServerGetSocket(TObject *Sender, int Socket,
      TServerClientWinSocket *&ClientSocket)
{
    //GetSocket is the Socket->SocketHandle
    Memo1->Lines->Add("GetSocket " + IntToStr(Socket));
}
//---------------------------------------------------------------------------
void __fastcall TForm1::ServerListen(TObject *Sender,
      TCustomWinSocket *Socket)
{
Memo1->Lines->Add("Listens on Port: " + IntToStr(Server->Port));

}
//---------------------------------------------------------------------------
void __fastcall TForm1::FormActivate(TObject *Sender)
{
//Opens the server (e.g Makes the server start Listening)
//Server->Active = true;

ConnectionCount = 1;    //Start counting on 1
}
//---------------------------------------------------------------------------
void __fastcall TForm1::ServerGetThread(TObject *Sender,
      TServerClientWinSocket *ClientSocket,
      TServerClientThread *&SocketThread)
{
Memo1->Lines->Add("GetThread");
}
//---------------------------------------------------------------------------
void __fastcall TForm1::ServerThreadStart(TObject *Sender,
      TServerClientThread *Thread)
{
Memo1->Lines->Add("OnThreadStart");

}
//---------------------------------------------------------------------------
void __fastcall TForm1::ServerThreadEnd(TObject *Sender,
      TServerClientThread *Thread)
{
Memo1->Lines->Add("OnThreadEnd");
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Timer1Timer(TObject *Sender)
{
    //Updates the current # of connections
    Label1->Caption = IntToStr(Server->Socket->ActiveConnections) + "/" + IntToStr(Max_Connections);
}
//---------------------------------------------------------------------------

void ClearUser(int SocketHandle)
{
//Use this when a user gets disconnected for whatever reason
int UserNo = GetConnectionNo(SocketHandle);
if (UserNo == -1) return;

/*Don't forget to update this section is you add more stuff to the User struct!*/
    User[UserNo].SocketHandle = 0;
    User[UserNo].Name = "";
    User[UserNo].Data = "";
    User[UserNo].IP = "";
/*_____________________________________________________________________________*/
}
//---------------------------------------------------------------------------

int GetConnectionNo(int SocketHandle)
{
//Retrieves which connection that represents the SocketHandle in question
for (int i=0; i<Max_Connections; i++)
{
    if (User[i].SocketHandle == SocketHandle) return i;
}
return -1;
}

void __fastcall TForm1::Button1Click(TObject *Sender)
{
//Activates the Server socket (e.g Starts to listen)
Memo1->Lines->Add("Server started!");
Server->Open();
}
//---------------------------------------------------------------------------

void __fastcall TForm1::ServerClientConnect(TObject *Sender,
      TCustomWinSocket *Socket)
{
Memo1->Lines->Add("connect");

}
//---------------------------------------------------------------------------

void BroadCastMessage(AnsiString Message, int SkipUser)
{

//Loops through the Socket->Connections array and sends the message to all users but SkipUser
//(You don't always want to broadcast the message to the user who sent it!)
//If you want to send to all the users including the one who sent it, call the function with SkipUser = -1 or something

for (int i=0;i<(Form1->Server->Socket->ActiveConnections); i++)
{
    if (Form1->Server->Socket->Connections[i]->SocketHandle == SkipUser)
    {
        // NOP
    }
    else
    {
        Form1->Server->Socket->Connections[i]->SendText(Message + AnsiString("\r\n"));
    }

}
}

void RemoveUser(TCustomWinSocket *Socket)
{
/*Clears the User[] and removes the Socket instance*/
    Form1->Memo1->Lines->Add("User " + User[GetConnectionNo(Socket->SocketHandle)].Name + " removed!");
    ClearUser(Socket->SocketHandle);
    delete Socket;

/*_________________________________*/
}
void __fastcall TForm1::cmdChangePortClick(TObject *Sender)
{
if (Server->Active == true)
{

 if (Application->MessageBox("Server must be shut down in order to change Listening port! \n Do you wish to continue?", "Temporarily shut down server?", MB_OKCANCEL + MB_DEFBUTTON1) == IDCANCEL)
   return;

    //Server must be shut down to be able to change port!
    cmdClose->Click();
    Server->Port = StrToInt(txtPort->Text);
    Memo1->Lines->Add("Listening port changed to " + txtPort->Text);
    Button1->Click();
}
else
{
    Server->Port = StrToInt(txtPort->Text);
        Memo1->Lines->Add("Listening port changed to " + txtPort->Text);
}

}
//---------------------------------------------------------------------------