/**
* Activity on our listen socket. Accept the
* incoming connection.
*
* @param cls the `struct GNUNET_NAT_Test`
* @param tc scheduler context
*/
static void
do_accept (void *cls,
const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct GNUNET_NAT_Test *tst = cls;
struct GNUNET_NETWORK_Handle *s;
struct NatActivity *wl;
tst->ltask = NULL;
if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
return;
tst->ltask =
GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, tst->lsock,
&do_accept, tst);
s = GNUNET_NETWORK_socket_accept (tst->lsock, NULL, NULL);
if (NULL == s)
{
GNUNET_log_strerror (GNUNET_ERROR_TYPE_INFO, "accept");
return; /* odd error */
}
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Got an inbound connection, waiting for data\n");
wl = GNUNET_new (struct NatActivity);
wl->sock = s;
wl->h = tst;
wl->rtask =
GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
wl->sock,
&do_read, wl);
GNUNET_CONTAINER_DLL_insert (tst->na_head, tst->na_tail, wl);
}
/**
* Create a connection handle by accepting on a listen socket. This
* function may block if the listen socket has no connection ready.
*
* @param access_cb function to use to check if access is allowed
* @param access_cb_cls closure for @a access_cb
* @param lsock listen socket
* @return the connection handle, NULL on error
*/
struct GNUNET_CONNECTION_Handle *
GNUNET_CONNECTION_create_from_accept (GNUNET_CONNECTION_AccessCheck access_cb,
void *access_cb_cls,
struct GNUNET_NETWORK_Handle *lsock)
{
struct GNUNET_CONNECTION_Handle *connection;
char addr[128];
socklen_t addrlen;
struct GNUNET_NETWORK_Handle *sock;
int aret;
struct sockaddr_in *v4;
struct sockaddr_in6 *v6;
struct sockaddr *sa;
void *uaddr;
struct GNUNET_CONNECTION_Credentials *gcp;
struct GNUNET_CONNECTION_Credentials gc;
#ifdef SO_PEERCRED
struct ucred uc;
socklen_t olen;
#endif
addrlen = sizeof (addr);
sock =
GNUNET_NETWORK_socket_accept (lsock,
(struct sockaddr *) &addr,
&addrlen);
if (NULL == sock)
{
if (EAGAIN != errno)
LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "accept");
return NULL;
}
if ((addrlen > sizeof (addr)) || (addrlen < sizeof (sa_family_t)))
{
GNUNET_break (0);
GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (sock));
return NULL;
}
sa = (struct sockaddr *) addr;
v6 = (struct sockaddr_in6 *) addr;
if ( (AF_INET6 == sa->sa_family) &&
(IN6_IS_ADDR_V4MAPPED (&v6->sin6_addr)) )
{
/* convert to V4 address */
v4 = GNUNET_new (struct sockaddr_in);
memset (v4, 0, sizeof (struct sockaddr_in));
v4->sin_family = AF_INET;
#if HAVE_SOCKADDR_IN_SIN_LEN
v4->sin_len = (u_char) sizeof (struct sockaddr_in);
#endif
GNUNET_memcpy (&v4->sin_addr,
&((char *) &v6->sin6_addr)[sizeof (struct in6_addr) -
sizeof (struct in_addr)],
sizeof (struct in_addr));
v4->sin_port = v6->sin6_port;
uaddr = v4;
addrlen = sizeof (struct sockaddr_in);
}
/**
* Create a connection handle by accepting on a listen socket. This
* function may block if the listen socket has no connection ready.
*
* @param access function to use to check if access is allowed
* @param access_cls closure for access
* @param lsock listen socket
* @return the connection handle, NULL on error
*/
struct GNUNET_CONNECTION_Handle *
GNUNET_CONNECTION_create_from_accept (GNUNET_CONNECTION_AccessCheck access,
void *access_cls,
struct GNUNET_NETWORK_Handle *lsock)
{
struct GNUNET_CONNECTION_Handle *connection;
char addr[128];
socklen_t addrlen;
struct GNUNET_NETWORK_Handle *sock;
int aret;
struct sockaddr_in *v4;
struct sockaddr_in6 *v6;
struct sockaddr *sa;
void *uaddr;
struct GNUNET_CONNECTION_Credentials *gcp;
struct GNUNET_CONNECTION_Credentials gc;
#ifdef SO_PEERCRED
struct ucred uc;
socklen_t olen;
#endif
addrlen = sizeof (addr);
sock =
GNUNET_NETWORK_socket_accept (lsock, (struct sockaddr *) &addr, &addrlen);
if (NULL == sock)
{
LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "accept");
return NULL;
}
if ((addrlen > sizeof (addr)) || (addrlen < sizeof (sa_family_t)))
{
GNUNET_break (0);
GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (sock));
return NULL;
}
sa = (struct sockaddr *) addr;
v6 = (struct sockaddr_in6 *) addr;
if ((AF_INET6 == sa->sa_family) && (IN6_IS_ADDR_V4MAPPED (&v6->sin6_addr)))
{
/* convert to V4 address */
v4 = GNUNET_malloc (sizeof (struct sockaddr_in));
memset (v4, 0, sizeof (struct sockaddr_in));
v4->sin_family = AF_INET;
#if HAVE_SOCKADDR_IN_SIN_LEN
v4->sin_len = (u_char) sizeof (struct sockaddr_in);
#endif
memcpy (&v4->sin_addr,
&((char *) &v6->sin6_addr)[sizeof (struct in6_addr) -
sizeof (struct in_addr)],
sizeof (struct in_addr));
v4->sin_port = v6->sin6_port;
uaddr = v4;
addrlen = sizeof (struct sockaddr_in);
}
else
{
uaddr = GNUNET_malloc (addrlen);
memcpy (uaddr, addr, addrlen);
}
gcp = NULL;
gc.uid = 0;
gc.gid = 0;
if (AF_UNIX == sa->sa_family)
{
#if HAVE_GETPEEREID
/* most BSDs */
if (0 == getpeereid (GNUNET_NETWORK_get_fd (sock), &gc.uid, &gc.gid))
gcp = &gc;
#else
#ifdef SO_PEERCRED
/* largely traditional GNU/Linux */
olen = sizeof (uc);
if ((0 ==
getsockopt (GNUNET_NETWORK_get_fd (sock), SOL_SOCKET, SO_PEERCRED, &uc,
&olen)) && (olen == sizeof (uc)))
{
gc.uid = uc.uid;
gc.gid = uc.gid;
gcp = &gc;
}
#else
#if HAVE_GETPEERUCRED
/* this is for Solaris 10 */
ucred_t *uc;
uc = NULL;
if (0 == getpeerucred (GNUNET_NETWORK_get_fd (sock), &uc))
{
gc.uid = ucred_geteuid (uc);
gc.gid = ucred_getegid (uc);
gcp = &gc;
}
ucred_free (uc);
#endif
#endif
#endif
}
if ((NULL != access) &&
(GNUNET_YES != (aret = access (access_cls, gcp, uaddr, addrlen))))
{
if (GNUNET_NO == aret)
LOG (GNUNET_ERROR_TYPE_INFO, _("Access denied to `%s'\n"),
GNUNET_a2s (uaddr, addrlen));
GNUNET_break (GNUNET_OK ==
GNUNET_NETWORK_socket_shutdown (sock, SHUT_RDWR));
GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (sock));
GNUNET_free (uaddr);
return NULL;
}
connection = GNUNET_malloc (sizeof (struct GNUNET_CONNECTION_Handle));
connection->write_buffer_size = GNUNET_SERVER_MIN_BUFFER_SIZE;
connection->write_buffer = GNUNET_malloc (connection->write_buffer_size);
connection->addr = uaddr;
connection->addrlen = addrlen;
connection->sock = sock;
LOG (GNUNET_ERROR_TYPE_INFO,
_("Accepting connection from `%s': %p\n"),
GNUNET_a2s (uaddr, addrlen), connection);
return connection;
}
