static void
hbn_listen_cb(int fd, gpointer data) {
StunHBNListenData *ld = (StunHBNListenData *)data;
GInetAddress *address = NULL;
GSocketAddress *socket_address = NULL;
struct stun_conn *sc;
static struct stun_header hdr_data;
if(fd < 0) {
nattype.status = PURPLE_STUN_STATUS_UNKNOWN;
nattype.lookup_time = time(NULL);
do_callbacks();
return;
}
sc = g_new0(struct stun_conn, 1);
sc->fd = fd;
sc->addr.sin_family = AF_INET;
sc->addr.sin_port = htons(purple_network_get_port_from_fd(fd));
sc->addr.sin_addr.s_addr = INADDR_ANY;
sc->incb = purple_input_add(fd, PURPLE_INPUT_READ, reply_cb, sc);
address = G_INET_ADDRESS(ld->addresses->data);
socket_address = g_inet_socket_address_new(address, ld->port);
g_socket_address_to_native(socket_address, &(sc->addr), g_socket_address_get_native_size(socket_address), NULL);
g_object_unref(G_OBJECT(address));
g_object_unref(G_OBJECT(socket_address));
g_resolver_free_addresses(ld->addresses);
g_free(ld);
hdr_data.type = htons(MSGTYPE_BINDINGREQUEST);
hdr_data.len = 0;
hdr_data.transid[0] = rand();
hdr_data.transid[1] = ntohl(((int)'g' << 24) + ((int)'a' << 16) + ((int)'i' << 8) + (int)'m');
hdr_data.transid[2] = rand();
hdr_data.transid[3] = rand();
if(sendto(sc->fd, &hdr_data, sizeof(struct stun_header), 0,
(struct sockaddr *)&(sc->addr),
sizeof(struct sockaddr_in)) < (gssize)sizeof(struct stun_header)) {
nattype.status = PURPLE_STUN_STATUS_UNKNOWN;
nattype.lookup_time = time(NULL);
do_callbacks();
close_stun_conn(sc);
return;
}
sc->test = 1;
sc->packet = &hdr_data;
sc->packetsize = sizeof(struct stun_header);
sc->timeout = purple_timeout_add(500, (GSourceFunc) timeoutfunc, sc);
}
/* Tries to resolve priv->name as an IP address, possibly including an
* IPv6 scope id.
*/
static void
maybe_resolve_ip (SoupAddress *addr)
{
SoupAddressPrivate *priv = SOUP_ADDRESS_GET_PRIVATE (addr);
const char *pct, *ip;
char *tmp = NULL;
GSocketConnectable *gaddr;
GSocketAddressEnumerator *sa_enum;
GSocketAddress *saddr;
if (priv->sockaddr || !priv->name)
return;
pct = strchr (priv->name, '%');
if (pct)
ip = tmp = g_strndup (priv->name, pct - priv->name);
else
ip = priv->name;
if (!g_hostname_is_ip_address (ip)) {
g_free (tmp);
return;
}
g_free (tmp);
gaddr = g_network_address_new (priv->name, priv->port);
if (!gaddr)
return;
sa_enum = g_socket_connectable_enumerate (gaddr);
saddr = g_socket_address_enumerator_next (sa_enum, NULL, NULL);
if (saddr) {
priv->n_addrs = 1;
priv->sockaddr = g_new (struct sockaddr_storage, 1);
if (!g_socket_address_to_native (saddr, priv->sockaddr,
sizeof (struct sockaddr_storage),
NULL)) {
/* can't happen: We know the address format is supported
* and the buffer is large enough
*/
g_warn_if_reached ();
}
g_object_unref (saddr);
}
g_object_unref (sa_enum);
g_object_unref (gaddr);
}
NiceSocket *
nice_tcp_passive_socket_accept (NiceSocket *sock)
{
union {
struct sockaddr_storage storage;
struct sockaddr addr;
} name;
TcpPassivePriv *priv = sock->priv;
GSocket *gsock = NULL;
GSocketAddress *gaddr;
NiceAddress remote_addr;
NiceSocket *new_socket = NULL;
gsock = g_socket_accept (sock->fileno, NULL, NULL);
if (gsock == NULL) {
return NULL;
}
/* GSocket: All socket file descriptors are set to be close-on-exec. */
g_socket_set_blocking (gsock, false);
gaddr = g_socket_get_remote_address (gsock, NULL);
if (gaddr == NULL ||
!g_socket_address_to_native (gaddr, &name.addr, sizeof (name), NULL)) {
g_socket_close (gsock, NULL);
g_object_unref (gsock);
return NULL;
}
g_object_unref (gaddr);
nice_address_set_from_sockaddr (&remote_addr, &name.addr);
new_socket = nice_tcp_bsd_socket_new_from_gsock (priv->context, gsock,
&sock->addr, &remote_addr, TRUE);
g_object_unref (gsock);
if (new_socket) {
NiceAddress *key = nice_address_dup (&remote_addr);
nice_socket_set_writable_callback (new_socket, _child_writable_cb, sock);
g_hash_table_insert (priv->connections, key, new_socket);
}
return new_socket;
}
static guint
update_addrs (SoupAddress *addr, GList *addrs, GError *error)
{
SoupAddressPrivate *priv = SOUP_ADDRESS_GET_PRIVATE (addr);
GInetAddress *gia;
GSocketAddress *gsa;
int i;
if (error) {
if (error->domain == G_IO_ERROR &&
error->code == G_IO_ERROR_CANCELLED)
return SOUP_STATUS_CANCELLED;
else
return SOUP_STATUS_CANT_RESOLVE;
} else if (!addrs)
return SOUP_STATUS_CANT_RESOLVE;
else if (priv->sockaddr)
return SOUP_STATUS_OK;
priv->n_addrs = g_list_length (addrs);
priv->sockaddr = g_new (struct sockaddr_storage, priv->n_addrs);
for (i = 0; addrs; addrs = addrs->next, i++) {
gia = addrs->data;
gsa = g_inet_socket_address_new (gia, priv->port);
if (!g_socket_address_to_native (gsa, &priv->sockaddr[i],
sizeof (struct sockaddr_storage),
NULL)) {
/* can't happen: We know the address format is supported
* and the buffer is large enough
*/
g_warn_if_reached ();
}
g_object_unref (gsa);
}
return SOUP_STATUS_OK;
}
static void
do_lookup_by_address (GTask *task,
gpointer source_object,
gpointer task_data,
GCancellable *cancellable)
{
GInetAddress *address = task_data;
struct sockaddr_storage sockaddr;
gsize sockaddr_size;
GSocketAddress *gsockaddr;
gchar name[NI_MAXHOST];
gint retval;
gsockaddr = g_inet_socket_address_new (address, 0);
g_socket_address_to_native (gsockaddr, (struct sockaddr *)&sockaddr,
sizeof (sockaddr), NULL);
sockaddr_size = g_socket_address_get_native_size (gsockaddr);
g_object_unref (gsockaddr);
retval = getnameinfo ((struct sockaddr *)&sockaddr, sockaddr_size,
name, sizeof (name), NULL, 0, NI_NAMEREQD);
if (retval == 0)
g_task_return_pointer (task, g_strdup (name), g_free);
else
{
gchar *phys;
phys = g_inet_address_to_string (address);
g_task_return_new_error (task,
G_RESOLVER_ERROR,
g_resolver_error_from_addrinfo_error (retval),
_("Error reverse-resolving “%s”: %s"),
phys ? phys : "(unknown)",
gai_strerror (retval));
g_free (phys);
}
}
NiceSocket *
nice_tcp_bsd_socket_new (GMainContext *ctx, NiceAddress *addr)
{
union {
struct sockaddr_storage storage;
struct sockaddr addr;
} name;
NiceSocket *sock;
TcpPriv *priv;
GSocket *gsock = NULL;
GError *gerr = NULL;
gboolean gret = FALSE;
GSocketAddress *gaddr;
if (addr == NULL) {
/* We can't connect a tcp socket with no destination address */
return NULL;
}
sock = g_slice_new0 (NiceSocket);
nice_address_copy_to_sockaddr (addr, &name.addr);
if (name.storage.ss_family == AF_UNSPEC || name.storage.ss_family == AF_INET) {
gsock = g_socket_new (G_SOCKET_FAMILY_IPV4, G_SOCKET_TYPE_STREAM,
G_SOCKET_PROTOCOL_TCP, NULL);
name.storage.ss_family = AF_INET;
#ifdef HAVE_SA_LEN
name.storage.ss_len = sizeof (struct sockaddr_in);
#endif
} else if (name.storage.ss_family == AF_INET6) {
gsock = g_socket_new (G_SOCKET_FAMILY_IPV6, G_SOCKET_TYPE_STREAM,
G_SOCKET_PROTOCOL_TCP, NULL);
name.storage.ss_family = AF_INET6;
#ifdef HAVE_SA_LEN
name.storage.ss_len = sizeof (struct sockaddr_in6);
#endif
}
if (gsock == NULL) {
g_slice_free (NiceSocket, sock);
return NULL;
}
gaddr = g_socket_address_new_from_native (&name.addr, sizeof (name));
if (gaddr == NULL) {
g_object_unref (gsock);
g_slice_free (NiceSocket, sock);
return NULL;
}
/* GSocket: All socket file descriptors are set to be close-on-exec. */
g_socket_set_blocking (gsock, false);
gret = g_socket_connect (gsock, gaddr, NULL, &gerr);
g_object_unref (gaddr);
if (gret == FALSE) {
if (g_error_matches (gerr, G_IO_ERROR, G_IO_ERROR_PENDING) == FALSE) {
g_error_free (gerr);
g_socket_close (gsock, NULL);
g_object_unref (gsock);
g_slice_free (NiceSocket, sock);
return NULL;
}
g_error_free (gerr);
}
gaddr = g_socket_get_local_address (gsock, NULL);
if (gaddr == NULL ||
!g_socket_address_to_native (gaddr, &name.addr, sizeof (name), NULL)) {
g_slice_free (NiceSocket, sock);
g_socket_close (gsock, NULL);
g_object_unref (gsock);
return NULL;
}
g_object_unref (gaddr);
nice_address_set_from_sockaddr (&sock->addr, &name.addr);
sock->priv = priv = g_slice_new0 (TcpPriv);
if (ctx == NULL)
ctx = g_main_context_default ();
priv->context = g_main_context_ref (ctx);
priv->server_addr = *addr;
priv->error = FALSE;
sock->fileno = gsock;
sock->send_messages = socket_send_messages;
sock->recv_messages = socket_recv_messages;
sock->is_reliable = socket_is_reliable;
sock->close = socket_close;
return sock;
}
NiceSocket *
nice_tcp_passive_socket_new (GMainContext *ctx, NiceAddress *addr)
{
union {
struct sockaddr_storage storage;
struct sockaddr addr;
} name;
NiceSocket *sock;
TcpPassivePriv *priv;
GSocket *gsock = NULL;
gboolean gret = FALSE;
GSocketAddress *gaddr;
if (addr != NULL) {
nice_address_copy_to_sockaddr(addr, &name.addr);
} else {
memset (&name, 0, sizeof (name));
name.storage.ss_family = AF_UNSPEC;
}
if (name.storage.ss_family == AF_UNSPEC || name.storage.ss_family == AF_INET) {
gsock = g_socket_new (G_SOCKET_FAMILY_IPV4, G_SOCKET_TYPE_STREAM,
G_SOCKET_PROTOCOL_TCP, NULL);
name.storage.ss_family = AF_INET;
#ifdef HAVE_SA_LEN
name.storage.ss_len = sizeof (struct sockaddr_in);
#endif
} else if (name.storage.ss_family == AF_INET6) {
gsock = g_socket_new (G_SOCKET_FAMILY_IPV6, G_SOCKET_TYPE_STREAM,
G_SOCKET_PROTOCOL_TCP, NULL);
name.storage.ss_family = AF_INET6;
#ifdef HAVE_SA_LEN
name.storage.ss_len = sizeof (struct sockaddr_in6);
#endif
}
if (gsock == NULL) {
return NULL;
}
gaddr = g_socket_address_new_from_native (&name.addr, sizeof (name));
if (gaddr == NULL) {
g_object_unref (gsock);
return NULL;
}
/* GSocket: All socket file descriptors are set to be close-on-exec. */
g_socket_set_blocking (gsock, false);
gret = g_socket_bind (gsock, gaddr, FALSE, NULL) &&
g_socket_listen (gsock, NULL);
g_object_unref (gaddr);
if (gret == FALSE) {
g_socket_close (gsock, NULL);
g_object_unref (gsock);
return NULL;
}
gaddr = g_socket_get_local_address (gsock, NULL);
if (gaddr == NULL ||
!g_socket_address_to_native (gaddr, &name.addr, sizeof (name), NULL)) {
g_socket_close (gsock, NULL);
g_object_unref (gsock);
return NULL;
}
g_object_unref (gaddr);
if (ctx == NULL) {
ctx = g_main_context_default ();
}
sock = g_slice_new0 (NiceSocket);
nice_address_set_from_sockaddr (&sock->addr, &name.addr);
sock->priv = priv = g_slice_new0 (TcpPassivePriv);
priv->context = g_main_context_ref (ctx);
priv->connections = g_hash_table_new_full ((GHashFunc) nice_address_hash,
(GEqualFunc) nice_address_equal, (
GDestroyNotify) nice_address_free, NULL);
priv->writable_cb = NULL;
priv->writable_data = NULL;
sock->type = NICE_SOCKET_TYPE_TCP_PASSIVE;
sock->fileno = gsock;
sock->send_messages = socket_send_messages;
sock->send_messages_reliable = socket_send_messages_reliable;
sock->recv_messages = socket_recv_messages;
sock->is_reliable = socket_is_reliable;
sock->can_send = socket_can_send;
sock->set_writable_callback = socket_set_writable_callback;
sock->close = socket_close;
return sock;
}
int moloch_http_connect(MolochConn_t *conn, char *name, int defaultport, int blocking)
{
GError *error = 0;
GSocketConnectable *connectable;
GSocketAddressEnumerator *enumerator;
GSocketAddress *sockaddr;
struct timeval startTime;
struct timeval stopTime;
gettimeofday(&startTime, NULL);
connectable = g_network_address_parse(name, defaultport, &error);
if (error) {
LOG("%p: Couldn't parse connect string of %s", (void*)conn, name);
exit(0);
}
conn->name = name;
enumerator = g_socket_connectable_enumerate (connectable);
g_object_unref(connectable);
while (!conn->conn && (sockaddr = g_socket_address_enumerator_next (enumerator, NULL, &error)))
{
conn->conn = g_socket_new(G_SOCKET_FAMILY_IPV4, G_SOCKET_TYPE_STREAM, G_SOCKET_PROTOCOL_TCP, &error);
if (!error) {
GValue value = G_VALUE_INIT;
g_value_init (&value, G_TYPE_BOOLEAN);
g_value_set_boolean (&value, blocking);
g_object_set_property(G_OBJECT(conn->conn), "blocking", &value);
g_socket_connect(conn->conn, sockaddr, NULL, &error);
}
if (error && error->code != G_IO_ERROR_PENDING) {
g_object_unref (conn->conn);
conn->conn = NULL;
} else {
struct sockaddr_in localAddress, remoteAddress;
socklen_t addressLength = sizeof(localAddress);
getsockname(g_socket_get_fd(conn->conn), (struct sockaddr*)&localAddress, &addressLength);
g_socket_address_to_native(sockaddr, &remoteAddress, addressLength, NULL);
char sessionId[MOLOCH_SESSIONID_LEN];
moloch_session_id(sessionId, localAddress.sin_addr.s_addr, localAddress.sin_port,
remoteAddress.sin_addr.s_addr, remoteAddress.sin_port);
DEBUGCONN("AAA connected %s %p %s", conn->server->names[0], conn,
moloch_friendly_session_id(17, localAddress.sin_addr.s_addr, htons(localAddress.sin_port),
remoteAddress.sin_addr.s_addr, htons(remoteAddress.sin_port)));
HASH_ADD(h_, connections, sessionId, conn);
memcpy(&conn->sessionIda, sessionId, 8);
memcpy(&conn->sessionIdb, sessionId+8, 4);
conn->server->numConns++;
}
g_object_unref (sockaddr);
}
g_object_unref (enumerator);
if (conn->conn) {
if (error) {
g_error_free(error);
error = 0;
}
} else if (error) {
LOG("%p: Error: %s", (void*)conn, error->message);
}
if (error || !conn->conn) {
if (config.logESRequests)
LOG("Connecting %p %s %d %d FAIL", (void*)conn, name, defaultport, blocking);
conn->server->lastFailedConnect = time(0);
return 1;
}
//g_object_ref (conn->conn);
g_socket_set_keepalive(conn->conn, TRUE);
int fd = g_socket_get_fd(conn->conn);
conn->readWatch = moloch_watch_fd(fd, MOLOCH_GIO_READ_COND, moloch_http_read_cb, conn);
if (!blocking) {
conn->writeWatch = moloch_watch_fd(fd, G_IO_OUT, moloch_http_conn_cb, conn);
DEBUGCONN("AAA connwritewatch %s %p fd:%d ww:%d", conn->server->names[0], conn, fd, conn->writeWatch);
}
int sendbuff = 0;
socklen_t optlen = sizeof(sendbuff);
int res = getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &sendbuff, &optlen);
if(res != -1 && sendbuff < 300000) {
sendbuff = 300000;
setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &sendbuff, sizeof(sendbuff));
}
#ifdef TCP_KEEPIDLE
res = getsockopt(fd, IPPROTO_TCP, TCP_KEEPIDLE, &sendbuff, &optlen);
if(res != -1 && sendbuff > 60*8) {
sendbuff = 60*8;
setsockopt(fd, IPPROTO_TCP, TCP_KEEPIDLE, &sendbuff, sizeof(sendbuff));
}
#endif
gettimeofday(&stopTime, NULL);
if (config.logESRequests)
LOG("Connecting %p %s %d %d %ldms", (void*)conn, name, defaultport, blocking,
(stopTime.tv_sec - startTime.tv_sec)*1000 + (stopTime.tv_usec - startTime.tv_usec)/1000);
return 0;
}
