static void drone_event_cb(struct bufferevent *bev, short events, void *arg) {
struct session *session = arg;
struct job *job = session->job;
struct timeval now;
if (events & BEV_EVENT_CONNECTED) {
evutil_socket_t fd = bufferevent_getfd(bev);
set_tcp_no_delay(fd);
job->result->total_sessions++;
} else if (events & BEV_EVENT_ERROR) {
perror("Not connected");
gettimeofday(&now, NULL);
if (drone_report_error_ready(job, &now)) {
snprintf(job->error_msg, sizeof(job->error_msg),
"Connection to the server lost(%zd message skipped)",
job->skipped_error_msg);
drone_report_error(job, &now);
}
if (job->result->total_sessions)
job->result->total_sessions--;
bufferevent_setfd(bev, -1);
}
}
void
buffertls_set(struct buffertls *buftls, struct bufferevent *bufev,
struct tls *ctx, int fd)
{
bufferevent_setfd(bufev, fd);
event_set(&bufev->ev_read, fd, EV_READ, buffertls_readcb, buftls);
event_set(&bufev->ev_write, fd, EV_WRITE, buffertls_writecb, buftls);
buftls->bt_bufev = bufev;
buftls->bt_ctx = ctx;
}
static void
on_accept(struct evconnlistener *l, evutil_socket_t fd,
struct sockaddr* addr, int socklen, void *arg)
{
struct peer* peer;
struct peers* peers = arg;
peers->clients = realloc(peers->clients,
sizeof(struct peer*) * (peers->clients_count+1));
peers->clients[peers->clients_count] =
make_peer(peers, peers->clients_count, (struct sockaddr_in*)addr);
peer = peers->clients[peers->clients_count];
bufferevent_setfd(peer->bev, fd);
bufferevent_setcb(peer->bev, on_read, NULL, on_client_event, peer);
bufferevent_enable(peer->bev, EV_READ|EV_WRITE);
socket_set_nodelay(fd);
paxos_log_info("Accepted connection from %s:%d",
inet_ntoa(((struct sockaddr_in*)addr)->sin_addr),
ntohs(((struct sockaddr_in*)addr)->sin_port));
peers->clients_count++;
}
void
IghtConnectionState::connect_next(void)
{
const char *address;
int error;
const char *family;
struct sockaddr_storage storage;
socklen_t total;
ight_info("connect_next - enter");
for (;;) {
address = this->addrlist->get_next();
if (address == NULL) {
ight_warn("connect_next - no more available addrs");
break;
}
family = this->pflist->get_next();
if (family == NULL)
abort();
ight_info("connect_next - %s %s", family, address);
error = ight_storage_init(&storage, &total, family,
address, this->port);
if (error != 0)
continue;
this->filedesc = ight_socket_create(storage.ss_family,
SOCK_STREAM, 0);
if (this->filedesc == IGHT_SOCKET_INVALID)
continue;
error = bufferevent_setfd(this->bev, (evutil_socket_t)
this->filedesc);
if (error != 0) {
(void) evutil_closesocket(this->filedesc);
this->filedesc = IGHT_SOCKET_INVALID;
continue;
}
error = bufferevent_socket_connect(this->bev, (struct
sockaddr *) &storage, (int) total);
if (error != 0) {
(void) evutil_closesocket(this->filedesc);
this->filedesc = IGHT_SOCKET_INVALID;
error = bufferevent_setfd(this->bev,
IGHT_SOCKET_INVALID);
if (error != 0) {
ight_warn("connect_next - internal error");
break;
}
continue;
}
ight_info("connect_next - ok");
return;
}
this->connecting = 0;
this->on_error(IghtError(-2));
}
int
bufferevent_socket_connect(struct bufferevent *bev,
struct sockaddr *sa, int socklen)
{
struct bufferevent_private *bufev_p =
EVUTIL_UPCAST(bev, struct bufferevent_private, bev);
evutil_socket_t fd;
int r = 0;
int result=-1;
int ownfd = 0;
bufferevent_incref_and_lock_(bev);
if (!bufev_p)
goto done;
fd = bufferevent_getfd(bev);
if (fd < 0) {
if (!sa)
goto done;
fd = evutil_socket_(sa->sa_family,
SOCK_STREAM|EVUTIL_SOCK_NONBLOCK, 0);
if (fd < 0)
goto done;
ownfd = 1;
}
if (sa) {
#ifdef _WIN32
if (bufferevent_async_can_connect_(bev)) {
bufferevent_setfd(bev, fd);
r = bufferevent_async_connect_(bev, fd, sa, socklen);
if (r < 0)
goto freesock;
bufev_p->connecting = 1;
result = 0;
goto done;
} else
#endif
r = evutil_socket_connect_(&fd, sa, socklen);
if (r < 0)
goto freesock;
}
#ifdef _WIN32
/* ConnectEx() isn't always around, even when IOCP is enabled.
* Here, we borrow the socket object's write handler to fall back
* on a non-blocking connect() when ConnectEx() is unavailable. */
if (BEV_IS_ASYNC(bev)) {
event_assign(&bev->ev_write, bev->ev_base, fd,
EV_WRITE|EV_PERSIST, bufferevent_writecb, bev);
}
#endif
bufferevent_setfd(bev, fd);
if (r == 0) {
if (! be_socket_enable(bev, EV_WRITE)) {
bufev_p->connecting = 1;
result = 0;
goto done;
}
} else if (r == 1) {
/* The connect succeeded already. How very BSD of it. */
result = 0;
bufev_p->connecting = 1;
event_active(&bev->ev_write, EV_WRITE, 1);
} else {
/* The connect failed already. How very BSD of it. */
bufev_p->connection_refused = 1;
bufev_p->connecting = 1;
result = 0;
event_active(&bev->ev_write, EV_WRITE, 1);
}
goto done;
freesock:
bufferevent_run_eventcb_(bev, BEV_EVENT_ERROR);
if (ownfd)
evutil_closesocket(fd);
/* do something about the error? */
done:
bufferevent_decref_and_unlock_(bev);
return result;
}
REGRESS_OPENSSL_CLIENT = 64,
REGRESS_OPENSSL_SERVER = 128,
REGRESS_OPENSSL_FREED = 256,
REGRESS_OPENSSL_TIMEOUT = 512,
REGRESS_OPENSSL_SLEEP = 1024,
REGRESS_OPENSSL_CLIENT_WRITE = 2048,
};
static void
bufferevent_openssl_check_fd(struct bufferevent *bev, int filter)
{
tt_int_op(bufferevent_getfd(bev), !=, -1);
tt_int_op(bufferevent_setfd(bev, -1), ==, 0);
if (filter) {
tt_int_op(bufferevent_getfd(bev), !=, -1);
} else {
tt_int_op(bufferevent_getfd(bev), ==, -1);
}
end:
;
}
static void
bufferevent_openssl_check_freed(struct bufferevent *bev)
{
tt_int_op(event_pending(&bev->ev_read, EVLIST_ALL, NULL), ==, 0);
tt_int_op(event_pending(&bev->ev_write, EVLIST_ALL, NULL), ==, 0);
