Das problem ist, das ich wenn ich mit nem client connecte auf dem client nur ne meldung kriege "verbindung zu ... hergestellt" beim serv passiert aber folgendes:

->Neuer Socket erstellt auf Platz 0
->Im Listenmodus(warte auf client...)
->Client Verbunden!
->Neuer Socket erstellt auf Platz 1
Client verloren...

auch der datenaustausch funktioniert nurnoch vom server zum client aber nichtmehr vom client zum server...
comments im sourcecode lesen für weitere infos!
danke für jede hilfe...(btw...hatte nur n tut zur hand welches mehrere clients per select verwaltet, wollte es aber mit threads machen, habs deswegen selbst mal probiert ^^)

//dies ist der server...
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <fstream.h>
#include "resource.h";
#define MAX_CLIENTS 10
LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM);
LRESULT CALLBACK MakeProc (HWND, UINT, WPARAM, LPARAM);
unsigned long RcvProc();
unsigned long RcvProcS();
HWND dlgBox;
///-------------------
//...
//...
//hier sind funktionen....
///-------------------

	class MakeSockets
	{
	private:
		int status;
		SOCKET s;
		SOCKADDR_IN addr;
		long rc;
	public:
		MakeSockets()
		{
			status = 0;
		}
		void ConnectSock(char *IPAdresse)
		{
			rc=startWinsock();
			// Winsock starten
			if(rc!=0)
			{
				//FEHLER! code in rc drin...
			}
			else
			{
				//OK
			}
			// Socket erstellen
			s=socket(AF_INET,SOCK_STREAM,0);
			if(s==INVALID_SOCKET)
			{
				closesocket(s);
			}
			else
			{
				//socket erstellt
			}
			memset(&addr,0,sizeof(SOCKADDR_IN)); // zuerst alles auf 0 setzten 
			addr.sin_family=AF_INET;
			addr.sin_port=htons(12345); // wir verwenden mal port 12345
			addr.sin_addr.s_addr=inet_addr(IPAdresse); // zielrechner ist unser eigener
			rc=connect(s,(SOCKADDR*)&addr,sizeof(SOCKADDR));
			if(rc==SOCKET_ERROR)
			{
				//Fehler: connect gescheitert, fehler code: %d\n",WSAGetLastError()
				closesocket(s);
				status = 2;
			}
			else
			{
				//Verbunden mit 127.0.0.1..
				status = 1;
			}
		}
		int GiveStatus()
		{
			return status;
		}
		char *recieve()
		{
			char *buffer = new char[256];
			rc=recv(s,buffer,256,0);
			buffer[rc] = '\0';
			if(rc==0 || rc==SOCKET_ERROR)
				return "";
			return buffer;
		}
		void sendData(char *strToSend)
		{
			rc=send(s,strToSend,strlen(strToSend),0);
		}
		void end()
		{
			closesocket(s);
			WSACleanup();
		}
	};
	class MakeSocketsServer
	{
	private:
		SOCKET acceptSocket;
		SOCKET connectedSocket[MAX_CLIENTS];
		long rc;
		int port;
		SOCKADDR_IN addr;
	public:
		MakeSocketsServer()
		{
			// Winsock starten
			rc=startWinsock();
			// Socket erstellen
		for(int i=0;i<MAX_CLIENTS;i++) 
		  {
			connectedSocket[i]=INVALID_SOCKET;
		  }
		}
		void setPort(int portnum)
		{
			port = portnum;
		}
		int CreateSock(SOCKET x)
		{
			int ret = -1;
			for(int i=0;i<MAX_CLIENTS;++i)
			{
				if(connectedSocket[i] == INVALID_SOCKET)
				{
					connectedSocket[i] = x;
					addLine(GetDlgItem(dlgBox,IDC_SHOW),CombinChars("->Neuer Socket erstellt auf Platz ",itos(i)));
					ret = i;
					break;
				}
				if(i == MAX_CLIENTS-1)
				{
					PostQuitMessage(0);
				}
			}
			acceptSocket=socket(AF_INET,SOCK_STREAM,0);
			if(acceptSocket==INVALID_SOCKET)
			{
				closesocket(acceptSocket);
			}
			else
			{
				//socket erstellt
			}
			memset(&addr,0,sizeof(SOCKADDR_IN));
			addr.sin_family=AF_INET;
			addr.sin_port=htons(port);
			addr.sin_addr.s_addr=INADDR_ANY;
			rc=bind(acceptSocket,(SOCKADDR*)&addr,sizeof(SOCKADDR_IN));
			if(rc==SOCKET_ERROR)
			{
				//Fehler: bind, fehler code: %d\n",WSAGetLastError()...
				closesocket(acceptSocket);
			}
			else
			{
				//Socket an port 12345 gebunden
			}
			return ret;
		}
		void listenS(int i)
		{
			rc=listen(acceptSocket,10);
			if(rc==SOCKET_ERROR)
			{
				//Fehler: listen, fehler code: %d\n",WSAGetLastError()
				closesocket(acceptSocket);
			}
			else
			{	
				//acceptSocket ist im listen Modus....
				addLine(GetDlgItem(dlgBox,IDC_SHOW),"->Im Listenmodus(warte auf client...)");
			}
			connectedSocket[i]=accept(acceptSocket,NULL,NULL);
			if(connectedSocket[i]==INVALID_SOCKET)
			{
				//Fehler: accept, fehler code: %d\n",WSAGetLastError()...
				closesocket(acceptSocket);
			}
			else
			{
				addLine(GetDlgItem(dlgBox,IDC_SHOW),"->Client Verbunden!");
///-------------------------------------------------
//Hier möchte ich, das jedesmal wenn ein client neu connected ein neuer thread erstellt wird, der auf den nächsten client wartet.
//wenn ich das weglasse, dann kann ich mit einem client connecten und daten austauschen...aber halt nur mit einem...
				HANDLE hAcceptThread = CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)RcvProcS, NULL, NULL, NULL);
//kann das problem sei, das die klasse immer nur ein listen verwalten kann?
//--------------------------------------------------
			}
		}
		int answer(int i)
		{
				char *buffer = new char[256];
				rc=recv(connectedSocket[i],buffer,256,0);
				buffer[rc] = '\0';
				if(rc!=0 && rc!=SOCKET_ERROR)
				{
					int lineCode = getStrCode(buffer);
					char *lineStr = new char[strlen(buffer)-3];
					lineStr = getLwC(buffer);
					switch(lineCode)
					{
					case 0:
						addLine(GetDlgItem(dlgBox,IDC_SHOW),lineStr);
						break;
					case 1:
						addLine(GetDlgItem(dlgBox,IDC_SHOW),"x changes name...");
						break;
					}
					delete [] buffer;
				}
				else
				{
					return 1;
				}
				return 0;
		}
		void sendData(char *strToSend, int i)
		{
			rc=send(connectedSocket[i],strToSend,strlen(strToSend),0);
		}
		void end()
		{
			for(int i=0;i<MAX_CLIENTS;++i)
				closesocket(connectedSocket[i]);
			closesocket(acceptSocket);
			WSACleanup();
		}
		void endCon(int i)
		{
			closesocket(connectedSocket[i]);
		}
		bool isValid(int i)
		{
			if(connectedSocket[i] == INVALID_SOCKET)
				return FALSE;
			return TRUE;
		}
};
MakeSockets Sock;
MakeSocketsServer SockServer;
//Deklaration der Windows-Nachrichten-Prozedur 
///---------------------WIndow krams.......
		HANDLE hAcceptThread;
		switch (message) 
		{
			case WM_INITDIALOG:
				ShowWindow(hwnd, SW_SHOWNORMAL);
				dlgBox=hwnd;
				return TRUE;
			case WM_COMMAND: 
            	if(LOWORD(wParam) == IDOK)
				{	
					char *ip = new char[GetEditTextLength(GetDlgItem(hwnd,IDC_IPADDRESS))];
					ip = WindowText(GetDlgItem(hwnd,IDC_IPADDRESS));
					Sock.ConnectSock(ip);
					if(Sock.GiveStatus() == 1)
					{
						addLine(GetDlgItem(dlgBox,IDC_SHOW),CombinChars("Konnte zu ",CombinChars(ip," verbinden")));
					}
					else if(Sock.GiveStatus() == 2)
					{
						addLine(GetDlgItem(dlgBox,IDC_SHOW),CombinChars("Konnte nicht zu ",CombinChars(ip," verbinden")));
					}
					hAcceptThread = CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)RcvProc, NULL, NULL, NULL);
				}
				if(LOWORD(wParam) == ID_SEND)
				{
					char *buf = new char[GetEditTextLength(GetDlgItem(hwnd,IDC_TOSEND))-3];
					buf = WindowText(GetDlgItem(hwnd,IDC_TOSEND));
					Sock.sendData(CombinChars("001",buf));
					addLine(GetDlgItem(dlgBox,IDC_SHOW),CombinChars("[me]:",buf));
				}
				return TRUE;
			case WM_CLOSE:
				Sock.end();
				EndDialog(hwnd,0);
		}  
		return FALSE;
	}
	LRESULT CALLBACK MakeProcS (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) 
	{
		HANDLE hAcceptThread;
		switch (message) 
		{
			case WM_INITDIALOG:
				dlgBox=hwnd;
				return TRUE;
			case WM_COMMAND: 
            	if(LOWORD(wParam) == IDOK)
				{	
					char *port = new char[GetEditTextLength(GetDlgItem(hwnd,IDC_PORT))];
					port = WindowText(GetDlgItem(hwnd,IDC_PORT));
					DWORD  idAcceptThread;
					SockServer.setPort(atof(port));
					hAcceptThread = CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)RcvProcS, NULL, NULL, &idAcceptThread);
				}
				if(LOWORD(wParam) == ID_SEND)
				{
					char *buf = new char[GetEditTextLength(GetDlgItem(hwnd,IDC_TOSEND))];
					buf = WindowText(GetDlgItem(hwnd,IDC_TOSEND));
					for(int x=0;x<MAX_CLIENTS;++x)
					{
						if(SockServer.isValid(x))
							SockServer.sendData(buf,x);
					}
					addLine(GetDlgItem(dlgBox,IDC_SHOW),CombinChars("[me]:",buf));
				}
				return TRUE;
			case WM_CLOSE:
				SockServer.end();
				EndDialog(hwnd,0);
		}  
		return FALSE;
	}
	LRESULT CALLBACK WndProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) 
	{ 
	switch (message) 
	{ 
	case WM_CREATE:
		if(LOWORD(wParam) == 0) 
		{

		}
		return 0 ;
	case WM_COMMAND:
		if(LOWORD(wParam) == ID_CONNECT)
		{
			DialogBox(hInst,(LPCTSTR)IDD_DIALOG, hwnd, (DLGPROC)MakeProc);
		}
		if(LOWORD(wParam) == ID_SERVER_ERSTELLEN)
		{
			DialogBox(hInst,(LPCTSTR)IDD_DIALOGS, hwnd, (DLGPROC)MakeProcS);
		}
		return 0;
	case WM_SIZE:
		return 0;
	case WM_CLOSE:
		DestroyWindow(hwnd);
	case WM_DESTROY:
		  PostQuitMessage (0);
		  return 0;
	}

return DefWindowProc (hwnd, message, wParam, lParam); 
} 

unsigned long RcvProc()
{
	while(1)
	{
		char *tmp = new char[256];
		tmp = Sock.recieve();
		if(tmp != "")
			addLine(GetDlgItem(dlgBox,IDC_SHOW),tmp);
		else
		{
			addLine(GetDlgItem(dlgBox,IDC_SHOW),"Connection Error");
			Sock.end();
			return 0;
		}
	}
return 0; 
}
unsigned long RcvProcS()
{
	SOCKET theSocket;
	int sockNum;
	sockNum = SockServer.CreateSock(theSocket);
	SockServer.listenS(sockNum);
	int x = 0;
	while(x==0)
	{
		x = SockServer.answer(sockNum);
	}
	SockServer.endCon(sockNum);
	addLine(GetDlgItem(dlgBox,IDC_SHOW),"Client verloren...");
	return 0;

}

edit wer n tut hat zu sockets in winAPI mit threads..bitte linken

fallen mir grad ein, wenn ich noch welche find, sag ichs...

Zu der Sache mit den Threads:

1. empfehle ich dir select()--> ist viel eleganter / ressourcenshconender / einfacher..

2.Wenn du Threads liebst und nicht loslassen kannst:
Du solltest mit ner map arbeiten, d.h. jedem clientsocket ein threadhandle zuordnen und immer wenn der client diesconnectet den thread auslaufen lassen.

Mfg. Tolga

edit:wobei ich immernoch nicht weiss, wo mein fehler liegt...

Mfg. Tolga

habe noch nicht viel Ahnung von dem Thema, versuche mich gerade mit Indy
gibt es da eine einfache Möglichkeit einen Text an einen anderen Rechner zu
senden von dem die IP bekannt ist?
Wenn der der andere Rechner meine IP erkennt soll er den Text auswerten.

Was ist in diesem Zusammenhang ein Thread ?

zwei Ports: port1, port2

Server -------------------------| Client ------------------------
________________________________|________________________________
- ServerSocket(port1) erstellen |
mit tread welcher auf neue      |
verbindungen wartet.            |
                                | - Client(port1) mit Server verbinden
- sobald Verbunden port2 senden | - sobald Verbunden port2 empfangen
                                | einen ServerSocket(port2) erstellen
- Client[i] (port2) mit         |
ServerSocket verbinden          |

--> Kommunikation nun über den port2 hergestellt

--> thread wartet nun wieder auf neue verbindungen welche dann einfach z.B über den Client[i+1] hergestellt wird

drausgekommen....tja egal bei mir hat es so wunderbar geklappt!!!