源码剖析---------webbench（测压工具）

1、webbench：是一个压力测试工具，最多可以有3万个并发客户端发起请求，适用于小型的网站。主要测试每秒钟请求数和每秒钟数据传输量，同时支持静态、动态、SSL，部署简单，静动态均可测试。

2、安装：特别简单，百度一下就知道。

3、选项：在安装完成后，在命令行输入webbench或webbench -h或webbench -help，

就可以知道他的它的命令选项有哪些。

第一行是他该怎么用，后面的是他的各种选项信息。

4、用法：

例如：对百度进行压力测试，用法为：webbench -c 10 -t 30  http://baidu.com/

-c 后面跟的是请求的客户端个数，-t 请求多长时间 。

5、主要流程图。

6、代码分析：

主要的函数：

  （1）调用getopt_long库函数进行命令行解析。

  （2）build_request函数进行http请求的构造。

  （3）执行bench函数，用Socket函数来判断是否可以连接，创建管道，派生子进程等等。

  （4）子进程执行benchcore函数。

Socket.c

int Socket(const char *host, int clientPort)  
{  
    int sock;  
    unsigned long inaddr;  
    struct sockaddr_in ad;  
    struct hostent *hp;  
  
    /* 初始化地址 */  
    memset(&ad, 0, sizeof(ad));  
    ad.sin_family = AF_INET;   //ipv4
  
    /* 尝试把主机名转化为数字 */  
    inaddr = inet_addr(host);  //把ip地址转化为网络字节序
    if (inaddr != INADDR_NONE)  //INADDR_NONE是0xffffffff
        memcpy(&ad.sin_addr, &inaddr, sizeof(inaddr));  
    else  
    {  
        /* 取得 ip 地址 */  
        hp = gethostbyname(host);  //百度一下
        if (hp == NULL)  
            return -1;  
        memcpy(&ad.sin_addr, hp->h_addr, hp->h_length);  //hp->h->addr中以二进制存储的ip地址
    }  
    ad.sin_port = htons(clientPort);  
  
    /* 建立 socket */  
    sock = socket(AF_INET, SOCK_STREAM, 0);  
    if (sock < 0)  
        return sock;  
    /* 建立链接 */  
    if (connect(sock, (struct sockaddr *)&ad, sizeof(ad)) < 0)  
        return -1;  
    return sock;  
}  

webbench.c

/* 
 * (C) Radim Kolar 1997-2004 
 * This is free software, see GNU Public License version 2 for 
 * details. 
 * 
 * Simple forking WWW Server benchmark: 
 * 
 * Usage: 
 *   webbench --help 
 * 
 * Return codes: 
 *    0 - sucess 
 *    1 - benchmark failed (server is not on-line) 
 *    2 - bad param 
 *    3 - internal error, fork failed 
 * 
 */  
#include "socket.c"  
#include <unistd.h>  
#include <sys/param.h>  
#include <rpc/types.h>  
#include <getopt.h>  
#include <strings.h>  
#include <time.h>  
#include <signal.h>  
  
/* values */  
volatile int timerexpired = 0;  //信号是否触发了
int speed = 0;    //成功的次数
int failed = 0;  //失败的次数
int bytes = 0;   //从服务器总共读了多少字节数
  
/* globals */  
int http10 = 1; /* 0 - http/0.9, 1 - http/1.0, 2 - http/1.1 */  
  
/* Allow: GET, HEAD, OPTIONS, TRACE */  
#define METHOD_GET 0  
#define METHOD_HEAD 1  
#define METHOD_OPTIONS 2  
#define METHOD_TRACE 3  
#define PROGRAM_VERSION "1.5"  
  
/* 默认设置 */  
int method = METHOD_GET; /* GET 方式 */  
int clients = 1; /* 只模拟一个客户端 */  
int force = 0; /* 等待响应 */  
int force_reload = 0; /* 失败时不重新请求 */  
int proxyport = 80; /* 访问端口 */  
char *proxyhost = NULL; /* 代理服务器 */  
int benchtime = 30; /* 模拟请求时间 */  
  
/* internal */  
int mypipe[2]; /* 管道 */  
char host[MAXHOSTNAMELEN]; /* 网络地址 */  
#define REQUEST_SIZE 2048  
char request[REQUEST_SIZE]; /* 请求 */  
  
static const struct option long_options[]=  
{  
    {"force",no_argument,&force,1},  
    {"reload",no_argument,&force_reload,1},  
    {"time",required_argument,NULL,'t'},  
    {"help",no_argument,NULL,'?'},  
    {"http09",no_argument,NULL,'9'},  
    {"http10",no_argument,NULL,'1'},  
    {"http11",no_argument,NULL,'2'},  
    {"get",no_argument,&method,METHOD_GET},  
    {"head",no_argument,&method,METHOD_HEAD},  
    {"options",no_argument,&method,METHOD_OPTIONS},  
    {"trace",no_argument,&method,METHOD_TRACE},  
    {"version",no_argument,NULL,'V'},  
    {"proxy",required_argument,NULL,'p'},  
    {"clients",required_argument,NULL,'c'},  
    {NULL,0,NULL,0}  
};  
  
/* prototypes */  
static void benchcore(const char* host,const int port, const char *request);  
static int bench(void);  
static void build_request(const char *url);  
  
static void alarm_handler(int signal)  
{  
    timerexpired = 1;  
}  
  
/* help 信息 */  
static void usage(void)  
{  
   fprintf(stderr,  
    "webbench [option]... URL\n"  
    "  -f|--force               Don't wait for reply from server.\n"  
    "  -r|--reload              Send reload request - Pragma: no-cache.\n"  
    "  -t|--time <sec>          Run benchmark for <sec> seconds. Default 30.\n"  
    "  -p|--proxy <server:port> Use proxy server for request.\n"  
    "  -c|--clients <n>         Run <n> HTTP clients at once. Default one.\n"  
    "  -9|--http09              Use HTTP/0.9 style requests.\n"  
    "  -1|--http10              Use HTTP/1.0 protocol.\n"  
    "  -2|--http11              Use HTTP/1.1 protocol.\n"  
    "  --get                    Use GET request method.\n"  
    "  --head                   Use HEAD request method.\n"  
    "  --options                Use OPTIONS request method.\n"  
    "  --trace                  Use TRACE request method.\n"  
    "  -?|-h|--help             This information.\n"  
    "  -V|--version             Display program version.\n"  
    );  
};  
  
int main(int argc, char *argv[])  
{  
    int opt = 0;  
    int options_index = 0;  
    char *tmp = NULL;  
  
    /* 不带参数时直接输出 help 信息 */  
    if(argc == 1)  
    {  
        usage();  
        return 2;  
    }  
  
    /* getopt_long 为命令行解析的库函数，可通过 man 3 getopt_long 查看 */  
    while((opt = getopt_long(argc,argv,"912Vfrt:p:c:?h",long_options,&options_index)) != EOF )  
    {  
        /* 如果有返回对应的命令行参数 */  
        switch(opt)  
        {  
            case  0 : break;                //flag不为NULL
            case 'f': force = 1;break;      //不等待服务器响应
            case 'r': force_reload = 1;break;  //失败时重新发送请求
            case '9': http10 = 0;break;      //http/0.9
            case '1': http10 = 1;break;      //http/1.0
            case '2': http10 = 2;break;      //http/1.1
            case 'V':     //打印系统的版本（1.5）
                      printf(PROGRAM_VERSION"\n");  
                      exit(0);  
            case 't':  //压力测试的运行时间
                      benchtime = atoi(optarg);   //optarg为选项后面所跟的参数
                      break;  
            case 'p':  
                      /* proxy server parsing server:port */   //以代理服务器（把一些请求和响应存在本地磁盘）的方式请求 （-p  server:port）
                      tmp = strrchr(optarg,':');  //在optarg中找最后一次出现：的位置
                      proxyhost = optarg;  
                      if(tmp == NULL)  
                      {  
                          break;  
                      }  
                      if(tmp == optarg)  
                      {  
                          fprintf(stderr,"Error in option --proxy %s: Missing hostname.\n",optarg);  
                          return 2;  
                      }  
                      if(tmp == optarg + strlen(optarg)-1)  // ：在字符串的尾部，则没有port参数
                      {  
                          fprintf(stderr,"Error in option --proxy %s Port number is missing.\n",optarg);  
                          return 2;  
                      }  
                      *tmp = '\0';  
                      proxyport = atoi(tmp+1);  //指向端口号地址
                      break;  
            case ':':                          //无效的选项
            case 'h':                          //help
            case '?': usage();return 2;break;     //无效的选项
            case 'c': clients = atoi(optarg);break;  //并发请求的客户端数目
        }  
    }  
  
    /* optind 被 getopt_long 设置为命令行参数中未读取的下一个元素下标值 */  
    if(optind == argc)                 //命令行参数中没有URL argv[optind]指向URL
    {  
        fprintf(stderr,"webbench: Missing URL!\n");  
        usage();  
        return 2;  
    }  
  
    // 不能指定客户端数和请求时间为0 
    if(clients == 0) clients = 1;  
    if(benchtime == 0) benchtime = 60;  
  
    //打印Copyright
    fprintf(stderr,"Webbench - Simple Web Benchmark "PROGRAM_VERSION"\n"  
     "Copyright (c) Radim Kolar 1997-2004, GPL Open Source Software.\n"  
     );  
  
    // 构造 HTTP 请求到 request 数组 
    build_request(argv[optind]);      //使用URL参数构造http请求
  
    /* 以下到函数结束为输出提示信息 */  
    /* print bench info */  
    printf("\nBenchmarking: ");  
    switch(method)  
    {  
        case METHOD_GET:  
        default:  
            printf("GET");break;  
        case METHOD_OPTIONS:  
            printf("OPTIONS");break;  
        case METHOD_HEAD:  
            printf("HEAD");break;  
        case METHOD_TRACE:  
            printf("TRACE");break;  
    }  
  
    printf(" %s",argv[optind]);  
    switch(http10)  
    {  
        case 0: printf(" (using HTTP/0.9)");break;  
        case 2: printf(" (using HTTP/1.1)");break;  
    }  
  
    printf("\n");  
  
    if(clients == 1) printf("1 client");  
    else  
        printf("%d clients",clients);  
  
    printf(", running %d sec", benchtime);  
    if(force) printf(", early socket close");  //不等待服务器响应
    if(proxyhost != NULL) printf(", via proxy server %s:%d",proxyhost,proxyport);  //代理服务器
    if(force_reload) printf(", forcing reload");  //失败时重新发送请求
    printf(".\n");  
  
    /* 开始压力测试，返回 bench 函数执行结果 */  
    return bench();  
}  
  
 //url--->http://www.baidu.com/      
void build_request(const char *url)  //构建http请求篇
{  
    char tmp[10];  
    int i;  
  
    /* 初始化 */  
    bzero(host,MAXHOSTNAMELEN);  
    bzero(request,REQUEST_SIZE);  
  
    /* 判断应该使用的 HTTP 协议 */  
    if(force_reload && proxyhost != NULL && http10 < 1) http10 = 1;  //http/0.9 该为http/1.0
    if(method == METHOD_HEAD && http10 < 1) http10 = 1;       //http/0.9 该为http/1.0
    if(method == METHOD_OPTIONS && http10 < 2) http10 = 2;   //http/1.0或http/0.9改为http/1.1
    if(method == METHOD_TRACE && http10 < 2) http10 = 2;     //http/1.0或http/0.9改为http/1.1
	
   /***********构造请求行--》 请求方法 资源路径  版本********/
  
    /*填写 method 方法 */  
    switch(method)  
    {  
        default:  
        case METHOD_GET: strcpy(request,"GET");break;  
        case METHOD_HEAD: strcpy(request,"HEAD");break;  
        case METHOD_OPTIONS: strcpy(request,"OPTIONS");break;  
        case METHOD_TRACE: strcpy(request,"TRACE");break;  
    }  
  
    strcat(request," ");  //追加
  
    /* URL 合法性判断 */  
    if(NULL == strstr(url,"://"))  //不合法
    {  
        fprintf(stderr, "\n%s: is not a valid URL.\n",url);  
        exit(2);  
    }  
  
    if(strlen(url)>1500)  //url太长，不合法
    {  
        fprintf(stderr,"URL is too long.\n");  
        exit(2);  
    }  
  
    if(proxyhost == NULL)  //不是代理服务器方式
        if(0 != strncasecmp("http://",url,7))  //忽略大小写的比较
        {  
            /* 只支持 HTTP 地址 */  
            fprintf(stderr,"\nOnly HTTP protocol is directly supported, set --proxy for others.\n");  
            exit(2);  
        }  
	  
		/* 找到主机名开始的地方 */  
		/* protocol/host delimiter */  
		i = strstr(url,"://")-url+3;     //i=7
	  
		// 必须以 / 结束
		if(strchr(url+i,'/')==NULL)  
		{  
			fprintf(stderr,"\nInvalid URL syntax - hostname don't ends with '/'.\n");  
			exit(2);  
		}  
  
		if(proxyhost == NULL)  //不是代理服务器方式，则没有指定端口号
		{  
			/* get port from hostname */  
			if(index(url+i,':') != NULL && index(url+i,':') < index(url+i,'/'))  //URL中有填写端口号 baidu.com:80
			{  
				strncpy(host,url+i,strchr(url+i,':')-url-i);  //host中存放网络地址，host baidu.com
				/* 端口 */  
				bzero(tmp,10);  
				strncpy(tmp,index(url+i,':')+1,strchr(url+i,'/')-index(url+i,':')-1);  //tmp 80
				proxyport = atoi(tmp);           // 设置端口 
				if(proxyport==0) proxyport=80;  
	  
			} else {  
				strncpy(host,url+i,strcspn(url+i,"/"));   //strcspn->找第一次出现/的位置，下标值    host baidu.com
			}  
			
			strcat(request+strlen(request),url+i+strcspn(url+i,"/"));  //现在请求行里面填有  method 资源路径
		} 
		else 
		{  
			strcat(request,url);  
        }  
  
    //给请求行构造版本号
    if(http10 == 1)  
        strcat(request," HTTP/1.0");  
    else if (http10==2)  
        strcat(request," HTTP/1.1");  
    strcat(request,"\r\n");  
    /*******************以上请求行构造完毕*************************/
   
   /************构造请求消息报头********************/
   //格式-->name: value
   //name: value
   //.......
    if(http10 > 0)  
        strcat(request,"User-Agent: WebBench "PROGRAM_VERSION"\r\n");   //告诉服务器你的信息
  
    if(proxyhost == NULL && http10 > 0)  //不是代理服务器方式
    {  
        strcat(request,"Host: ");  //发送请求时，报头域时必须的。
        strcat(request,host);  
        strcat(request,"\r\n");  
    }  
  
    if(force_reload && proxyhost != NULL)  //失败时重新发送和是代理服务器方式
    {  
        strcat(request,"Pragma: no-cache\r\n");   //请求消息不能缓存
    }  
  
    if(http10 > 1)  
        strcat(request,"Connection: close\r\n");  //如果版本号为1.1时，就通知服务器响应完成后，就关闭连接。
	/****************以上是构造请求消息报头******************/

	/*********构造空行*************/
    if(http10>0) strcat(request,"\r\n");  
}  
  
/* vraci system rc error kod */  
static int bench(void)  
{  
    int i,j,k;  
    pid_t pid = 0;  
    FILE *f;  
  
    /* 作为测试地址是否合法 */  
    /* check avaibility of target server */  
    i = Socket(proxyhost == NULL?host:proxyhost, proxyport);  //i为创建的套接字
    if(i < 0){  
        fprintf(stderr,"\nConnect to server failed. Aborting benchmark.\n");  
        return 1;  
    }  
    close(i);    //测试阶段
  
    /* 建立管道 */  
    /* create pipe */  
    if(pipe(mypipe))    //匿名管道
    {  
        perror("pipe failed.");  
        return 3;  
    }  
  
    /* not needed, since we have alarm() in childrens */  
    /* wait 4 next system clock tick */  
    /* 
     * cas=time(NULL); 
     * while(time(NULL)==cas) 
     * sched_yield(); 
     * */  
  
    /* 派生子进程 */  
    /* fork childs */  
    for(i = 0;i < clients;i++)  
    {  
        pid = fork();  
        if(pid <= (pid_t)0)  //特别重要
        {  
            /* child process or error*/  
            sleep(1); /* make childs faster */  
            break; /* 子进程立刻跳出循环，要不就子进程继续 fork 了 */  
        }  
    }  
  
    //创建失败
    if( pid < (pid_t)0)  
    {  
        fprintf(stderr,"problems forking worker no. %d\n",i);  
        perror("fork failed.");  
        return 3;  
    }  
  
    //子进程
    if(pid == (pid_t)0)  
    {  
        /* 子进程发出实际请求 */  
        /* I am a child */  
        if(proxyhost == NULL)  
            benchcore(host,proxyport,request);         //跳到下面的函数
        else  
            benchcore(proxyhost,proxyport,request);  
  
        /* 打开管道写 */  
        /* write results to pipe */  
        f = fdopen(mypipe[1],"w");   //将一个现有的文件描述符与标准I/O相结合，也就是把文件描述符转为文件指针
        if(f == NULL)  
        {  
            perror("open pipe for writing failed.");  
            return 3;  
        }  
  
        /* fprintf(stderr,"Child - %d %d\n",speed,failed); */  
        fprintf(f,"%d %d %d\n",speed,failed,bytes);  
        fclose(f);  
  
        return 0;  
  
    } else {  
        /* 父进程打开管道读 */  
        f = fdopen(mypipe[0],"r");  
        if(f == NULL)  
        {  
            perror("open pipe for reading failed.");  
            return 3;  
        }  
     
        setvbuf(f,NULL,_IONBF,0);   //设置文件流的缓冲区，类型：IONRF：无缓冲区，
        speed = 0; /* 传输速度 */  
        failed = 0; /* 失败请求数 */  
        bytes = 0; /* 传输字节数 */  
  
        while(1)  
        {  
            pid = fscanf(f,"%d %d %d",&i,&j,&k);  
            if(pid<2)  
            {  
                fprintf(stderr,"Some of our childrens died.\n");  
                break;  
            }  
			//汇总
            speed += i;  
            failed += j;  
            bytes += k;  
            /* fprintf(stderr,"*Knock* %d %d read=%d\n",speed,failed,pid); */  
            /* 子进程是否读取完 */  
            if(--clients == 0) break;  
        }  
        fclose(f);  
  
        /* 结果计算 */  
        printf("\nSpeed=%d pages/min, %d bytes/sec.\nRequests: %d susceed, %d failed.\n",  
                (int)((speed+failed)/(benchtime/60.0f)),  
                (int)(bytes/(float)benchtime),  
                speed,  
                failed);  
    }  
    return i;  
}  
  
//子进程来发送请求
void benchcore(const char *host,const int port,const char *req)         //ip   端口号   http请求
{  
    int rlen;  
    char buf[1500];  
    int s,i;  
    struct sigaction sa;  
  
    /*安装信号 */  
    /* setup alarm signal handler */  
    sa.sa_handler = alarm_handler;  //对信号进行处理的函数
    sa.sa_flags = 0;  
    if(sigaction(SIGALRM,&sa,NULL))  //设置信号处理
        exit(3);  
  
    /* 设置闹钟函数 */  
    alarm(benchtime);  
  
    rlen = strlen(req);  
  
nexttry:  
    while(1){  
        /* 收到信号则 timerexpired = 1 */  
        if(timerexpired)  
        {  
            if(failed > 0)  //因为信号而导致的失败
            {  
                /* fprintf(stderr,"Correcting failed by signal\n"); */  
                failed--;  
            }  
            return;  
        }  
        /* 建立 socket, 进行 HTTP 请求 */  
        s = Socket(host,port);  
        if(s < 0)  
        {  
            failed++;  
            continue;  
        }  
        if(rlen!=write(s,req,rlen))  
        {  
            failed++;  
            close(s);  
            continue;  
        }  
        /* HTTP 0.9 的处理 */  
        if(http10==0)  
            /* 如果关闭不成功 */  
            if(shutdown(s,1))   //禁止在一个套接字上进行写，成功0，失败-1
            {  
                failed++;  
                close(s);  
                continue;  
            }  
  
        /* -f 选项时不读取服务器回复 */  
        if(force == 0)  //等待服务器的响应
        {  
            /* read all available data from socket */  
            while(1)  
            {  
                if(timerexpired) break;   //信号触发了
                i = read(s,buf,1500);  
                /* fprintf(stderr,"%d\n",i); */  
                if(i<0)  
                {  
                    failed++;  
                    close(s);  
                    goto nexttry;  
                }  
                else  
                    if(i == 0) break;  
                    else bytes+=i;  
            }  
        }  
        if(close(s))  
        {  
            failed++;  
            continue;  
        }  
        speed++;  
    }  
}