之前写的SSL的性能测试程序

client.c

#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <sys/socket.h>
#include <resolv.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <openssl/ssl.h>
#include <openssl/err.h>
#include <sys/mman.h>

#define MAXBUF 1024
#define MAX_THREADS 100
#define SUBTHREADNUM 2

int pkgSize = 1024;
int threads = 10;
int times = 10;
int mode = 0;            //0-handshake 1-throughput 2-full
int sslversion = 1;        //0-SSLv2 1-SSLv3 2-SSLv23 3-TLSv1 4-TLSv1_1 5-TLSv1_2
char *ip = "127.0.0.1";
int port = 8701;
char *cipher = "AES128-SHA";
int debug = 0;
int showTitle = 1;


struct cpuinfo
{
    char name[20];
    unsigned int user;
    unsigned int nice;
    unsigned int system;
    unsigned int idle;
    unsigned int iowait;
    unsigned int irq;
    unsigned int softirq;
    unsigned int stealstolen;
    unsigned int guest;
};

void throughputTest();
void handshakeTest();
void fullTest();
void apacheTest();
void getCpuInfo (struct cpuinfo *cpu);
void calCpuUseRatio (struct cpuinfo *old, struct cpuinfo *new);
int getCpuTotalUseRatio();

struct shm_layout
{
    u_int64_t count[MAX_THREADS];
    u_int64_t t1[MAX_THREADS];
    u_int64_t t2[MAX_THREADS];
    int ready[MAX_THREADS];
    int done[MAX_THREADS];
    volatile int start;
    volatile int exit;
    volatile int stop;
};

struct subthread_layout
{
    u_int64_t starttime[SUBTHREADNUM];
    u_int64_t endtime[SUBTHREADNUM];
    u_int64_t count[SUBTHREADNUM];
};

struct shm_layout *shared_region = NULL;
struct subthread_layout subthread_region;
u_int64_t total_count = 0ull;
int thread_id = 0;
u_int64_t min_t1 = 0ull, max_t2 = 0ull;
u_int64_t total_throughput = 0;
int pid[100];
struct sockaddr_in dest;
char *buffer;
SSL_CTX *ctx;

void usage()
{
    printf("Usage: Client \n\
            -a   IP Addr (127.0.0.1) \n\
            -c   Cipher (AES128-SHA) \n\
            -p   Port (8701)\n\
            -s   Package Size (1024)\n\
            -t   Times (10)\n\
            -l   Threads (10)\n\
            -m   Mode (0-handshake 1-throughput 2-full 3-apachessl default 0)\n\
            -v   SSLVersion (0-SSLv2 1-SSLv3 2-SSLv23 3-TLSv1 4-TLSv1_1 5-TLSv1_2 default 1)\n\
            -d   Debug Info\n\
            -h   Help\n");
    exit(-1);
}

void min_max_times(int count, u_int64_t *t1, u_int64_t *t2, u_int64_t *min_t1, u_int64_t *max_t2)
{
    int i = 0;
    
    *min_t1 = t1[0];
    *max_t2 = t2[0];
    for(i = 1; i < count; i++)
    {
        if(t1[i] < *min_t1)
            *min_t1 = t1[i];
        if(t2[i] > *max_t2)
            *max_t2 = t2[i];
    }
}

u_int64_t apiTimeUs()
{
  struct timeval m_real1;
  u_int64_t temp;

  gettimeofday (&m_real1, 0);
  temp = m_real1.tv_sec;
  temp = (temp * 1000000) + m_real1.tv_usec;

  return temp;
}

char* randomStr()
{
    char *tmp = malloc(pkgSize * sizeof(char) + 1);
    int i;
    srand(time(NULL));
    for(i = 0; i < pkgSize; i++)
    {
        do
        {
            tmp[i] = rand() % 128;
        }while(!isprint(tmp[i]));
    }
    tmp[i] = '\0';
    return tmp;
}

int main(int argc, char **argv)
{
    char options[] = "a:c:m:t:s:p:v:l:hde";
    int opt;
    while((opt = getopt(argc, argv, options)) != -1)
    {
        switch(opt)
        {
            case 't':
                times = atoi(optarg);
                //printf("times:%d\n", times);
                break;
            case 'c':
                cipher = optarg;
                break;
            case 's':
                pkgSize = atoi(optarg);
                //printf("pkgSize:%d\n", pkgSize);
                break;
            case 'l':
                threads = atoi(optarg);
                //printf("threads:%d\n", threads);
                break;
            case 'p':
                port = atoi(optarg);
                //printf("port:%d\n", port);
                break;
            case 'a':
                ip = optarg;
                //printf("IP:%s\n", ip);
                break;
            case 'm':
                mode = atoi(optarg);
                //printf("type:%d\n", mode);
                break;
            case 'v':
                sslversion = atoi(optarg);  
                //printf("type:%d\n", sslversion);
                break;
            case 'd':
                debug = 1;
                break;
            case 'e':
                showTitle = 0;
                break;
            case 'h':
            default:
                usage();
                break;
        }
    }
    if(showTitle)
    {
        char *title[4] = {"Handshake Test", "Throughput Test", "HS And TP Test", "Apache SSL Test"};
        char *version[6] = {"SSLv2", "SSLv3", "SSLv23", "TLSv1", "TLSv1_1", "TLSv1_2"};
        char tmpStr[200] = {0};
        sprintf(tmpStr, "%s%s%s", "------------------------------------------------ ", title[mode], " ------------------------------------------------");
        printf("%s\n", tmpStr);
        printf("Server IP        Server Port        Thread Number        Times        Package Size        Cipher        Version\n");
        printf("%-20s %-20d %-15d %-16d %-12d %-16s %s\n", ip, port, threads, times, pkgSize, cipher, version[sslversion]);
    }
    int status[100];
    
    shared_region = mmap(NULL, sizeof(struct shm_layout), PROT_READ|PROT_WRITE, MAP_ANON|MAP_SHARED, -1, 0);
    if(shared_region == MAP_FAILED)
    {
        printf("\n ERROR mapping \n");
        exit(1);
    }
    memset(shared_region, 0, sizeof(struct shm_layout));
    //SSL 库初始化，参看 ssl-server.c 代码
    SSL_library_init();
    OpenSSL_add_all_algorithms();
    SSL_load_error_strings();
    ctx = SSL_CTX_new(SSLv3_client_method());
    if (ctx == NULL) 
    {
        ERR_print_errors_fp(stdout);
        exit(1);
    }
    
    //初始化服务器端（对方）的地址和端口信息
    bzero(&dest, sizeof(dest));
    dest.sin_family = AF_INET;
    dest.sin_port = htons(port);
    if (inet_aton(ip, (struct in_addr *) &dest.sin_addr.s_addr) == 0)
    {
        perror(argv[1]);
        exit(errno);
    }
    //printf("address created\n");
    
    if(!SSL_CTX_set_cipher_list(ctx, cipher))
    {
        SSL_CTX_free(ctx);
        exit(1);
    }
    buffer = randomStr();
    if(debug)
    {
        printf("buffer:%s\n", buffer);
    }
    int i;
    for(i = 0; i < threads; i++)
    {
        int kid = fork();
        if(kid < 0)
        {
            printf("Fork failed, Failed to create a new thread\n");
        }
        if(kid == 0)
        {
            thread_id = i;
            
            if(mode == 0)
            {
                handshakeTest();
            }
            else if(mode == 1)
            {
                throughputTest();
            }
            else if(mode == 2)
            {
                fullTest();
            }
            else if(mode == 3)
            {
                apacheTest();
            }
             
            shared_region->done[thread_id] = 1;
            sync();
            /* loop till all other threads are ready */
            while ((volatile int)shared_region->exit == 0)
            {
                sleep(1);
            }
            exit(0);
        }
        else
        {
            pid[i] = kid;
        }
    }
    
    for(i = 0;i < threads; i++)
    {
        while((volatile int)shared_region->ready[i] == 0)
        {
            usleep(10);
        }
    }
    shared_region->start = 1;
    u_int64_t starttime, endtime;
    starttime = apiTimeUs();
    sync();
    sleep(2);
    endtime = apiTimeUs();
    u_int64_t timeuse = endtime - starttime;
    while(timeuse < times * 1000000)
    {
        usleep(times * 1000000 - timeuse);
        endtime = apiTimeUs();
        timeuse = endtime - starttime;
        continue;
    }
    shared_region->stop = 1;
    for(i = 0;i < threads; i++)
    {
        while((volatile int)shared_region->done[i] == 0)
        {
            usleep(10);
        }
    }
    shared_region->exit = 1;
    sync();


    for(i = 0; i < threads; i++)
    {
        waitpid(pid[i], &status[i], 0);
    }

    for(i = 0;i < threads; i++)
    {
        total_count += shared_region->count[i];
    }
    
    min_max_times(threads, shared_region->t1, shared_region->t2, &min_t1, &max_t2);
    total_throughput = (u_int64_t)((total_count) * 1000000) / (max_t2 - min_t1);
    if(showTitle)
    {
        printf("                        --------------------------- Result ---------------------------\n");
    }
    if(mode == 1)
    {
        total_throughput = total_throughput * pkgSize / 1024 / 1024 * 8;
        if(showTitle)
        {
            printf("                        Package Size(Bytes)        Operations        Throughtput(Mbps)\n");
            printf("                              %-22d %-20llu %llu\n", pkgSize, (unsigned long long)total_count, (unsigned long long)total_throughput);
        }
        else
        {
            printf("                     %-22d %-20llu %llu\n", pkgSize, (unsigned long long)total_count, (unsigned long long)total_throughput);
        }
    }
    else if(mode == 0)
    {
        if(showTitle)
        {
            printf("                        Package Size(Bytes)        Operations         Operations/Sec\n");
            printf("                              %-23d %-20llu %llu\n", pkgSize, (unsigned long long)total_count, (unsigned long long)total_throughput);
        }
        else
        {
            printf("                     %-23d %-20llu %llu\n", pkgSize, (unsigned long long)total_count, (unsigned long long)total_throughput);
        }
    }
    else if(mode == 2)
    {
        if(showTitle)
        {
            printf("                        Module Size (Bytes)        Operations         Operations/Sec\n");
            printf("                              %-23d %-20llu %llu\n", 1024, (unsigned long long)total_count, (unsigned long long)total_throughput);
        }
        else
        {
            printf("                     %-23d %-20llu %llu\n", 1024, (unsigned long long)total_count, (unsigned long long)total_throughput);
        }
    }
    else if(mode == 3)
    {
        if(showTitle)
        {
            printf("                        Module Size (Bytes)        Operations         Operations/Sec\n");
            printf("                              %-23d %-20llu %llu\n", 1024, (unsigned long long)total_count, (unsigned long long)total_throughput);
        }
        else
        {
            printf("                     %-23d %-20llu %llu\n", 1024, (unsigned long long)total_count, (unsigned long long)total_throughput);
        }
    }
    //printf ("%-8d          %-8u         %-8%llu           %-dd8llu\n", buflen, total_throughput, total_count, max_t2-min_t1);
    munmap(shared_region, sizeof(struct shm_layout));
    fflush(stdout);
    sleep(2);
    return 0;
}


void handshakeTest()
{
    int sockfd, len;
    SSL *ssl;
    shared_region->ready[thread_id] = 1;
    sync();
    while ((volatile int)shared_region->start == 0);
    
    u_int64_t count = 0;
    u_int64_t starttime, endtime;
    starttime = apiTimeUs();
    while ((volatile int)shared_region->stop == 0)
    {
        //创建一个 socket 用于 tcp 通信
        if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
        {
            perror("Socket");
            break;
        }
        //printf("socket created!\n");
        
        //连接服务器
        if (connect(sockfd, (struct sockaddr *) &dest, sizeof(dest)) != 0)
        {
            perror("Connect ");
            close(sockfd);
            break;
        }
        //printf("server connected!\n");

        //基于 ctx 产生一个新的 SSL
        ssl = SSL_new(ctx);
        if(count % 2 == 0)
        {
            SSL_free(ssl);
            ssl = SSL_new(ctx);
        }
        
        SSL_set_fd(ssl, sockfd);
        //建立 SSL 连接
        if (SSL_connect(ssl) == -1)
        {
            perror("SSL connect");
            SSL_free(ssl);
            close(sockfd);
            break;
        }
        else 
        {
            count++;
            if(debug)
            {
                if(count == 1)
                {
                    printf("Connected with %s encryption\n", SSL_get_cipher(ssl));
                }
            }
        }
        // 关闭连接
        //SSL_shutdown(ssl);
        SSL_free(ssl);
        close(sockfd);
    }
    endtime = apiTimeUs();
    SSL_CTX_free(ctx);
    
    shared_region->count[thread_id] = count;
    shared_region->t1[thread_id] = starttime;
    shared_region->t2[thread_id] = endtime;
    sync();
}

void *createThread(void *arg)
{
    int sockfd, len;
    SSL *ssl;
    //创建一个 socket 用于 tcp 通信
    if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
    {
        perror("Socket");
        SSL_CTX_free(ctx);
        return;
    }
    //printf("socket created!\n");
    
    //连接服务器
    if (connect(sockfd, (struct sockaddr *) &dest, sizeof(dest)) != 0)
    {
        perror("Connect ");
        close(sockfd);
        SSL_CTX_free(ctx);
        return;
    }
    //printf("server connected!\n");
    //基于 ctx 产生一个新的 SSL
    ssl = SSL_new(ctx);
    SSL_set_fd(ssl, sockfd);
    //建立 SSL 连接
    if (SSL_connect(ssl) == -1)
    {
        //ERR_print_errors_fp(stderr);
        perror("SSL connect");
        SSL_free(ssl);
        close(sockfd);
        SSL_CTX_free(ctx);
        return;
    }
    else 
    {
        if(debug)
        {
            printf("Connected with %s encryption\n", SSL_get_cipher(ssl));
        }
    }

    u_int64_t count = 0;
    int threadNum = (int)(*((int*)arg));
    subthread_region.starttime[threadNum] = apiTimeUs();
    while ((volatile int)shared_region->stop == 0)
    {
        len = SSL_write(ssl, buffer, strlen(buffer));
        if (len < 0)
        {
            printf("消息发送失败！错误代码是%d，错误信息是'%s'\n", errno, strerror(errno));
            break;
        }
        else
        {
            count++;
            //printf("消息'%s'发送成功，共发送了%d个字节！\n", buffer, len);
        }
    }
    subthread_region.endtime[threadNum] = apiTimeUs();
    subthread_region.count[threadNum] = count;
    // 关闭连接
    SSL_shutdown(ssl);
    SSL_free(ssl);
    close(sockfd);
    return NULL;
}

void throughputTest()
{
    shared_region->ready[thread_id] = 1;
    sync();
    while ((volatile int)shared_region->start == 0);
/*    
    pthread_t thread[SUBTHREADNUM];
    int i;
    for(i = 0; i < SUBTHREADNUM; i++)
    {
        if(pthread_create(&thread[i], NULL, createThread, (void *)&i) != 0)//创建子线程
        {
            perror("pthread_create");
            break;
        }
    }
    
    for(i = 0; i < SUBTHREADNUM; i++)
    {
        pthread_join(thread[i], NULL);
    }
*/    
    int sockfd, len;
    SSL *ssl;
    //创建一个 socket 用于 tcp 通信
    if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
    {
        perror("Socket");
        SSL_CTX_free(ctx);
        return;
    }
    //printf("socket created!\n");
    
    //连接服务器
    if (connect(sockfd, (struct sockaddr *) &dest, sizeof(dest)) != 0)
    {
        perror("Connect ");
        close(sockfd);
        SSL_CTX_free(ctx);
        return;
    }
    //printf("server connected!\n");
    //基于 ctx 产生一个新的 SSL
    ssl = SSL_new(ctx);
    if(thread_id >= threads / 2)
    {
        SSL_free(ssl);
        ssl = SSL_new(ctx);
    }
    SSL_set_fd(ssl, sockfd);
    //建立 SSL 连接
    if (SSL_connect(ssl) == -1)
    {
        //ERR_print_errors_fp(stderr);
        perror("SSL connect");
        SSL_free(ssl);
        close(sockfd);
        SSL_CTX_free(ctx);
        return;
    }
    else 
    {
        if(debug)
        {
            printf("Connected with %s encryption\n", SSL_get_cipher(ssl));
        }
    }

    u_int64_t count = 0;
    u_int64_t starttime, endtime;
    starttime = apiTimeUs();
    while ((volatile int)shared_region->stop == 0)
    {
        len = SSL_write(ssl, buffer, strlen(buffer));
        if (len < 0)
        {
            printf("消息发送失败！错误代码是%d，错误信息是'%s'\n", errno, strerror(errno));
            break;
        }
        else
        {
            count++;
            //printf("消息'%s'发送成功，共发送了%d个字节！\n", buffer, len);
        }
    }
    endtime = apiTimeUs();
    // 关闭连接
    //SSL_shutdown(ssl);
    SSL_free(ssl);
    close(sockfd);
    SSL_CTX_free(ctx);
    //业务处理结束
/*
    u_int64_t starttime, endtime;
    min_max_times(SUBTHREADNUM, subthread_region.starttime, subthread_region.endtime, &starttime, &endtime);
    u_int64_t count = 0;
    for(i = 0; i < SUBTHREADNUM; i++)
    {
        count += subthread_region.count[i];
    }
*/
    shared_region->count[thread_id] = count;
    shared_region->t1[thread_id] = starttime;
    shared_region->t2[thread_id] = endtime;
    sync();
}


void fullTest()
{
    int sockfd, len;
    SSL *ssl;
    shared_region->ready[thread_id] = 1;
    sync();
    while ((volatile int)shared_region->start == 0);
    
    u_int64_t count = 0;
    u_int64_t starttime, endtime;
    starttime = apiTimeUs();
    while ((volatile int)shared_region->stop == 0)
    {
        //创建一个 socket 用于 tcp 通信
        if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
        {
            perror("Socket");
            break;
        }
        //printf("socket created!\n");
        
        //连接服务器
        if (connect(sockfd, (struct sockaddr *) &dest, sizeof(dest)) != 0)
        {
            perror("Connect ");
            close(sockfd);
            break;
        }
        //printf("server connected!\n");

        //基于 ctx 产生一个新的 SSL
        ssl = SSL_new(ctx);
        SSL_set_fd(ssl, sockfd);
        //建立 SSL 连接
        if (SSL_connect(ssl) == -1)
        {
            perror("SSL connect");
            SSL_free(ssl);
            close(sockfd);
            break;
        }
        else 
        {
            len = SSL_write(ssl, buffer, strlen(buffer));
            if (len < 0)
            {
                printf("消息发送失败！错误代码是%d，错误信息是'%s'\n", errno, strerror(errno));
                SSL_free(ssl);
                close(sockfd);
                break;
            }
            else
            {
                count++;
                //printf("消息'%s'发送成功，共发送了%d个字节！\n", buffer, len);
            }
            if(debug)
            {
                if(count == 1)
                {
                    printf("Connected with %s encryption\n", SSL_get_cipher(ssl));
                }
            }
        }
        // 关闭连接
        //SSL_shutdown(ssl);
        SSL_free(ssl);
        close(sockfd);
    }
    endtime = apiTimeUs();
    SSL_CTX_free(ctx);
    
    shared_region->count[thread_id] = count;
    shared_region->t1[thread_id] = starttime;
    shared_region->t2[thread_id] = endtime;
    sync();
}

void apacheTest()
{
    int sockfd, len;
    SSL *ssl;
    shared_region->ready[thread_id] = 1;
    sync();
    while ((volatile int)shared_region->start == 0);
    
    u_int64_t count = 0;
    u_int64_t starttime, endtime;
    starttime = apiTimeUs();
    char readBuff[MAXBUF] = {0};
    char writeData[200] = {0};
    sprintf(writeData, "%s%s%s", "GET /index.html HTTP/1.1\r\nHost: ", ip, "\r\nConnection: Close\r\n");
    while ((volatile int)shared_region->stop == 0)
    {
        //创建一个 socket 用于 tcp 通信
        if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
        {
            perror("Socket");
            break;
        }
        //printf("socket created!\n");
        
        //连接服务器
        if (connect(sockfd, (struct sockaddr *) &dest, sizeof(dest)) != 0)
        {
            perror("Connect ");
            close(sockfd);
            break;
        }
        //printf("server connected!\n");

        //基于 ctx 产生一个新的 SSL
        ssl = SSL_new(ctx);
        SSL_set_fd(ssl, sockfd);
        //建立 SSL 连接
        if (SSL_connect(ssl) == -1)
        {
            perror("SSL connect");
            SSL_free(ssl);
            close(sockfd);
            break;
        }
        else 
        {
            len = SSL_write(ssl, writeData, strlen(writeData));
            if (len < 0)
            {
                printf("消息发送失败！错误代码是%d，错误信息是'%s'\n", errno, strerror(errno));
                SSL_free(ssl);
                close(sockfd);
                break;
            }
            else
            {
                count++;
                printf("消息'%s'发送成功，共发送了%d个字节！\n", readBuff, len);
            }
            memset(readBuff, 0 , MAXBUF);
            len = SSL_read(ssl, readBuff, MAXBUF);
            if(len < 0)
            {
                printf("消息接收失败！错误代码是%d，错误信息是'%s'\n", errno, strerror(errno));
                SSL_free(ssl);
                close(sockfd);
                break;
            }
            if(debug)
            {
                if(count == 1)
                {
                    printf("Connected with %s encryption\n", SSL_get_cipher(ssl));
                    printf("The Apache data: %s\n", readBuff);
                }
            }
        }
        // 关闭连接
        //SSL_shutdown(ssl);
        SSL_free(ssl);
        close(sockfd);
    }
    endtime = apiTimeUs();
    SSL_CTX_free(ctx);
    
    shared_region->count[thread_id] = count;
    shared_region->t1[thread_id] = starttime;
    shared_region->t2[thread_id] = endtime;
    sync();
}

/**
 * 获取总的CPU利用率
*/
int getCpuTotalUseRatio()
{
    struct cpuinfo oldinfo;
    struct cpuinfo newinfo;
    getCpuInfo(&oldinfo);
    sleep(1);
    getCpuInfo(&newinfo);
    calCpuUseRatio(&oldinfo, &newinfo);
}

/**
 * 计算CPU利用率
*/
void calCpuUseRatio (struct cpuinfo *old, struct cpuinfo *new)
{
    double oldTotal, newTotal, total, idle, user, system, softirq, irq;
    float totalRatio, userRatio, systemRatio, softirqRatio, irqRatio;
    oldTotal = (double)(old->user + old->nice + old->system + old->idle + old->iowait +
                        old->irq + old->softirq + old->stealstolen + old->guest);
    newTotal = (double)(new->user + new->nice + new->system + new->idle + new->iowait +
                        new->irq + new->softirq + new->stealstolen + new->guest);
                        
    total = newTotal - oldTotal;
    idle  = new->idle - old->idle;
    user = new->user - old->user;
    system = new->system - old->system;
    softirq = new->softirq - old->softirq;
    irq = new->irq - old->irq;
    
    //CPU利用率
    totalRatio = (total - idle) / total;
    //用户空间CPU利用率
    userRatio = user / total;
    //内核空间CPU利用率
    systemRatio = system / total;
    //软中断CPU利用率
    softirqRatio = softirq / total;
    //硬中断CPU利用率
    irqRatio = irq / total;
    //printf("total:%f, idle:%f, new->idle:%u, old->idle:%u\n", total, idle, new->idle, old->idle);
    printf("总的CPU利用率为：%f(%f + %f + %f + %f)\n", totalRatio, userRatio, systemRatio, softirqRatio, irqRatio);
}

/**
 * 获取当前CPU信息
*/
void getCpuInfo (struct cpuinfo *cpu)
{
    FILE *fd;
    char buff[1024];
    fd = fopen ("/proc/stat", "r");
    fgets (buff, sizeof(buff), fd);
    sscanf (buff, "%s  %u %u %u %u %u %u %u %u %u", &cpu->name, &cpu->user, &cpu->nice, &cpu->system, 
            &cpu->idle,&cpu->iowait, &cpu->irq, &cpu->softirq, &cpu->stealstolen, &cpu->guest);
    printf ("%s %u %u %u %u %u %u %u %u %u\n", cpu->name, cpu->user, cpu->nice, cpu->system, 
            cpu->idle, cpu->iowait, cpu->irq, cpu->softirq, cpu->stealstolen, cpu->guest);
    fclose(fd);
}

server.c

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/wait.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <openssl/ssl.h>
#include <openssl/err.h>
#include <sys/mman.h>

#define SUBTHREADNUM 2
#define MAX_THREADS 100

int pkgSize = 1024;
int threads = 10;
int mode = 0;    //0-handshake 1-throughput
int port = 8701;

void handshakeTest();
void throughputTest();

SSL_CTX *ctx;
char *buffer;
int sockfd;
int debug = 0;
int thread_id = 0;
int pid[100];
int showTitle = 1;
int times = 10;

struct cpuinfo
{
    char name[20];
    unsigned int user;
    unsigned int nice;
    unsigned int system;
    unsigned int idle;
    unsigned int iowait;
    unsigned int irq;
    unsigned int softirq;
    unsigned int stealstolen;
    unsigned int guest;
};

void getCpuInfo (struct cpuinfo *cpu);
void calCpuUseRatio (struct cpuinfo *old, struct cpuinfo *new);
int getCpuTotalUseRatio();

struct shm_layout
{
    int ready[MAX_THREADS];
    int done[MAX_THREADS];
    int failCount[MAX_THREADS];
};

struct shm_layout *shared_region = NULL;
void usage()
{
    printf("Usage: Client \n\
            -p   Port (8701)\n\
            -s   Package Size (1024)\n\
            -l   Threads (10)\n\
            -m   Type (0-handshake 1-throughput default 0)\n\
            -d   Debug Info\n\
            -t   Time\n\
            -h   Help\n");
    exit(-1);
}

int main(int argc, char **argv)
{
    char options[] = "a:s:p:m:l:t:hde";
    int opt;
    while((opt = getopt(argc, argv, options)) != -1)
    {
        switch(opt)
        {
            case 's':
                pkgSize = atoi(optarg);
                //printf("pkgSize:%d\n", pkgSize);
                break;
            case 'l':
                threads = atoi(optarg);
                //printf("threads:%d\n", threads);
                break;
            case 'p':
                port = atoi(optarg);
                //printf("port:%d\n", port);
                break;
            case 'm':
                mode = atoi(optarg);
                //printf("type:%d\n", mode);
                break;
            case 'd':
                debug = 1;
                break;
            case 't':
                times = atoi(optarg);
            case 'e':
                showTitle = 0;
                break;
            case 'h':
            default:
                usage();
                break;
        }
    }
    if(showTitle)
    {
        if(mode == 0)
        {
            printf("------------------- Handshake Test -------------------\n");
        } 
        else if(mode == 1)
        {
            printf("------------------- Throughput Test -------------------\n");
        }
        printf("Server Port        Thread Number        Package Size\n");
    }
    printf("    %-20d %-20d %-18d\n", port, threads, pkgSize);
    
    shared_region = mmap(NULL, sizeof(struct shm_layout), PROT_READ|PROT_WRITE, MAP_ANON|MAP_SHARED, -1, 0);
    if(shared_region == MAP_FAILED)
    {
        printf("\n ERROR mapping \n");
        exit(1);
    }
    memset(shared_region, 0, sizeof(struct shm_layout));
    
    struct sockaddr_in my_addr;
    unsigned int lisnum;

    lisnum = 20;

    buffer = malloc(pkgSize + 1);
    memset(buffer, 0 , pkgSize + 1);
    
    //SSL 库初始化
    SSL_library_init();
    //载入所有 SSL 算法
    OpenSSL_add_all_algorithms();
    //载入所有 SSL 错误消息
    SSL_load_error_strings();
    //以 SSL V2 和 V3 标准兼容方式产生一个 SSL_CTX ，即 SSL Content Text
    ctx = SSL_CTX_new(SSLv3_server_method());
    //也可以用 SSLv2_server_method() 或 SSLv3_server_method() 单独表示 V2 或 V3标准
    if (ctx == NULL)
    {
        printf("SSLContext failed!\n");
        exit(1);
    }
    //载入用户的数字证书， 此证书用来发送给客户端。 证书里包含有公钥
    if (SSL_CTX_use_certificate_file(ctx, "cacert.pem", SSL_FILETYPE_PEM) <= 0)
    {
        printf("Certificate load failed!\n");
        exit(1);
    }
    //载入用户私钥
    if (SSL_CTX_use_PrivateKey_file(ctx, "privkey.pem", SSL_FILETYPE_PEM) <= 0)
    {
        printf("PrivateKey load failed!\n");
        exit(1);
    }
    //检查用户私钥是否正确
    if (!SSL_CTX_check_private_key(ctx))
    {
        printf("PrivateKey check failed!\n");
        exit(1);
    }

    //开启一个 socket 监听
    if ((sockfd = socket(PF_INET, SOCK_STREAM, 0)) == -1)
    {
        perror("socket");
        exit(1);
    }
    else
    {
        if(debug)
        {
            printf("socket created\n");
        }
    }

    bzero(&my_addr, sizeof(my_addr));
    my_addr.sin_family = PF_INET;
    my_addr.sin_port = htons(port);
    my_addr.sin_addr.s_addr = INADDR_ANY;

    if (bind(sockfd, (struct sockaddr *) &my_addr, sizeof(struct sockaddr)) == -1)
    {
        perror("bind");
        exit(1);
    }
    else
    {
        if(debug)
        {
            printf("binded\n");
        }
    }    

    if (listen(sockfd, lisnum) == -1)
    {
        perror("listen");
        exit(1);
    }
    else
    {
        if(debug)
        {
            printf("begin listen\n");
        }
    }
    
    int i;
    for(i = 0; i < threads; i++)
    {
        int kid = fork();
        if(kid < 0)
        {
            printf("Fork failed, Failed to create a new thread\n");
        }
        if(kid == 0)
        {
            thread_id = i;
            if(mode == 0)
            {
                handshakeTest();
            }
            else if(mode == 1)
            {
                throughputTest();
            }
            shared_region->done[thread_id] = 1;
            exit(0);
        }
        else
        {
            pid[i] = kid;
        }
    }
    
    for(i = 0;i < threads; i++)
    {
        while((volatile int)shared_region->ready[i] == 0)
        {
            usleep(10);
        }
    }
    
    getCpuTotalUseRatio();
    
    for(i = 0;i < threads; i++)
    {
        while((volatile int)shared_region->done[i] == 0)
        {
            usleep(1000);
        }
    }
    
    int total_fail_count = 0;
    for(i = 0;i < threads; i++)
    {
        total_fail_count += shared_region->failCount[i];
    }
    if(total_fail_count != threads)
    {
        printf("-------------------------------- Warning: failed count is %d --------------------------------\n", total_fail_count);
    }
    // 关闭监听的 socket
    close(sockfd);
}

void handshakeTest()
{
    SSL *ssl;
    int new_fd;
    int i = 0;
    int count = 0;
    while(1)
    {
        //等待客户端连上来
        if ((new_fd = accept(sockfd, NULL, NULL)) == -1)
        {
            if(count == 0)
            {
                shared_region->ready[thread_id] = 1;
                sync();
            }
            perror("accept");
            exit(errno);
        }
        else
        {
            //printf("Accepted success!\n");
        }
        //基于 ctx 产生一个新的 SSL
        ssl = SSL_new(ctx);
        if(count % 2 == 0)
        {
            SSL_free(ssl);
            ssl = SSL_new(ctx);
        }
        //将连接用户的 socket 加入到 SSL
        SSL_set_fd(ssl, new_fd);
        //建立 SSL 连接
        if (SSL_accept(ssl) == -1)
        {
            perror("accept");
            SSL_free(ssl);
            close(new_fd);
            break;
        }
        count++;
        //SSL_shutdown(ssl);
        //释放 SSL
        SSL_shutdown(ssl);
        SSL_free(ssl);
        //关闭 socket
        close(new_fd);
    }
    SSL_CTX_free(ctx);
}

void *createThread(void *arg)
{
    SSL *ssl;
    int new_fd;
    int len;
    /* 等待客户端连上来 */
    if ((new_fd = accept(sockfd, NULL, NULL)) == -1)
    {
        perror("accept");
        exit(errno);
    } 
    else
    {
        if(debug)
        {
            printf("Accepted success!\n");
        }
    }

    //基于 ctx 产生一个新的 SSL
    ssl = SSL_new(ctx);
    //将连接用户的 socket 加入到 SSL
    SSL_set_fd(ssl, new_fd);
    //建立 SSL 连接
    if (SSL_accept(ssl) == -1)
    {
        perror("accept");
        close(new_fd);
        exit(0);
    }
    int i = 0;
    while(1)
    {
        bzero(buffer, pkgSize + 1);
        //接收客户端的消息
        len = SSL_read(ssl, buffer, pkgSize);
        if (len > 0)
        {
            if(debug)
            {
                i++;
                if(i == 1)
                {
                    printf("接收消息成功:'%s'，共%d个字节的数据\n", buffer, len);
                }
            }
        }
        else
        {
            printf("消息接收失败！错误代码是%d，错误信息是'%s'\n", errno, strerror(errno));
            break;
        }
    }
    //SSL_shutdown(ssl);
    //释放 SSL
    SSL_free(ssl);
    //关闭 socket
    close(new_fd);
    return NULL;
}

void throughputTest()
{
/*
    pthread_t thread[SUBTHREADNUM];
    int i;
    for(i = 0; i < SUBTHREADNUM; i++)
    {
        if(pthread_create(&thread[i], NULL, createThread, NULL) != 0)//创建子线程
        {
            perror("pthread_create");
            break;
        }
    }
    
    for(i = 0; i < SUBTHREADNUM; i++)
    {
        pthread_join(thread[i], NULL);
    }
*/
    SSL *ssl;
    int new_fd;
    int len;
    /* 等待客户端连上来 */
    if ((new_fd = accept(sockfd, NULL, NULL)) == -1)
    {
        perror("accept");
        exit(errno);
    } 
    else
    {
        if(debug)
        {
            printf("Accepted success!\n");
        }
    }
    shared_region->ready[thread_id] = 1;
    sync();
    //基于 ctx 产生一个新的 SSL
    ssl = SSL_new(ctx);
    if(thread_id >= threads / 2)
    {
        SSL_free(ssl);
        ssl = SSL_new(ctx);
    }
    //将连接用户的 socket 加入到 SSL
    SSL_set_fd(ssl, new_fd);
    //建立 SSL 连接
    if (SSL_accept(ssl) == -1)
    {
        perror("accept");
        close(new_fd);
        exit(0);
    }
    int i = 0;
    while(1)
    {
        bzero(buffer, pkgSize + 1);
        //接收客户端的消息
        len = SSL_read(ssl, buffer, pkgSize);
        if (len > 0)
        {
            if(debug)
            {
                i++;
                if(i == 1)
                {
                    printf("接收消息成功:'%s'，共%d个字节的数据\n", buffer, len);
                }
            }
        }
        else
        {
            if(debug)
            {
                printf("消息接收失败！错误代码是%d，错误信息是'%s'\n", errno, strerror(errno));
            }
            shared_region->failCount[thread_id]++;
            break;
        }
    }
    sync();
    //SSL_shutdown(ssl);
    //释放 SSL
    SSL_free(ssl);
    //关闭 socket
    close(new_fd);
    SSL_CTX_free(ctx);
}

/**
 * 获取总的CPU利用率
*/
int getCpuTotalUseRatio()
{
    struct cpuinfo oldinfo;
    struct cpuinfo newinfo;
    getCpuInfo(&oldinfo);
    sleep(times - 1);
    getCpuInfo(&newinfo);
    calCpuUseRatio(&oldinfo, &newinfo);
}

/**
 * 计算CPU利用率
*/
void calCpuUseRatio (struct cpuinfo *old, struct cpuinfo *new)
{
    double oldTotal, newTotal, total, idle, user, system, softirq, irq;
    float totalRatio, userRatio, systemRatio, softirqRatio, irqRatio;
    oldTotal = (double)(old->user + old->nice + old->system + old->idle + old->iowait +
                        old->irq + old->softirq + old->stealstolen + old->guest);
    newTotal = (double)(new->user + new->nice + new->system + new->idle + new->iowait +
                        new->irq + new->softirq + new->stealstolen + new->guest);
                        
    total = newTotal - oldTotal;
    idle  = new->idle - old->idle;
    user = new->user - old->user;
    system = new->system - old->system;
    softirq = new->softirq - old->softirq;
    irq = new->irq - old->irq;
    
    //CPU利用率
    totalRatio = (total - idle) / total;
    //用户空间CPU利用率
    userRatio = user / total;
    //内核空间CPU利用率
    systemRatio = system / total;
    //软中断CPU利用率
    softirqRatio = softirq / total;
    //硬中断CPU利用率
    irqRatio = irq / total;
    //printf("total:%f, idle:%f, new->idle:%u, old->idle:%u\n", total, idle, new->idle, old->idle);
    printf("%f(%f + %f + %f + %f)\n", totalRatio, userRatio, systemRatio, softirqRatio, irqRatio);
}

/**
 * 获取当前CPU信息
*/
void getCpuInfo (struct cpuinfo *cpu)
{
    FILE *fd;
    char buff[1024];
    fd = fopen ("/proc/stat", "r");
    fgets (buff, sizeof(buff), fd);
    sscanf (buff, "%s  %u %u %u %u %u %u %u %u %u", &cpu->name, &cpu->user, &cpu->nice, &cpu->system, 
            &cpu->idle,&cpu->iowait, &cpu->irq, &cpu->softirq, &cpu->stealstolen, &cpu->guest);
    //printf ("%s %u %u %u %u %u %u %u %u %u\n", cpu->name, cpu->user, cpu->nice, cpu->system, 
            //cpu->idle, cpu->iowait, cpu->irq, cpu->softirq, cpu->stealstolen, cpu->guest);
    fclose(fd);
}

Makefile

CIPHER    = AES128-SHA      #AES128-SHA AES256-SHA RC4-SHA RC4-MD5
PKT_SIZES = 256 512 1024 1500 2048
RSA       = RSA_CRT RSA_NOCRT MODEXP
HANDSHAKE = RSASERVERFULL
NUM_THREADS      = 40       #MAX 100
NUM_THREADSHS    = 60       #MAX 100
NB_TEST_DURATION = 5 
HANDSHAKEIP      = 168.1.1.10
THROUGHPUTIP     = 169.1.1.10
TIME             = 10
LOOP             = 1 2 3 4 5 6
PORT             = 8701

CFLAGS = -I/usr/local/ssl/include -L/usr/local/ssl/lib -lssl -lcrypto -ldl
CC = gcc
OBJS_SERVER = server.o
OBJS_CLIENT = client.o

all:server client

server: $(OBJS_SERVER)
	$(CC) -o $@ $^ ${CFLAGS}
client: $(OBJS_CLIENT)
	$(CC) -o $@ $^ ${CFLAGS}
	
handshake_client:
	for pktsize in ${PKT_SIZES}; do \
	./client -a ${THROUGHPUTIP} -l ${NUM_THREADSHS} -s $$pktsize -c AES128-SHA -t ${TIME};\
	done
throughput_AES128-SHA:
	@echo "------------------------------------- Throughput Test -------------------------------------";
	@echo "Server IP        Server Port        Thread Number        Times        Cipher        Version";
	@echo "${THROUGHPUTIP}            ${PORT}                ${NUM_THREADS}       ${TIME}        AES128-SHA       SSLv3";
	@echo "               Package Size(Bytes)        Operations        Throughtput(Mbps)";
	for pktsize in ${PKT_SIZES}; do \
	./client -m 1 -a ${THROUGHPUTIP} -l ${NUM_THREADS} -s $$pktsize -c AES128-SHA -t ${TIME} -e;\
	done
throughput_AES256-SHA:
	@echo "-------------------------------------------------------------------------------------------";
	@echo "Server IP        Server Port        Thread Number        Times        Cipher        Version";
	@echo "${THROUGHPUTIP}            ${PORT}                ${NUM_THREADS}       ${TIME}        AES256-SHA       SSLv3";
	@echo "               Package Size(Bytes)        Operations        Throughtput(Mbps)";
	for pktsize in ${PKT_SIZES}; do \
	./client -m 1 -a ${THROUGHPUTIP} -l ${NUM_THREADS} -s $$pktsize -c AES256-SHA -t ${TIME} -e;\
	done
throughput_RC4-SHA:
	@echo "-------------------------------------------------------------------------------------------";
	@echo "Server IP        Server Port        Thread Number        Times        Cipher        Version";
	@echo "${THROUGHPUTIP}            ${PORT}                ${NUM_THREADS}       ${TIME}          RC4-SHA         SSLv3";
	@echo "               Package Size(Bytes)        Operations        Throughtput(Mbps)";
	for pktsize in ${PKT_SIZES}; do \
	./client -m 1 -a ${THROUGHPUTIP} -l ${NUM_THREADS} -s $$pktsize -c RC4-SHA -t ${TIME} -e;\
	done
throughput_RC4-MD5:
	@echo "-------------------------------------------------------------------------------------------";
	@echo "Server IP        Server Port        Thread Number        Times        Cipher        Version";
	@echo "${THROUGHPUTIP}            ${PORT}                ${NUM_THREADS}       ${TIME}          RC4-MD5       SSLv3";
	@echo "               Package Size(Bytes)        Operations        Throughtput(Mbps)";
	for pktsize in ${PKT_SIZES}; do \
	./client -m 1 -a ${THROUGHPUTIP} -l ${NUM_THREADS} -s $$pktsize -c RC4-MD5 -t ${TIME} -e;\
	done
throughput_DES-CBC-SHA:
	@echo "-------------------------------------------------------------------------------------------";
	@echo "Server IP        Server Port        Thread Number        Times        Cipher        Version";
	@echo "${THROUGHPUTIP}            ${PORT}                ${NUM_THREADS}       ${TIME}       DES-CBC-SHA       SSLv3";
	@echo "               Package Size(Bytes)        Operations        Throughtput(Mbps)";
	for pktsize in ${PKT_SIZES}; do \
	./client -m 1 -a ${THROUGHPUTIP} -l ${NUM_THREADS} -s $$pktsize -c DES-CBC-SHA -t ${TIME} -e;\
	done
throughput_DES-CBC3-SHA:
	@echo "-------------------------------------------------------------------------------------------";
	@echo "Server IP        Server Port        Thread Number        Times        Cipher        Version";
	@echo "${THROUGHPUTIP}            ${PORT}                ${NUM_THREADS}       ${TIME}       DES-CBC3-SHA      SSLv3";
	@echo "               Package Size(Bytes)        Operations        Throughtput(Mbps)";
	for pktsize in ${PKT_SIZES}; do \
	./client -m 1 -a ${THROUGHPUTIP} -l ${NUM_THREADS} -s $$pktsize -c DES-CBC3-SHA -t ${TIME} -e;\
	done
handshake_server:
	./server -l ${NUM_THREADSHS};
throughput_server:
	@echo "------------------ Throughput Test ------------------";
	@echo "Server Port        Thread Number        Package Size";
	for var in ${LOOP}; do \
		for pktsize in ${PKT_SIZES}; do \
		./server -m 1 -l ${NUM_THREADS} -s $$pktsize -e;\
		done \
	done

run_client: throughput_AES128-SHA throughput_AES256-SHA throughput_RC4-SHA throughput_RC4-MD5 throughput_DES-CBC-SHA throughput_DES-CBC3-SHA handshake_client
run_server: throughput_server handshake_server

clean:
	rm -f *.o server client

make_key.sh

#!/bin/sh
openssl genrsa -out privkey.pem 2048
openssl req -new -x509 -key privkey.pem -out cacert.pem -days 1095