serverSSL.c

Vai alla documentazione di questo file.

#include <stdio.h>
#include <unistd.h>
#include <signal.h>

#include "pool.h"
#include "commSSL.h"
#include "errore.h"

#define MAXSRVSLEEP 128

volatile sig_atomic_t quitflag;

void *client_comm(void * client_info);
void gestore(int sig);

int main(int argc,char* argv[]){
        int nsec;
        char * service = "12100"; 
        srvSkSSL * server = NULL; 
        cli_conn * client = NULL; 
        th_pool * pool;                   
        sigset_t poolset;                 
        sigset_t set;                     
        struct sigaction action;
        quitflag = 0;

        /* ========= Gestione dei segnali ========= */
        /* Blocco i segnali */
        if (sigfillset(&set) == -1){
        sys_err(__FILE__,__LINE__,"Server: error sigfillset");
        return EXIT_FAILURE;
        }

        if (pthread_sigmask(SIG_SETMASK, &set, NULL) != 0) {
                sys_err(__FILE__,__LINE__,
                        "Server: pthread_sigmask error 'sigsetmask'");
                return EXIT_FAILURE;
        }

        /* Installo il nuovo gestore */
        memset(&action, 0, sizeof(action));
        if (sigemptyset(&action.sa_mask) == -1){
        sys_err(__FILE__,__LINE__,"Server: error sigemptyset");
        return EXIT_FAILURE;
        }

        /* Ignoro il SIGPIPE */
        action.sa_handler = SIG_IGN;
        if (sigaction(SIGPIPE, &action, NULL) == -1) {
                sys_err(__FILE__,__LINE__, "Server: sigaction error 'SIGPIPE'");
                exit(EXIT_FAILURE);
        }

        action.sa_handler = gestore;
        action.sa_flags = 0;

        /* Definisco i segnali che voglio gestire */
        if (sigaction(SIGINT, &action, NULL) < 0){
                sys_err(__FILE__,__LINE__,"Server: sigaction error 'SIGINT'");
                return EXIT_FAILURE;
        }

        if (sigaction(SIGTERM, &action, NULL) < 0){
        sys_err(__FILE__,__LINE__,"Server: sigaction error 'SIGTERM'");
        return EXIT_FAILURE;;
        }

        /* Installo la nuova maschera dei segnali */
        if (pthread_sigmask(SIG_SETMASK, &action.sa_mask, NULL) != 0) {
                sys_err(__FILE__,__LINE__,
                        "Server: pthread_sigmask error 'sigsetmask'");
                return EXIT_FAILURE;
        }

        /* Questa maschera per il pool che ignora tutti i segnali */
        if (sigfillset(&poolset) == -1){
                sys_err(__FILE__,__LINE__,"Server: error sigfillset");
                exit(errno);
        }

        /* Creo una socket di comunicazione */
        if ((server = newSSLServerChannel(service)) == NULL){
                sys_err(__FILE__,__LINE__,"Server: createServerChannel");
                exit(errno);
        }

        /* Inizializzo un pool di thread di dimensione 5 e con
         * un numero massimo di job in attesa nella coda di 10 */
        pool = poolInit(5, 10, &poolset);

        while (!quitflag){
                /* Pongo il server in attesa di nuove connessioni */
                if ((client = acceptSSLConnection(server)) != NULL){
                        /* Sottomissione job al pool con riprova (lenta) */
                        for (nsec = 1; nsec<=MAXSRVSLEEP && poolDispatcher(pool, client_comm, client)==-5; nsec<<=1)
                                if (nsec<=MAXSRVSLEEP/2) sleep(nsec);
                }
                /* TODO Manca la gestione degli errori */
        }
        /* Arresto il pool di threads e libero le risorse */
        poolDestroy(pool);
        /* Chiudo la socket di comunicazione */
        closeSSLServerSocket(server);
        unloadSSL();
        return 0;
}

void *client_comm(void * client_info){
        cli_conn * client = NULL;
        message_t msg;
        int recive_val = 1, sent_val = 1, quit = 0;

        client = (cli_conn *) client_info;
        msg.buffer = NULL;

        while ((recive_val>0) && (sent_val>0) && (quit!=1)){
                /* Ricevo un messaggio */
                if ((recive_val = receiveSSLMessage(client, &msg)) > 0){
                        /* Controllo il tipo di messaggio ricevuto */
                        switch(msg.type){
                                case MSG_EXIT:
                                        quit = 1;
                                        msg.type = MSG_OK;
                                        msg.length = 0;
                                        if (msg.buffer){
                                                free(msg.buffer);
                                                msg.buffer=NULL;
                                        }
                                break;
                                case MSG_PRINT:
                                        msg.type = MSG_OK;
                                        msg.length = 0;
                                        if (msg.buffer){
                                                printf ("Mgs: %s\n",msg.buffer);
                                                free(msg.buffer);
                                                msg.buffer = NULL;
                                        }
                                break;
                        }
                        /* Invio il messaggio di risposta */
                        sent_val = sendSSLMessage(client, &msg);
                }
        }

        printf("Server: Chiusura comunicazione con client\n");
        /* Chiudo la socket di comunicazione */
        closeSSLConnection(client);
        return 0;
}

void gestore(int sig) {
        switch (sig) {
                case SIGTERM:
                        write(2, "server: signal 15 detected\n", 27);
                        quitflag = 1;
                break;
                case SIGINT:
                        write(2, "server: signal 2 detected\n", 26);
                        quitflag = 1;
                break;
        }
}