/*
* add_listener- create a new listener
* port - the port number to listen on
* vhost_ip - if non-null must contain a valid IP address string in
* the format "255.255.255.255"
*/
void
add_listener(int port, const char *vhost_ip, int family, int ssl)
{
struct Listener *listener;
struct rb_sockaddr_storage vaddr;
/*
* if no port in conf line, don't bother
*/
if(port == 0)
return;
memset(&vaddr, 0, sizeof(vaddr));
vaddr.ss_family = family;
if(vhost_ip != NULL)
{
if(family == AF_INET)
{
if(rb_inet_pton(family, vhost_ip, &((struct sockaddr_in *)&vaddr)->sin_addr) <= 0)
return;
}
#ifdef RB_IPV6
else
{
if(rb_inet_pton(family, vhost_ip, &((struct sockaddr_in6 *)&vaddr)->sin6_addr) <= 0)
return;
}
#endif
} else
{
switch(family)
{
case AF_INET:
((struct sockaddr_in *)&vaddr)->sin_addr.s_addr = INADDR_ANY;
break;
#ifdef RB_IPV6
case AF_INET6:
memcpy(&((struct sockaddr_in6 *)&vaddr)->sin6_addr, &in6addr_any, sizeof(struct in6_addr));
break;
default:
return;
#endif
}
}
switch(family)
{
case AF_INET:
SET_SS_LEN(&vaddr, sizeof(struct sockaddr_in));
((struct sockaddr_in *)&vaddr)->sin_port = htons(port);
break;
#ifdef RB_IPV6
case AF_INET6:
SET_SS_LEN(&vaddr, sizeof(struct sockaddr_in6));
((struct sockaddr_in6 *)&vaddr)->sin6_port = htons(port);
break;
#endif
default:
break;
}
if((listener = find_listener(&vaddr)))
{
if(listener->F != NULL)
return;
}
else
{
listener = make_listener(&vaddr);
listener->next = ListenerPollList;
ListenerPollList = listener;
}
listener->F = NULL;
listener->ssl = ssl;
if(inetport(listener))
listener->active = 1;
else
close_listener(listener);
}
/*
* add_listener- create a new listener
* port - the port number to listen on
* vhost_ip - if non-null must contain a valid IP address string in the format "255.255.255.255"
* options - listener options
* cp - listener default code page
*/
void add_listener(int port, const char* vhost_ip, char* options, char* cp)
{
struct Listener* listener;
struct IN_ADDR vaddr;
/*
* if no port in conf line, don't bother
*/
if (0 == port)
return;
#ifdef IPV6
vaddr = INADDRANY;
#else
vaddr.s_addr = INADDRANY;
#endif
if (vhost_ip) {
#ifdef IPV6
if(inetpton(AFINET, vhost_ip, &vaddr) == 0)
return;
#else
vaddr.s_addr = inet_addr(vhost_ip);
if (INADDR_NONE == vaddr.s_addr)
return;
#endif
}
if ((listener = find_listener(port, vaddr))) {
listener->active = 1;
return;
}
if(options && *options)
irclog(L_NOTICE,"Adding listener for %s, port %d Options:%s",
vhost_ip ? vhost_ip : "ANY", port, options );
else
irclog(L_NOTICE,"Adding listener for %s, port %d",
vhost_ip ? vhost_ip : "ANY", port);
listener = make_listener(port, vaddr);
if(options)
{
while(*options)
{
switch(*options)
{
case 's' :
#ifdef HAVE_SSL
if(no_ssl)
irclog(L_WARN,"ignoring port with 's' option!");
else
listener->options |= LST_SSL;
#else
irclog(L_WARN,"ircd compiled without SSL support, ignoring port with 's' option!");
#endif
break;
case 'S' : listener->options |= LST_SERVER; break;
case 'W' : listener->options |= LST_WEBCHAT; break;
case 'J' : listener->options |= LST_JAVACR; break;
case 'n' : listener->options |= LST_NOSPOOF; break;
}
++options;
}
}
if(cp && cp[0])
{
listener->codepage = codepage_find(cp);
if(listener->codepage==-1)
irclog(L_WARN,"Codepage %s defined on P:line was not loaded!", cp);
}
else
listener->codepage=-1;
if (inetport(listener)) {
listener->active = 1;
listener->next = ListenerPollList;
ListenerPollList = listener;
}
else
free_listener(listener);
}
static int
inetport(struct Listener* listener)
{
struct irc_sockaddr lsin;
int fd;
int opt = 1;
/*
* At first, open a new socket
*/
fd = comm_open(DEF_FAM, SOCK_STREAM, 0, "Listener socket");
#ifdef IPV6
if (!IN6_ARE_ADDR_EQUAL((struct in6_addr *)&listener->addr, &in6addr_any))
{
#else
if (INADDR_ANY != listener->addr.sins.sin.s_addr)
{
#endif
inetntop(DEF_FAM, &IN_ADDR(listener->addr), listener->vhost, HOSTLEN);
listener->name = listener->vhost;
}
if (fd == -1)
{
report_error(L_ALL, "opening listener socket %s:%s",
get_listener_name(listener), errno);
return 0;
}
else if ((HARD_FDLIMIT - 10) < fd)
{
report_error(L_ALL, "no more connections left for listener %s:%s",
get_listener_name(listener), errno);
fd_close(fd);
return 0;
}
/*
* XXX - we don't want to do all this crap for a listener
* set_sock_opts(listener);
*/
if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (char*) &opt, sizeof(opt)))
{
report_error(L_ALL, "setting SO_REUSEADDR for listener %s:%s",
get_listener_name(listener), errno);
fd_close(fd);
return 0;
}
/*
* Bind a port to listen for new connections if port is non-null,
* else assume it is already open and try get something from it.
*/
memset(&lsin, 0, sizeof(struct irc_sockaddr));
S_FAM(lsin) = DEF_FAM;
copy_s_addr(S_ADDR(lsin), IN_ADDR(listener->addr));
S_PORT(lsin) = htons(listener->port);
if (bind(fd, (struct sockaddr*) &SOCKADDR(lsin),
sizeof(struct irc_sockaddr)))
{
report_error(L_ALL, "binding listener socket %s:%s",
get_listener_name(listener), errno);
fd_close(fd);
return 0;
}
if (listen(fd, HYBRID_SOMAXCONN)) {
report_error(L_ALL, "listen failed for %s:%s",
get_listener_name(listener), errno);
fd_close(fd);
return 0;
}
/*
* XXX - this should always work, performance will suck if it doesn't
*/
if (!set_non_blocking(fd))
report_error(L_ALL, NONB_ERROR_MSG, get_listener_name(listener), errno);
listener->fd = fd;
/* Listen completion events are READ events .. */
accept_connection(fd, listener);
return 1;
}
static struct Listener*
find_listener(int port, struct irc_inaddr *addr)
{
struct Listener* listener = NULL;
struct Listener* last_closed = NULL;
for (listener = ListenerPollList; listener; listener = listener->next)
{
if ( (port == listener->port) &&
(!memcmp(&PIN_ADDR(addr),
&IN_ADDR(listener->addr),
sizeof(struct irc_inaddr))))
{
/* Try to return an open listener, otherwise reuse a closed one */
if (listener->fd == -1)
last_closed = listener;
else
return listener;
}
}
return last_closed;
}
/*
* add_listener- create a new listener
* port - the port number to listen on
* vhost_ip - if non-null must contain a valid IP address string in
* the format "255.255.255.255"
*/
void
add_listener(int port, const char* vhost_ip)
{
struct Listener* listener;
struct irc_inaddr vaddr;
/*
* if no port in conf line, don't bother
*/
if (port == 0)
return;
#ifdef IPV6
copy_s_addr(IN_ADDR(vaddr), &in6addr_any);
#else
copy_s_addr(IN_ADDR(vaddr), INADDR_ANY);
#endif
if (vhost_ip)
{
if(inetpton(DEF_FAM, vhost_ip, &IN_ADDR(vaddr)) <= 0)
return;
}
if ((listener = find_listener(port, &vaddr)))
{
if (listener->fd > -1)
return;
}
else
{
listener = make_listener(port, &vaddr);
listener->next = ListenerPollList;
ListenerPollList = listener;
}
listener->fd = -1;
if (inetport(listener))
listener->active = 1;
else
close_listener(listener);
}
/*
* close_listener - close a single listener
*/
void close_listener(struct Listener* listener)
{
assert(listener != NULL);
if(listener == NULL)
return;
if (listener->fd >= 0)
{
fd_close(listener->fd);
listener->fd = -1;
}
listener->active = 0;
if (listener->ref_count)
return;
free_listener(listener);
}
int
main(int argc, char *argv[])
{
typedef struct ip_list_t {
char *addr;
int family;
struct ip_list_t *next;
} ip_list_t;
static struct option longopts[] = {
{ "help", no_argument, 0, 'h' },
{ "version", no_argument, 0, 'V' },
{ "port", required_argument, 0, 'p' },
{ "loglevel", required_argument, 0, 'l' },
{ "interface", required_argument, 0, 'i' },
{ 0, 0, 0, 0 }
};
long loglevel = LOG_NOTICE;
char *portstr = 0;
ip_list_t *ip = 0, *listen_ips = 0;
int ch;
while ((ch = getopt_long(argc, argv, "hVl:p:i:", longopts, 0)) != -1) {
switch (ch) {
case 'V':
print_version(basename(argv[0]));
exit(0);
break;
case 'l':
errno = 0;
loglevel = strtol(optarg, 0, 10);
if (errno || loglevel < 0 || loglevel > 7) {
fprintf(stderr, "Log level must be between 0 and 7, inclusive.\n");
exit(1);
}
break;
case 'p':
portstr = strdup(optarg);
if (!portstr) {
perror("strdup");
exit(1);
}
break;
case 'i':
if (ip) {
ip->next = (ip_list_t *) malloc(sizeof(ip_list_t));
ip = ip->next;
} else {
listen_ips = (ip_list_t *) malloc(sizeof(ip_list_t));
ip = listen_ips;
}
ip->addr = strdup(optarg);
ip->family = AF_UNSPEC;
ip->next = 0;
break;
case 'h':
default:
usage(basename(argv[0]));
exit(0);
}
}
/*
* If no listen IPs were specified, listen on all interfaces
* (i.e., the wildcard address).
*
* Regarding IPv4 and IPv6 wildcard binds on the same port:
*
* The Linux kernel maps both IPv4 and IPv6 wildcard binds to the
* same local port space, in which case only one family can be
* bound to a given port. An IPv6 wildcard bind on a GNU/Linux
* system will see both IPv4 and IPv6 traffic.
*
* BSD-based platforms (e.g., Mac OS X) recommend listening on two
* sockets for the same port, one for IPv4 and one for IPv6, when
* you want to accept traffic for both transports, especially when
* access control (firewalling) is in effect.
*
* OpenBSD simply won't route IPv4 traffic to IPv6 sockets; on
* that platform, an application must bind to both of the IPv4 and
* IPv6 wildcard addresses to receive both types of traffic.
*/
if (!listen_ips) {
ip = (ip_list_t *) malloc(sizeof(ip_list_t));
if (!ip) {
perror("malloc");
exit(1);
}
listen_ips = ip;
ip->addr = 0;
ip->family = AF_INET6;
#ifndef ECHOEV_PLATFORM_LINUX
ip->next = (ip_list_t *) malloc(sizeof(ip_list_t));
if (!ip->next) {
perror("malloc");
exit(1);
}
ip = ip->next;
ip->addr = 0;
ip->family = AF_INET;
#endif
ip->next = 0;
}
get_stderr_logger(&log, 0, &logmask);
logmask(LOG_UPTO(loglevel));
if (ignore_sigpipe() == -1) {
log(LOG_ERR, "Trying to ignore SIGPIPE, but failed: %m");
exit(1);
}
struct ev_loop *loop = EV_DEFAULT;
struct addrinfo hints, *res;
memset(&hints, 0, sizeof(hints));
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = IPPROTO_TCP;
hints.ai_flags = AI_PASSIVE | AI_NUMERICHOST;
for (ip = listen_ips; ip != 0; ip = ip->next) {
hints.ai_family = ip->family;
int err = getaddrinfo(ip->addr,
portstr ? portstr : default_portstr,
&hints,
&res);
if (err) {
log(LOG_ERR, "getaddrinfo failed: %s", gai_strerror(err));
exit(err);
}
assert(!res->ai_next);
listener_io *lio =
make_listener(res->ai_addr, res->ai_addrlen);
if (lio) {
log_with_addr(LOG_NOTICE,
"listening on %s",
res->ai_addr,
res->ai_addrlen);
ev_io_start(loop, &lio->listener);
} else {
log(LOG_ERR, "Can't create listening socket: %m");
exit(1);
}
freeaddrinfo(res);
}
/* Clean up before entering ev_run loop */
if (portstr)
free(portstr);
while (listen_ips) {
ip = listen_ips;
listen_ips = ip->next;
free(ip->addr);
free(ip);
}
listen_ips = 0;
log(LOG_DEBUG, "entering ev_run");
ev_run(loop, 0);
log(LOG_DEBUG, "ev_run exited");
return 0;
}
