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

#include "server.h"
#include "xmpp.h"

#define HOST "im.celepar.parana"
#define IP "10.15.20.219"
#define PORT "5222"

int tls = 0;

void Read(void * fd, void *buf, int count)
{
        bzero(buf, count);
        if ( tls == 0 )
                read(*(int *) fd, buf, (ssize_t)count);
        else
                SSL_read((SSL *) fd, buf, count);
}

void Write(void * fd, void *buf, int count)
{
        if ( tls == 0 )
                write(*(int *) fd, buf, (ssize_t)count);
        else
                SSL_write((SSL *) fd, buf, count);
}

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;

        SSL_CTX * ctx;

        pthread_t threads;

        // clear screen
        system(__CLEAR_SCREEN__);

        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);
        }

        OpenSSL_add_all_algorithms();
        SSL_library_init();
        SSL_load_error_strings();

        if ( !(ctx = SSL_CTX_new(TLSv1_server_method())) )
        {
                printf("Error creating the context.\n");
                exit(0);
        }

        if ( SSL_CTX_set_cipher_list(ctx, CIPHER_LIST) < 1 )
        {
                printf("Error setting the cipher list.\n");
                exit(0);
        }

        //Indicate the certificate file to be used
        if ( SSL_CTX_use_certificate_file(ctx, CERT_FILE, SSL_FILETYPE_PEM) < 1 )
        {
                printf("Error setting the certificate file.\n");
                exit(0);
        }

        //Load the password for the Private Key
        SSL_CTX_set_default_passwd_cb_userdata(ctx, KEY_PASSWD);

        //Indicate the key file to be used
        if ( SSL_CTX_use_PrivateKey_file(ctx, KEY_FILE, SSL_FILETYPE_PEM) < 1 )
        {
                printf("Error setting the key file.\n");
                exit(0);
        }

        //Make sure the key and certificate file match
        if ( !SSL_CTX_check_private_key(ctx) )
        {
                printf("Private key does not match the certificate public key\n");
                exit(0);
        }

        // Set the list of trusted CAs based on the file and/or directory provided
        if ( SSL_CTX_load_verify_locations(ctx, CA_FILE, CA_DIR) < 1 )
        {
                printf("Error setting verify location\n");
                exit(0);
        }

        // Set for server verification
        SSL_CTX_set_verify(ctx, SSL_VERIFY_NONE, NULL);

        /* 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 ( 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->ctx            = ctx;
                        current->last           = time(NULL);

                        pthread_create(&(threads), NULL, handler, (void *) current);
                }
        }
        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);
        /*---------------------------------------------------*/

        int client_is_connected = -1;
        int jabber_is_connected = -1;

        struct sockaddr_in socketaddr;
        int socketfd,
                nHostPort;

        char buff[4096];
        char * xml = (char)NULL;
        SSL_CTX  *ctx;
        SSL  *myssl;

        char * old_host,
                 * replace_host;

        xml = (char *) malloc(sizeof(__CONNECT__));

        if ( (nHostPort = strtol(PORT, 0, 10)) == 0 )
        {
                printf("\n<port>\n\n");
                printf("\ncould not make a socket\n");
                return 0;
        }

        socketfd = socket(AF_INET, SOCK_STREAM, 0);

        socketaddr.sin_family = AF_INET;
        socketaddr.sin_addr.s_addr = inet_addr(IP);
        socketaddr.sin_port = htons(nHostPort);

        if ( !(ctx = SSL_CTX_new(TLSv1_client_method())) )
        {
                printf("Error creating the context.\n");
                exit(0);
        }

        err = connect(socketfd, (struct sockaddr*)&socketaddr, sizeof(socketaddr));
        fcntl(socketfd, F_SETFL, fcntl(socketfd, F_GETFL, 0) | O_NDELAY);

        if ( err < 0 )
        {
                printf("Socket returned error #%d,program terminated\n", err);
                exit(0);
        }

        while ( client_is_connected != 0 )
        {
                /* read from client */
                puts("\tread - client");
                bzero(buffer_client, __BUFFER_SIZE__);
                if ( (client_is_connected = read(client->fd, buffer_client, __BUFFER_SIZE__)) != 0 )
                {
                        if ( strlen(buffer_jabber) > 0 )
                        {
                                puts("\twrite - client");
                                printf("\t%s\n", buffer_jabber);
                                /* write in the client */
                                write(client->fd, buffer_jabber, strlen(buffer_jabber));
                        }

                        if ( strstr(buffer_client, "<stream:stream") && (old_host = strstr(buffer_client, "to=")) )
                        {
                                strncpy(replace_host, buffer_client, (strlen(buffer_client) - strlen(old_host))+4);
                                strcat(replace_host, HOST);
                                old_host = strstr(old_host, " ");
                                old_host--;
                                strcat(replace_host, old_host);
                                strcpy(buffer_client, replace_host);
                        }
                }

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

                if ( strstr(buffer_jabber, "<proceed xmlns='urn:ietf:params:xml:ns:xmpp-tls'/>") )
                {
                        fcntl( socketfd, F_SETFL, fcntl( socketfd, F_GETFL ) & ~O_NDELAY );
                        SSL_CTX_set_verify(ctx,SSL_VERIFY_NONE,NULL);
                        //Create new ssl object
                        myssl=SSL_new(ctx);

                        if(!myssl){
                                printf("Error creating SSL structure.\n");
                                exit(0);
                        }

                        //Bind the socket to the SSL structure
                        SSL_set_fd(myssl,socketfd);

                        //Connect to the server, SSL layer.
                        err=SSL_connect(myssl);
                        printf("SSL error #%d in accept,program terminated\n",err);
                        //Check for error in connect.
                        if (err<1) {

                                err=SSL_get_error(myssl,err);
                                printf("SSL error #%d in accept,program terminated\n",err);
                                printf("%d -- %d\n\n", SSL_ERROR_WANT_READ, SSL_ERROR_WANT_WRITE);

                                if(err==5){printf("sockerrno is:\n");}

                                close(socketfd);
                                SSL_CTX_free(ctx);
                                exit(0);
                        }

                        fcntl(socketfd, F_SETFL, fcntl(socketfd, F_GETFL, 0) | O_NDELAY);

                        write(client->fd, buffer_jabber, strlen(buffer_jabber));
                        bzero(buffer_jabber, __BUFFER_SIZE__);

                        fcntl( client->fd, F_SETFL, fcntl( client->fd, F_GETFL ) & ~O_NDELAY );

                        //Create new ssl object
                        if( !(client->myssl = SSL_new(client->ctx)) )
                        {
                                printf("Error creating SSL structure.\n");
                                exit(0);
                        }

                        //Bind the socket to the SSL structure
                        SSL_set_fd(client->myssl, client->fd);

                        puts("_____TESTE______");
                        //Connect to the server, SSL layer.
                        err = SSL_accept(client->myssl);
                        puts("_____TESTE______");

                        //Check for error in connect.
                        if ( err < 1 )
                        {
                                printf("SSL error #%d in accept,program terminated\n", err);
                                err = SSL_get_error(client->myssl, 0);
                                printf("SSL error #%d in accept,program terminated\n", err);

                                switch ( err )
                                {
                                        case SSL_ERROR_NONE : puts("SSL_ERROR_NONE");break;
                                        case SSL_ERROR_SSL : puts("SSL_ERROR_SSL");break;
                                        case SSL_ERROR_WANT_READ : puts("SSL_ERROR_WANT_READ");
                                }

                                if ( err == 5 )
                                        printf("sockerrno is: %d\n", err);


                                SSL_CTX_free(client->ctx);
                                client_is_connected = 0;
                        }
                }

                if ( jabber_is_connected == 0 )
                        client_is_connected = jabber_is_connected;

                puts("end loop");
                usleep(500000);
        }
    if ( close(socketfd) == __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);
}