C++ Winsock Server - mehrere Clients handlen

Cyax

Hallo zusammen,

ich habe folgendes Problem: ich möchte einen Server (der mit winsocks arbeitet)
so schreiben, dass er mehrere Clients akzeptiert und dann bestimmten
Clients (per send()) einen Text sendet und ebenso von ausgewählten Clients Daten empfängt.

Das mit dem akzeptieren der Clients war relativ leicht zu realisieren (multithreading). Allerdings weiß ich nicht wirklich wie ich das mit dem
Senden anstellen soll. Hat da jmd. vielleicht einen kleinen Hinweis für mich?
Würde mich über eine Antwort freuen

Gruß

Cyax

Tobiking2

Cyax schrieb:

Das mit dem akzeptieren der Clients war relativ leicht zu realisieren (multithreading). Allerdings weiß ich nicht wirklich wie ich das mit dem
Senden anstellen soll. Hat da jmd. vielleicht einen kleinen Hinweis für mich?
Würde mich über eine Antwort freuen

Das accept gibt dir ein Socket zurück, das für die Verbindung mit genau diesem Client steht. Beim send und recv gibst du mit Socket an mit welchem Client du kommunizieren möchtest.

Cyax

Hm ja, stimmt, aber wenn ich z.B. einen
SOCKET array nehme geht das nicht.

SOCKET s[10];

//...

s[x] = accept(...);
send(s[x], ...);
// WSAGetLastError() : 10038

Da mache ich irgendwas falsch...
was brauche ich denn noch alles um die Clients dann
einzeln anzusteuern?

Bengo

Wenn du in jedem Thread durch accept EIN Socket zurückbekommst, kannst du damit einfach schreiben. Und dann kannst du mehrere Clients durch multithreading gleichzeitig bedienen.

TGGC

Cyax schrieb:

SOCKET s[10];

//...

= accept(...);

send(s[x], ...);
// WSAGetLastError() : 10038
[/code]

Da mache ich irgendwas falsch...

ueberschrieben.

Cyax

Bengo schrieb:

Wenn du in jedem Thread durch accept EIN Socket zurückbekommst, kannst du damit einfach schreiben. Und dann kannst du mehrere Clients durch multithreading gleichzeitig bedienen.

Naja, so hab ichs ja letztendlich gemacht, allerdings ist mir noch nicht
ganz klar wie ich dann "mehrere Clients durch multithreading gleichzeitig bedienen" kann...

Hier mal mein Code für das "akzeptieren" von neuen Clients.

DWORD WINAPI cmd_handler(LPVOID lpParam)
{
	SOCKET active_socket = (SOCKET)lpParam;
	char recv_buffer[256];
	std::string sent_data = "msg";
	int rc;

	for (;;){
		if (active_socket != INVALID_SOCKET){
			rc = send(active_socket, sent_data.c_str(), strlen(sent_data.c_str()), 0);
			if (rc <= 0){
				std::cout << "Error sending command" << std::endl;
				closesocket(active_socket);
				ExitThread(0);
				return 1;
			}
		}
		else{
			std::cout << "Client disconnected" << std::endl;
			closesocket(active_socket);
			ExitThread(0);
			return 1;
		}
		sent_data.clear();
	}
}

//main und anderes Zeug
SOCKET client;
//...
client = accept(acceptSocket, (sockaddr*)&from, &fromlen);
char *connected_ip = inet_ntoa(from.sin_addr);
std::cout << "Client " << clientCounter << " connected from " << connected_ip << std::endl;
CreateThread(NULL, 0, cmd_handler, (LPVOID)client, 0, &thread);

dachschaden

Cyax schrieb:

Naja, so hab ichs ja letztendlich gemacht, allerdings ist mir noch nicht
ganz klar wie ich dann "mehrere Clients durch multithreading gleichzeitig bedienen" kann..

Das kaufe ich dir nicht ab.

while((current_socket = accept(main_socket)) !=  INVALID_SOCKET)
{
        //Du willst vielleicht nicht, dass dir jemand nur Müll sendet und du dann später abbrechen musst,
        //und du daher einen Thread umsonst aufgemacht hast. Deswegen willst du vielleicht noch eine
        //kleine, schnelle Plausibilitätsprüfung machen ...
        if(check_if_alright(current_socket))
        {
                close(current_socket);
                continue;
        }

        //Dann brauchst du einen Pool für die TIDs, das ist aber auch relativ einfach.
        //Wenn das nicht geklappt hat, kannst du den Socket auch gleich wieder schließen.
        tids[current_tid] = start_thread(current_socket);
        if(!tids[current_tid])
        {
                close(current_socket);
                continue;
        }

        //Jetzt ist der Thread gestarted - lass ihn machen, er wird von alleine Abräumen. Aber aufpassen,
        //dass der Thread fertig ist, bevor du tids wieder überschreibst. Du musst den Thread ja später
        //noch abräumen.

        ++current_tid;
}

Das Konzept ist ganz einfach, nur die Implementierung ist schwer. Zumindest, wenn du das ordentlich machen willst. Was da noch fehlt, ist das Durchrollen in deinem Threadpoolbuffer, und natürlich das Freigeben. Dafür gibts aber API-Dokus. Die musst du dann nutzen.

Und jetzt erkläre mal, wie du darauf nicht kommst. Du weißt, was Threads sind, oder? Du weißt, wie die funzen? Wenn nicht - es gibt im Internet tausenundeinen Artikel dazu. Wenn du's weißt - wieso kommst du dann nicht auf diese Lösung? Verstehst du die API-Dokumentationen nicht?

Cyax

Also ok, ich habs jetzt einfach so gelöst, das dem Thread eine
Struktur übergeben wird, in welcher unter anderem der von accept
zurückgegebene Socket eingetragen wird und zudem eine einzigartige
ID des Clients. Dann gibt es noch eine globale Variable über welche
ich quasi die Clients auswählen kann, da der Thread in einer endlos
Schleife immer schaut, ob denn seine eigene ID zufällig grad in der
globalen Variable gespeichert wurde. Sollte dies der Fall sein, so
öffnet der Thread eine Konsole, um dem ausgewählten Client Befehle
zu senden.