source: trunk/instant_messenger/socket/BKP_20071105/BKP_20071026/BKP_20071019/BKP_20071018/BKP_20071009/BKP_20071008/BKP/server.c @ 151

#include "server.h"

void my_shutdown(int n){
        printf("server recvd SIGPIPE");
        exit(1);
}

int main(int argc, char ** argv)
{
        /* variables to parse arguments */
        extern int optind,
                           optopt;
        extern char * optarg;

        char * log_file;
        int c           = (int)NULL,
                errflg  = (int)NULL,
                verbose = (int)NULL,
                optval  = 1;

        socklen_t optlen = sizeof(optval);

        /* fd -> file descriptor */
        int socket_server_fd    = (int)NULL,
                socket_server_port      = (int)NULL,
                socket_accept_fd        = (int)NULL,
                sockaddr_in_size        = sizeof(struct sockaddr_in),
                err                                     = (int)NULL;

        /* Internet socket address stuct */
        struct sockaddr_in server_addr,
                                           accept_addr;

        struct client * clients = (struct client *) NULL,
                                  * current = (struct client *) NULL;

        pthread_t threads;

        /* clear screen */
        system(__CLEAR_SCREEN__);
        signal(SIGPIPE, my_shutdown);

        while ( (c = getopt(argc, argv, ":vp:")) != -1 )
        {
                switch ( c )
                {
                        case 'p':
                                if ( socket_server_port = strtol(optarg, 0, 10) == 0 )
                                {
                                        fprintf(stderr, "Option -%c requires a valid port and '%s' isn't valid\n", optopt, optarg);
                                        ++errflg;
                                }
                                break;
                        case 'v':
                                verbose = 1;
                                break;
                        case ':':
                                /* -f or -o without operand */
                                fprintf(stderr, "Option -%c requires an operand\n", optopt);
                                ++errflg;
                                break;
                        case '?':
                                fprintf(stderr, "Unrecognized option: -%c\n", optopt);
                                ++errflg;
                }
        }
        if ( errflg )
        {
                fprintf(stderr, "usage: . . . \n\n");
                exit(2);
        }
        //exit(0);

        /*if ( argc != 2 || (socket_server_port = strtol(argv[1], 0, 10)) == 0 )
                usage();*/

        /* make a socket */
        socket_server_fd = socket(AF_INET, SOCK_STREAM, 0);
        if ( socket_server_fd == __SOCKET_ERROR__ )
        {
                printf("\nCould not make a socket\n");
                return 0;
        }

        bzero((char *) &server_addr, sockaddr_in_size);
        bzero((char *) &accept_addr, sockaddr_in_size);

        if ( !socket_server_port )
                socket_server_port = __DEFAULT_OPEN_PORT__;

        /* fill address struct */
        server_addr.sin_addr.s_addr     = INADDR_ANY;
        server_addr.sin_port            = htons(socket_server_port);
        server_addr.sin_family          = AF_INET;
        bzero(&(server_addr.sin_zero), 8);

        if ( __DEBUG__  || verbose )
                printf("\nBinding to port %d...\n", socket_server_port);

        /* bind to a port */
        if ( bind(socket_server_fd, (struct sockaddr *)&(server_addr), sizeof(server_addr)) == __SOCKET_ERROR__ )
        {
                printf("\nCould not connect to host\n");
                exit(1);
        }

        /* get port number */
        getsockname(socket_server_fd, (struct sockaddr *)&(server_addr), (socklen_t *) &(sockaddr_in_size));
        if ( __DEBUG__  || verbose )
        {
                printf("\nopened socket as fd (%d) on port (%d) for stream i/o\n", socket_server_fd, ntohs(server_addr.sin_port));

                printf("Server\n\
                                sin_family        = %d\n\
                                sin_addr.s_addr   = %d\n\
                                sin_port          = %d\n"
                                , server_addr.sin_family
                                , server_addr.sin_addr.s_addr
                                , ntohs(server_addr.sin_port)
                          );
                printf("\nMaking a listen queue of %d elements", __QUEUE_SIZE__);
        }

        /* establish listen queue */
        if ( listen(socket_server_fd, __QUEUE_SIZE__) == __SOCKET_ERROR__ )
        {
                printf("\nCould not listen\n");
                return 0;
        }

        for ( ; ; )
        {
                if ( __DEBUG__  || verbose )
                        puts("\nWaiting for a connection\n");

                /* get the connected socket */
                socket_accept_fd = accept(socket_server_fd, (struct sockaddr *) &(accept_addr), (socklen_t *) &(sockaddr_in_size));
                fcntl(socket_accept_fd, F_SETFL, fcntl(socket_accept_fd, F_GETFL, 0) | O_NDELAY);

                if ( setsockopt(socket_accept_fd, SOL_SOCKET, SO_KEEPALIVE, &optval, optlen) < 0)
                {
                        perror("setsockopt()");
                        exit(EXIT_FAILURE);
                }

                int val;
                val = 10; /* 10 sec before starting probes */
                setsockopt (socket_accept_fd, SOL_TCP, TCP_KEEPIDLE, &val, sizeof (val));
                val = 2; /* 2 probes max */
                setsockopt (socket_accept_fd, SOL_TCP, TCP_KEEPCNT, &val, sizeof (val));
                val = 5; /* 5 seconds between each probe */
                setsockopt (socket_accept_fd, SOL_TCP, TCP_KEEPINTVL, &val, sizeof (val));


                if ( socket_accept_fd > -1 )
                {
                        if ( clients == (struct client *) NULL )
                                current = clients;
                        else
                                while ( (current = clients->next) != (struct client *) NULL );

                        current                         = (struct client *) malloc(sizeof(struct client));
                        current->next           = (struct client *) NULL;
                        current->fd                     = socket_accept_fd;
                        current->sockaddr       = accept_addr;
                        current->last           = time(NULL);

                        pthread_create(&(threads), NULL, handler, (void *) current);
                }
                puts("jah era #5");
        }
        pthread_exit(NULL);
}

void * handler(void * pClient)
{
    char buffer_client[__BUFFER_SIZE__],
                 buffer_jabber[__BUFFER_SIZE__];
    struct client * client = (struct client *) pClient;
    int i = 0, err;
        time_t last;

        char ip[46];
        unsigned short port;
        inet_ntop(AF_INET, &(client->sockaddr.sin_addr), ip, sizeof (ip));
        port = ntohs(client->sockaddr.sin_port);
        printf("\nGot a connection from %s, port %hu\n", ip, port);
        //fcntl( client->fd, F_SETFL, fcntl( client->fd, F_GETFL ) & ~O_NONBLOCK );
        //printf(":::client %d\n\n\n", fcntl( client->fd, F_GETFL, 0));
        //printf(":::client %d\n\n\n", fcntl( client->fd, F_SETFL, fcntl( client->fd, F_GETFL ) & ~O_NONBLOCK ));
        /*---------------------------------------------------*/

        int jabber_fd           = (int)NULL,
                jabber_port             = (int)NULL,
                jabber_error    = (int)NULL;

        struct sockaddr_in jabber_addr;

        jabber_port = __DEFAULT_JABBER_PORT__;
        //jabber_port = strtol(__DEFAULT_JABBER_PORT__, 0, 10);
        jabber_fd = socket(AF_INET, SOCK_STREAM, 0);
        fcntl(jabber_fd, F_SETFL, fcntl(jabber_fd, F_GETFL, 0) | O_NDELAY);

        jabber_addr.sin_family = AF_INET;
        inet_aton(__DEFAULT_JABBER_IP__, &jabber_addr.sin_addr);
        jabber_addr.sin_port = htons(jabber_port);

        jabber_error = connect(jabber_fd, (struct sockaddr *) &(jabber_addr), sizeof(jabber_addr));

        last = time(NULL);
        int client_is_connected = -1;
        int jabber_is_connected = -1;
        int sockaddr_in_size    = sizeof(struct sockaddr_in);
        while ( client_is_connected != 0 )
        {
                puts("begin loop");
                /* read from client */
                puts("\tread - client");
                bzero(buffer_client, __BUFFER_SIZE__);
                if ( (client_is_connected = read(client->fd, buffer_client, __BUFFER_SIZE__)) != 0 && strlen(buffer_jabber) > 0 )
                {
                        puts("\twrite - jabber");
                        /* write in the client */
                        write(client->fd, buffer_jabber, strlen(buffer_jabber));
                }

                /*if ( client_is_connected == 0 )
                        break;*/

                /* read from jabber service */
                puts("\tread - jabber");
                bzero(buffer_jabber, __BUFFER_SIZE__);
                if ( (jabber_is_connected = read(jabber_fd, buffer_jabber, __BUFFER_SIZE__)) && strlen(buffer_client) > 0 )
                {
                        puts("\twrite - client");
                        /* write in the jabber service */
                        write(jabber_fd, buffer_client, strlen(buffer_client));
                }

                if ( jabber_is_connected == 0 )
                        client_is_connected = jabber_is_connected;

                puts("end loop");
                usleep(500000);
        }

    if ( close(jabber_fd) == __SOCKET_ERROR__ )
    {
        printf("\nCould not close jabber socket\n");
        return 0;
    }
        /*---------------------------------------------------*/
    if ( close(client->fd) == __SOCKET_ERROR__ )
    {
        printf("\nCould not close socket\n");
        return 0;
    }

    fflush(stdin);
    fflush(stdout);
        free(client);
    pthread_exit(NULL);
}