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; }