sock_t sock_accept(sock_t serversock, char *ip, size_t len)
{
#ifdef HAVE_GETNAMEINFO
struct sockaddr_storage sa;
#else
struct sockaddr_in sa;
#endif
sock_t ret;
socklen_t slen;
slen = sizeof(sa);
ret = accept(serversock, (struct sockaddr *)&sa, &slen);
if (ret != SOCK_ERROR)
{
sock_set_cloexec (ret);
if (ip)
{
#ifdef HAVE_GETNAMEINFO
if (getnameinfo ((struct sockaddr *)&sa, slen, ip, len, NULL, 0, NI_NUMERICHOST))
snprintf (ip, len, "unknown");
#else
/* inet_ntoa is not reentrant, we should protect this */
strncpy(ip, inet_ntoa(sa.sin_addr), len);
#endif
}
sock_set_nolinger(ret);
sock_set_keepalive(ret);
}
return ret;
}
/** Set TCP keepalive parameters
* Turn on TCP keepalive and set timeout and interval. Zero timeout
* disables TCP keepalives. The parameters are applied immediately for
* a non disconnected object. Also, they are applied when the connection
* object connects successfully.
*
* @param conn a Strophe connection object
* @param timeout TCP keepalive timeout in seconds
* @param interval TCP keepalive interval in seconds
*
* @ingroup Connections
*/
void xmpp_conn_set_keepalive(xmpp_conn_t * const conn, int timeout, int interval)
{
int ret = 0;
conn->ka_timeout = timeout;
conn->ka_interval = interval;
if (conn->state != XMPP_STATE_DISCONNECTED)
ret = sock_set_keepalive(conn->sock, timeout, interval);
if (ret < 0) {
xmpp_error(conn->ctx, "xmpp", "Setting TCP keepalive (%d,%d) error: %d",
timeout, interval, sock_error());
}
}
static int _conn_connect(xmpp_conn_t * const conn,
const char * const domain,
const char * const host,
unsigned short port,
xmpp_conn_type_t type,
xmpp_conn_handler callback,
void * const userdata)
{
xmpp_open_handler open_handler;
if (conn->state != XMPP_STATE_DISCONNECTED) return XMPP_EINVOP;
if (type != XMPP_CLIENT && type != XMPP_COMPONENT) return XMPP_EINVOP;
if (host == NULL || port == 0) return XMPP_EINT;
_conn_reset(conn);
conn->type = type;
conn->domain = xmpp_strdup(conn->ctx, domain);
if (!conn->domain) return XMPP_EMEM;
conn->sock = sock_connect(host, port);
xmpp_debug(conn->ctx, "xmpp", "sock_connect() to %s:%u returned %d",
host, port, conn->sock);
if (conn->sock == -1) return XMPP_EINT;
if (conn->ka_timeout || conn->ka_interval)
sock_set_keepalive(conn->sock, conn->ka_timeout, conn->ka_interval);
/* setup handler */
conn->conn_handler = callback;
conn->userdata = userdata;
open_handler = conn->is_raw ? auth_handle_open_stub :
type == XMPP_CLIENT ? auth_handle_open :
auth_handle_component_open;
conn_prepare_reset(conn, open_handler);
/* FIXME: it could happen that the connect returns immediately as
* successful, though this is pretty unlikely. This would be a little
* hard to fix, since we'd have to detect and fire off the callback
* from within the event loop */
conn->state = XMPP_STATE_CONNECTING;
conn->timeout_stamp = time_stamp();
xmpp_debug(conn->ctx, "xmpp", "Attempting to connect to %s", host);
return 0;
}
gint
accept_do (ACCEPT_POOL ap, addr_info_t *cltaddr, GError **err)
{
struct sockaddr_storage sa;
socklen_t saSize;
int clt;
errno=0;
if (!ap) {
GSETERROR(err,"Invalid parameter");
return -1;
}
if (!ap->srv || ap->count<=0) {
GSETERROR(err, "Empty server socket pool");
return -1;
}
memset(&sa, 0, sizeof(sa));
saSize = sizeof(sa);
clt = UNSAFE_accept_do (ap, (struct sockaddr*) &sa, &saSize, err);
if (clt < 0)
return -1;
if (cltaddr != NULL) {
memset(cltaddr, 0, sizeof(addr_info_t));
addrinfo_from_sockaddr(cltaddr, (struct sockaddr*)&sa, saSize);
}
/*Set all the helpful socket options*/
if (gridd_flags & GRIDD_FLAG_NOLINGER)
sock_set_linger_default(clt);
if (gridd_flags & GRIDD_FLAG_KEEPALIVE)
sock_set_keepalive(clt, TRUE);
if (gridd_flags & GRIDD_FLAG_QUICKACK)
sock_set_tcpquickack(clt, TRUE);
return clt;
}
SOCKET sock_accept(SOCKET s, struct sockaddr * addr, socklen_t * addrlen)
{
SOCKET rs = accept(s, addr, addrlen);
xa_debug (4, "DEBUG: sock_accept() created socket %d", s);
if (sock_valid(rs)) {
#ifdef DEBUG_SOCKETS
sock_add (rs, AF_INET, SOCK_STREAM, 0);
#endif
/*
* Turn on KEEPALIVE to detect crashed hosts
*/
sock_set_keepalive(rs, 1);
#ifdef SO_LINGER
sock_set_no_linger(rs);
#endif
}
return rs;
}
SOCKET sock_socket(int domain, int type, int protocol)
{
SOCKET s = socket(domain, type, protocol);
xa_debug (4, "DEBUG: sock_socket() creating socket %d", s);
if (sock_valid(s)) {
#ifdef DEBUG_SOCKETS
sock_add (s, domain, type, protocol);
#endif
/*
* Turn on KEEPALIVE to detect crashed hosts
*/
sock_set_keepalive(s, 1);
#ifdef SO_LINGER
sock_set_no_linger(s);
#endif
}
return s;
}
int sock_accept(sock_t serversock, char *ip, int len)
{
#ifdef HAVE_INET_PTON
struct sockaddr_storage sa;
#else
struct sockaddr_in sa;
#endif
int ret;
socklen_t slen;
if (!sock_valid_socket(serversock))
return SOCK_ERROR;
slen = sizeof(sa);
ret = accept(serversock, (struct sockaddr *)&sa, &slen);
if (ret >= 0 && ip != NULL) {
#ifdef HAVE_INET_PTON
if(((struct sockaddr_in *)&sa)->sin_family == AF_INET)
inet_ntop(AF_INET, &((struct sockaddr_in *)&sa)->sin_addr,
ip, len);
else if(((struct sockaddr_in6 *)&sa)->sin6_family == AF_INET6)
inet_ntop(AF_INET6, &((struct sockaddr_in6 *)&sa)->sin6_addr,
ip, len);
else {
strncpy(ip, "ERROR", len-1);
ip[len-1] = 0;
}
#else
/* inet_ntoa is not reentrant, we should protect this */
strncpy(ip, inet_ntoa(sa.sin_addr), len);
#endif
sock_set_nolinger(ret);
sock_set_keepalive(ret);
}
return ret;
}
