pthread - przeciążenie kolejki

Napisałem prosta aplikację w C - serwer uzywając pthread.
Problem w tym, że po czasie przestaje odpowiadać - prawdopodobnie za dużo prób połączeń.

Kod:

#include<stdio.h>
#include<string.h>    //strlen
#include<stdlib.h>    //strlen
#include<sys/socket.h>
#include<arpa/inet.h> //inet_addr
#include<unistd.h>    //write
#include<pthread.h> //for threading , link with lpthread
#include <stdint.h>

#define	SERVER_PORT	8888


//the thread function
void *connection_handler(void *);
void *listen_handler();

int main(int argc , char *argv[])
{
	puts("Creating server...");
	pthread_t sniffer_thread;
	if( pthread_create( &sniffer_thread, NULL, listen_handler ,NULL) )
	{
		perror("Could not create thread for listen");
		return 1;
	}
	
	while(1)
	{
		// my code ... 
        delay( 1000 );
	}
    
	return 0;
}

void *listen_handler()
{
	int socket_desc , client_sock , c , *new_sock;
    struct sockaddr_in server , client;
     
    //Create socket
    socket_desc = socket(AF_INET , SOCK_STREAM , 0);
    if (socket_desc == -1)
    {
        printf("Could not create socket");
    }
    puts("Socket created");
     
    //Prepare the sockaddr_in structure
    server.sin_family = AF_INET;
    server.sin_addr.s_addr = INADDR_ANY;
    server.sin_port = htons( SERVER_PORT );
     
    //Bind
    if( bind(socket_desc,(struct sockaddr *)&server , sizeof(server)) < 0)
    {
        //print the error message
        perror("bind failed. Error");
        exit( 1 );
    }
    puts("bind done");
     
    //Listen
    listen(socket_desc , 3);
     
    //Accept and incoming connection	
    puts("Waiting for incoming connections...");
    c = sizeof(struct sockaddr_in);

    while( (client_sock = accept(socket_desc, (struct sockaddr *)&client, (socklen_t*)&c)) )
    {
#ifdef DEBUG
        puts("Client connected!");
#endif

        pthread_t sniffer_thread;
        new_sock = malloc(1);
        *new_sock = client_sock;

        if( pthread_create( &sniffer_thread , NULL ,  connection_handler , (void*) new_sock) < 0)
        {
            perror("Could not create thread for client");
            exit( 1 );
        }

        //Now join the thread , so that we dont terminate before the thread
        pthread_join( sniffer_thread , NULL);
        //puts("Handler assigned");
    }

    if (client_sock < 0)
    {
        perror("Accept failed");
        exit( 1 );
    }
}

/*
 * This will handle connection for each client
 * */
void *connection_handler(void *socket_desc)
{
    //Get the socket descriptor
    int sock = *(int*)socket_desc;
    int read_size;
    char message[1024];

    //Send reply to the client
	sprintf(message, "good data!");
    write(sock , message , strlen(message));
     
    if(read_size == 0)
    {
#ifdef DEBUG
        puts("Client disconnected");
#endif

        fflush(stdout);
    }
    else if(read_size == -1)
    {
        perror("recv failed");
    }
         
    //Free the socket pointer
    free(socket_desc);
     
    return 0;
}

Zadanie jest proste - jest połączenie serwer wysyła dane i klient się rozłącza - od razu.
Problem w tym, że jak wyłączę wszystkie klienty, to serwer dalej rejestruje połączenia.
Jakiś pomysł? Da się oczyścić jakoś kolejkę np. ustawić maksymalny czas oczekiwania przez próbę połączenia?

Pytanie zasadnicze: a czy muszą być wątki? Tzn. ja się nie czepiam, ale kod wskazuje, że raczej nie wiesz co robisz, stąd moje pytanie, bo nieblokujące IO można uzyskać inaczej i prościej.

// zamiast: 
new_sock = malloc(1);

// powinno być:
new_sock = malloc(sizeof(int));

W funkcji main musi być watek, bo aplikacja coś sobie tam liczy i wysyła do klientów.
W części serwerowej, czyli listen, nie musi.

#edit:
Usunąłem wątekw listen_handler, bo faktycznie jest zbędny

#edit2
Niestety @up i @2XUP nie naprawił błędu.

Kod:

#include<stdio.h>
#include<string.h>    //strlen
#include<stdlib.h>    //strlen
#include<sys/socket.h>
#include<arpa/inet.h> //inet_addr
#include<unistd.h>    //write
#include<pthread.h> //for threading , link with lpthread
#include <stdint.h>

#define	DEBUG
#define MAX_TIMINGS 100
#define DHT_PIN 7

#define	SERVER_PORT	8888


//the thread function
void *connection_handler(void *);
void *listen_handler();
void read_dht_data();

int data[5] = { 0, 0, 0, 0, 0 };

int num_steps = 0;
float avg_temp = 0.0;
float avg_humidity = 0.0;

float result_humidity = 0.0;
float result_tempC = 0.0;

int main(int argc , char *argv[])
{
	puts("Creating server...");
	pthread_t sniffer_thread;
	if( pthread_create( &sniffer_thread, NULL, listen_handler ,NULL) )
	{
		perror("Could not create thread for listen");
		return 1;
	}
	
	while(1)
	{

        delay( 2000 );
	}
    
	return 0;
}

void *listen_handler()
{
	int socket_desc , client_sock , c , *new_sock;
    struct sockaddr_in server , client;
     
    //Create socket
    socket_desc = socket(AF_INET , SOCK_STREAM , 0);
    if (socket_desc == -1)
    {
        printf("Could not create socket");
    }
    puts("Socket created");
     
    //Prepare the sockaddr_in structure
    server.sin_family = AF_INET;
    server.sin_addr.s_addr = INADDR_ANY;
    server.sin_port = htons( SERVER_PORT );
     
    //Bind
    if( bind(socket_desc,(struct sockaddr *)&server , sizeof(server)) < 0)
    {
        //print the error message
        perror("bind failed. Error");
        exit( 1 );
    }
    puts("bind done");
     
    //Listen
    listen(socket_desc , 3);
     
    //Accept and incoming connection	
    puts("Waiting for incoming connections...");
    c = sizeof(struct sockaddr_in);

    while( (client_sock = accept(socket_desc, (struct sockaddr *)&client, (socklen_t*)&c)) )
    {
#ifdef DEBUG
        puts("Client connected!");
#endif

		int read_size;
		char message[1024];

		//Send reply to the client
		sprintf(message, "good data");
		write(client_sock, message, strlen(message));
		 
		if(read_size == 0)
		{
	#ifdef DEBUG
			puts("Client disconnected");
	#endif

			fflush(stdout);
		}
		else if(read_size == -1)
		{
			perror("recv failed");
		}
         

    }

    if (client_sock < 0)
    {
        perror("Accept failed");
        exit( 1 );
    }
}

Cześć

Focusx napisał(a):

Napisałem prosta aplikację w C - serwer uzywając pthread.
Problem w tym, że po czasie przestaje odpowiadać - prawdopodobnie za dużo prób połączeń.

Problem polega na tym, że nigdzie nie wywołujesz funkcji close()
Powinieneś użyć jej za każdym razem gdy kończysz połączenie utworzone przez accept
Nawet jeśli klient kończy połączenie to na serwerze masz ciągle otwarty deskryptor pliku.
Po pewnym czasie po prostu kończą Ci się zasoby.

Powinieneś też użyć close() kiedy kończysz działanie serwera.
Musisz zamknąć gniazdo na którym serwer nasłuchiwał.

Focusx napisał(a):

Zadanie jest proste - jest połączenie serwer wysyła dane i klient się rozłącza - od razu.
Problem w tym, że jak wyłączę wszystkie klienty, to serwer dalej rejestruje połączenia.

To normalne, że serwer dalej oczekuje na połączenia. Serwer nie jest duchem świętym i nie wie ile klientów ma obsłużyć.
Jeśli chcesz obsłużyć określoną liczbę klientów to powinieneś trzymać w jakiejś zmiennej ilość wysłanych odpowiedzi, którą będziesz zwiększał za każdym razem o 1.
Jeśli ilość jest większa niż np. 5 to kończysz działanie.

Focusx napisał(a):

Jakiś pomysł? Da się oczyścić jakoś kolejkę np. ustawić maksymalny czas oczekiwania przez próbę połączenia?

Jeśli chcesz ustawić czas oczekiwania funkcji accept na połączenie to poczytaj o gniazdach nie blokujących i funkcji select()