static void close_listeners(void)
{
if (!listen_list)
return;
hlog(LOG_DEBUG, "Closing listening sockets....");
while (listen_list)
listener_free(listen_list);
}
static void _epollwatch_free(gpointer data) {
EpollWatch* watch = data;
MAGIC_ASSERT(watch);
descriptor_removeStatusListener(watch->descriptor, watch->listener);
listener_free(watch->listener);
descriptor_unref(watch->descriptor);
MAGIC_CLEAR(watch);
g_free(watch);
}
static int close_removed_listeners(void)
{
int closed = 0;
hlog(LOG_DEBUG, "Closing removed listening sockets....");
struct listen_t *l, *next;
next = listen_list;
while (next) {
l = next;
next = l->next;
struct listen_config_t *lc = find_listen_config_id(listen_config, l->id);
if (!lc) {
hlog(LOG_INFO, "Listener %d (%s) no longer in configuration, closing port....",
l->id, l->addr_s);
listener_free(l);
closed++;
}
}
return closed;
}
int main(int argc, char **argv)
{
/* open log */
if (0 != LOG_OPEN("./center", LOG_LEVEL_DEBUG, -1)) {
fprintf(stderr, "open center log failed!\n");
return 1;
}
if (0 != check_cmd()) {
return 1;
}
/* protobuf verify version */
GOOGLE_PROTOBUF_VERIFY_VERSION;
struct event_base *main_base = event_base_new();
if (NULL == main_base) {
mfatal("main_base = event_base_new() failed!");
return 1;
}
conn_init();
/* thread */
pthread_t worker[WORKER_NUM];
thread_init(main_base, WORKER_NUM, worker);
/* signal */
struct event *signal_event;
signal_event = evsignal_new(main_base, SIGINT, signal_cb, (void *)main_base);
if (NULL == signal_event || 0 != event_add(signal_event, NULL)) {
mfatal("create/add a signal event failed!");
return 1;
}
/* listener for gate */
struct sockaddr_in sa;
bzero(&sa, sizeof(sa));
sa.sin_family = AF_INET;
sa.sin_addr.s_addr = htonl(INADDR_ANY);
sa.sin_port = htons(44000);
listener *lg = listener_new(main_base, (struct sockaddr *)&sa, sizeof(sa), gate_cb);
if (NULL == lg) {
mfatal("create client listener failed!");
return 1;
}
/* connector to center */
struct sockaddr_in csa;
bzero(&csa, sizeof(csa));
csa.sin_family = AF_INET;
csa.sin_addr.s_addr = inet_addr("127.0.0.1");
csa.sin_port = htons(43001);
connector *ce = connector_new((struct sockaddr *)&csa, sizeof(csa), center_cb);
if (NULL == ce) {
mfatal("create center connector failed!");
return 1;
}
event_base_dispatch(main_base);
for (int i = 0; i < WORKER_NUM; i++)
pthread_join(worker[i], NULL);
connector_free(ce);
listener_free(lg);
event_free(signal_event);
event_base_free(main_base);
/* shutdown protobuf */
google::protobuf::ShutdownProtobufLibrary();
/* close log */
LOG_CLOSE();
return 0;
}
static int open_listener(struct listen_config_t *lc)
{
struct listen_t *l;
int i;
l = listener_alloc();
l->id = lc->id;
l->hidden = lc->hidden;
l->corepeer = lc->corepeer;
l->client_flags = lc->client_flags;
l->clients_max = lc->clients_max;
l->portaccount = port_accounter_alloc();
/* Pick first of the AIs for this listen definition */
l->addr_s = strsockaddr( lc->ai->ai_addr, lc->ai->ai_addrlen );
l->name = hstrdup(lc->name);
l->portnum = lc->portnum;
l->ai_protocol = lc->ai->ai_protocol;
l->listener_id = keyhash(l->addr_s, strlen(l->addr_s), 0);
l->listener_id = keyhash(&lc->ai->ai_socktype, sizeof(lc->ai->ai_socktype), l->listener_id);
l->listener_id = keyhash(&lc->ai->ai_protocol, sizeof(lc->ai->ai_protocol), l->listener_id);
hlog(LOG_DEBUG, "Opening listener %d/%d '%s': %s", lc->id, l->listener_id, lc->name, l->addr_s);
if (lc->ai->ai_socktype == SOCK_DGRAM &&
lc->ai->ai_protocol == IPPROTO_UDP) {
/* UDP listenting is not quite same as TCP listening.. */
i = open_udp_listener(l, lc->ai);
} else if (lc->ai->ai_socktype == SOCK_STREAM && lc->ai->ai_protocol == IPPROTO_TCP) {
/* TCP listenting... */
i = open_tcp_listener(l, lc->ai, "TCP");
#ifdef USE_SCTP
} else if (lc->ai->ai_socktype == SOCK_STREAM &&
lc->ai->ai_protocol == IPPROTO_SCTP) {
i = open_tcp_listener(l, lc->ai, "SCTP");
if (i >= 0)
i = sctp_set_listen_params(l);
#endif
} else {
hlog(LOG_ERR, "Unsupported listener protocol for '%s'", l->name);
listener_free(l);
return -1;
}
if (i < 0) {
hlog(LOG_DEBUG, "... failed");
listener_free(l);
return -1;
}
hlog(LOG_DEBUG, "... ok, bound");
/* Set up an SSL context if necessary */
#ifdef USE_SSL
if (lc->keyfile && lc->certfile) {
l->ssl = ssl_alloc();
if (ssl_create(l->ssl, (void *)l)) {
hlog(LOG_ERR, "Failed to create SSL context for '%s*': %s", lc->name, l->addr_s);
listener_free(l);
return -1;
}
if (ssl_certificate(l->ssl, lc->certfile, lc->keyfile)) {
hlog(LOG_ERR, "Failed to load SSL key and certificates for '%s*': %s", lc->name, l->addr_s);
listener_free(l);
return -1;
}
/* optional client cert validation */
if (lc->cafile) {
if (ssl_ca_certificate(l->ssl, lc->cafile, 2)) {
hlog(LOG_ERR, "Failed to load trusted SSL CA certificates for '%s*': %s", lc->name, l->addr_s);
listener_free(l);
return -1;
}
}
hlog(LOG_INFO, "SSL initialized for '%s': %s%s", lc->name, l->addr_s, (lc->cafile) ? " (client validation enabled)" : "");
}
#endif
/* Copy access lists */
if (lc->acl)
l->acl = acl_dup(lc->acl);
/* Copy filter definitions */
listener_copy_filters(l, lc);
hlog(LOG_DEBUG, "... adding %s to listened sockets", l->addr_s);
// put (first) in the list of listening sockets
l->next = listen_list;
l->prevp = &listen_list;
if (listen_list)
listen_list->prevp = &l->next;
listen_list = l;
return 0;
}
