void handle(int fd) {
char buf[200];
ssize_t n_read;
while((n_read = read(fd, buf, sizeof(buf))) > 0) {
buf[n_read-1] = '\0';
char* bufp = buf;
char* cursor;
while((cursor = strsep(&bufp, "\n")) != NULL) {
int fdd = dup(fd);
FILE* f = fdopen(fdd, "a");
char command[20];
char const* const remainder = flatjson_next(chomp(buf), command, sizeof(command), NULL);
if(strcmp(command, "list") == 0) {
handle_list(f, true);
} else if(strcmp(command, "configure") == 0) {
handle_configure(f, remainder);
} else if(strcmp(command, "connect") == 0) {
handle_connect(f, remainder);
} else if(strcmp(command, "disconnect") == 0) {
handle_disconnect(f, remainder);
} else {
warn("Unknown command");
}
fclose(f);
}
}
}
int main(int argc, char *argv[])
{
int s_s; /*服务器套接字文件描述符*/
struct sockaddr_in local; /*本地地址*/
signal(SIGINT, sig_int);
/*建立TCP套接字*/
s_s = socket(AF_INET, SOCK_DGRAM, 0);
/*初始化地址*/
memset(&local, 0, sizeof(local)); /*清零*/
local.sin_family = AF_INET; /*AF_INET协议族*/
local.sin_addr.s_addr = htonl(INADDR_ANY); /*任意本地地址*/
local.sin_port = htons(SERVER_PORT); /*服务器端口*/
/*将套接字文件描述符绑定到本地地址和端口*/
bind(s_s, (struct sockaddr*)&local, sizeof(local));
/*处理客户端连接*/
pid_t pid[PIDNUMB];
int i =0;
for(i=0;i<PIDNUMB;i++)
{
pid[i] = fork();
if(pid[i] == 0) /*子进程*/
{
handle_connect(s_s);
}
}
while(1);
return 0;
}
static void handle_fd_events(struct poll_fd_mgr *poll_mgr)
{
int i;
/* Process the fd array from end to start. This allows us to handle
* removing entries from the array. Also ignore the signal fd at index 0.
*/
for (i = poll_mgr->nfds-1; i > 0; i--) {
if (!poll_mgr->poll_fds[i].revents)
continue;
switch (poll_mgr->poll_info[i].type) {
case CONNECT_SOCK:
handle_connect(poll_mgr, i);
if (poll_mgr->poll_info[i].state == CONNECT_DONE)
poll_fds_swap_del_last(poll_mgr, i);
break;
case PASSIVE_SOCK:
handle_connreq(poll_mgr, &poll_mgr->poll_info[i]);
break;
case ACCEPT_SOCK:
handle_accept_conn(poll_mgr, &poll_mgr->poll_info[i]);
poll_fds_swap_del_last(poll_mgr, i);
break;
default:
FI_WARN(&tcpx_prov, FI_LOG_EP_CTRL,
"should never end up here\n");
}
}
}
/* argc命令行参数输入个数，argv存储了所有变量参数 */
int output_tcp(int argc, char *argv[])
{
/** 服务器套接字文件描述符 */
int s_s;
/** 本地地址 */
struct sockaddr_in local;
/** 建立TCP套接字 */
s_s = socket( AF_INET, SOCK_STREAM, 0);
/** 初始化地址 */
memset(&local, 0,sizeof(local)); // 清零
local.sin_family = AF_INET;
local.sin_addr.s_addr = htonl(INADDR_ANY);
local.sin_port = htons(SERVER_PORT);
/** 将套接字文件描述符绑定到本地地址和端口 */
int err = bind(s_s, (struct sockaddr *)&local,sizeof(local));
err = listen(s_s, BACKLOG);
handle_connect(s_s);
close(s_s);
return 0;
}
int main(int argc,char * argv[]) {
int svr_cmd_sock;
//svr_cmd_sock init
struct sockaddr_in cmd_sock_addr;
svr_cmd_sock = socket(AF_INET,SOCK_STREAM,0);
memset(&cmd_sock_addr,0,sizeof(cmd_sock_addr));
cmd_sock_addr.sin_family = AF_INET;
cmd_sock_addr.sin_addr.s_addr = htonl(INADDR_ANY);
cmd_sock_addr.sin_port = htons(CMD_PORT);
if (-1 == bind(svr_cmd_sock,(struct sockaddr *)&cmd_sock_addr,sizeof(cmd_sock_addr))) {
printf("svr cmd socket bind err\n");
}
if (-1 == listen(svr_cmd_sock,BACKLOG)) {
printf("svr cmd socket listen err\n");
}
/*
if (fork() != 0)
exit(1);
if (setsid() < 0)
exit(1);
if (fork() != 0)
exit(1);
if (chdir("/tmp") == -1)
exit(1);
for (int fd = 0, fdtablesize = getdtablesize(); fd < fdtablesize; fd++)
close(fd);
umask(0);
*/
handle_connect(svr_cmd_sock);
return 0;
}
int main(int argc, char *argv[])
{
int s_s; /*服务器套接字文件描述符*/
struct sockaddr_in local; /*本地地址*/
/*建立TCP套接字*/
s_s = socket(AF_INET, SOCK_STREAM, 0);
/*初始化地址和端口*/
memset(&local, 0, sizeof(local)); /*清零*/
local.sin_family = AF_INET; /*AF_INET协议族*/
local.sin_addr.s_addr = htonl(INADDR_ANY); /*任意本地地址*/
local.sin_port = htons(SERVER_PORT); /*服务器端口*/
/*将套接字文件描述符绑定到本地地址和端口*/
bind(s_s, (struct sockaddr*)&local, sizeof(local));
listen(s_s, BACKLOG); /*侦听*/
/*处理客户端连接*/
handle_connect(s_s);
close(s_s); /*关闭套接字*/
return 0;
}
int handle(int sock, package_buf_t* buf)
{
byte = buf->package[0];
if (byte && 0xF0 == 0x01)
{
handle_connect(sock, buf);
}
}
void pipeline_connector::do_connect(){
tcode::io::ip::address& addr = _address[_current_address_index];
_connect_in_progress = true;
_connect_time = tcode::timestamp::now();
_socket.connect( addr , [this]( const std::error_code& ec
, const tcode::io::ip::address& addr )
{
handle_connect(ec);
});
}
int main()
{
handle_connect(1);
return 1;
int uids[UID_NUM];
readFile(uids);
pid_t pid[UID_NUM];
int i = 0;
for (i = 0; i < UID_NUM; i++)
{
pid[i] = fork();
if (pid[i] == 0)
{
handle_connect(uids[i]);
}
else
{
break;
}
}
return 1;
}
static void
write_cb(int fd, void *arg)
{
struct argos_net_conn *conn = arg;
if (conn->state == ARGOS_NET_CONN_CONNECTING) {
handle_connect(conn);
}
else if (conn->state == ARGOS_NET_CONN_CONNECTED) {
/* this callback shouldn't happen unless outbuf is non-empty */
size_t datalen = buffer_len(conn->outbuf);
assert(datalen > 0);
/*
* when possible, we want to make sure to feed send() large blocks of
* data at a time, so if there is only a little data in the outbuf, try
* to get some more by compressing and moving over some of the pktbuf
*/
if (datalen < SEND_SOFT_MIN) {
(void) compress_and_xfer(conn, 0 /* don't force */);
datalen = buffer_len(conn->outbuf);
}
ssize_t len = socket_send(conn, buffer_head(conn->outbuf), datalen);
if (len != -1) {
if (buffer_discard(conn->outbuf, len) == -1)
KABOOM("buffer_discard");
/*
* When a partial-send occurs, this means we might have sent part of
* a message and left the remainder sitting at the head of the
* outbuf. This is not a problem for the server (it will receive
* and buffer the portion that was sent, waiting for us to send the
* remainder) - however, it means that we cannot arbitrarily send
* things down the socket until we finish off this partially-sent
* message. We call this state "unsynced" because we don't know if
* we stopped sending on a message boundary or not.
*/
if (buffer_len(conn->outbuf) == 0)
conn->outbuf_unsync = 0;
else if (datalen != len)
conn->outbuf_unsync = 1;
/* if connection is shutting down, check if buffers are now empty */
if (conn->shutdown && buffers_are_empty(conn))
kill_connection(conn);
}
}
}
int main (int argc,char *argv[]) {
int s_s;
struct sockaddr_in local;
s_s = socket(AF_INET,SOCK_STREAM,0);
memset(&local,0,sizeof(local));
local.sin_family = AF_INET;
local.sin_addr.s_addr = htonl(INADDR_ANY);
local.sin_port = htons(SERVER_PORT);
int err = bind(s_s,(struct sockaddr *)&local,sizeof(local));
err = listen(s_s,BACKLOG);
handle_connect(s_s);
close(s_s);
return 0;
}
int gdbr_connect(libgdbr_t* g, const char* host, int port) {
int ret;
char tmp[255];
ret = snprintf (tmp, 255, "%d", port);
if (!ret) return -1;
ret = r_socket_connect_tcp (g->sock, host, tmp, 200);
if (!ret) return -1;
g->connected = 1;
// TODO add config possibility here
char* message = "qSupported:multiprocess+;qRelocInsn+";
ret = send_command(g, message);
if (ret < 0)
return ret;
read_packet(g);
return handle_connect(g);
}
int gdbr_connect(libgdbr_t* g, const char* host, int port) {
int fd;
int connected;
struct protoent *protocol;
struct hostent *hostaddr;
struct sockaddr_in socketaddr;
protocol = getprotobyname("tcp");
if (!protocol) {
printf("Error prot\n");
//TODO Error here
return -1;
}
fd = socket( PF_INET, SOCK_STREAM, protocol->p_proto);
if (fd == -1) {
printf("Error sock\n");
//TODO Error here
return -1;
}
memset(&socketaddr, 0, sizeof(socketaddr));
socketaddr.sin_family = AF_INET;
socketaddr.sin_port = htons(port);
hostaddr = (struct hostent *)gethostbyname(host);
if (!hostaddr) {
printf("Error host\n");
//TODO Error here
return -1;
}
connected = connect(fd, (struct sockaddr *) &socketaddr, sizeof(socketaddr));
if (connected == -1) {
printf("error conn\n");
//TODO Error here
return -1;
}
g->fd = fd;
g->connected = 1;
// TODO add config possibility here
char* message = "qSupported:multiprocess+;qRelocInsn+";
send_command(g, message);
read_packet(g);
return handle_connect(g);
}
/* argc命令行参数输入个数，argv存储了所有变量参数 */
int output_tcp(int argc, char *argv[])
{
/** 服务器套接字文件描述符 */
int s_s,s_c;
/** 本地地址 */
struct sockaddr_in local,from;
time_t now;
char buff[BUFFLEN];
int n = 0;
int len =sizeof(from);
/** 建立TCP套接字 */
s_s = socket( AF_INET, SOCK_STREAM, 0);
/** 初始化地址 */
memset(&local, 0,sizeof(local)); // 清零
local.sin_family = AF_INET;
local.sin_addr.s_addr = htonl(INADDR_ANY);
local.sin_port = htons(SERVER_PORT);
/** 将套接字文件描述符绑定到本地地址和端口 */
int err = bind(s_s, (struct sockaddr *)&local,sizeof(local));
err = listen(s_s, BACKLOG);
// while(1)
// {
// /** 接收客户端连接 */
// s_c = accept(s_s,(struct sockaddr *)&from,&len);
// memset(buff, 0, BUFFLEN);
// n = recv(s_c, buff, BUFFLEN, 0);
// if(n > 0 && !strncmp(buff,"TIME",4))
// {
// memset(buff, 0,BUFFLEN);
// now = time(NULL);
// sprintf(buff,"%24s\r\n",ctime(&now));
// printf("Send data:%s",buff);
// send(s_c,buff,strlen(buff),0);
// }
// close(s_c);
// }
handle_connect(s_s);
close(s_s);
return 0;
}
void handle_poll(int listenfd)
{
int connfd, sockfd;
struct sockaddr_in cliaddr;
socklen_t cliaddrlen;
struct pollfd clientfds[OPEN_MAX];
int nready;
//添加监听描述符
clientfds[0].fd = listenfd;
clientfds[0].events = POLLIN;
//初始化客户连接描述符
//int i, conn_num = 1;
int i, imax = 0;
for (i = 1; i < OPEN_MAX; i++)
{
clientfds[i].fd = -1;
}
//循环处理
while(1)
{
//获取可用描述符的个数
printf("wztest ==================\n");
nready = poll(clientfds, imax + 1 , -1);
if (nready == -1)
{
perror("poll error:");
exit(1);
}
if (clientfds[0].revents & POLLIN) {
handle_accept(listenfd, clientfds, &imax);
}
//if (--nready > 0){
handle_connect(clientfds, imax);
//}
}
}
void response_base< Timer >::handle_request( const json::object& request,
const boost::shared_ptr< response_interface >& self, const std::string& connection_name, bool last_message )
{
const json::string channel = extract_channel( request );
if ( channel == meta_handshake_channel )
{
handle_handshake( request, connection_name );
return;
}
const json::string client_id = check_client_id( request, channel );
if ( client_id.empty() )
return;
if ( !check_session( request, client_id, channel ) )
return;
if ( channel == meta_connect_channel )
{
handle_connect( request, self, last_message );
}
else if ( channel == meta_disconnect_channel )
{
handle_disconnect( request );
}
else if ( channel == meta_subscribe_channel )
{
handle_subscribe( request );
}
else if ( channel == meta_unsubscribe_channel )
{
handle_unsubscribe( request );
}
else
{
handle_publish( channel, request );
}
}
int clients_write(clients_t* list, fd_set* set)
{
if(!list)
return -1;
slist_element_t* tmp = list->list_.first_;
while(tmp) {
client_t* c = (client_t*)tmp->data_;
tmp = tmp->next_;
if(c && c->state_ == CONNECTED) {
int i;
for(i=0; i<2; ++i) {
if(FD_ISSET(c->fd_[i], set)) {
int len = send(c->fd_[i], c->write_buf_[i].buf_, c->write_buf_offset_[i], 0);
if(len < 0) {
log_printf(INFO, "Error on send(): %s, removing client %d", strerror(errno), c->fd_[0]);
slist_remove(&(list->list_), c);
break;
}
else {
c->transferred_[i] += len;
if(c->write_buf_offset_[i] > len) {
memmove(c->write_buf_[i].buf_, &c->write_buf_[i].buf_[len], c->write_buf_offset_[i] - len);
c->write_buf_offset_[i] -= len;
}
else
c->write_buf_offset_[i] = 0;
}
}
}
} else if(c && c->state_ == CONNECTING && FD_ISSET(c->fd_[1], set)) {
int ret = handle_connect(c, list->buffer_size_);
if(ret)
slist_remove(&(list->list_), c);
}
}
return 0;
}
void
dispatch_db_cmd(ETERM *msg)
{
ETERM *tag;
char *tag_name;
tag = erl_element(1, msg);
tag_name = (char *)ERL_ATOM_PTR(tag);
if (strncmp(tag_name, CONNECT_MSG, strlen(CONNECT_MSG)) == 0)
handle_connect(msg);
else if (strncmp(tag_name, QUERY_MSG, strlen(QUERY_MSG)) == 0)
handle_query(msg);
else if (strncmp(tag_name, PARAM_QUERY_MSG, strlen(PARAM_QUERY_MSG)) == 0)
handle_param_query(msg);
else if (strncmp(tag_name, SELECT_COUNT_MSG, strlen(SELECT_COUNT_MSG)) == 0)
handle_select_count(msg);
else if (strncmp(tag_name, SELECT_MSG, strlen(SELECT_MSG)) == 0)
handle_select(msg);
else if (strncmp(tag_name, FIRST_MSG, strlen(FIRST_MSG)) == 0)
handle_first(msg);
else if (strncmp(tag_name, LAST_MSG, strlen(LAST_MSG)) == 0)
handle_last(msg);
else if (strncmp(tag_name, NEXT_MSG, strlen(NEXT_MSG)) == 0)
handle_next(msg);
else if (strncmp(tag_name, PREV_MSG, strlen(PREV_MSG)) == 0)
handle_prev(msg);
else {
ETERM *resp;
resp = erl_format("{error, {uknown_message, ~s}}", tag);
write_msg(resp);
erl_free_term(resp);
}
erl_free_term(tag);
}
int clients_add(clients_t* list, int fd, const tcp_endpoint_t remote_end, const tcp_endpoint_t source_end)
{
if(!list)
return -1;
client_t* element = malloc(sizeof(client_t));
if(!element) {
close(fd);
return -2;
}
int i;
for(i = 0; i < 2; ++i) {
element->write_buf_[i].buf_ = NULL;
element->write_buf_[i].length_ = 0;
element->write_buf_offset_[i] = 0;
}
element->state_ = CONNECTING;
element->fd_[0] = fd;
element->fd_[1] = socket(remote_end.addr_.ss_family, SOCK_STREAM, 0);
if(element->fd_[1] < 0) {
log_printf(INFO, "Error on socket(): %s, not adding client %d", strerror(errno), element->fd_[0]);
close(element->fd_[0]);
free(element);
return -1;
}
int on = 1;
if(setsockopt(element->fd_[0], IPPROTO_TCP, TCP_NODELAY, &on, sizeof(on)) ||
setsockopt(element->fd_[1], IPPROTO_TCP, TCP_NODELAY, &on, sizeof(on))) {
log_printf(ERROR, "Error on setsockopt(): %s", strerror(errno));
close(element->fd_[0]);
close(element->fd_[1]);
free(element);
return -1;
}
if(fcntl(element->fd_[0], F_SETFL, O_NONBLOCK) ||
fcntl(element->fd_[1], F_SETFL, O_NONBLOCK)) {
log_printf(ERROR, "Error on fcntl(): %s", strerror(errno));
close(element->fd_[0]);
close(element->fd_[1]);
free(element);
return -1;
}
if(source_end.addr_.ss_family != AF_UNSPEC) {
if(bind(element->fd_[1], (struct sockaddr *)&(source_end.addr_), source_end.len_)==-1) {
log_printf(INFO, "Error on bind(): %s, not adding client %d", strerror(errno), element->fd_[0]);
close(element->fd_[0]);
close(element->fd_[1]);
free(element);
return -1;
}
}
if(slist_add(&(list->list_), element) == NULL) {
close(element->fd_[0]);
close(element->fd_[1]);
free(element);
return -2;
}
if(connect(element->fd_[1], (struct sockaddr *)&(remote_end.addr_), remote_end.len_)==-1) {
if(errno == EINPROGRESS)
return 0;
log_printf(INFO, "Error on connect(): %s, not adding client %d", strerror(errno), element->fd_[0]);
slist_remove(&(list->list_), element);
return -1;
}
log_printf(DEBUG, "connect() for client %d returned immediatly", element->fd_[0]);
int ret = handle_connect(element, list->buffer_size_);
if(ret)
slist_remove(&(list->list_), element);
return ret;
}
static void
start_socket( int url_num, int cnum, struct timeval* nowP )
{
ClientData client_data;
int flags;
int sip_num;
/* Start filling in the connection slot. */
connections[cnum].url_num = url_num;
connections[cnum].started_at = *nowP;
client_data.i = cnum;
connections[cnum].did_connect = 0;
connections[cnum].did_response = 0;
connections[cnum].idle_timer = tmr_create(
nowP, idle_connection, client_data, idle_secs * 1000L, 0 );
connections[cnum].wakeup_timer = (Timer*) 0;
connections[cnum].content_length = -1;
connections[cnum].bytes = 0;
connections[cnum].checksum = 0;
connections[cnum].http_status = -1;
/* Make a socket. */
connections[cnum].conn_fd = socket(
urls[url_num].sock_family, urls[url_num].sock_type,
urls[url_num].sock_protocol );
if ( connections[cnum].conn_fd < 0 )
{
perror( urls[url_num].url_str );
return;
}
/* Set the file descriptor to no-delay mode. */
flags = fcntl( connections[cnum].conn_fd, F_GETFL, 0 );
if ( flags == -1 )
{
perror( urls[url_num].url_str );
(void) close( connections[cnum].conn_fd );
return;
}
if ( fcntl( connections[cnum].conn_fd, F_SETFL, flags | O_NDELAY ) < 0 )
{
perror( urls[url_num].url_str );
(void) close( connections[cnum].conn_fd );
return;
}
if ( num_sips > 0 )
{
/* Try a random source IP address. */
sip_num = ( (unsigned long) random() ) % ( (unsigned int) num_sips );
if ( bind(
connections[cnum].conn_fd,
(struct sockaddr*) &sips[sip_num].sa,
sizeof(sips[sip_num].sa) ) < 0 )
{
perror( "binding local address" );
(void) close( connections[cnum].conn_fd );
return;
}
}
/* Connect to the host. */
connections[cnum].sa_len = urls[url_num].sa_len;
(void) memmove(
(void*) &connections[cnum].sa, (void*) &urls[url_num].sa,
urls[url_num].sa_len );
connections[cnum].connect_at = *nowP;
if ( connect(
connections[cnum].conn_fd,
(struct sockaddr*) &connections[cnum].sa,
connections[cnum].sa_len ) < 0 )
{
if ( errno == EINPROGRESS )
{
connections[cnum].conn_state = CNST_CONNECTING;
return;
}
else
{
perror( urls[url_num].url_str );
(void) close( connections[cnum].conn_fd );
return;
}
}
/* Connect succeeded instantly, so handle it now. */
(void) gettimeofday( nowP, (struct timezone*) 0 );
handle_connect( cnum, nowP, 0 );
}
int
main( int argc, char** argv )
{
int argn;
int start;
#define START_NONE 0
#define START_PARALLEL 1
#define START_RATE 2
int start_parallel = -1, start_rate = -1;
int end;
#define END_NONE 0
#define END_FETCHES 1
#define END_SECONDS 2
int end_fetches = -1, end_seconds = -1;
int cnum;
char* url_file;
char* sip_file;
#ifdef RLIMIT_NOFILE
struct rlimit limits;
#endif /* RLIMIT_NOFILE */
fd_set rfdset;
fd_set wfdset;
struct timeval now;
int i, r;
max_connections = 64 - RESERVED_FDS; /* a guess */
#ifdef RLIMIT_NOFILE
/* Try and increase the limit on # of files to the maximum. */
if ( getrlimit( RLIMIT_NOFILE, &limits ) == 0 )
{
if ( limits.rlim_cur != limits.rlim_max )
{
if ( limits.rlim_max == RLIM_INFINITY )
limits.rlim_cur = 8192; /* arbitrary */
else if ( limits.rlim_max > limits.rlim_cur )
limits.rlim_cur = limits.rlim_max;
(void) setrlimit( RLIMIT_NOFILE, &limits );
}
max_connections = limits.rlim_cur - RESERVED_FDS;
}
#endif /* RLIMIT_NOFILE */
/* Parse args. */
argv0 = argv[0];
argn = 1;
do_checksum = do_throttle = do_verbose = do_jitter = do_proxy = 0;
throttle = THROTTLE;
sip_file = (char*) 0;
idle_secs = IDLE_SECS;
start = START_NONE;
end = END_NONE;
while ( argn < argc && argv[argn][0] == '-' && argv[argn][1] != '\0' )
{
if ( strncmp( argv[argn], "-checksum", strlen( argv[argn] ) ) == 0 )
do_checksum = 1;
else if ( strncmp( argv[argn], "-throttle", strlen( argv[argn] ) ) == 0 )
do_throttle = 1;
else if ( strncmp( argv[argn], "-Throttle", strlen( argv[argn] ) ) == 0 && argn + 1 < argc )
{
do_throttle = 1;
throttle = atoi( argv[++argn] ) / 10.0;
}
else if ( strncmp( argv[argn], "-verbose", strlen( argv[argn] ) ) == 0 )
do_verbose = 1;
else if ( strncmp( argv[argn], "-timeout", strlen( argv[argn] ) ) == 0 && argn + 1 < argc )
idle_secs = atoi( argv[++argn] );
else if ( strncmp( argv[argn], "-jitter", strlen( argv[argn] ) ) == 0 )
do_jitter = 1;
else if ( strncmp( argv[argn], "-parallel", strlen( argv[argn] ) ) == 0 && argn + 1 < argc )
{
start = START_PARALLEL;
start_parallel = atoi( argv[++argn] );
if ( start_parallel < 1 )
{
(void) fprintf(
stderr, "%s: parallel must be at least 1\n", argv0 );
exit( 1 );
}
if ( start_parallel > max_connections )
{
(void) fprintf(
stderr, "%s: parallel may be at most %d\n", argv0, max_connections );
exit( 1 );
}
}
else if ( strncmp( argv[argn], "-rate", strlen( argv[argn] ) ) == 0 && argn + 1 < argc )
{
start = START_RATE;
start_rate = atoi( argv[++argn] );
if ( start_rate < 1 )
{
(void) fprintf(
stderr, "%s: rate must be at least 1\n", argv0 );
exit( 1 );
}
if ( start_rate > 1000 )
{
(void) fprintf(
stderr, "%s: rate may be at most 1000\n", argv0 );
exit( 1 );
}
}
else if ( strncmp( argv[argn], "-fetches", strlen( argv[argn] ) ) == 0 && argn + 1 < argc )
{
end = END_FETCHES;
end_fetches = atoi( argv[++argn] );
if ( end_fetches < 1 )
{
(void) fprintf(
stderr, "%s: fetches must be at least 1\n", argv0 );
exit( 1 );
}
}
else if ( strncmp( argv[argn], "-seconds", strlen( argv[argn] ) ) == 0 && argn + 1 < argc )
{
end = END_SECONDS;
end_seconds = atoi( argv[++argn] );
if ( end_seconds < 1 )
{
(void) fprintf(
stderr, "%s: seconds must be at least 1\n", argv0 );
exit( 1 );
}
}
else if ( strncmp( argv[argn], "-sip", strlen( argv[argn] ) ) == 0 && argn + 1 < argc )
sip_file = argv[++argn];
#ifdef USE_SSL
else if ( strncmp( argv[argn], "-cipher", strlen( argv[argn] ) ) == 0 && argn + 1 < argc )
{
cipher = argv[++argn];
if ( strcasecmp( cipher, "fastsec" ) == 0 )
cipher = "RC4-MD5";
else if ( strcasecmp( cipher, "highsec" ) == 0 )
cipher = "DES-CBC3-SHA";
else if ( strcasecmp( cipher, "paranoid" ) == 0 )
cipher = "AES256-SHA";
}
#endif /* USE_SSL */
else if ( strncmp( argv[argn], "-proxy", strlen( argv[argn] ) ) == 0 && argn + 1 < argc )
{
char* colon;
do_proxy = 1;
proxy_hostname = argv[++argn];
colon = strchr( proxy_hostname, ':' );
if ( colon == (char*) 0 )
proxy_port = 80;
else
{
proxy_port = (unsigned short) atoi( colon + 1 );
*colon = '\0';
}
}
else
usage();
++argn;
}
if ( argn + 1 != argc )
usage();
if ( start == START_NONE || end == END_NONE )
usage();
if ( do_jitter && start != START_RATE )
usage();
url_file = argv[argn];
/* Read in and parse the URLs. */
printf("Loading url file...");
read_url_file( url_file );
printf("Total %d urls loaded.\n", num_urls);
/* Read in the source IP file, if specified. */
if ( sip_file != (char*) 0 )
read_sip_file( sip_file );
/* Initialize the connections table. */
if ( start == START_PARALLEL )
max_connections = start_parallel;
connections = (connection*) malloc_check(
max_connections * sizeof(connection) );
for ( cnum = 0; cnum < max_connections; ++cnum )
connections[cnum].conn_state = CNST_FREE;
num_connections = max_parallel = 0;
/* Initialize the HTTP status-code histogram. */
for ( i = 0; i < 1000; ++i )
http_status_counts[i] = 0;
/* Initialize the statistics. */
fetches_started = 0;
connects_completed = 0;
responses_completed = 0;
fetches_completed = 0;
total_bytes = 0;
total_connect_usecs = 0;
max_connect_usecs = 0;
min_connect_usecs = 1000000000L;
total_response_usecs = 0;
max_response_usecs = 0;
min_response_usecs = 1000000000L;
total_timeouts = 0;
total_badbytes = 0;
total_badchecksums = 0;
/* Initialize the random number generator. */
#ifdef HAVE_SRANDOMDEV
srandomdev();
#else
srandom( (int) time( (time_t*) 0 ) ^ getpid() );
#endif
/* Initialize the rest. */
tmr_init();
(void) gettimeofday( &now, (struct timezone*) 0 );
start_at = now;
if ( do_verbose )
(void) tmr_create(
&now, progress_report, JunkClientData, PROGRESS_SECS * 1000L, 1 );
if ( start == START_RATE )
{
start_interval = 1000L / start_rate;
if ( do_jitter )
{
low_interval = start_interval * 9 / 10;
high_interval = start_interval * 11 / 10;
range_interval = high_interval - low_interval + 1;
}
(void) tmr_create(
&now, start_timer, JunkClientData, start_interval, ! do_jitter );
}
if ( end == END_SECONDS )
(void) tmr_create(
&now, end_timer, JunkClientData, end_seconds * 1000L, 0 );
(void) signal( SIGPIPE, SIG_IGN );
/* Main loop. */
for (;;)
{
if ( end == END_FETCHES && fetches_completed >= end_fetches )
finish( &now );
if ( start == START_PARALLEL )
{
/* See if we need to start any new connections; but at most 10. */
for ( i = 0;
i < 10 &&
num_connections < start_parallel &&
( end != END_FETCHES || fetches_started < end_fetches );
++i )
{
start_connection( &now );
(void) gettimeofday( &now, (struct timezone*) 0 );
tmr_run( &now );
}
}
/* Build the fdsets. */
FD_ZERO( &rfdset );
FD_ZERO( &wfdset );
for ( cnum = 0; cnum < max_connections; ++cnum )
switch ( connections[cnum].conn_state )
{
case CNST_CONNECTING:
FD_SET( connections[cnum].conn_fd, &wfdset );
break;
case CNST_HEADERS:
case CNST_READING:
FD_SET( connections[cnum].conn_fd, &rfdset );
break;
}
r = select(
FD_SETSIZE, &rfdset, &wfdset, (fd_set*) 0, tmr_timeout( &now ) );
if ( r < 0 )
{
perror( "select" );
exit( 1 );
}
(void) gettimeofday( &now, (struct timezone*) 0 );
/* Service them. */
for ( cnum = 0; cnum < max_connections; ++cnum )
switch ( connections[cnum].conn_state )
{
case CNST_CONNECTING:
if ( FD_ISSET( connections[cnum].conn_fd, &wfdset ) )
handle_connect( cnum, &now, 1 );
break;
case CNST_HEADERS:
case CNST_READING:
if ( FD_ISSET( connections[cnum].conn_fd, &rfdset ) )
handle_read( cnum, &now );
break;
}
/* And run the timers. */
tmr_run( &now );
}
/* NOT_REACHED */
}
NET_API int
net_wait(struct net_service* service, int timeout)
{
int ret;
int err;
struct iocp_data* ov_data;
PULONG_PTR data;
DWORD bytes;
int cnt;
#if _WIN32_WINNT >= 0x0600
ULONG ulCount;
ULONG ulNR;
ULONG i;
OVERLAPPED_ENTRY entries[32];
cnt = 0;
ulCount = sizeof(entries) / sizeof(OVERLAPPED_ENTRY);
ulNR = 0;
ov_data = 0;
data = 0;
bytes = 0;
err = 0;
while(1)
{
ret = GetQueuedCompletionStatusEx(service->net_service_fd, entries, ulCount, &ulNR, timeout, 0);
err = net_get_error();
if (err == WAIT_TIMEOUT)
{
err = 0;
}
if (!ret)
{
if (err)
{
return -err;
}
return cnt;
}
for (i = 0; i < ulNR; ++i)
{
ov_data = (struct iocp_data*)entries[i].lpOverlapped;
bytes = entries[i].dwNumberOfBytesTransferred;
if (ov_data)
{
switch(ov_data->op_type)
{
case OP_NET_ACCEPT:
handle_accept(service, ret, err, (struct accept_session*)ov_data);
break;
case OP_NET_READ:
handle_read(service, ret, err, (struct read_session*)ov_data, bytes);
break;
case OP_NET_WRITE:
handle_write(service, ret, err, (struct write_session*)ov_data, bytes);
break;
case OP_NET_CONNECT:
handle_connect(service, ret, err, (struct connect_session *)ov_data, bytes);
break;
}
}
}
cnt += (int)ulNR;
}
return cnt;
#else
cnt = 0;
while(1)
{
ret = GetQueuedCompletionStatus(service->net_service_fd, &bytes, (PULONG_PTR) &data, (LPOVERLAPPED*)&ov_data, timeout);
err = 0;
if (!ret)
{
err = net_get_error();
}
if (err == WAIT_TIMEOUT)
{
err = 0;
}
if(!ov_data)
{
if(err)
{
return -err;
}
return cnt;
}
else
{
switch(ov_data->op_type)
{
case OP_NET_ACCEPT:
handle_accept(service, ret, err, (struct accept_session*)ov_data);
break;
case OP_NET_READ:
handle_read(service, ret, err, (struct read_session*)ov_data, bytes);
break;
case OP_NET_WRITE:
handle_write(service, ret, err, (struct write_session*)ov_data, bytes);
break;
case OP_NET_CONNECT:
handle_connect(service, ret, err, (struct connect_session *)ov_data, bytes);
break;
}
}
cnt += 1;
}
return cnt;
#endif
}
static void http_server_handler(int c)
{
int code;
struct socket_buffer sock;
struct http_request request;
char *buf;
socket_buffer_init(&sock, c);
#if HAVE_OPENSSL
if (o.ssl) {
sock.fdn.ssl = new_ssl(sock.fdn.fd);
if (SSL_accept(sock.fdn.ssl) != 1) {
loguser("Failed SSL connection: %s\n",
ERR_error_string(ERR_get_error(), NULL));
fdinfo_close(&sock.fdn);
return;
}
}
#endif
code = http_read_request_line(&sock, &buf);
if (code != 0) {
if (o.verbose)
logdebug("Error reading Request-Line.\n");
send_string(&sock.fdn, http_code2str(code));
fdinfo_close(&sock.fdn);
return;
}
if (o.debug > 1)
logdebug("Request-Line: %s", buf);
code = http_parse_request_line(buf, &request);
free(buf);
if (code != 0) {
if (o.verbose)
logdebug("Error parsing Request-Line.\n");
send_string(&sock.fdn, http_code2str(code));
fdinfo_close(&sock.fdn);
return;
}
if (!method_is_known(request.method)) {
if (o.debug > 1)
logdebug("Bad method: %s.\n", request.method);
http_request_free(&request);
send_string(&sock.fdn, http_code2str(405));
fdinfo_close(&sock.fdn);
return;
}
code = http_read_header(&sock, &buf);
if (code != 0) {
if (o.verbose)
logdebug("Error reading header.\n");
http_request_free(&request);
send_string(&sock.fdn, http_code2str(code));
fdinfo_close(&sock.fdn);
return;
}
if (o.debug > 1)
logdebug("Header:\n%s", buf);
code = http_request_parse_header(&request, buf);
free(buf);
if (code != 0) {
if (o.verbose)
logdebug("Error parsing header.\n");
http_request_free(&request);
send_string(&sock.fdn, http_code2str(code));
fdinfo_close(&sock.fdn);
return;
}
/* Check authentication. */
if (o.proxy_auth) {
struct http_credentials credentials;
int ret, stale;
if (http_header_get_proxy_credentials(request.header, &credentials) == NULL) {
/* No credentials or a parsing error. */
send_proxy_authenticate(&sock.fdn, 0);
http_request_free(&request);
fdinfo_close(&sock.fdn);
return;
}
ret = check_auth(&request, &credentials, &stale);
http_credentials_free(&credentials);
if (!ret) {
/* Password doesn't match. */
/* RFC 2617, section 1.2: "If a proxy does not accept the
credentials sent with a request, it SHOULD return a 407 (Proxy
Authentication Required). */
send_proxy_authenticate(&sock.fdn, stale);
http_request_free(&request);
fdinfo_close(&sock.fdn);
return;
}
}
if (strcmp(request.method, "CONNECT") == 0) {
code = handle_connect(&sock, &request);
} else if (strcmp(request.method, "GET") == 0
|| strcmp(request.method, "HEAD") == 0
|| strcmp(request.method, "POST") == 0) {
code = handle_method(&sock, &request);
} else {
code = 500;
}
http_request_free(&request);
if (code != 0) {
send_string(&sock.fdn, http_code2str(code));
fdinfo_close(&sock.fdn);
return;
}
fdinfo_close(&sock.fdn);
}
//--------------------------------------------------------------------------------
void Session::handle_resolve(tcp::resolver::iterator endpoint_iterator)
{
boost::system::error_code e;
socket_->connect(*endpoint_iterator, e);
handle_connect(e);
}
