* @file util/service_new.c
* @brief functions related to starting services (redesign)
* @author Christian Grothoff
+ * @author Florian Dold
*/
#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_protocols.h"
#include "gnunet_constants.h"
#include "gnunet_resolver_service.h"
+#include "speedup.h"
+
+#if HAVE_MALLINFO
+#include <malloc.h>
+#include "gauger.h"
+#endif
+
+
+#define LOG(kind,...) GNUNET_log_from (kind, "util", __VA_ARGS__)
+
+#define LOG_STRERROR(kind,syscall) GNUNET_log_from_strerror (kind, "util", syscall)
+
+#define LOG_STRERROR_FILE(kind,syscall,filename) GNUNET_log_from_strerror_file (kind, "util", syscall, filename)
/**
/**
* Message handlers to use for all clients.
*/
- const struct GNUNET_MQ_MessageHandler *handlers;
+ struct GNUNET_MQ_MessageHandler *handlers;
/**
* Closure for @e task.
int ret;
/**
- * Inherited listening sockets, only
- * used during initialization.
- * FIXME: remove from struct
- */
- struct GNUNET_NETWORK_Handle **lsocks;
-
- /**
- * If GNUNET_YES, consider unknown message types an error where the
+ * If #GNUNET_YES, consider unknown message types an error where the
* client is disconnected.
- * FIXME: remove?
*/
int require_found;
};
/**
* Tokenizer we use for processing incoming data.
*/
- struct GNUNET_SERVER_MessageStreamTokenizer *mst;
+ struct GNUNET_MessageStreamTokenizer *mst;
/**
* Task that warns about missing calls to
*/
struct GNUNET_SCHEDULER_Task *warn_task;
+ /**
+ * Task run to finish dropping the client after the stack has
+ * properly unwound.
+ */
+ struct GNUNET_SCHEDULER_Task *drop_task;
+
/**
* Task that receives data from the client to
* pass it to the handlers.
*/
struct GNUNET_SCHEDULER_Task *send_task;
+ /**
+ * Pointer to the message to be transmitted by @e send_task.
+ */
+ const struct GNUNET_MessageHeader *msg;
+
/**
* User context value, value returned from
* the connect callback.
*/
void *user_context;
+ /**
+ * Time when we last gave a message from this client
+ * to the application.
+ */
+ struct GNUNET_TIME_Absolute warn_start;
+
+ /**
+ * Current position in @e msg at which we are transmitting.
+ */
+ size_t msg_pos;
+
/**
* Persist the file handle for this client no matter what happens,
* force the OS to close once the process actually dies. Should only
*/
int is_monitor;
+ /**
+ * Are we waiting for the application to call #GNUNET_SERVICE_client_continue()?
+ */
+ int needs_continue;
+
/**
* Type of last message processed (for warn_no_receive_done).
*/
* @param cls our `struct GNUNET_SERVICE_Handle`
*/
static void
-service_main (void *cls)
+service_shutdown (void *cls)
{
struct GNUNET_SERVICE_Handle *sh = cls;
- struct GNUNET_SERVICE_Client *client;
- int alive;
switch (sh->options)
{
}
+/**
+ * First task run by any service. Initializes our shutdown task,
+ * starts the listening operation on our listen sockets and launches
+ * the custom logic of the application service.
+ *
+ * @param cls our `struct GNUNET_SERVICE_Handle`
+ */
+static void
+service_main (void *cls)
+{
+ struct GNUNET_SERVICE_Handle *sh = cls;
+
+ if (GNUNET_SERVICE_OPTION_MANUAL_SHUTDOWN != sh->options)
+ GNUNET_SCHEDULER_add_shutdown (&service_shutdown,
+ sh);
+ GNUNET_SERVICE_resume (sh);
+ if (NULL != sh->service_init_cb)
+ sh->service_init_cb (sh->cb_cls,
+ sh->cfg,
+ sh);
+}
+
+
/**
* Parse an IPv4 access control list.
*
{
char *opt;
- if (!GNUNET_CONFIGURATION_have_value (sh->cfg, sh->service_name, option))
+ if (! GNUNET_CONFIGURATION_have_value (sh->cfg,
+ sh->service_name,
+ option))
{
*ret = NULL;
return GNUNET_OK;
GNUNET_break (GNUNET_OK ==
GNUNET_CONFIGURATION_get_value_string (sh->cfg,
sh->service_name,
- option, &opt));
+ option,
+ &opt));
if (NULL == (*ret = GNUNET_STRINGS_parse_ipv4_policy (opt)))
{
LOG (GNUNET_ERROR_TYPE_WARNING,
_("Could not parse IPv4 network specification `%s' for `%s:%s'\n"),
- opt, sh->service_name, option);
+ opt,
+ sh->service_name,
+ option);
GNUNET_free (opt);
return GNUNET_SYSERR;
}
{
char *opt;
- if (!GNUNET_CONFIGURATION_have_value (sh->cfg, sh->service_name, option))
+ if (! GNUNET_CONFIGURATION_have_value (sh->cfg,
+ sh->service_name,
+ option))
{
*ret = NULL;
return GNUNET_OK;
GNUNET_break (GNUNET_OK ==
GNUNET_CONFIGURATION_get_value_string (sh->cfg,
sh->service_name,
- option, &opt));
+ option,
+ &opt));
if (NULL == (*ret = GNUNET_STRINGS_parse_ipv6_policy (opt)))
{
LOG (GNUNET_ERROR_TYPE_WARNING,
_("Could not parse IPv6 network specification `%s' for `%s:%s'\n"),
- opt, sh->service_name, option);
+ opt,
+ sh->service_name,
+ option);
GNUNET_free (opt);
return GNUNET_SYSERR;
}
}
+/**
+ * Add the given UNIX domain path as an address to the
+ * list (as the first entry).
+ *
+ * @param saddrs array to update
+ * @param saddrlens where to store the address length
+ * @param unixpath path to add
+ * @param abstract #GNUNET_YES to add an abstract UNIX domain socket. This
+ * parameter is ignore on systems other than LINUX
+ */
+static void
+add_unixpath (struct sockaddr **saddrs,
+ socklen_t *saddrlens,
+ const char *unixpath,
+ int abstract)
+{
+#ifdef AF_UNIX
+ struct sockaddr_un *un;
+
+ un = GNUNET_new (struct sockaddr_un);
+ un->sun_family = AF_UNIX;
+ strncpy (un->sun_path,
+ unixpath,
+ sizeof (un->sun_path) - 1);
+#ifdef LINUX
+ if (GNUNET_YES == abstract)
+ un->sun_path[0] = '\0';
+#endif
+#if HAVE_SOCKADDR_IN_SIN_LEN
+ un->sun_len = (u_char) sizeof (struct sockaddr_un);
+#endif
+ *saddrs = (struct sockaddr *) un;
+ *saddrlens = sizeof (struct sockaddr_un);
+#else
+ /* this function should never be called
+ * unless AF_UNIX is defined! */
+ GNUNET_assert (0);
+#endif
+}
+
+
/**
* Get the list of addresses that a server for the given service
* should bind to.
*/
static int
get_server_addresses (const char *service_name,
- const struct GNUNET_CONFIGURATION_Handle *cfg,
- struct sockaddr ***addrs,
- socklen_t ** addr_lens)
+ const struct GNUNET_CONFIGURATION_Handle *cfg,
+ struct sockaddr ***addrs,
+ socklen_t **addr_lens)
{
int disablev6;
struct GNUNET_NETWORK_Handle *desc;
*addrs = NULL;
*addr_lens = NULL;
desc = NULL;
- if (GNUNET_CONFIGURATION_have_value (cfg, service_name, "DISABLEV6"))
+ if (GNUNET_CONFIGURATION_have_value (cfg,
+ service_name,
+ "DISABLEV6"))
{
if (GNUNET_SYSERR ==
(disablev6 =
- GNUNET_CONFIGURATION_get_value_yesno (cfg, service_name, "DISABLEV6")))
+ GNUNET_CONFIGURATION_get_value_yesno (cfg,
+ service_name,
+ "DISABLEV6")))
return GNUNET_SYSERR;
}
else
if (! disablev6)
{
/* probe IPv6 support */
- desc = GNUNET_NETWORK_socket_create (PF_INET6, SOCK_STREAM, 0);
+ desc = GNUNET_NETWORK_socket_create (PF_INET6,
+ SOCK_STREAM,
+ 0);
if (NULL == desc)
{
- if ((ENOBUFS == errno) || (ENOMEM == errno) || (ENFILE == errno) ||
- (EACCES == errno))
+ if ( (ENOBUFS == errno) ||
+ (ENOMEM == errno) ||
+ (ENFILE == errno) ||
+ (EACCES == errno) )
{
- LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "socket");
+ LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR,
+ "socket");
return GNUNET_SYSERR;
}
LOG (GNUNET_ERROR_TYPE_INFO,
_("Disabling IPv6 support for service `%s', failed to create IPv6 socket: %s\n"),
- service_name, STRERROR (errno));
+ service_name,
+ STRERROR (errno));
disablev6 = GNUNET_YES;
}
else
{
- GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (desc));
+ GNUNET_break (GNUNET_OK ==
+ GNUNET_NETWORK_socket_close (desc));
desc = NULL;
}
}
port = 0;
- if (GNUNET_CONFIGURATION_have_value (cfg, service_name, "PORT"))
+ if (GNUNET_CONFIGURATION_have_value (cfg,
+ service_name,
+ "PORT"))
{
if (GNUNET_OK !=
- GNUNET_CONFIGURATION_get_value_number (cfg, service_name,
- "PORT", &port))
+ GNUNET_CONFIGURATION_get_value_number (cfg,
+ service_name,
+ "PORT",
+ &port))
{
LOG (GNUNET_ERROR_TYPE_ERROR,
_("Require valid port number for service `%s' in configuration!\n"),
}
}
- if (GNUNET_CONFIGURATION_have_value (cfg, service_name, "BINDTO"))
+ if (GNUNET_CONFIGURATION_have_value (cfg,
+ service_name,
+ "BINDTO"))
{
GNUNET_break (GNUNET_OK ==
- GNUNET_CONFIGURATION_get_value_string (cfg, service_name,
- "BINDTO", &hostname));
+ GNUNET_CONFIGURATION_get_value_string (cfg,
+ service_name,
+ "BINDTO",
+ &hostname));
}
else
hostname = NULL;
abstract = GNUNET_NO;
#ifdef AF_UNIX
if ((GNUNET_YES ==
- GNUNET_CONFIGURATION_have_value (cfg, service_name, "UNIXPATH")) &&
+ GNUNET_CONFIGURATION_have_value (cfg,
+ service_name,
+ "UNIXPATH")) &&
(GNUNET_OK ==
- GNUNET_CONFIGURATION_get_value_filename (cfg, service_name, "UNIXPATH",
- &unixpath)) &&
+ GNUNET_CONFIGURATION_get_value_filename (cfg,
+ service_name,
+ "UNIXPATH",
+ &unixpath)) &&
(0 < strlen (unixpath)))
{
/* probe UNIX support */
if (strlen (unixpath) >= sizeof (s_un.sun_path))
{
LOG (GNUNET_ERROR_TYPE_WARNING,
- _("UNIXPATH `%s' too long, maximum length is %llu\n"), unixpath,
+ _("UNIXPATH `%s' too long, maximum length is %llu\n"),
+ unixpath,
(unsigned long long) sizeof (s_un.sun_path));
unixpath = GNUNET_NETWORK_shorten_unixpath (unixpath);
LOG (GNUNET_ERROR_TYPE_INFO,
if (GNUNET_SYSERR == abstract)
abstract = GNUNET_NO;
#endif
- if ((GNUNET_YES != abstract)
- && (GNUNET_OK !=
- GNUNET_DISK_directory_create_for_file (unixpath)))
+ if ( (GNUNET_YES != abstract) &&
+ (GNUNET_OK !=
+ GNUNET_DISK_directory_create_for_file (unixpath)) )
GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR,
"mkdir",
unixpath);
}
if (NULL != unixpath)
{
- desc = GNUNET_NETWORK_socket_create (AF_UNIX, SOCK_STREAM, 0);
+ desc = GNUNET_NETWORK_socket_create (AF_UNIX,
+ SOCK_STREAM,
+ 0);
if (NULL == desc)
{
- if ((ENOBUFS == errno) || (ENOMEM == errno) || (ENFILE == errno) ||
+ if ((ENOBUFS == errno) ||
+ (ENOMEM == errno) ||
+ (ENFILE == errno) ||
(EACCES == errno))
{
- LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "socket");
+ LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR,
+ "socket");
GNUNET_free_non_null (hostname);
GNUNET_free (unixpath);
return GNUNET_SYSERR;
}
else
{
- GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (desc));
+ GNUNET_break (GNUNET_OK ==
+ GNUNET_NETWORK_socket_close (desc));
desc = NULL;
}
}
}
if (0 == port)
{
- saddrs = GNUNET_malloc (2 * sizeof (struct sockaddr *));
- saddrlens = GNUNET_malloc (2 * sizeof (socklen_t));
- add_unixpath (saddrs, saddrlens, unixpath, abstract);
+ saddrs = GNUNET_new_array (2,
+ struct sockaddr *);
+ saddrlens = GNUNET_new_array (2,
+ socklen_t);
+ add_unixpath (saddrs,
+ saddrlens,
+ unixpath,
+ abstract);
GNUNET_free_non_null (unixpath);
GNUNET_free_non_null (hostname);
*addrs = saddrs;
"Resolving `%s' since that is where `%s' will bind to.\n",
hostname,
service_name);
- memset (&hints, 0, sizeof (struct addrinfo));
+ memset (&hints,
+ 0,
+ sizeof (struct addrinfo));
if (disablev6)
hints.ai_family = AF_INET;
hints.ai_protocol = IPPROTO_TCP;
- if ((0 != (ret = getaddrinfo (hostname, NULL, &hints, &res))) ||
+ if ((0 != (ret = getaddrinfo (hostname,
+ NULL,
+ &hints,
+ &res))) ||
(NULL == res))
{
LOG (GNUNET_ERROR_TYPE_ERROR,
while (NULL != (pos = next))
{
next = pos->ai_next;
- if ((disablev6) && (pos->ai_family == AF_INET6))
+ if ( (disablev6) &&
+ (pos->ai_family == AF_INET6) )
continue;
i++;
}
resi = i;
if (NULL != unixpath)
resi++;
- saddrs = GNUNET_malloc ((resi + 1) * sizeof (struct sockaddr *));
- saddrlens = GNUNET_malloc ((resi + 1) * sizeof (socklen_t));
+ saddrs = GNUNET_new_array (resi + 1,
+ struct sockaddr *);
+ saddrlens = GNUNET_new_array (resi + 1,
+ socklen_t);
i = 0;
if (NULL != unixpath)
{
- add_unixpath (saddrs, saddrlens, unixpath, abstract);
+ add_unixpath (saddrs,
+ saddrlens,
+ unixpath,
+ abstract);
i++;
}
next = res;
while (NULL != (pos = next))
{
next = pos->ai_next;
- if ((disablev6) && (AF_INET6 == pos->ai_family))
+ if ( (disablev6) &&
+ (AF_INET6 == pos->ai_family) )
continue;
- if ((IPPROTO_TCP != pos->ai_protocol) && (0 != pos->ai_protocol))
+ if ( (IPPROTO_TCP != pos->ai_protocol) &&
+ (0 != pos->ai_protocol) )
continue; /* not TCP */
- if ((SOCK_STREAM != pos->ai_socktype) && (0 != pos->ai_socktype))
+ if ( (SOCK_STREAM != pos->ai_socktype) &&
+ (0 != pos->ai_socktype) )
continue; /* huh? */
- LOG (GNUNET_ERROR_TYPE_DEBUG, "Service `%s' will bind to `%s'\n",
- service_name, GNUNET_a2s (pos->ai_addr, pos->ai_addrlen));
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Service `%s' will bind to `%s'\n",
+ service_name,
+ GNUNET_a2s (pos->ai_addr,
+ pos->ai_addrlen));
if (AF_INET == pos->ai_family)
{
GNUNET_assert (sizeof (struct sockaddr_in) == pos->ai_addrlen);
saddrlens[i] = pos->ai_addrlen;
saddrs[i] = GNUNET_malloc (saddrlens[i]);
- GNUNET_memcpy (saddrs[i], pos->ai_addr, saddrlens[i]);
+ GNUNET_memcpy (saddrs[i],
+ pos->ai_addr,
+ saddrlens[i]);
((struct sockaddr_in *) saddrs[i])->sin_port = htons (port);
}
else
GNUNET_assert (sizeof (struct sockaddr_in6) == pos->ai_addrlen);
saddrlens[i] = pos->ai_addrlen;
saddrs[i] = GNUNET_malloc (saddrlens[i]);
- GNUNET_memcpy (saddrs[i], pos->ai_addr, saddrlens[i]);
+ GNUNET_memcpy (saddrs[i],
+ pos->ai_addr,
+ saddrlens[i]);
((struct sockaddr_in6 *) saddrs[i])->sin6_port = htons (port);
}
i++;
if (NULL != unixpath)
resi++;
i = 0;
- saddrs = GNUNET_malloc ((resi + 1) * sizeof (struct sockaddr *));
- saddrlens = GNUNET_malloc ((resi + 1) * sizeof (socklen_t));
+ saddrs = GNUNET_new_array (resi + 1,
+ struct sockaddr *);
+ saddrlens = GNUNET_new_array (resi + 1,
+ socklen_t);
if (NULL != unixpath)
{
- add_unixpath (saddrs, saddrlens, unixpath, abstract);
+ add_unixpath (saddrs,
+ saddrlens,
+ unixpath,
+ abstract);
i++;
}
saddrlens[i] = sizeof (struct sockaddr_in);
resi = 2;
if (NULL != unixpath)
resi++;
- saddrs = GNUNET_malloc ((resi + 1) * sizeof (struct sockaddr *));
- saddrlens = GNUNET_malloc ((resi + 1) * sizeof (socklen_t));
+ saddrs = GNUNET_new_array (resi + 1,
+ struct sockaddr *);
+ saddrlens = GNUNET_new_array (resi + 1,
+ socklen_t);
i = 0;
if (NULL != unixpath)
{
- add_unixpath (saddrs, saddrlens, unixpath, abstract);
+ add_unixpath (saddrs,
+ saddrlens,
+ unixpath,
+ abstract);
i++;
}
saddrlens[i] = sizeof (struct sockaddr_in6);
* Read listen sockets from the parent process (ARM).
*
* @param sh service context to initialize
- * @return #GNUNET_YES if ok, #GNUNET_NO if not ok (must bind yourself),
- * and #GNUNET_SYSERR on error.
+ * @return NULL-terminated array of sockets on success,
+ * NULL if not ok (must bind yourself)
*/
-static int
+static struct GNUNET_NETWORK_Handle **
receive_sockets_from_parent (struct GNUNET_SERVICE_Handle *sh)
{
+ static struct GNUNET_NETWORK_Handle **lsocks;
const char *env_buf;
int fail;
uint64_t count;
HANDLE lsocks_pipe;
env_buf = getenv ("GNUNET_OS_READ_LSOCKS");
- if ((NULL == env_buf) || (strlen (env_buf) <= 0))
- return GNUNET_NO;
+ if ( (NULL == env_buf) ||
+ (strlen (env_buf) <= 0) )
+ return NULL;
/* Using W32 API directly here, because this pipe will
* never be used outside of this function, and it's just too much of a bother
* to create a GNUnet API that boxes a HANDLE (the way it is done with socks)
*/
- lsocks_pipe = (HANDLE) strtoul (env_buf, NULL, 10);
- if ( (0 == lsocks_pipe) || (INVALID_HANDLE_VALUE == lsocks_pipe))
- return GNUNET_NO;
+ lsocks_pipe = (HANDLE) strtoul (env_buf,
+ NULL,
+ 10);
+ if ( (0 == lsocks_pipe) ||
+ (INVALID_HANDLE_VALUE == lsocks_pipe))
+ return NULL;
fail = 1;
do
{
int fail2;
DWORD rd;
- ret = ReadFile (lsocks_pipe, &count, sizeof (count), &rd, NULL);
- if ((0 == ret) || (sizeof (count) != rd) || (0 == count))
+ ret = ReadFile (lsocks_pipe,
+ &count,
+ sizeof (count),
+ &rd,
+ NULL);
+ if ( (0 == ret) ||
+ (sizeof (count) != rd) ||
+ (0 == count) )
break;
- sh->lsocks =
- GNUNET_malloc (sizeof (struct GNUNET_NETWORK_Handle *) * (count + 1));
+ lsocks = GNUNET_new_array (count + 1,
+ struct GNUNET_NETWORK_Handle *);
fail2 = 1;
for (i = 0; i < count; i++)
uint64_t size;
SOCKET s;
- ret = ReadFile (lsocks_pipe, &size, sizeof (size), &rd, NULL);
- if ( (0 == ret) || (sizeof (size) != rd) || (sizeof (pi) != size) )
+ ret = ReadFile (lsocks_pipe,
+ &size,
+ sizeof (size),
+ &rd,
+ NULL);
+ if ( (0 == ret) ||
+ (sizeof (size) != rd) ||
+ (sizeof (pi) != size) )
break;
- ret = ReadFile (lsocks_pipe, &pi, sizeof (pi), &rd, NULL);
- if ( (0 == ret) || (sizeof (pi) != rd))
+ ret = ReadFile (lsocks_pipe,
+ &pi,
+ sizeof (pi),
+ &rd,
+ NULL);
+ if ( (0 == ret) ||
+ (sizeof (pi) != rd))
break;
- s = WSASocketA (pi.iAddressFamily, pi.iSocketType, pi.iProtocol, &pi, 0, WSA_FLAG_OVERLAPPED);
- sh->lsocks[i] = GNUNET_NETWORK_socket_box_native (s);
- if (NULL == sh->lsocks[i])
+ s = WSASocketA (pi.iAddressFamily,
+ pi.iSocketType,
+ pi.iProtocol,
+ &pi,
+ 0,
+ WSA_FLAG_OVERLAPPED);
+ lsocks[i] = GNUNET_NETWORK_socket_box_native (s);
+ if (NULL == lsocks[i])
break;
else if (i == count - 1)
fail2 = 0;
}
if (fail2)
break;
- sh->lsocks[count] = NULL;
+ lsocks[count] = NULL;
fail = 0;
}
while (fail);
-
CloseHandle (lsocks_pipe);
if (fail)
{
LOG (GNUNET_ERROR_TYPE_ERROR,
_("Could not access a pre-bound socket, will try to bind myself\n"));
- for (i = 0; (i < count) && (NULL != sh->lsocks[i]); i++)
- GNUNET_break (0 == GNUNET_NETWORK_socket_close (sh->lsocks[i]));
- GNUNET_free_non_null (sh->lsocks);
- sh->lsocks = NULL;
- return GNUNET_NO;
+ for (i = 0; (i < count) && (NULL != lsocks[i]); i++)
+ GNUNET_break (GNUNET_OK ==
+ GNUNET_NETWORK_socket_close (lsocks[i]));
+ GNUNET_free (lsocks);
+ return NULL;
}
- return GNUNET_YES;
+ return lsocks;
}
#endif
port = 0;
break;
}
- sock = GNUNET_NETWORK_socket_create (server_addr->sa_family, SOCK_STREAM, 0);
+ sock = GNUNET_NETWORK_socket_create (server_addr->sa_family,
+ SOCK_STREAM,
+ 0);
if (NULL == sock)
{
- LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "socket");
+ LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR,
+ "socket");
errno = 0;
return NULL;
}
/* bind the socket */
- if (GNUNET_OK != GNUNET_NETWORK_socket_bind (sock, server_addr, socklen))
+ if (GNUNET_OK != GNUNET_NETWORK_socket_bind (sock,
+ server_addr,
+ socklen))
{
eno = errno;
if (EADDRINUSE != errno)
GNUNET_a2s (server_addr, socklen));
}
}
- GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (sock));
+ GNUNET_break (GNUNET_OK ==
+ GNUNET_NETWORK_socket_close (sock));
errno = eno;
return NULL;
}
- if (GNUNET_OK != GNUNET_NETWORK_socket_listen (sock, 5))
+ if (GNUNET_OK != GNUNET_NETWORK_socket_listen (sock,
+ 5))
{
LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR,
"listen");
- GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (sock));
+ GNUNET_break (GNUNET_OK ==
+ GNUNET_NETWORK_socket_close (sock));
errno = 0;
return NULL;
}
}
-
-
/**
* Setup service handle
*
static int
setup_service (struct GNUNET_SERVICE_Handle *sh)
{
- struct GNUNET_TIME_Relative idleout;
int tolerant;
-
+ struct GNUNET_NETWORK_Handle **lsocks;
#ifndef MINGW
const char *nfds;
unsigned int cnt;
#endif
if (GNUNET_CONFIGURATION_have_value
- (sh->cfg, sh->service_name, "TOLERANT"))
+ (sh->cfg,
+ sh->service_name,
+ "TOLERANT"))
{
if (GNUNET_SYSERR ==
(tolerant =
- GNUNET_CONFIGURATION_get_value_yesno (sh->cfg, sh->service_name,
+ GNUNET_CONFIGURATION_get_value_yesno (sh->cfg,
+ sh->service_name,
"TOLERANT")))
{
LOG (GNUNET_ERROR_TYPE_ERROR,
_("Specified value for `%s' of service `%s' is invalid\n"),
- "TOLERANT", sh->service_name);
+ "TOLERANT",
+ sh->service_name);
return GNUNET_SYSERR;
}
}
else
tolerant = GNUNET_NO;
+ lsocks = NULL;
#ifndef MINGW
errno = 0;
- if ((NULL != (nfds = getenv ("LISTEN_FDS"))) &&
- (1 == SSCANF (nfds, "%u", &cnt)) && (cnt > 0) && (cnt < FD_SETSIZE) &&
- (cnt + 4 < FD_SETSIZE))
+ if ( (NULL != (nfds = getenv ("LISTEN_FDS"))) &&
+ (1 == SSCANF (nfds,
+ "%u",
+ &cnt)) &&
+ (cnt > 0) &&
+ (cnt < FD_SETSIZE) &&
+ (cnt + 4 < FD_SETSIZE) )
{
- sh->lsocks =
- GNUNET_malloc (sizeof (struct GNUNET_NETWORK_Handle *) * (cnt + 1));
+ lsocks = GNUNET_new_array (cnt + 1,
+ struct GNUNET_NETWORK_Handle *);
while (0 < cnt--)
{
- flags = fcntl (3 + cnt, F_GETFD);
- if ((flags < 0) || (0 != (flags & FD_CLOEXEC)) ||
- (NULL ==
- (sh->lsocks[cnt] = GNUNET_NETWORK_socket_box_native (3 + cnt))))
+ flags = fcntl (3 + cnt,
+ F_GETFD);
+ if ( (flags < 0) ||
+ (0 != (flags & FD_CLOEXEC)) ||
+ (NULL ==
+ (lsocks[cnt] = GNUNET_NETWORK_socket_box_native (3 + cnt))))
{
LOG (GNUNET_ERROR_TYPE_ERROR,
- _
- ("Could not access pre-bound socket %u, will try to bind myself\n"),
+ _("Could not access pre-bound socket %u, will try to bind myself\n"),
(unsigned int) 3 + cnt);
cnt++;
- while (sh->lsocks[cnt] != NULL)
- GNUNET_break (0 == GNUNET_NETWORK_socket_close (sh->lsocks[cnt++]));
- GNUNET_free (sh->lsocks);
- sh->lsocks = NULL;
+ while (NULL != lsocks[cnt])
+ GNUNET_break (GNUNET_OK ==
+ GNUNET_NETWORK_socket_close (lsocks[cnt++]));
+ GNUNET_free (lsocks);
+ lsocks = NULL;
break;
}
}
unsetenv ("LISTEN_FDS");
}
#else
- if (getenv ("GNUNET_OS_READ_LSOCKS") != NULL)
+ if (NULL != getenv ("GNUNET_OS_READ_LSOCKS"))
{
- receive_sockets_from_parent (sh);
+ lsocks = receive_sockets_from_parent (sh);
putenv ("GNUNET_OS_READ_LSOCKS=");
}
#endif
- if (NULL != sh->lsocks)
+ if (NULL != lsocks)
{
/* listen only on inherited sockets if we have any */
- struct GNUNET_NETWORK_Handle **ls = sh->lsocks;
- for (; NULL != *ls; ls++)
+ struct GNUNET_NETWORK_Handle **ls;
+
+ for (ls = lsocks; NULL != *ls; ls++)
{
struct ServiceListenContext *slc;
slc = GNUNET_new (struct ServiceListenContext);
+ slc->sh = sh;
slc->listen_socket = *ls;
- GNUNET_CONTAINER_DLL_insert (sh->slc_head, sh->slc_tail, slc);
+ GNUNET_CONTAINER_DLL_insert (sh->slc_head,
+ sh->slc_tail,
+ slc);
}
- GNUNET_free_non_null (sh->lsocks);
+ GNUNET_free (lsocks);
}
else
{
socklen_t *addrlens;
int num;
- num = get_server_addresses (sh->service_name, sh->cfg,
- &addrs, &addrlens);
+ num = get_server_addresses (sh->service_name,
+ sh->cfg,
+ &addrs,
+ &addrlens);
if (GNUNET_SYSERR == num)
return GNUNET_SYSERR;
struct ServiceListenContext *slc;
slc = GNUNET_new (struct ServiceListenContext);
- slc->listen_socket = open_listen_socket (addrs[i], addrlens[i]);
- GNUNET_break (NULL != slc->listen_socket);
- GNUNET_CONTAINER_DLL_insert (sh->slc_head, sh->slc_tail, slc);
+ slc->sh = sh;
+ slc->listen_socket = open_listen_socket (addrs[i],
+ addrlens[i]);
+ if (NULL == slc->listen_socket)
+ {
+ GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
+ "bind");
+ GNUNET_free (addrs[i++]);
+ GNUNET_free (slc);
+ continue;
+ }
+ GNUNET_free (addrs[i++]);
+ GNUNET_CONTAINER_DLL_insert (sh->slc_head,
+ sh->slc_tail,
+ slc);
+ }
+ GNUNET_free_non_null (addrlens);
+ GNUNET_free_non_null (addrs);
+ if ( (0 != num) &&
+ (NULL == sh->slc_head) )
+ {
+ /* All attempts to bind failed, hard failure */
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ _("Could not bind to any of the ports I was supposed to, refusing to run!\n"));
+ return GNUNET_SYSERR;
}
}
sh->require_found = tolerant ? GNUNET_NO : GNUNET_YES;
- sh->match_uid =
- GNUNET_CONFIGURATION_get_value_yesno (sh->cfg, sh->service_name,
+ sh->match_uid
+ = GNUNET_CONFIGURATION_get_value_yesno (sh->cfg,
+ sh->service_name,
"UNIX_MATCH_UID");
- sh->match_gid =
- GNUNET_CONFIGURATION_get_value_yesno (sh->cfg, sh->service_name,
+ sh->match_gid
+ = GNUNET_CONFIGURATION_get_value_yesno (sh->cfg,
+ sh->service_name,
"UNIX_MATCH_GID");
- process_acl4 (&sh->v4_denied, sh, "REJECT_FROM");
- process_acl4 (&sh->v4_allowed, sh, "ACCEPT_FROM");
- process_acl6 (&sh->v6_denied, sh, "REJECT_FROM6");
- process_acl6 (&sh->v6_allowed, sh, "ACCEPT_FROM6");
+ process_acl4 (&sh->v4_denied,
+ sh,
+ "REJECT_FROM");
+ process_acl4 (&sh->v4_allowed,
+ sh,
+ "ACCEPT_FROM");
+ process_acl6 (&sh->v6_denied,
+ sh,
+ "REJECT_FROM6");
+ process_acl6 (&sh->v6_allowed,
+ sh,
+ "ACCEPT_FROM6");
+ return GNUNET_OK;
+}
+
+
+/**
+ * Get the name of the user that'll be used
+ * to provide the service.
+ *
+ * @param sh service context
+ * @return value of the 'USERNAME' option
+ */
+static char *
+get_user_name (struct GNUNET_SERVICE_Handle *sh)
+{
+ char *un;
+
+ if (GNUNET_OK !=
+ GNUNET_CONFIGURATION_get_value_filename (sh->cfg,
+ sh->service_name,
+ "USERNAME",
+ &un))
+ return NULL;
+ return un;
+}
+
+
+/**
+ * Set user ID.
+ *
+ * @param sh service context
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
+ */
+static int
+set_user_id (struct GNUNET_SERVICE_Handle *sh)
+{
+ char *user;
+
+ if (NULL == (user = get_user_name (sh)))
+ return GNUNET_OK; /* keep */
+#ifndef MINGW
+ struct passwd *pws;
+ errno = 0;
+ pws = getpwnam (user);
+ if (NULL == pws)
+ {
+ LOG (GNUNET_ERROR_TYPE_ERROR,
+ _("Cannot obtain information about user `%s': %s\n"),
+ user,
+ errno == 0 ? _("No such user") : STRERROR (errno));
+ GNUNET_free (user);
+ return GNUNET_SYSERR;
+ }
+ if ( (0 != setgid (pws->pw_gid)) ||
+ (0 != setegid (pws->pw_gid)) ||
+#if HAVE_INITGROUPS
+ (0 != initgroups (user,
+ pws->pw_gid)) ||
+#endif
+ (0 != setuid (pws->pw_uid)) ||
+ (0 != seteuid (pws->pw_uid)))
+ {
+ if ((0 != setregid (pws->pw_gid,
+ pws->pw_gid)) ||
+ (0 != setreuid (pws->pw_uid,
+ pws->pw_uid)))
+ {
+ LOG (GNUNET_ERROR_TYPE_ERROR,
+ _("Cannot change user/group to `%s': %s\n"),
+ user,
+ STRERROR (errno));
+ GNUNET_free (user);
+ return GNUNET_SYSERR;
+ }
+ }
+#endif
+ GNUNET_free (user);
+ return GNUNET_OK;
+}
+
+
+/**
+ * Get the name of the file where we will
+ * write the PID of the service.
+ *
+ * @param sh service context
+ * @return name of the file for the process ID
+ */
+static char *
+get_pid_file_name (struct GNUNET_SERVICE_Handle *sh)
+{
+ char *pif;
+
+ if (GNUNET_OK !=
+ GNUNET_CONFIGURATION_get_value_filename (sh->cfg,
+ sh->service_name,
+ "PIDFILE",
+ &pif))
+ return NULL;
+ return pif;
+}
+
+
+/**
+ * Delete the PID file that was created by our parent.
+ *
+ * @param sh service context
+ */
+static void
+pid_file_delete (struct GNUNET_SERVICE_Handle *sh)
+{
+ char *pif = get_pid_file_name (sh);
+
+ if (NULL == pif)
+ return; /* no PID file */
+ if (0 != UNLINK (pif))
+ LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING,
+ "unlink",
+ pif);
+ GNUNET_free (pif);
+}
+
+
+/**
+ * Detach from terminal.
+ *
+ * @param sh service context
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
+ */
+static int
+detach_terminal (struct GNUNET_SERVICE_Handle *sh)
+{
+#ifndef MINGW
+ pid_t pid;
+ int nullfd;
+ int filedes[2];
+
+ if (0 != PIPE (filedes))
+ {
+ LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR,
+ "pipe");
+ return GNUNET_SYSERR;
+ }
+ pid = fork ();
+ if (pid < 0)
+ {
+ LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR,
+ "fork");
+ return GNUNET_SYSERR;
+ }
+ if (0 != pid)
+ {
+ /* Parent */
+ char c;
+
+ GNUNET_break (0 == CLOSE (filedes[1]));
+ c = 'X';
+ if (1 != READ (filedes[0],
+ &c,
+ sizeof (char)))
+ LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING,
+ "read");
+ fflush (stdout);
+ switch (c)
+ {
+ case '.':
+ exit (0);
+ case 'I':
+ LOG (GNUNET_ERROR_TYPE_INFO,
+ _("Service process failed to initialize\n"));
+ break;
+ case 'S':
+ LOG (GNUNET_ERROR_TYPE_INFO,
+ _("Service process could not initialize server function\n"));
+ break;
+ case 'X':
+ LOG (GNUNET_ERROR_TYPE_INFO,
+ _("Service process failed to report status\n"));
+ break;
+ }
+ exit (1); /* child reported error */
+ }
+ GNUNET_break (0 == CLOSE (0));
+ GNUNET_break (0 == CLOSE (1));
+ GNUNET_break (0 == CLOSE (filedes[0]));
+ nullfd = OPEN ("/dev/null",
+ O_RDWR | O_APPEND);
+ if (nullfd < 0)
+ return GNUNET_SYSERR;
+ /* set stdin/stdout to /dev/null */
+ if ( (dup2 (nullfd, 0) < 0) ||
+ (dup2 (nullfd, 1) < 0) )
+ {
+ LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR,
+ "dup2");
+ (void) CLOSE (nullfd);
+ return GNUNET_SYSERR;
+ }
+ (void) CLOSE (nullfd);
+ /* Detach from controlling terminal */
+ pid = setsid ();
+ if (-1 == pid)
+ LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR,
+ "setsid");
+ sh->ready_confirm_fd = filedes[1];
+#else
+ /* FIXME: we probably need to do something else
+ * elsewhere in order to fork the process itself... */
+ FreeConsole ();
+#endif
return GNUNET_OK;
}
+/**
+ * Tear down the service, closing the listen sockets and
+ * freeing the ACLs.
+ *
+ * @param sh handle to the service to tear down.
+ */
+static void
+teardown_service (struct GNUNET_SERVICE_Handle *sh)
+{
+ struct ServiceListenContext *slc;
+
+ GNUNET_free_non_null (sh->v4_denied);
+ GNUNET_free_non_null (sh->v6_denied);
+ GNUNET_free_non_null (sh->v4_allowed);
+ GNUNET_free_non_null (sh->v6_allowed);
+ while (NULL != (slc = sh->slc_head))
+ {
+ GNUNET_CONTAINER_DLL_remove (sh->slc_head,
+ sh->slc_tail,
+ slc);
+ if (NULL != slc->listen_task)
+ GNUNET_SCHEDULER_cancel (slc->listen_task);
+ GNUNET_break (GNUNET_OK ==
+ GNUNET_NETWORK_socket_close (slc->listen_socket));
+ GNUNET_free (slc);
+ }
+}
+
+
+/**
+ * Low-level function to start a service if the scheduler
+ * is already running. Should only be used directly in
+ * special cases.
+ *
+ * The function will launch the service with the name @a service_name
+ * using the @a service_options to configure its shutdown
+ * behavior. When clients connect or disconnect, the respective
+ * @a connect_cb or @a disconnect_cb functions will be called. For
+ * messages received from the clients, the respective @a handlers will
+ * be invoked; for the closure of the handlers we use the return value
+ * from the @a connect_cb invocation of the respective client.
+ *
+ * Each handler MUST call #GNUNET_SERVICE_client_continue() after each
+ * message to receive further messages from this client. If
+ * #GNUNET_SERVICE_client_continue() is not called within a short
+ * time, a warning will be logged. If delays are expected, services
+ * should call #GNUNET_SERVICE_client_disable_continue_warning() to
+ * disable the warning.
+ *
+ * Clients sending invalid messages (based on @a handlers) will be
+ * dropped. Additionally, clients can be dropped at any time using
+ * #GNUNET_SERVICE_client_drop().
+ *
+ * The service must be stopped using #GNUNET_SERVICE_stoP().
+ *
+ * @param service_name name of the service to run
+ * @param cfg configuration to use
+ * @param connect_cb function to call whenever a client connects
+ * @param disconnect_cb function to call whenever a client disconnects
+ * @param cls closure argument for @a connect_cb and @a disconnect_cb
+ * @param handlers NULL-terminated array of message handlers for the service,
+ * the closure will be set to the value returned by
+ * the @a connect_cb for the respective connection
+ * @return NULL on error
+ */
+struct GNUNET_SERVICE_Handle *
+GNUNET_SERVICE_starT (const char *service_name,
+ const struct GNUNET_CONFIGURATION_Handle *cfg,
+ GNUNET_SERVICE_ConnectHandler connect_cb,
+ GNUNET_SERVICE_DisconnectHandler disconnect_cb,
+ void *cls,
+ const struct GNUNET_MQ_MessageHandler *handlers)
+{
+ struct GNUNET_SERVICE_Handle *sh;
+
+ sh = GNUNET_new (struct GNUNET_SERVICE_Handle);
+ sh->service_name = service_name;
+ sh->cfg = cfg;
+ sh->connect_cb = connect_cb;
+ sh->disconnect_cb = disconnect_cb;
+ sh->cb_cls = cls;
+ if (NULL != handlers)
+ {
+ unsigned int i;
+
+ for (i=0;NULL != handlers[i].cb; i++) ;
+ sh->handlers = GNUNET_new_array (i + 1,
+ struct GNUNET_MQ_MessageHandler);
+ GNUNET_memcpy (sh->handlers,
+ handlers,
+ i * sizeof (struct GNUNET_MQ_MessageHandler));
+ }
+ if (GNUNET_OK != setup_service (sh))
+ {
+ GNUNET_free (sh->handlers);
+ GNUNET_free (sh);
+ return NULL;
+ }
+ GNUNET_SERVICE_resume (sh);
+ return sh;
+}
+
+
+/**
+ * Stops a service that was started with #GNUNET_SERVICE_starT().
+ *
+ * @param srv service to stop
+ */
+void
+GNUNET_SERVICE_stoP (struct GNUNET_SERVICE_Handle *srv)
+{
+ struct GNUNET_SERVICE_Client *client;
+
+ GNUNET_SERVICE_suspend (srv);
+ while (NULL != (client = srv->clients_head))
+ GNUNET_SERVICE_client_drop (client);
+ teardown_service (srv);
+ GNUNET_free (srv->handlers);
+ GNUNET_free (srv);
+}
+
+
/**
* Creates the "main" function for a GNUnet service. You
* should almost always use the #GNUNET_SERVICE_MAIN macro
const char *xdg;
char *logfile;
int do_daemonize;
- unsigned int i;
unsigned long long skew_offset;
unsigned long long skew_variance;
long long clock_offset;
GNUNET_GETOPT_OPTION_END
};
+ memset (&sh,
+ 0,
+ sizeof (sh));
xdg = getenv ("XDG_CONFIG_HOME");
if (NULL != xdg)
GNUNET_asprintf (&cfg_filename,
GNUNET_OS_project_data_get ()->config_file);
else
cfg_filename = GNUNET_strdup (GNUNET_OS_project_data_get ()->user_config_file);
-
+ sh.ready_confirm_fd = -1;
sh.options = options;
sh.cfg = cfg = GNUNET_CONFIGURATION_create ();
sh.service_init_cb = service_init_cb;
sh.connect_cb = connect_cb;
sh.disconnect_cb = disconnect_cb;
sh.cb_cls = cls;
- sh.handlers = handlers;
+ if (NULL != handlers)
+ {
+ unsigned int i;
+
+ for (i=0;NULL != handlers[i].cb; i++) ;
+ sh.handlers = GNUNET_new_array (i + 1,
+ struct GNUNET_MQ_MessageHandler);
+ GNUNET_memcpy (sh.handlers,
+ handlers,
+ i * sizeof (struct GNUNET_MQ_MessageHandler));
+ }
+ sh.service_name = service_name;
/* setup subsystems */
- ret = GNUNET_GETOPT_run (service_name, service_options, argc, argv);
+ loglev = NULL;
+ logfile = NULL;
+ opt_cfg_filename = NULL;
+ do_daemonize = 0;
+ ret = GNUNET_GETOPT_run (service_name,
+ service_options,
+ argc,
+ argv);
if (GNUNET_SYSERR == ret)
goto shutdown;
if (GNUNET_NO == ret)
err = 0;
goto shutdown;
}
- if (GNUNET_OK != GNUNET_log_setup (service_name, loglev, logfile))
+ if (GNUNET_OK != GNUNET_log_setup (service_name,
+ loglev,
+ logfile))
{
GNUNET_break (0);
goto shutdown;
opt_cfg_filename = GNUNET_strdup (cfg_filename);
if (GNUNET_YES == GNUNET_DISK_file_test (opt_cfg_filename))
{
- if (GNUNET_SYSERR == GNUNET_CONFIGURATION_load (cfg, opt_cfg_filename))
+ if (GNUNET_SYSERR == GNUNET_CONFIGURATION_load (cfg,
+ opt_cfg_filename))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Malformed configuration file `%s', exit ...\n"),
}
else
{
- if (GNUNET_SYSERR == GNUNET_CONFIGURATION_load (cfg, NULL))
+ if (GNUNET_SYSERR == GNUNET_CONFIGURATION_load (cfg,
+ NULL))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Malformed configuration, exit ...\n"));
goto shutdown;
}
- if (0 != strcmp (opt_cfg_filename, cfg_filename))
+ if (0 != strcmp (opt_cfg_filename,
+ cfg_filename))
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Could not access configuration file `%s'\n"),
opt_cfg_filename);
}
if (GNUNET_OK != setup_service (&sh))
goto shutdown;
- if ((1 == do_daemonize) && (GNUNET_OK != detach_terminal (&sh)))
+ if ( (1 == do_daemonize) &&
+ (GNUNET_OK != detach_terminal (&sh)) )
{
GNUNET_break (0);
goto shutdown;
service_name,
opt_cfg_filename);
if ((GNUNET_OK ==
- GNUNET_CONFIGURATION_get_value_number (sh.cfg, "TESTING",
- "SKEW_OFFSET", &skew_offset)) &&
+ GNUNET_CONFIGURATION_get_value_number (sh.cfg,
+ "TESTING",
+ "SKEW_OFFSET",
+ &skew_offset)) &&
(GNUNET_OK ==
- GNUNET_CONFIGURATION_get_value_number (sh.cfg, "TESTING",
- "SKEW_VARIANCE", &skew_variance)))
+ GNUNET_CONFIGURATION_get_value_number (sh.cfg,
+ "TESTING",
+ "SKEW_VARIANCE",
+ &skew_variance)))
{
clock_offset = skew_offset - skew_variance;
GNUNET_TIME_set_offset (clock_offset);
- LOG (GNUNET_ERROR_TYPE_DEBUG, "Skewing clock by %dll ms\n", clock_offset);
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Skewing clock by %dll ms\n",
+ clock_offset);
}
+ GNUNET_RESOLVER_connect (sh.cfg);
+
/* actually run service */
err = 0;
- GNUNET_SCHEDULER_run (&service_main, &sh);
+ GNUNET_SCHEDULER_run (&service_main,
+ &sh);
/* shutdown */
if (1 == do_daemonize)
pid_file_delete (&sh);
shutdown:
if (-1 != sh.ready_confirm_fd)
{
- if (1 != WRITE (sh.ready_confirm_fd, err ? "I" : "S", 1))
- LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "write");
+ if (1 != WRITE (sh.ready_confirm_fd,
+ err ? "I" : "S",
+ 1))
+ LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING,
+ "write");
GNUNET_break (0 == CLOSE (sh.ready_confirm_fd));
}
#if HAVE_MALLINFO
char *counter;
if ( (GNUNET_YES ==
- GNUNET_CONFIGURATION_have_value (sh.cfg, service_name,
+ GNUNET_CONFIGURATION_have_value (sh.cfg,
+ service_name,
"GAUGER_HEAP")) &&
(GNUNET_OK ==
- GNUNET_CONFIGURATION_get_value_string (sh.cfg, service_name,
+ GNUNET_CONFIGURATION_get_value_string (sh.cfg,
+ service_name,
"GAUGER_HEAP",
&counter)) )
{
struct mallinfo mi;
mi = mallinfo ();
- GAUGER (service_name, counter, mi.usmblks, "blocks");
+ GAUGER (service_name,
+ counter,
+ mi.usmblks,
+ "blocks");
GNUNET_free (counter);
}
}
#endif
+ teardown_service (&sh);
+ GNUNET_free (sh.handlers);
GNUNET_SPEEDUP_stop_ ();
GNUNET_CONFIGURATION_destroy (cfg);
-
- while (NULL != sh.slc_head)
- {
- struct ServiceListenContext *slc = sh.slc_head;
- sh.slc_head = slc->next;
- // FIXME: destroy slc
- GNUNET_free (slc);
- }
-
GNUNET_free_non_null (logfile);
GNUNET_free_non_null (loglev);
GNUNET_free (cfg_filename);
GNUNET_free_non_null (opt_cfg_filename);
- GNUNET_free_non_null (sh.v4_denied);
- GNUNET_free_non_null (sh.v6_denied);
- GNUNET_free_non_null (sh.v4_allowed);
- GNUNET_free_non_null (sh.v6_allowed);
return err ? GNUNET_SYSERR : sh.ret;
}
for (slc = sh->slc_head; NULL != slc; slc = slc->next)
{
if (NULL != slc->listen_task)
- {
- GNUNET_SCHEDULER_cancel (slc->listen_task);
- slc->listen_task = NULL;
- }
+ {
+ GNUNET_SCHEDULER_cancel (slc->listen_task);
+ slc->listen_task = NULL;
+ }
+ }
+}
+
+
+/**
+ * Task run when we are ready to transmit data to the
+ * client.
+ *
+ * @param cls the `struct GNUNET_SERVICE_Client *` to send to
+ */
+static void
+do_send (void *cls)
+{
+ struct GNUNET_SERVICE_Client *client = cls;
+ ssize_t ret;
+ size_t left;
+ const char *buf;
+
+ client->send_task = NULL;
+ buf = (const char *) client->msg;
+ left = ntohs (client->msg->size) - client->msg_pos;
+ ret = GNUNET_NETWORK_socket_send (client->sock,
+ &buf[client->msg_pos],
+ left);
+ GNUNET_assert (ret <= (ssize_t) left);
+ if (0 == ret)
+ {
+ GNUNET_MQ_inject_error (client->mq,
+ GNUNET_MQ_ERROR_WRITE);
+ return;
+ }
+ if (-1 == ret)
+ {
+ if ( (EAGAIN == errno) ||
+ (EINTR == errno) )
+ {
+ /* ignore */
+ ret = 0;
+ }
+ else
+ {
+ if (EPIPE != errno)
+ GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING,
+ "send");
+ GNUNET_MQ_inject_error (client->mq,
+ GNUNET_MQ_ERROR_WRITE);
+ return;
+ }
+ }
+ client->msg_pos += ret;
+ if (left > ret)
+ {
+ client->send_task
+ = GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL,
+ client->sock,
+ &do_send,
+ client);
+ return;
}
+ GNUNET_MQ_impl_send_continue (client->mq);
}
*
* @param mq the message queue
* @param msg the message to send
- * @param impl_state state of the implementation
+ * @param impl_state our `struct GNUNET_SERVICE_Client *`
*/
static void
service_mq_send (struct GNUNET_MQ_Handle *mq,
const struct GNUNET_MessageHeader *msg,
void *impl_state)
{
- // struct GNUNET_SERVICE_Client *client = cls;
-
- // FIXME 1: setup "client->send_task" for transmission.
- // FIXME 2: I seriously hope we do not need to make a copy of `msg`!
- // OPTIMIZATION: ideally, we'd like the ability to peak at the rest of
- // the queue and transmit more than one message if possible.
+ struct GNUNET_SERVICE_Client *client = impl_state;
+
+ GNUNET_assert (NULL == client->send_task);
+ client->msg = msg;
+ client->msg_pos = 0;
+ client->send_task
+ = GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL,
+ client->sock,
+ &do_send,
+ client);
}
service_mq_cancel (struct GNUNET_MQ_Handle *mq,
void *impl_state)
{
- // struct GNUNET_SERVICE_Client *client = cls;
+ struct GNUNET_SERVICE_Client *client = impl_state;
+ GNUNET_assert (0); // not implemented
// FIXME: stop transmission! (must be possible, otherwise
// we must have told MQ that the message was sent!)
}
* the message queue.
* Not every message queue implementation supports an error handler.
*
- * @param cls closure
+ * @param cls closure with our `struct GNUNET_SERVICE_Client`
* @param error error code
*/
static void
enum GNUNET_MQ_Error error)
{
struct GNUNET_SERVICE_Client *client = cls;
+ struct GNUNET_SERVICE_Handle *sh = client->sh;
- // FIXME!
+ if ( (GNUNET_MQ_ERROR_NO_MATCH == error) &&
+ (GNUNET_NO == sh->require_found) )
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "No handler for message of type %u found\n",
+ (unsigned int) client->warn_type);
+ GNUNET_SERVICE_client_continue (client);
+ return; /* ignore error */
+ }
+ GNUNET_SERVICE_client_drop (client);
+}
+
+
+/**
+ * Task run to warn about missing calls to #GNUNET_SERVICE_client_continue().
+ *
+ * @param cls our `struct GNUNET_SERVICE_Client *` to process more requests from
+ */
+static void
+warn_no_client_continue (void *cls)
+{
+ struct GNUNET_SERVICE_Client *client = cls;
+
+ GNUNET_break (0 != client->warn_type); /* type should never be 0 here, as we don't use 0 */
+ client->warn_task
+ = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES,
+ &warn_no_client_continue,
+ client);
+ LOG (GNUNET_ERROR_TYPE_WARNING,
+ _("Processing code for message of type %u did not call `GNUNET_SERVICE_client_continue' after %s\n"),
+ (unsigned int) client->warn_type,
+ GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (client->warn_start),
+ GNUNET_YES));
}
* Functions with this signature are called whenever a
* complete message is received by the tokenizer for a client.
*
- * Do not call #GNUNET_SERVER_mst_destroy() from within
+ * Do not call #GNUNET_MST_destroy() from within
* the scope of this callback.
*
* @param cls closure with the `struct GNUNET_SERVICE_Client *`
- * @param client_cls closure with the `struct GNUNET_SERVICE_Client *`
* @param message the actual message
- * @return #GNUNET_OK on success (always)
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR if the client was dropped
*/
static int
service_client_mst_cb (void *cls,
- void *client_cls,
const struct GNUNET_MessageHeader *message)
{
struct GNUNET_SERVICE_Client *client = cls;
+ GNUNET_assert (GNUNET_NO == client->needs_continue);
+ client->needs_continue = GNUNET_YES;
+ client->warn_type = ntohs (message->type);
+ client->warn_start = GNUNET_TIME_absolute_get ();
+ GNUNET_assert (NULL == client->warn_task);
+ client->warn_task
+ = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES,
+ &warn_no_client_continue,
+ client);
GNUNET_MQ_inject_message (client->mq,
message);
+ if (NULL != client->drop_task)
+ return GNUNET_SYSERR;
return GNUNET_OK;
}
service_client_recv (void *cls)
{
struct GNUNET_SERVICE_Client *client = cls;
+ int ret;
- // FIXME: read into buffer, pass to MST, then client->mq inject!
- // FIXME: revise MST API to avoid the memcpy!
- // i.e.: GNUNET_MST_read (client->sock);
+ client->recv_task = NULL;
+ ret = GNUNET_MST_read (client->mst,
+ client->sock,
+ GNUNET_NO,
+ GNUNET_YES);
+ if (GNUNET_SYSERR == ret)
+ {
+ /* client closed connection (or IO error) */
+ if (NULL == client->drop_task)
+ {
+ GNUNET_assert (GNUNET_NO == client->needs_continue);
+ GNUNET_SERVICE_client_drop (client);
+ }
+ return;
+ }
+ if (GNUNET_NO == ret)
+ return; /* more messages in buffer, wait for application
+ to be done processing */
+ GNUNET_assert (GNUNET_OK == ret);
+ if (GNUNET_YES == client->needs_continue)
+ return;
+ if (NULL != client->recv_task)
+ return;
+ /* MST needs more data, re-schedule read job */
+ client->recv_task
+ = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
+ client->sock,
+ &service_client_recv,
+ client);
}
sh->handlers,
&service_mq_error_handler,
client);
- client->mst = GNUNET_SERVER_mst_create (&service_client_mst_cb,
- client);
+ client->mst = GNUNET_MST_create (&service_client_mst_cb,
+ client);
client->user_context = sh->connect_cb (sh->cb_cls,
client,
client->mq);
GNUNET_MQ_set_handlers_closure (client->mq,
client->user_context);
- client->recv_task = GNUNET_SCHEDULER_add_read (client->sock,
- &service_client_recv,
- client);
+ client->recv_task
+ = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
+ client->sock,
+ &service_client_recv,
+ client);
+}
+
+
+/**
+ * Check if the given IP address is in the list of IP addresses.
+ *
+ * @param list a list of networks
+ * @param add the IP to check (in network byte order)
+ * @return #GNUNET_NO if the IP is not in the list, #GNUNET_YES if it it is
+ */
+static int
+check_ipv4_listed (const struct GNUNET_STRINGS_IPv4NetworkPolicy *list,
+ const struct in_addr *add)
+{
+ unsigned int i;
+
+ if (NULL == list)
+ return GNUNET_NO;
+ i = 0;
+ while ( (0 != list[i].network.s_addr) ||
+ (0 != list[i].netmask.s_addr) )
+ {
+ if ((add->s_addr & list[i].netmask.s_addr) ==
+ (list[i].network.s_addr & list[i].netmask.s_addr))
+ return GNUNET_YES;
+ i++;
+ }
+ return GNUNET_NO;
+}
+
+
+/**
+ * Check if the given IP address is in the list of IP addresses.
+ *
+ * @param list a list of networks
+ * @param ip the IP to check (in network byte order)
+ * @return #GNUNET_NO if the IP is not in the list, #GNUNET_YES if it it is
+ */
+static int
+check_ipv6_listed (const struct GNUNET_STRINGS_IPv6NetworkPolicy *list,
+ const struct in6_addr *ip)
+{
+ unsigned int i;
+ unsigned int j;
+ struct in6_addr zero;
+
+ if (NULL == list)
+ return GNUNET_NO;
+ memset (&zero,
+ 0,
+ sizeof (struct in6_addr));
+ i = 0;
+NEXT:
+ while (0 != memcmp (&zero,
+ &list[i].network,
+ sizeof (struct in6_addr)))
+ {
+ for (j = 0; j < sizeof (struct in6_addr) / sizeof (int); j++)
+ if (((((int *) ip)[j] & ((int *) &list[i].netmask)[j])) !=
+ (((int *) &list[i].network)[j] & ((int *) &list[i].netmask)[j]))
+ {
+ i++;
+ goto NEXT;
+ }
+ return GNUNET_YES;
+ }
+ return GNUNET_NO;
}
slc->listen_task = NULL;
while (1)
+ {
+ struct GNUNET_NETWORK_Handle *sock;
+ const struct sockaddr_in *v4;
+ const struct sockaddr_in6 *v6;
+ struct sockaddr_storage sa;
+ socklen_t addrlen;
+ int ok;
+
+ addrlen = sizeof (sa);
+ sock = GNUNET_NETWORK_socket_accept (slc->listen_socket,
+ (struct sockaddr *) &sa,
+ &addrlen);
+ if (NULL == sock)
+ break;
+ switch (sa.ss_family)
{
- struct GNUNET_NETWORK_Handle *sock;
- struct sockaddr_in *v4;
- struct sockaddr_in6 *v6;
- struct sockaddr_storage sa;
- socklen_t addrlen;
- int ok;
-
- addrlen = sizeof (sa);
- sock = GNUNET_NETWORK_socket_accept (slc->listen_socket,
- (struct sockaddr *) &sa,
- &addrlen);
- if (NULL == sock)
- break;
- switch (sa.ss_family)
- {
- case AF_INET:
- GNUNET_assert (addrlen == sizeof (struct sockaddr_in));
- v4 = (const struct sockaddr_in *) &sa;
- ok = ( ( (NULL == sh->v4_allowed) ||
- (check_ipv4_listed (sh->v4_allowed,
- &v4->sin_addr))) &&
- ( (NULL == sh->v4_denied) ||
- (! check_ipv4_listed (sh->v4_denied,
- &v4->sin_addr)) ) );
- break;
- case AF_INET6:
- GNUNET_assert (addrlen == sizeof (struct sockaddr_in6));
- v6 = (const struct sockaddr_in6 *) &sa;
- ok = ( ( (NULL == sh->v6_allowed) ||
- (check_ipv6_listed (sh->v6_allowed,
- &v6->sin6_addr))) &&
- ( (NULL == sh->v6_denied) ||
- (! check_ipv6_listed (sh->v6_denied,
- &v6->sin6_addr)) ) );
- break;
+ case AF_INET:
+ GNUNET_assert (addrlen == sizeof (struct sockaddr_in));
+ v4 = (const struct sockaddr_in *) &sa;
+ ok = ( ( (NULL == sh->v4_allowed) ||
+ (check_ipv4_listed (sh->v4_allowed,
+ &v4->sin_addr))) &&
+ ( (NULL == sh->v4_denied) ||
+ (! check_ipv4_listed (sh->v4_denied,
+ &v4->sin_addr)) ) );
+ break;
+ case AF_INET6:
+ GNUNET_assert (addrlen == sizeof (struct sockaddr_in6));
+ v6 = (const struct sockaddr_in6 *) &sa;
+ ok = ( ( (NULL == sh->v6_allowed) ||
+ (check_ipv6_listed (sh->v6_allowed,
+ &v6->sin6_addr))) &&
+ ( (NULL == sh->v6_denied) ||
+ (! check_ipv6_listed (sh->v6_denied,
+ &v6->sin6_addr)) ) );
+ break;
#ifndef WINDOWS
- case AF_UNIX:
- ok = GNUNET_OK; /* controlled using file-system ACL now */
- break;
+ case AF_UNIX:
+ ok = GNUNET_OK; /* controlled using file-system ACL now */
+ break;
#endif
- default:
- LOG (GNUNET_ERROR_TYPE_WARNING,
- _("Unknown address family %d\n"),
- sa.ss_family);
- return GNUNET_SYSERR;
- }
- if (! ok)
- {
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Service rejected incoming connection from %s due to policy.\n",
- GNUNET_a2s ((const struct sockaddr *) &sa,
- addrlen));
- GNUNET_NETWORK_socket_close (sock);
- continue;
- }
+ default:
+ LOG (GNUNET_ERROR_TYPE_WARNING,
+ _("Unknown address family %d\n"),
+ sa.ss_family);
+ return;
+ }
+ if (! ok)
+ {
LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Service accepted incoming connection from %s.\n",
- GNUNET_a2s ((const struct sockaddr *) &sa,
- addrlen));
- start_client (slc->sh,
- sock);
+ "Service rejected incoming connection from %s due to policy.\n",
+ GNUNET_a2s ((const struct sockaddr *) &sa,
+ addrlen));
+ GNUNET_break (GNUNET_OK ==
+ GNUNET_NETWORK_socket_close (sock));
+ continue;
}
- slc->listen_task = GNUNET_SCHEDULER_add_read (slc->listen_socket,
- &accept_client,
- slc);
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Service accepted incoming connection from %s.\n",
+ GNUNET_a2s ((const struct sockaddr *) &sa,
+ addrlen));
+ start_client (slc->sh,
+ sock);
+ }
+ slc->listen_task
+ = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
+ slc->listen_socket,
+ &accept_client,
+ slc);
}
for (slc = sh->slc_head; NULL != slc; slc = slc->next)
{
GNUNET_assert (NULL == slc->listen_task);
- slc->listen_task = GNUNET_SCHEDULER_add_read (slc->listen_socket,
- &accept_client,
- slc);
+ slc->listen_task
+ = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
+ slc->listen_socket,
+ &accept_client,
+ slc);
}
}
+/**
+ * Task run to resume receiving data from the client after
+ * the client called #GNUNET_SERVICE_client_continue().
+ *
+ * @param cls our `struct GNUNET_SERVICE_Client`
+ */
+static void
+resume_client_receive (void *cls)
+{
+ struct GNUNET_SERVICE_Client *c = cls;
+ int ret;
+
+ c->recv_task = NULL;
+ /* first, check if there is still something in the buffer */
+ ret = GNUNET_MST_next (c->mst,
+ GNUNET_YES);
+ if (GNUNET_SYSERR == ret)
+ {
+ GNUNET_break (0);
+ GNUNET_SERVICE_client_drop (c);
+ return;
+ }
+ if (GNUNET_NO == ret)
+ return; /* done processing, wait for more later */
+ GNUNET_assert (GNUNET_OK == ret);
+ if (GNUNET_YES == c->needs_continue)
+ return; /* #GNUNET_MST_next() did give a message to the client */
+ /* need to receive more data from the network first */
+ if (NULL != c->recv_task)
+ return;
+ c->recv_task
+ = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
+ c->sock,
+ &service_client_recv,
+ c);
+}
+
+
/**
* Continue receiving further messages from the given client.
* Must be called after each message received.
void
GNUNET_SERVICE_client_continue (struct GNUNET_SERVICE_Client *c)
{
- GNUNET_break (0); // not implemented
+ GNUNET_assert (GNUNET_YES == c->needs_continue);
+ GNUNET_assert (NULL == c->recv_task);
+ c->needs_continue = GNUNET_NO;
+ if (NULL != c->warn_task)
+ {
+ GNUNET_SCHEDULER_cancel (c->warn_task);
+ c->warn_task = NULL;
+ }
+ c->recv_task
+ = GNUNET_SCHEDULER_add_now (&resume_client_receive,
+ c);
}
}
+/**
+ * Asynchronously finish dropping the client.
+ *
+ * @param cls the `struct GNUNET_SERVICE_Client`.
+ */
+static void
+finish_client_drop (void *cls)
+{
+ struct GNUNET_SERVICE_Client *c = cls;
+ struct GNUNET_SERVICE_Handle *sh = c->sh;
+
+ GNUNET_MST_destroy (c->mst);
+ GNUNET_MQ_destroy (c->mq);
+ if (GNUNET_NO == c->persist)
+ {
+ GNUNET_break (GNUNET_OK ==
+ GNUNET_NETWORK_socket_close (c->sock));
+ }
+ else
+ {
+ GNUNET_NETWORK_socket_free_memory_only_ (c->sock);
+ }
+ GNUNET_free (c);
+ if ( (GNUNET_YES == sh->got_shutdown) &&
+ (GNUNET_NO == have_non_monitor_clients (sh)) )
+ GNUNET_SERVICE_shutdown (sh);
+}
+
+
/**
* Ask the server to disconnect from the given client. This is the
* same as returning #GNUNET_SYSERR within the check procedure when
{
struct GNUNET_SERVICE_Handle *sh = c->sh;
+ if (NULL != c->drop_task)
+ {
+ /* asked to drop twice! */
+ GNUNET_break (0);
+ return;
+ }
GNUNET_CONTAINER_DLL_remove (sh->clients_head,
sh->clients_tail,
c);
GNUNET_SCHEDULER_cancel (c->send_task);
c->send_task = NULL;
}
- GNUNET_SERVER_mst_destroy (c->mst);
- GNUNET_MQ_destroy (c->mq);
- if (GNUNET_NO == c->persist)
- {
- GNUNET_NETWORK_socket_close (c->sock);
- }
- else
- {
- GNUNET_NETWORK_socket_free_memory_only_ (c->sock);
- }
- GNUNET_free (c);
- if ( (GNUNET_YES == sh->got_shutdown) &&
- (GNUNET_NO == have_non_monitor_clients (sh)) )
- GNUNET_SERVICE_shutdown (sh);
+ c->drop_task = GNUNET_SCHEDULER_add_now (&finish_client_drop,
+ c);
}
}
+/**
+ * Obtain the message queue of @a c. Convenience function.
+ *
+ * @param c the client to continue receiving from
+ * @return the message queue of @a c
+ */
+struct GNUNET_MQ_Handle *
+GNUNET_SERVICE_client_get_mq (struct GNUNET_SERVICE_Client *c)
+{
+ return c->mq;
+}
+
+
/* end of service_new.c */