webbench源码分析

   根据提供的参数构造http请求的消息头，然后fork出N个子进程（也就是webbench时候提供的参数-c N)，每个子进程根据根据参数-t提供的时间，持续这么多秒，这这么长的时间内利用socket创建一个tcp连接到我们想要的网址页面。然后每个进程统计自己再这个时间内取得了多少页面和多少数据，然后由父进程统计，最后发送的consel上面来。

我提取出主要的几个函数

void build_request(const char *url)
{
  char tmp[10];
  int i;

  bzero(host,MAXHOSTNAMELEN);
  bzero(request,REQUEST_SIZE);

  if(force_reload && proxyhost!=NULL && http10<1) http10=1;
  if(method==METHOD_HEAD && http10<1) http10=1;
  if(method==METHOD_OPTIONS && http10<2) http10=2;
  if(method==METHOD_TRACE && http10<2) http10=2;

  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," ");

  if(NULL==strstr(url,"://"))
  {
      fprintf(stderr, "\n%s: is not a valid URL.\n",url);
      exit(2);
  }
  if(strlen(url)>1500)
  {
         fprintf(stderr,"URL is too long.\n");
     exit(2);
  }
  if(proxyhost==NULL)
       if (0!=strncasecmp("http://",url,7))
       { fprintf(stderr,"\nOnly HTTP protocol is directly supported, set --proxy for others.\n");
             exit(2);
           }
 
  i=strstr(url,"://")-url+3;
 

  if(strchr(url+i,'/')==NULL) {
                                fprintf(stderr,"\nInvalid URL syntax - hostname don't ends with '/'.\n");
                                exit(2);
                              }
  if(proxyhost==NULL)
  {
  
   if(index(url+i,':')!=NULL &&
      index(url+i,':')<index(url+i,'/'))
   {
       strncpy(host,url+i,strchr(url+i,':')-url-i);
       bzero(tmp,10);
       strncpy(tmp,index(url+i,':')+1,strchr(url+i,'/')-index(url+i,':')-1);
      
       proxyport=atoi(tmp);
       if(proxyport==0) proxyport=80;
   } else
   {
     strncpy(host,url+i,strcspn(url+i,"/"));
   }
   // printf("Host=%s\n",host);
   strcat(request+strlen(request),url+i+strcspn(url+i,"/"));
  } else
  {
   // printf("ProxyHost=%s\nProxyPort=%d\n",proxyhost,proxyport);
   strcat(request,url);
  }
  if(http10==1)
      strcat(request," HTTP/1.0");
  else if (http10==2)
      strcat(request," HTTP/1.1");
  strcat(request,"\r\n");
  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");
 
  if(http10>0) strcat(request,"\r\n");
  // printf("Req=%s\n",request);
}

上面这个函数很简单，就是根据提供的网址获取主机地址和端口号 （其中有获取代理主机的处理）

static int bench(void)
{
  int i,j,k;    
  pid_t pid=0;
  FILE *f;

 
  i=Socket(proxyhost==NULL?host:proxyhost,proxyport);
  if(i<0) {
       fprintf(stderr,"\nConnect to server failed. Aborting benchmark.\n");
           return 1;
         }
  close(i);
 
  if(pipe(mypipe))
  {
      perror("pipe failed.");
      return 3;
  }

 
 
 

 
  for(i=0;i<clients;i++)
  {
       pid=fork();
       if(pid <= (pid_t) 0)
       {
          
               sleep(1);
           break;
       }
  }

  if( pid< (pid_t) 0)
  {
          fprintf(stderr,"problems forking worker no. %d\n",i);
      perror("fork failed.");
      return 3;
  }

  if(pid== (pid_t) 0)
  {
   
    if(proxyhost==NULL)
      benchcore(host,proxyport,request);
         else
      benchcore(proxyhost,proxyport,request);

        
     f=fdopen(mypipe[1],"w");
     if(f==NULL)
     {
         perror("open pipe for writing failed.");
         return 3;
     }
    
     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);
      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;
         
          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;
}

这个函数也简单，就是创建N个子进程，子进程调用benchcore来获得t时间内连接到网址的三个数据，speed(其实不太准确，应该是success数目），fail（失败数目），总共获取到的字节数。父进程利用管道统计三种数据，最终负责显示。

void benchcore(const char *host,const int port,const char *req)
{
 int rlen;
 char buf[1500];
 int s,i;
 struct sigaction sa;

 
 sa.sa_handler=alarm_handler;
 sa.sa_flags=0;
 if(sigaction(SIGALRM,&sa,NULL))
    exit(3);
 alarm(benchtime);

 rlen=strlen(req);
 nexttry:while(1)
 {
    if(timerexpired)
    {
       if(failed>0)
       {
         
          failed--;
       }
       return;
    }
    s=Socket(host,port);                          
    if(s<0) { failed++;continue;}
    if(rlen!=write(s,req,rlen)) {failed++;close(s);continue;}
    if(http10==0)
        if(shutdown(s,1)) { failed++;close(s);continue;}
    if(force==0)
    {
           
        while(1)
        {
              if(timerexpired) break;
          i=read(s,buf,1500);
             
          if(i<0)
              {
                 failed++;
                 close(s);
                 goto nexttry;
              }
           else
               if(i==0) break;
               else
                   bytes+=i;
        }
    }
    if(close(s)) {failed++;continue;}
    speed++;
 }
}

这个函数作用就是连接到网页上，持续benchtime时间（也就是t时间），其中利用到了信号处理函数来注册了sigalarm，当时间到达后，结束循环。连接使用的是自己封装了的Socket,其实也是很简单的。

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;

    inaddr = inet_addr(host);
    if (inaddr != INADDR_NONE)
        memcpy(&ad.sin_addr, &inaddr, sizeof(inaddr));
    else
    {
        hp = gethostbyname(host);
        if (hp == NULL)
            return -1;
        memcpy(&ad.sin_addr, hp->h_addr, hp->h_length);
    }
    ad.sin_port = htons(clientPort);
    
    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;
}

这就是封装的。

从代码中我们可以看到这个过程是比较简单的，但是问题也是很明显的，无法模拟多个ip测试，而且准确性很低，时间不是真正的web服务器处理请求的时间。但是这个工具比较简单，可以用来做初步分析。