374 lines
9.8 KiB
C
374 lines
9.8 KiB
C
#include <sys/types.h>
|
|
#include <sys/socket.h>
|
|
#include <netinet/in.h>
|
|
#include <arpa/inet.h>
|
|
#include <netdb.h> // for gethostbyname
|
|
|
|
#include <stddef.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include <signal.h>
|
|
|
|
#include <getopt.h>
|
|
#include <unistd.h>
|
|
|
|
int Connect(const char* host, int port) {
|
|
struct sockaddr_in addr;
|
|
addr.sin_family = AF_INET;
|
|
in_addr_t inaddr = inet_addr(host);
|
|
if (inaddr != INADDR_NONE) {
|
|
addr.sin_addr.s_addr = inaddr;
|
|
}
|
|
else {
|
|
struct hostent* phe = gethostbyname(host);
|
|
if (phe == NULL) {
|
|
return -1;
|
|
}
|
|
memcpy(&addr.sin_addr, phe->h_addr_list[0], phe->h_length);
|
|
}
|
|
addr.sin_port = htons(port);
|
|
int sock = socket(AF_INET, SOCK_STREAM, 0);
|
|
if (sock < 0) {
|
|
perror("socket");
|
|
return -2;
|
|
}
|
|
if (connect(sock, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
|
|
perror("connect");
|
|
return -3;
|
|
}
|
|
return sock;
|
|
}
|
|
|
|
#define METHOD_GET 0
|
|
#define METHOD_HEAD 1
|
|
#define METHOD_OPTIONS 2
|
|
#define METHOD_TRACE 3
|
|
|
|
#define VERSION "webbench/1.19.3.15"
|
|
|
|
int verbose = 0;
|
|
int quiet = 0;
|
|
volatile int timerexpired = 0; // for timer
|
|
int time = 30;
|
|
int clients = 1;
|
|
char host[64] = {0};
|
|
int port = 80;
|
|
char* proxy_host = NULL;
|
|
int proxy_port = 80;
|
|
int method = METHOD_GET;
|
|
int http = 1; // 1=HTTP/1.1 0=HTTP/1.0
|
|
int keepalive = 0;
|
|
const char* url = NULL;
|
|
|
|
#define REQUEST_SIZE 2048
|
|
char request[REQUEST_SIZE] = {0};
|
|
char buf[1460] = {0};
|
|
|
|
int mypipe[2]; // IPC
|
|
|
|
static const char options[] = "?hVvq01kt:p:c:";
|
|
|
|
static const struct option long_options[] = {
|
|
{"help", no_argument, NULL, 'h'},
|
|
{"version", no_argument, NULL, 'V'},
|
|
{"verbose", no_argument, NULL, 'v'},
|
|
{"quiet", no_argument, NULL, 'q'},
|
|
{"time", required_argument, NULL, 't'},
|
|
{"proxy", required_argument, NULL, 'p'},
|
|
{"clients", required_argument, NULL, 'c'},
|
|
{"http10", no_argument, NULL, '0'},
|
|
{"http11", no_argument, NULL, '1'},
|
|
{"keepalive", no_argument, NULL, 'k'},
|
|
{"get", no_argument, &method, METHOD_GET},
|
|
{"head", no_argument, &method, METHOD_HEAD},
|
|
{"options", no_argument, &method, METHOD_OPTIONS},
|
|
{"trace", no_argument, &method, METHOD_TRACE},
|
|
{NULL, 0, NULL, 0}
|
|
};
|
|
|
|
void print_usage() {
|
|
printf("Usage: webbench [%s] URL\n", options);
|
|
puts("\n\
|
|
Options:\n\
|
|
-?|-h|--help Print this information.\n\
|
|
-V|--version Print version.\n\
|
|
-v|--verbose Print verbose.\n\
|
|
-q|--quiet Print quiet.\n\
|
|
-0|--http10 Use HTTP/1.0 protocol.\n\
|
|
-1|--http11 Use HTTP/1.1 protocol.\n\
|
|
-k|--keepalive Connection: keep-alive.\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. Default one.\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\
|
|
");
|
|
}
|
|
|
|
int parse_cmdline(int argc, char** argv) {
|
|
int opt = 0;
|
|
int opt_idx = 0;
|
|
while ((opt=getopt_long(argc, argv, options, long_options, &opt_idx)) != EOF) {
|
|
switch (opt) {
|
|
case '?':
|
|
case 'h': print_usage(); exit(1);
|
|
case 'V': puts(VERSION); exit(1);
|
|
case 'v': verbose = 1; break;
|
|
case 'q': quiet = 1; break;
|
|
case '0': http = 0; break;
|
|
case '1': http = 1; break;
|
|
case 'k': keepalive = 1; break;
|
|
case 't': time = atoi(optarg); break;
|
|
case 'c': clients = atoi(optarg); break;
|
|
case 'p':
|
|
{
|
|
// host:port
|
|
char* pos = strrchr(optarg, ':');
|
|
proxy_host = optarg;
|
|
if (pos == NULL) break;
|
|
if (pos == optarg ||
|
|
pos == optarg + strlen(optarg) - 1) {
|
|
printf("Error option --proxy\n");
|
|
return -2;
|
|
}
|
|
*pos = '\0';
|
|
proxy_port = atoi(pos+1);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (optind == argc) {
|
|
printf("Missing URL\n");
|
|
return -2;
|
|
}
|
|
|
|
url = argv[optind];
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void alarm_handler(int singal) {
|
|
timerexpired = 1;
|
|
}
|
|
|
|
int main(int argc, char** argv) {
|
|
if (argc == 1) {
|
|
print_usage();
|
|
return 2;
|
|
}
|
|
|
|
int ret = parse_cmdline(argc, argv);
|
|
if (ret != 0) {
|
|
return ret;
|
|
}
|
|
|
|
printf("%d clients, running %d sec\n", clients, time);
|
|
|
|
// domain port url
|
|
const char* req_url = "/";
|
|
if (proxy_host) {
|
|
strncpy(host, proxy_host, sizeof(host));
|
|
port = proxy_port;
|
|
} else {
|
|
// http://host:port/path
|
|
const char* pos1 = strstr(url, "http://");
|
|
if (pos1 == NULL) {
|
|
pos1 = url;
|
|
} else {
|
|
pos1 += strlen("http://");
|
|
}
|
|
const char* pos2 = strchr(pos1, '/');
|
|
if (pos2 == NULL) {
|
|
pos2 = url + strlen(url);
|
|
} else {
|
|
req_url = pos2;
|
|
}
|
|
int len = pos2 - pos1;
|
|
char* server = (char*)malloc(len+1);
|
|
memcpy(server, pos1, len);
|
|
server[len] = '\0';
|
|
char* pos3 = strrchr(server, ':');
|
|
if (pos3 == NULL) {
|
|
port = 80;
|
|
} else {
|
|
*pos3 = '\0';
|
|
port = atoi(pos3+1);
|
|
}
|
|
strncpy(host, server, sizeof(host));
|
|
free(server);
|
|
}
|
|
char Host[256];
|
|
snprintf(Host, sizeof(Host), "Host: %s:%d\r\n", host, port);
|
|
printf("%s", Host);
|
|
|
|
// test connect
|
|
int sock = Connect(host, port);
|
|
if (sock < 0) {
|
|
printf("Connect failed!\n");
|
|
return -20;
|
|
} else {
|
|
printf("Connect test OK!\n");
|
|
close(sock);
|
|
}
|
|
|
|
// build request
|
|
switch (method) {
|
|
case METHOD_GET:
|
|
default:
|
|
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, " ");
|
|
strcat(request, req_url);
|
|
strcat(request, " ");
|
|
if (http == 0) {
|
|
strcat(request, "HTTP/1.0");
|
|
} else if (http == 1) {
|
|
strcat(request, "HTTP/1.1");
|
|
}
|
|
strcat(request, "\r\n");
|
|
strcat(request, "User-Agent: webbench/1.18.3.15\r\n");
|
|
strcat(request, Host);
|
|
strcat(request, "Cache-Control: no-cache\r\n");
|
|
if (keepalive) {
|
|
strcat(request, "Connection: keep-alive\r\n");
|
|
}
|
|
else {
|
|
strcat(request, "Connection: close\r\n");
|
|
}
|
|
strcat(request, "\r\n");
|
|
if (!quiet) {
|
|
printf("%s", request);
|
|
}
|
|
|
|
// IPC
|
|
if (pipe(mypipe) < 0) {
|
|
perror("pipe");
|
|
exit(20);
|
|
}
|
|
|
|
// fork childs
|
|
pid_t pid = 0;
|
|
FILE* fp = NULL;
|
|
long long succeed = 0, failed = 0, bytes = 0;
|
|
int childs = clients;
|
|
int i;
|
|
for (i = 0; i < childs; ++i) {
|
|
pid = fork();
|
|
if (pid < 0) {
|
|
perror("fork");
|
|
exit(-10);
|
|
}
|
|
|
|
if (pid == 0) {
|
|
// child
|
|
//printf("child[%d] start\n", getpid());
|
|
signal(SIGALRM, alarm_handler);
|
|
alarm(time);
|
|
int sock = -1;
|
|
int len = strlen(request);
|
|
int wrbytes, rdbytes;
|
|
while (1) {
|
|
connect:
|
|
if (timerexpired) break;
|
|
if (sock == -1) {
|
|
sock = Connect(host, port);
|
|
}
|
|
if (sock < 0) {
|
|
++failed;
|
|
continue;
|
|
}
|
|
int total_rdbytes = 0;
|
|
write:
|
|
if (timerexpired) break;
|
|
wrbytes = write(sock, request, len);
|
|
if (verbose) {
|
|
printf("write %d bytes\n", wrbytes);
|
|
}
|
|
if (wrbytes != len) {
|
|
++failed;
|
|
goto close;
|
|
}
|
|
if (verbose) {
|
|
printf("%s\n", request);
|
|
}
|
|
read:
|
|
if (timerexpired) break;
|
|
rdbytes = read(sock, buf, sizeof(buf));
|
|
if (verbose) {
|
|
printf("read %d bytes\n", rdbytes);
|
|
}
|
|
if (rdbytes <= 0) {
|
|
++failed;
|
|
goto close;
|
|
}
|
|
if (verbose) {
|
|
printf("%.*s\n", rdbytes, buf);
|
|
}
|
|
static int s_rdbytes = 0;
|
|
if (s_rdbytes == 0) {
|
|
s_rdbytes = rdbytes;
|
|
}
|
|
bytes += rdbytes;
|
|
total_rdbytes += rdbytes;
|
|
if (total_rdbytes < s_rdbytes) {
|
|
// NOTE: some http server head and body send not one packet.
|
|
goto read;
|
|
}
|
|
++succeed;
|
|
close:
|
|
if (!keepalive) {
|
|
close(sock);
|
|
sock = -1;
|
|
}
|
|
}
|
|
|
|
fp = fdopen(mypipe[1], "w");
|
|
if (fp == NULL) {
|
|
perror("fdopen");
|
|
return 30;
|
|
}
|
|
fprintf(fp, "%lld %lld %lld\n", succeed, failed, bytes);
|
|
fclose(fp);
|
|
//printf("child[%d] end\n", getpid());
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
fp = fdopen(mypipe[0], "r");
|
|
if (fp == NULL) {
|
|
perror("fdopen");
|
|
return 30;
|
|
}
|
|
while (1) {
|
|
long long i,j,k;
|
|
fscanf(fp, "%lld %lld %lld", &i, &j, &k);
|
|
succeed += i;
|
|
failed += j;
|
|
bytes += k;
|
|
if (--childs==0) break;
|
|
}
|
|
fclose(fp);
|
|
printf("recv %lld bytes/sec, %lld succeed, %lld failed\n",
|
|
bytes/time,
|
|
succeed,
|
|
failed);
|
|
|
|
return 0;
|
|
}
|