void cServerHandleImpl::Close(void)
{
// Stop the listener sockets:
evconnlistener_disable(m_ConnListener);
if (m_SecondaryConnListener != nullptr)
{
evconnlistener_disable(m_SecondaryConnListener);
}
m_IsListening = false;
// Shutdown all connections:
cTCPLinkImplPtrs Conns;
{
cCSLock Lock(m_CS);
std::swap(Conns, m_Connections);
}
for (auto conn: Conns)
{
conn->Shutdown();
}
// Remove the ptr to self, so that the object may be freed:
m_SelfPtr.reset();
// Remove self from cNetworkSingleton:
cNetworkSingleton::Get().RemoveServer(this);
}
static void
errorcb(struct evconnlistener *lis, void *data_)
{
int *data = data_;
*data = 1000;
evconnlistener_disable(lis);
}
static void
trigger_listener(int flags, void *ctx)
{
struct evconnlistener *listener = ctx;
if (flags & MODULE_READY)
evconnlistener_enable(listener);
else
evconnlistener_disable(listener);
}
static void
acceptcb(struct evconnlistener *listener, evutil_socket_t fd,
struct sockaddr *addr, int socklen, void *arg)
{
int *ptr = arg;
--*ptr;
TT_BLATHER(("Got one for %p", ptr));
EVUTIL_CLOSESOCKET(fd);
if (! *ptr)
evconnlistener_disable(listener);
}
static void on_output_timer (evutil_socket_t fd, short event, void *ctx)
{
OutData *out = (OutData *) ctx;
struct timeval tv;
struct evbuffer *out_buf;
char *buf;
char c;
LOG_debug (HTTP_TEST, "SRV: on output timer ..");
if (out->test_id < TID_body && out->timer_count >= evbuffer_get_length (out->out_buf)) {
bufferevent_free (out->bev);
evconnlistener_disable (out->listener);
event_base_loopbreak (out->evbase);
LOG_debug (HTTP_TEST, "SRV: All headers data sent !! ");
return;
}
out_buf = evbuffer_new ();
if (out->test_id < TID_body) {
buf = (char *)evbuffer_pullup (out->out_buf, -1);
c = buf[out->timer_count];
evbuffer_add (out_buf, &c, sizeof (c));
out->timer_count++;
LOG_debug (HTTP_TEST, "SRV: Sending %zd bytes:\n>>%s<<\n", evbuffer_get_length (out_buf), evbuffer_pullup (out_buf, -1));
} else {
if (!out->header_sent) {
evbuffer_add_buffer (out_buf, out->out_buf);
out->header_sent = TRUE;
}
/*
if (evbuffer_get_length (out->in_file) < 1) {
bufferevent_free (out->bev);
evconnlistener_disable (out->listener);
event_base_loopbreak (out->evbase);
LOG_debug (HTTP_TEST, "SRV: All data sent !! ");
return;
}*/
evbuffer_remove_buffer (out->in_file, out_buf, 1024*100);
LOG_debug (HTTP_TEST, "SRV: Sending BODY %zd bytes", evbuffer_get_length (out_buf));
}
bufferevent_write_buffer (out->bev, out_buf);
evbuffer_free (out_buf);
evutil_timerclear(&tv);
tv.tv_sec = 0;
tv.tv_usec = 500;
event_add(out->timeout, &tv);
}
void NetServer::StopListen() {
evconnlistener_disable(listener);
StopBroadcast();
}
int
server_init(struct server *s, struct event_base *evbase)
{
struct cfg_sockaddress *it_listen = NULL;
struct cfg_sockaddress *ite_listen = NULL;
struct cfg_sockaddress *it_client = NULL;
struct cfg_sockaddress *ite_client = NULL;
struct cfg_sockaddress *it_peer = NULL;
struct cfg_sockaddress *ite_peer = NULL;
size_t i = 0;
s->peers = v_mc_new();
s->pending_peers = v_mc_new();
s->srv_list = v_evl_new();
s->frames_to_send = v_frame_new();
s->evbase = evbase;
it_listen = v_sockaddr_begin(serv_opts.listen_addrs);
ite_listen = v_sockaddr_end(serv_opts.listen_addrs);
s->ev_sched = sched_new(evbase);
/* Listen on all ListenAddress */
for (; it_listen != ite_listen; it_listen = v_sockaddr_next(it_listen), ++i)
{
struct evconnlistener *evl = NULL;
char listenname[INET6_ADDRSTRLEN];
struct endpoint endp;
evl = evconnlistener_new_bind(evbase, listen_callback,
s, LEV_OPT_CLOSE_ON_FREE | LEV_OPT_REUSEABLE, -1,
(struct sockaddr *)&it_listen->sockaddr, it_listen->len);
if (evl == NULL) {
log_warnx("[INIT] failed to allocate the listener to listen to %s",
address_presentation((struct sockaddr *)&it_listen->sockaddr,
it_listen->len, listenname, sizeof listenname));
continue;
}
evconnlistener_set_error_cb(evl, NULL);
evconnlistener_disable(evl);
/* udp endpoint init */
/*
* We listen on the same address for the udp socket
*/
endpoint_init(&endp, (struct sockaddr *)&it_listen->sockaddr,
it_listen->len);
s->udp = server_udp_new(s, &endp);
if (s->udp == NULL)
{
log_warnx("[INIT] [UDP] failed to init the udp socket on %s",
address_presentation((struct sockaddr *)&it_listen->sockaddr,
it_listen->len, listenname,
sizeof listenname));
continue;
}
v_evl_push(s->srv_list, evl);
}
// Listen enable for client in the ports registered
it_client = v_sockaddr_begin(serv_opts.client_addrs);
ite_client = v_sockaddr_end(serv_opts.client_addrs);
#ifdef USE_TCLT
/* Listen on all ClientAddress */
for (; it_client != ite_client; it_client = v_sockaddr_next(it_client), ++i)
{
char clientname[INET6_ADDRSTRLEN];
struct evconnlistener *evl = NULL;
evl = evconnlistener_new_bind(evbase, listen_client_callback,
s, LEV_OPT_CLOSE_ON_FREE | LEV_OPT_REUSEABLE, -1,
(struct sockaddr *)&it_client->sockaddr, it_client->len);
if (evl == NULL) {
log_warnx("[INIT] [TCP] failed to allocate the listener to listen to %s",
address_presentation((struct sockaddr *)
&it_client->sockaddr, it_client->len, clientname,
sizeof clientname));
continue;
}
evconnlistener_set_error_cb(evl, NULL);
evconnlistener_enable(evl);
v_evl_push(s->srv_list, evl);
}
#endif
/* If we don't have any PeerAddress it's finished */
if (v_sockaddr_size(serv_opts.peer_addrs) == 0)
return 0;
it_peer = v_sockaddr_begin(serv_opts.peer_addrs);
ite_peer = v_sockaddr_end(serv_opts.peer_addrs);
for (;it_peer != ite_peer; it_peer = v_sockaddr_next(it_peer))
{
struct mc *mc_peer = NULL;
#ifdef USE_TCLT
peer p;
char *cmd;
/* TODO : Real information */
p.name = strdup("");
p.name = strdup("");
p.name = strdup("");
#endif
mc_peer = mc_peer_connect(s, evbase,
(struct sockaddr *)&it_peer->sockaddr,
it_peer->len);
#ifdef USE_TCLT
if (mc_peer != NULL && s->mc_client.bev)
{
cmd = tclt_add_peer(&p);
bufferevent_write(s->mc_client.bev, cmd, strlen(cmd));
free(cmd);
}
#endif
}
return 0;
}
