int network_server_listen_tcp(struct network_server *ns,
const char *host, uint16_t port)
{
if (ns == NULL) {
return -1;
}
ns->sin.sin6_family = AF_INET6;
ns->sin.sin6_port = htons((uint16_t)port);
ns->port = port;
if (host == NULL) {
ns->sin.sin6_addr = in6addr_any;
ns->host = strdup("0.0.0.0");
} else {
// TODO bind to the specified host instead
ns->sin.sin6_addr = in6addr_any;
ns->host = strdup(host);
}
ns->listener = socket(AF_INET6, SOCK_STREAM, 0);
if (ns->listener == -1) {
goto err;
}
make_socket_nonblocking(ns->listener);
/*
* SO_REUSEADDR means something different in windows
*/
#ifndef _WIN32
int yes = 1;
setsockopt(ns->listener, SOL_SOCKET, SO_REUSEADDR, (void *)&yes, sizeof(yes));
#endif
/*
* Override system default and allow socket to accept IPv4 and IPv6
*/
#ifdef IPV6_V6ONLY
int no = 0;
setsockopt(ns->listener, IPPROTO_IPV6, IPV6_V6ONLY, (void *)&no, sizeof(no));
#endif
if (bind(ns->listener, (struct sockaddr *)&ns->sin, sizeof(ns->sin)) == -1) {
goto err;
}
if (listen(ns->listener, 16) == -1) {
goto err;
}
ev_io_init(&ns->connect_event, connect_cb, ns->listener, EV_READ);
ns->connect_event.data = ns;
ev_io_start(ns->loop, &ns->connect_event);
return 0;
err:
close(ns->listener);
ns->listener = 0;
return -1;
}
int bufferev_connect_addrinfo(struct bufferev *be,
struct addrinfo *src, struct addrinfo *dst, float timeout_s)
{
be->sock = socket(dst->ai_family, dst->ai_socktype, dst->ai_protocol);
if (be->sock < 0) {
return -1;
}
make_socket_nonblocking(be->sock);
if (dst->ai_protocol == IPPROTO_UDP) {
be->proto = network_proto_udp;
struct sockaddr *udp_src;
socklen_t udp_src_len;
struct sockaddr_in any_src = {
.sin_family = AF_INET,
.sin_port = htons(0),
.sin_addr.s_addr = INADDR_ANY
};
if (src) {
udp_src = src->ai_addr;
udp_src_len = src->ai_addrlen;
} else {
udp_src = (struct sockaddr *)(&any_src);
udp_src_len = sizeof any_src;
}
if (bind(be->sock, udp_src, udp_src_len) != 0) {
log_debug("could not bind: %s", strerror(errno));
}
} else {
void server_accept_cb(evutil_socket_t server_sockfd, short ev_flag, void *arg) {
client_handler_common_struct *bases = (client_handler_common_struct *)arg;
assert(ev_flag == EV_READ);
(void)ev_flag;
int client_sockfd = accept(server_sockfd, NULL, NULL);
if (client_sockfd < 0) {perror("accept"); return;}
if (make_socket_nonblocking(client_sockfd)) {
perror("fcntl");
if (close(client_sockfd)) perror("close");
return;
}
client_handler_construct_and_run(bases, client_sockfd);
}
lcb_socket_t
cb_io_socket(struct lcb_io_opt_st *iops, int domain, int type,
int protocol)
{
lcb_socket_t sock = socket(domain, type, protocol);
if (sock == INVALID_SOCKET) {
iops->v.v0.error = errno;
} else {
if (make_socket_nonblocking(sock) != 0) {
int error = errno;
iops->v.v0.close(iops, sock);
iops->v.v0.error = error;
sock = INVALID_SOCKET;
}
}
return sock;
}
void connect_cb(struct ev_loop *loop, struct ev_io *w, int revents)
{
struct network_server *ns = w->data;
struct sockaddr_storage sockaddr;
socklen_t slen;
int fd = accept(ns->listener, (struct sockaddr *)&sockaddr, &slen);
if (fd < 0) {
log_error("could not accept: %s", strerror(errno));
} else if (fd > FD_SETSIZE) {
close(fd);
} else {
make_socket_nonblocking(fd);
struct bufferev *be = bufferev_new(loop);
if (be) {
bufferev_set_cbs(be, ns->read_cb, ns->write_cb, ns->event_cb, ns->cb_arg);
bufferev_connect_tcp_sock(be, fd);
}
}
}
static lcb_socket_t
socket_impl(lcb_io_opt_t iops, int domain, int type, int protocol)
{
lcb_socket_t sock;
#ifdef _WIN32
sock = (lcb_socket_t)WSASocket(domain, type, protocol, NULL, 0, 0);
#else
sock = socket(domain, type, protocol);
#endif
if (sock == INVALID_SOCKET) {
LCB_IOPS_ERRNO(iops) = errno;
} else {
if (make_socket_nonblocking(sock) != 0) {
#ifdef _WIN32
LCB_IOPS_ERRNO(iops) = get_wserr(sock);
#else
LCB_IOPS_ERRNO(iops) = errno;
#endif
close_impl(iops, sock);
sock = INVALID_SOCKET;
}
}
return sock;
}
/*
** open sockets and make them non-blocking
*/
void
open_sockets(
void
)
{
sockaddr_u name;
if (-1 == sock4) {
sock4 = socket(PF_INET, SOCK_DGRAM, 0);
if (-1 == sock4) {
/* error getting a socket */
msyslog(LOG_ERR, "open_sockets: socket(PF_INET) failed: %m");
exit(1);
}
/* Make it non-blocking */
make_socket_nonblocking(sock4);
/* Let's try using a wildcard... */
ZERO(name);
AF(&name) = AF_INET;
SET_ADDR4N(&name, INADDR_ANY);
SET_PORT(&name, (HAVE_OPT(USERESERVEDPORT) ? 123 : 0));
if (-1 == bind(sock4, &name.sa,
SOCKLEN(&name))) {
msyslog(LOG_ERR, "open_sockets: bind(sock4) failed: %m");
exit(1);
}
/* Register an NTP callback for recv/timeout */
ev_sock4 = event_new(base, sock4,
EV_TIMEOUT | EV_READ | EV_PERSIST,
&sock_cb, NULL);
if (NULL == ev_sock4) {
msyslog(LOG_ERR,
"open_sockets: event_new(base, sock4) failed!");
} else {
event_add(ev_sock4, &wakeup_tv);
}
}
/* We may not always have IPv6... */
if (-1 == sock6 && ipv6_works) {
sock6 = socket(PF_INET6, SOCK_DGRAM, 0);
if (-1 == sock6 && ipv6_works) {
/* error getting a socket */
msyslog(LOG_ERR, "open_sockets: socket(PF_INET6) failed: %m");
exit(1);
}
/* Make it non-blocking */
make_socket_nonblocking(sock6);
/* Let's try using a wildcard... */
ZERO(name);
AF(&name) = AF_INET6;
SET_ADDR6N(&name, in6addr_any);
SET_PORT(&name, (HAVE_OPT(USERESERVEDPORT) ? 123 : 0));
if (-1 == bind(sock6, &name.sa,
SOCKLEN(&name))) {
msyslog(LOG_ERR, "open_sockets: bind(sock6) failed: %m");
exit(1);
}
/* Register an NTP callback for recv/timeout */
ev_sock6 = event_new(base, sock6,
EV_TIMEOUT | EV_READ | EV_PERSIST,
&sock_cb, NULL);
if (NULL == ev_sock6) {
msyslog(LOG_ERR,
"open_sockets: event_new(base, sock6) failed!");
} else {
event_add(ev_sock6, &wakeup_tv);
}
}
return;
}
