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

#include "server.h"

int main(int argc, char* argv[])
{
        /* handle to socket */
        int hSocket = (int)NULL,
                hServerSocket = (int)NULL;

        int nAddressSize = sizeof(struct sockaddr_in);
        int nHostPort = (int)NULL;
        int err;

        /* holds info about a machine */
        struct hostent * pHostInfo = (struct hostent *)NULL;

        /* Internet socket address stuct */
        struct sockaddr_in Address;

        struct client * clients = (struct client *)NULL;
        pthread_t threads;
        //pthread_t clients;

        SSL_CTX * ctx;
        SSL * myssl;

        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_PEER, NULL);

        if ( argc != 2 || (nHostPort = strtol(argv[1], 0, 10)) == 0 )
        {
                printf("\n<PORT>\n\n");
                printf("\nCould not make a socket\n");
                return 0;
        }

        printf("\nStarting server");
        printf("\nMaking socket");

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

        /* fill address struct */
        Address.sin_addr.s_addr = INADDR_ANY;
        Address.sin_port = htons(nHostPort);
        Address.sin_family = AF_INET;

        printf("\nBinding to port %d", nHostPort);

        /* bind to a port */
        if ( bind(hServerSocket, (struct sockaddr*)&Address, sizeof(Address)) == SOCKET_ERROR )
        {
                printf("\nCould not connect to host\n");
                return 0;
        }

        /* get port number */
        getsockname( hServerSocket, (struct sockaddr *) &Address,(socklen_t *)&nAddressSize);
        printf("opened socket as fd (%d) on port (%d) for stream i/o\n", hServerSocket, ntohs(Address.sin_port));

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

        /* establish listen queue */
        if ( listen(hServerSocket, QUEUE_SIZE) == SOCKET_ERROR )
        {
                printf("\nCould not listen\n");
                return 0;
        }

        for ( ; ; )
        {
                fflush(stdin);
                fflush(stdout);
                ///printf("\nWaiting for a connection\n");
                puts("\nWaiting for a connection\n");

                /* get the connected socket */
                hSocket = accept(hServerSocket, (struct sockaddr*)&Address, (socklen_t *)&nAddressSize);
                clients = (struct client *) malloc(sizeof(struct client));
                clients->hSocket = hSocket;

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

                /*Bind the socket to the SSL structure*/
                SSL_set_fd(clients->myssl, hSocket);

                puts("_____TESTE______");
                /*Connect to the server, SSL layer.*/
                err = SSL_accept(clients->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(clients->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);


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

                //clients->myssl = myssl;
                pthread_create(&threads, NULL, handler, (void *)clients);
                clients = (struct client *)NULL;
        }
        pthread_exit(NULL);
        puts("FIM LAssO");
}

void * handler(void * pClient)
{
    char pBuffer[BUFFER_SIZE];
    struct client * client = (struct client *)pClient;
    int i = 0, err;

    printf("\nGot a connection");
    strcpy(pBuffer,MESSAGE);
    printf("\nSending \"%s\" to client",pBuffer);

    /* number returned by read() and write() is the number of bytes
    ** read or written, with -1 being that an error occured
    ** write what we received back to the server */
    //write(client->hSocket, pBuffer, strlen(pBuffer)+1);
    err=SSL_write(client->myssl, pBuffer, strlen(pBuffer)+1);
         printf("-------%s\n\n", pBuffer);


    /* read from socket into buffer */
    //read(client->hSocket, pBuffer, BUFFER_SIZE);
         err = SSL_read(client->myssl, pBuffer, BUFFER_SIZE);

         printf("-------%s\n\n", pBuffer);

    if ( strcmp(pBuffer, MESSAGE) == 0 )
        printf("\nThe messages match");
    else
        printf("\nSomething was changed in the message");

    while (i < 10)
    {
                 printf("%d\n", i);
                 usleep(1000000);
                 i++;
    }

    printf("\nClosing the socket");

         /*pBuffer[0] = '\0';
         printf("\n\nread = %s\n\nsd = %d\n\n\n", pBuffer, SSL_get_shutdown(client->myssl));
         SSL_shutdown(client->myssl);
         pBuffer[0] = '\0';
         printf("\n\nread = %s\n\nsd = %d\n\n\n", pBuffer, SSL_get_shutdown(client->myssl));
         SSL_shutdown(client->myssl);
         pBuffer[0] = '\0';
         printf("\n\nread = %s\n\nsd = %d\n\n\n", pBuffer, SSL_get_shutdown(client->myssl));
    SSL_free(client->myssl);
        */
    /* close socket */
    if ( close(client->hSocket) == SOCKET_ERROR )
    {
        printf("\nCould not close socket\n");
        return 0;
    }

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