Server verwaltet Clients über Threads

Mr.Bean06

Hi,
ich hatte schon in meinem anderen Thread die Frage gestellt, mache aber besser einen eigenen Faden hier für auf...

ich würde gerne realisieren, das mehrere Clients ein Lebenszeichen an einen Server senden, und diese Clients beim Server über Threads verwaltet werden.
Die Clients sollten dann in einer Liste oder Map gespeichert werden und einen "Lebenszeichentimer" bekommen.
Wie muss ich dieses Problem am besten angehen?

Danke

am besten erstellst du für jeden client einen thread, und die clients verwaltest du in einer liste (oder einer map). außerdem hat jeder client einen "lebenszeichentimer".

worüber genau willst du was wissen? threads? timer? liste? map?

Mr.Bean06

Zunächst einmal würde mich interessieren wie ich in meinen vorhandenen Code die Verwaltung durch Threads einbinden kann? und wie kann ich die Clients unterschieden, da ich sie ja zunächst alle nur lokal auf meinen Rechner starten möchte? Kann ich hier eine Unterschiedung durch Ports treffen? Wenn ja wie, und wenn nein, wie dann?

Hier mal der Code des Servers:

// Server.cpp : Definiert den Einsprungpunkt für die Konsolenanwendung.
//

#include "stdafx.h"
#include <winsock2.h>
#include <iostream>

//Mitteilung an den Linker, wo sich die nötigen Implemanteation der Winsock Funktionen befinden
#pragma comment(lib, "ws2_32.lib")

using namespace std;

int main()
{
	WSADATA wsa;
	//initialisierung von Winsock (Parameter(Version, Infos zur API))
	WSAStartup (MAKEWORD (1,1) ,&wsa);

	SOCKET listenSocket;
	listenSocket = socket (AF_INET, SOCK_STREAM, 0 );

	sockaddr_in addr;
	addr.sin_addr.s_addr = INADDR_ANY; 
	addr.sin_port = htons (1001);
	addr.sin_family = AF_INET;

	if(bind(listenSocket,(struct sockaddr*)&addr, sizeof(addr)) == -1)
	{
		cout<<"Fehler bei bind";
	}	

	if (listen(listenSocket,3) == -1)
	{
		cout<<"Fehler beim listen";

	}
	printf("Waiting for client to connect...\n");

	SOCKET clientSocket = accept(listenSocket,(struct sockaddr*)&addr, 0); 
	if (clientSocket == -1) 
	{ 
		cout<<"Fehler bei accept";
		closesocket(listenSocket);
    WSACleanup();
    return 1;

	} 
	cout<<"Client connected."<<endl;

	char buffer[254]; 
	int bytes; 

	//Daten die empfangen werden 
	bytes = recv(clientSocket, buffer, sizeof(buffer) - 1, 0); 

	buffer[bytes] = '\0';

	cout<<buffer;
	MessageBox(0, buffer, "Client Connect!", MB_ICONINFORMATION);

	//listenSocket wird geschlossen
	closesocket(listenSocket);
	WSACleanup();

	cout<<"Close Connect";
	cin.get();
	return 0;
}

und hier der Code des Clients:

// Client.cpp : Definiert den Einsprungpunkt für die Konsolenanwendung.
//

#include "stdafx.h" 
#include <iostream>
#include <winsock2.h>

//Mitteilung an den Linker, wo sich die nötigen Implemanteation der Winsock Funktionen befinden
#pragma comment(lib, "ws2_32.lib")

using namespace std;

int main()
{
	WSADATA wsa;
	//initialisierung von Winsock (Parameter(Version, Infos zur API))
  WSAStartup (MAKEWORD (1,1) ,&wsa);

	//Schnittstelle zur Netzwerkschicht
	SOCKET s;
	char clientNummer[254] = "Client 1\r\n";
	//Socket beinhaltet (IP, TCP, Raw-Sockets das Protokoll)
	s = socket (AF_INET, SOCK_STREAM, 0 );

	//hier wird die Serveradresse gespeichert	
	sockaddr_in addr;
	//umwandeln von einem IP Strin in einen 4 byte Wert
	addr.sin_addr.s_addr = inet_addr("127.0.0.1");
	//mit htons wird ein short (TCP Ports) von host byte order (höchstes byte links) in network byte order umgewandelt (höchstes byte rechts)
	addr.sin_port = htons (1001);
	//Adressenfamilie -> IP
	addr.sin_family = AF_INET;

	//Verbindung zum Server (Verbindung zum eigenen Socket, Serveradresse, Größe der Serveradresse) 
	if(connect(s, (SOCKADDR *) &addr, sizeof(addr)) == SOCKET_ERROR)
		//wenn kein Connect, dann gibt es einen Socketerror und es wird eine Fehlermeldung ausgegeben
		return (MessageBox(0, "Verbindung fehlgeschlagen!", "WinSock Tutorial Series", MB_ICONEXCLAMATION));

	//zusendene Daten(mein Socket, den wert aus dem Buffer, Länge des Buffer, Flag)
	send(s, clientNummer, strlen(clientNummer), 0);

	cout<<"\nEnde";
	cin.get();
	return 0;
}