struct client_t *accept_client_for_listener(struct listen_t *l, int fd, char *addr_s, union sockaddr_u *sa, unsigned addr_len)
{
struct client_t *c;
char *s;
int i;
union sockaddr_u sa_loc; /* local address */
socklen_t addr_len_loc = sizeof(sa_loc);
c = client_alloc();
if (!c)
return NULL;
c->fd = fd;
c->listener_id = l->listener_id;
c->addr = *sa;
c->ai_protocol = l->ai_protocol;
c->portnum = l->portnum;
c->hidden = l->hidden;
c->flags = l->client_flags;
c->udpclient = client_udp_find(udpclients, sa->sa.sa_family, l->portnum);
c->portaccount = l->portaccount;
c->last_read = tick; /* not simulated time */
inbound_connects_account(1, c->portaccount); /* account all ports + port-specifics */
/* text format of client's IP address + port */
strncpy(c->addr_rem, addr_s, sizeof(c->addr_rem));
c->addr_rem[sizeof(c->addr_rem)-1] = 0;
/* hex format of client's IP address + port */
s = hexsockaddr( &sa->sa, addr_len );
strncpy(c->addr_hex, s, sizeof(c->addr_hex));
c->addr_hex[sizeof(c->addr_hex)-1] = 0;
hfree(s);
/* text format of servers' connected IP address + port */
if (getsockname(fd, &sa_loc.sa, &addr_len_loc) == 0) { /* Fails very rarely.. */
if (addr_len_loc > sizeof(sa_loc))
hlog(LOG_ERR, "accept_client_for_listener: getsockname for client %s truncated local address of %d to %d bytes", c->addr_rem, addr_len_loc, sizeof(sa_loc));
/* present my socket end address as a malloced string... */
s = strsockaddr( &sa_loc.sa, addr_len_loc );
} else {
s = hstrdup( l->addr_s ); /* Server's bound IP address */
hlog(LOG_ERR, "accept_client_for_listener: getsockname for client %s failed: %s (using '%s' instead)", c->addr_rem, strerror(errno), s);
}
strncpy(c->addr_loc, s, sizeof(c->addr_loc));
c->addr_loc[sizeof(c->addr_loc)-1] = 0;
hfree(s);
/* apply predefined filters */
for (i = 0; i < (sizeof(l->filters)/sizeof(l->filters[0])); ++i) {
if (l->filters[i]) {
if (filter_parse(c, l->filters[i], 0) < 0) { /* system filters */
hlog(LOG_ERR, "Bad system filter definition: %s", l->filters[i]);
}
}
}
if (l->filter_s) {
strncpy(c->filter_s, l->filter_s, sizeof(c->filter_s));
c->filter_s[FILTER_S_SIZE-1] = 0;
}
return c;
}
int make_uplink(struct uplink_config_t *l)
{
int fd, i, addrc, arg;
int uplink_index;
union sockaddr_u sa; /* large enough for also IPv6 address */
socklen_t addr_len;
struct addrinfo *ai, *a, *ap[21];
struct addrinfo req;
char *addr_s = NULL;
int port;
struct sockaddr *srcaddr;
socklen_t srcaddr_len;
memset(&req, 0, sizeof(req));
req.ai_family = 0;
req.ai_socktype = SOCK_STREAM;
req.ai_protocol = IPPROTO_TCP;
req.ai_flags = AI_ADDRCONFIG;
ai = NULL;
#ifdef USE_SSL
/* SSL requires both a cert and a key, or none at all */
if ((l->certfile && !l->keyfile) || (l->keyfile && !l->certfile)) {
hlog(LOG_ERR, "Uplink %s: Only one of sslkey and sslcert defined - both needed for SSL authentication", l->name);
return -2;
}
/* todo: allow triggering SSL without client auth */
if (l->keyfile && l->certfile) {
if (!l->ssl) {
if (config_uplink_ssl_setup(l)) {
hlog(LOG_ERR, "Uplink '%s': SSL setup failed", l->name);
return -2;
}
}
}
#endif
/* find a free uplink slot */
for (uplink_index = 0; uplink_index < MAX_UPLINKS; uplink_index++) {
if (!uplink_client[uplink_index])
break;
}
if (uplink_index == MAX_UPLINKS) {
hlog(LOG_ERR, "Uplink %s: No available uplink slots, %d used", l->name, MAX_UPLINKS);
return -2;
}
if (strcasecmp(l->proto, "tcp") == 0) {
// well, do nothing for now.
} else if (strcasecmp(l->proto, "udp") == 0) {
req.ai_socktype = SOCK_DGRAM;
req.ai_protocol = IPPROTO_UDP;
#ifdef USE_SCTP
} else if (strcasecmp(l->proto, "sctp") == 0) {
req.ai_socktype = SOCK_STREAM;
req.ai_protocol = IPPROTO_SCTP;
#endif
} else {
hlog(LOG_ERR, "Uplink %s: Unsupported protocol '%s'\n", l->name, l->proto);
return -2;
}
port = atoi(l->port);
if (port < 1 || port > 65535) {
hlog(LOG_ERR, "Uplink %s: unsupported port number '%s'\n", l->name, l->port);
return -2;
}
l->state = UPLINK_ST_CONNECTING;
i = getaddrinfo(l->host, l->port, &req, &ai);
if (i != 0) {
hlog(LOG_INFO, "Uplink %s: address resolving failure of '%s' '%s': %s", l->name, l->host, l->port, gai_strerror(i));
l->state = UPLINK_ST_NOT_LINKED;
return -2;
}
/* Count the amount of addresses in response */
addrc = 0;
for (a = ai; a && addrc < 20 ; a = a->ai_next, ++addrc) {
ap[addrc] = a; /* Up to 20 first addresses */
}
ap[addrc] = NULL;
if (addrc == 0) {
hlog(LOG_INFO, "Uplink %s: address resolving of '%s' '%s': returned 0 addresses", l->name, l->host, l->port);
l->state = UPLINK_ST_NOT_LINKED;
return -2;
}
/* Pick random address to start from */
i = random() % addrc;
/* Then lets try making socket and connection in address order */
/* TODO: BUG: If the TCP connection succeeds, but the server rejects our
* login due to a bad source address (like, IPv4 would be allowed but our
* IPv6 address is not in the server's ACL), this currently does not switch
* to the next destination address.
* Instead it'll wait for the retry timer and then try a random
* destination address, and eventually succeed (unless very unlucky).
*/
fd = -1;
while ((a = ap[i])) {
ap[i] = NULL;
addr_s = strsockaddr(a->ai_addr, a->ai_addrlen);
hlog(LOG_INFO, "Uplink %s: Connecting to %s:%s (%s) [link %d, addr %d/%d]",
l->name, l->host, l->port, addr_s, uplink_index, i+1, addrc);
i++;
if (i == addrc)
i = 0;
if ((fd = socket(a->ai_family, a->ai_socktype, a->ai_protocol)) < 0) {
hlog(LOG_CRIT, "Uplink %s: socket(): %s\n", l->name, strerror(errno));
hfree(addr_s);
continue;
}
arg = 1;
if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (char *)&arg, sizeof(arg)))
hlog(LOG_ERR, "Uplink %s: Failed to set SO_REUSEADDR on new socket: %s", l->name, strerror(errno));
/* bind source address */
srcaddr_len = 0;
if (a->ai_family == AF_INET && uplink_bind_v4_len != 0) {
srcaddr = (struct sockaddr *)&uplink_bind_v4;
srcaddr_len = uplink_bind_v4_len;
} else if (a->ai_family == AF_INET6 && uplink_bind_v6_len != 0) {
srcaddr = (struct sockaddr *)&uplink_bind_v6;
srcaddr_len = uplink_bind_v6_len;
}
if (srcaddr_len) {
if (bind(fd, srcaddr, srcaddr_len)) {
char *s = strsockaddr(srcaddr, srcaddr_len);
hlog(LOG_ERR, "Uplink %s: Failed to bind source address '%s': %s", l->name, s, strerror(errno));
hfree(s);
goto connerr;
}
}
/* set non-blocking mode at this point, so that we can make a
* non-blocking connect() with a short timeout
*/
if (fcntl(fd, F_SETFL, O_NONBLOCK)) {
hlog(LOG_CRIT, "Uplink %s: Failed to set non-blocking mode on new socket: %s", l->name, strerror(errno));
goto connerr;
}
/* Use TCP_NODELAY for APRS-IS sockets. High delays can cause packets getting past
* the dupe filters.
*/
#ifdef TCP_NODELAY
if (a->ai_protocol == IPPROTO_TCP) {
int arg = 1;
if (setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (void *)&arg, sizeof(arg)))
hlog(LOG_ERR, "Uplink %s: %s: setsockopt(TCP_NODELAY, %d) failed: %s", l->name, addr_s, arg, strerror(errno));
}
#endif
if (connect(fd, a->ai_addr, a->ai_addrlen) && errno != EINPROGRESS) {
hlog(LOG_ERR, "Uplink %s: connect(%s) failed: %s", l->name, addr_s, strerror(errno));
goto connerr;
}
/* Only wait a few seconds for the connection to be created.
* If the connection setup is very slow, it is unlikely to
* perform well enough anyway.
*/
struct pollfd connect_fd;
connect_fd.fd = fd;
connect_fd.events = POLLOUT;
connect_fd.revents = 0;
int r = poll(&connect_fd, 1, 3000);
hlog(LOG_DEBUG, "Uplink %s: poll after connect returned %d, revents %d", l->name, r, connect_fd.revents);
if (r < 0) {
hlog(LOG_ERR, "Uplink %s: connect to %s: poll failed: %s", l->name, addr_s, strerror(errno));
goto connerr;
}
if (r < 1) {
hlog(LOG_ERR, "Uplink %s: connect to %s timed out", l->name, addr_s);
goto connerr;
}
socklen_t optlen = sizeof(arg);
if (getsockopt(fd, SOL_SOCKET, SO_ERROR, (char *)&arg, &optlen) == -1) {
hlog(LOG_ERR, "Uplink %s: getsockopt() after connect failed: %s", l->name, strerror(errno));
goto connerr;
} else if (arg == 0) {
/* Successful connect! */
hlog(LOG_DEBUG, "Uplink %s: successful connect", l->name);
break;
}
hlog(LOG_ERR, "Uplink %s: connect to %s failed: %s", l->name, addr_s, strerror(arg));
connerr:
close(fd);
fd = -1;
hfree(addr_s);
}
freeaddrinfo(ai); /* Not needed anymore.. */
if (fd < 0) {
l->state = UPLINK_ST_NOT_LINKED;
return -3; /* No successfull connection at any address.. */
}
struct client_t *c = client_alloc();
if (!c) {
hlog(LOG_ERR, "Uplink %s: client_alloc() failed, too many clients", l->name);
close(fd);
l->state = UPLINK_ST_NOT_LINKED;
return -3; /* No successfull connection at any address.. */
}
l->client_ptr = (void *)c;
c->uplink_index = uplink_index;
c->fd = fd;
c->addr = sa;
c->ai_protocol = req.ai_protocol;
c->state = CSTATE_INIT;
/* use the default login handler */
c->handler_line_in = &uplink_login_handler;
c->flags = l->client_flags;
c->keepalive = tick;
c->last_read = tick;
c->connect_time = now;
strncpy(c->username, l->name, sizeof(c->username));
c->username[sizeof(c->username)-1] = 0;
c->username_len = strlen(c->username);
/* These peer/sock name calls can not fail -- or the socket closed
on us in which case it gets abandoned a bit further below. */
addr_len = sizeof(sa);
getpeername(fd, (struct sockaddr *)&sa, &addr_len);
//s = strsockaddr( &sa.sa, addr_len ); /* server side address */
strncpy(c->addr_rem, addr_s, sizeof(c->addr_rem));
c->addr_rem[sizeof(c->addr_rem)-1] = 0;
hfree(addr_s);
/* hex format of client's IP address + port */
char *s = hexsockaddr( &sa.sa, addr_len );
strncpy(c->addr_hex, s, sizeof(c->addr_hex));
c->addr_hex[sizeof(c->addr_hex)-1] = 0;
hfree(s);
addr_len = sizeof(sa);
getsockname(fd, (struct sockaddr *)&sa, &addr_len);
s = strsockaddr( &sa.sa, addr_len ); /* client side address */
strncpy(c->addr_loc, s, sizeof(c->addr_loc));
c->addr_loc[sizeof(c->addr_loc)-1] = 0;
hfree(s);
hlog(LOG_INFO, "Uplink %s: %s: Connection established on fd %d using source address %s", l->name, c->addr_rem, c->fd, c->addr_loc);
if (set_client_sockopt(c) < 0)
goto err;
uplink_client[uplink_index] = c;
l->state = UPLINK_ST_CONNECTED;
/* set up SSL if necessary */
#ifdef USE_SSL
if (l->ssl) {
if (ssl_create_connection(l->ssl, c, 1))
goto err;
}
#endif
/* Push it on the first worker, which ever it is..
*/
if (pass_client_to_worker(worker_threads, c))
goto err;
if ((i = pthread_mutex_lock(& uplink_connects.mutex )))
hlog(LOG_ERR, "make_uplink: could not lock uplink_connects: %s", strerror(i));
++ uplink_connects.gauge;
++ uplink_connects.counter;
++ uplink_connects.refcount; /* <-- that does not get decremented at any time.. */
if ((i = pthread_mutex_unlock(& uplink_connects.mutex )))
hlog(LOG_ERR, "make_uplink: could not unlock uplink_connects: %s", strerror(i));
c->portaccount = & uplink_connects; /* calculate traffic bytes/packets */
return 0;
err:
client_free(c);
uplink_client[uplink_index] = NULL;
l->state = UPLINK_ST_NOT_LINKED;
return -1;
}
static void peerip_clients_config(void)
{
struct client_t *c;
struct peerip_config_t *pe;
struct client_udp_t *udpclient;
char *s;
union sockaddr_u sa; /* large enough for also IPv6 address */
socklen_t addr_len = sizeof(sa);
for (pe = peerip_config; (pe); pe = pe->next) {
hlog(LOG_DEBUG, "Setting up UDP peer %s (%s)", pe->name, pe->host);
udpclient = client_udp_find(udppeers, pe->af, pe->local_port);
if (!udpclient) {
hlog(LOG_ERR, "Failed to find UDP socket on port %d for peer %s (%s)", pe->local_port, pe->name, pe->host);
continue;
}
c = client_alloc();
if (!c) {
hlog(LOG_ERR, "peerip_clients_config: client_alloc returned NULL");
abort();
}
c->fd = -1; // Right, this client will never have a socket of it's own.
c->ai_protocol = IPPROTO_UDP;
c->portnum = pe->local_port; // local port
c->state = CSTATE_COREPEER;
c->validated = VALIDATED_WEAK;
c->flags = CLFLAGS_UPLINKPORT;
c->handler_line_in = &incoming_handler;
memcpy((void *)&c->udpaddr.sa, (void *)pe->ai->ai_addr, pe->ai->ai_addrlen);
c->udpaddrlen = pe->ai->ai_addrlen;
c->udp_port = pe->remote_port; // remote port
c->addr = c->udpaddr;
c->udpclient = udpclient;
//c->portaccount = l->portaccount;
c->keepalive = tick + keepalive_interval;
c->last_read = tick; /* not simulated time */
inbound_connects_account(3, c->udpclient->portaccount); /* "3" = udp, not listening.. */
/* set up peer serverid to username */
strncpy(c->username, pe->serverid, sizeof(c->username));
c->username[sizeof(c->username)-1] = 0;
c->username_len = strlen(c->username);
/* convert client address to string */
s = strsockaddr( &c->udpaddr.sa, c->udpaddrlen );
/* text format of client's IP address + port */
strncpy(c->addr_rem, s, sizeof(c->addr_rem));
c->addr_rem[sizeof(c->addr_rem)-1] = 0;
hfree(s);
/* hex format of client's IP address + port */
s = hexsockaddr( &c->udpaddr.sa, c->udpaddrlen );
strncpy(c->addr_hex, s, sizeof(c->addr_hex));
c->addr_hex[sizeof(c->addr_hex)-1] = 0;
hfree(s);
/* text format of servers' connected IP address + port */
addr_len = sizeof(sa);
if (getsockname(c->udpclient->fd, &sa.sa, &addr_len) == 0) { /* Fails very rarely.. */
/* present my socket end address as a malloced string... */
s = strsockaddr( &sa.sa, addr_len );
} else {
hlog(LOG_ERR, "Peer config: getsockname on udpclient->fd failed: %s", strerror(errno));
s = hstrdup( "um" ); /* Server's bound IP address.. TODO: what? */
}
strncpy(c->addr_loc, s, sizeof(c->addr_loc));
c->addr_loc[sizeof(c->addr_loc)-1] = 0;
hfree(s);
/* pass the client to the first worker thread */
if (pass_client_to_worker(worker_threads, c)) {
hlog(LOG_ERR, "Failed to pass UDP peer %s (%s) to worker", pe->name, pe->host);
client_free(c);
}
}
}
