![[HaBo]](/styles/default/logoklein.png){kind=small}
Hi !
Ich habe mal folgende Frage zu diesem Programm ( abgändert von pronix )
server
Die Funktion cl_handler übernimmt dabei die kommunikation mit einem client. Ein boost Thread wird gestartet, wenn ein client eine Verbindung zum Server herstellt.
Der Server soll mit dem Client eine einfache Text Nachricht austauschen.
client
Problem ist, verbinden sich > 1 Clients mit dem Server, so habe ich nur einen Socket, der von allen Clients benutzt wird d.h. bei einer neuen Verbindung wird der vorherige Client "gekillt". Die Threads benutzen ja die gleichen Ressourcen wie der Hauptthread, wie könntem man die gemeine Nutzung der sockets organisieren ?
PS : Ich weiß, man könnte es auch mit fork() machen aber das starten neuer Prozesse ist rechenintensiver als threads.
Ich habe mal folgende Frage zu diesem Programm ( abgändert von pronix )
server
Code:
#include <boost/thread/thread.hpp>
#include <boost/bind.hpp>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <errno.h>
#define MAX_ZEICHEN 1024
#define PORT_NUMMER 15000
int connfd;
void client_handler()
{
while(1)
{
char buffer[256];
char *c_ptr = "TEST";
ssize_t r;
if((r = recv(connfd, buffer,255,0)) > 0)
buffer[r] = '\0';
printf("%s",buffer);
send(connfd,c_ptr,strlen(c_ptr),0);
}
}
int main (void) {
int sockfd, j, n, ngesamt;
struct sockaddr_in adresse;
const int y = 1;
size_t adrlaenge = sizeof (struct sockaddr_in);
char puffer[MAX_ZEICHEN];
char path_file[MAX_ZEICHEN];
pid_t pid;
if ((sockfd = socket (PF_INET, SOCK_STREAM, 0)) < 0) {
printf ("Fehler bei socket() ...(%s)\n", strerror(errno));
exit (EXIT_FAILURE);
}
printf ("Socket erfolgreich angelegt\n");
adresse.sin_family = AF_INET;
adresse.sin_port = htons (PORT_NUMMER);
memset (&adresse.sin_addr, 0, sizeof (adresse.sin_addr));
setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &y, sizeof(int));
if (bind ( sockfd,
(struct sockaddr *) &adresse,
sizeof (adresse) ) ) {
printf ("Fehler bei bind() ...(%s)\n", strerror(errno));
exit (EXIT_FAILURE);
}
printf ("Server ist bereit und wartet ...\n");
if (listen (sockfd, 5) ) {
printf ("Fehler bei listen() ...(%s)\n", strerror(errno));
exit (EXIT_FAILURE);
}
while(1) {
connfd = accept ( sockfd,
(struct sockaddr *) &adresse,
&adrlaenge );
if( connfd < 0 ) {
if( errno == EINTR )
continue;
else {
printf("Fehler bei accept() (%s)\n",strerror(errno));
exit(EXIT_FAILURE);
}
}
boost::thread t(client_handler);
}//Ende while(1)
close (sockfd);
exit (EXIT_SUCCESS);
}Die Funktion cl_handler übernimmt dabei die kommunikation mit einem client. Ein boost Thread wird gestartet, wenn ein client eine Verbindung zum Server herstellt.
Der Server soll mit dem Client eine einfache Text Nachricht austauschen.
client
Code:
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#define BUF 1024
int main (int argc, char **argv) {
int create_socket;
char *buffer = malloc (BUF);
struct sockaddr_in address;
int size;
if( argc < 2 ){
printf("Usage: %s ServerAdresse\n", *argv);
exit(EXIT_FAILURE);
}
printf ("\e[2J");
if ((create_socket = socket (AF_INET, SOCK_STREAM, 0)) > 0)
printf ("Socket wurde angelegt\n");
address.sin_family = AF_INET;
address.sin_port = htons (15000);
inet_aton (argv[1], &address.sin_addr);
if (connect ( create_socket,
(struct sockaddr *) &address,
sizeof (address)) == 0)
printf ("Verbindung mit dem Server (%s) hergestellt\n",
inet_ntoa (address.sin_addr));
char *c_ptr = "192.168.4.1";
while(1)
{
send(create_socket,c_ptr,strlen(c_ptr),0);
size = recv(create_socket,buffer,BUF-1,0);
if(size > 0)
buffer[size] = '\0';
printf("%s",buffer);
}
close (create_socket);
return EXIT_SUCCESS;
}Problem ist, verbinden sich > 1 Clients mit dem Server, so habe ich nur einen Socket, der von allen Clients benutzt wird d.h. bei einer neuen Verbindung wird der vorherige Client "gekillt". Die Threads benutzen ja die gleichen Ressourcen wie der Hauptthread, wie könntem man die gemeine Nutzung der sockets organisieren ?
PS : Ich weiß, man könnte es auch mit fork() machen aber das starten neuer Prozesse ist rechenintensiver als threads.
