/*
This file is part of GNUnet.
- Copyright (C) 2009-2013 Christian Grothoff (and other contributing authors)
+ Copyright (C) 2009-2013 GNUnet e.V.
GNUnet is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published
You should have received a copy of the GNU General Public License
along with GNUnet; see the file COPYING. If not, write to the
- Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA.
+ Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
*/
/**
*
* @param cls handle to our server for which we are processing the listen
* socket
- * @param tc reason why we are running right now
*/
static void
-process_listen_socket (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc)
+process_listen_socket (void *cls)
{
struct GNUNET_SERVER_Handle *server = cls;
+ const struct GNUNET_SCHEDULER_TaskContext *tc;
struct GNUNET_CONNECTION_Handle *sock;
- struct GNUNET_SERVER_Client *client;
unsigned int i;
server->listen_task = NULL;
- if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
- {
- /* ignore shutdown, someone else will take care of it! */
- GNUNET_SERVER_resume (server);
- return;
- }
- i = 0;
- while (NULL != server->listen_sockets[i])
+ tc = GNUNET_SCHEDULER_get_task_context ();
+ for (i = 0; NULL != server->listen_sockets[i]; i++)
{
- if (GNUNET_NETWORK_fdset_isset (tc->read_ready, server->listen_sockets[i]))
+ if (GNUNET_NETWORK_fdset_isset (tc->read_ready,
+ server->listen_sockets[i]))
{
sock =
GNUNET_CONNECTION_create_from_accept (server->access_cb,
{
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Server accepted incoming connection.\n");
- client = GNUNET_SERVER_connect_socket (server, sock);
- /* decrement reference count, we don't keep "client" alive */
- GNUNET_SERVER_client_drop (client);
+ (void) GNUNET_SERVER_connect_socket (server,
+ sock);
}
}
- i++;
}
/* listen for more! */
GNUNET_SERVER_resume (server);
* @return NULL on error, otherwise the listen socket
*/
static struct GNUNET_NETWORK_Handle *
-open_listen_socket (const struct sockaddr *server_addr, socklen_t socklen)
+open_listen_socket (const struct sockaddr *server_addr,
+ socklen_t socklen)
{
struct GNUNET_NETWORK_Handle *sock;
uint16_t port;
* Helper function for #test_monitor_clients() to trigger
* #GNUNET_SERVER_destroy() after the stack has unwound.
*
- * @param cls the 'struct GNUNET_SERVER_Handle' to destroy
- * @param tc unused
+ * @param cls the `struct GNUNET_SERVER_Handle *` to destroy
*/
static void
-do_destroy (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc)
+do_destroy (void *cls)
{
struct GNUNET_SERVER_Handle *server = cls;
if (GNUNET_NO == client->is_monitor)
return; /* not done yet */
server->in_soft_shutdown = GNUNET_SYSERR;
- GNUNET_SCHEDULER_add_now (&do_destroy, server);
+ (void) GNUNET_SCHEDULER_add_now (&do_destroy, server);
}
return; /* nothing to do, no listen sockets! */
if (NULL == server->listen_sockets[1])
{
- /* simplified method: no fd set needed; this is then much simpler and
- much more efficient */
+ /* simplified method: no fd set needed; this is then much simpler
+ and much more efficient */
server->listen_task =
GNUNET_SCHEDULER_add_read_net_with_priority (GNUNET_TIME_UNIT_FOREVER_REL,
GNUNET_SCHEDULER_PRIORITY_HIGH,
}
while (NULL != (npos = server->disconnect_notify_list_head))
{
- npos->callback (npos->callback_cls, NULL);
+ npos->callback (npos->callback_cls,
+ NULL);
GNUNET_CONTAINER_DLL_remove (server->disconnect_notify_list_head,
server->disconnect_notify_list_tail,
npos);
}
while (NULL != (npos = server->connect_notify_list_head))
{
- npos->callback (npos->callback_cls, NULL);
+ npos->callback (npos->callback_cls,
+ NULL);
GNUNET_CONTAINER_DLL_remove (server->connect_notify_list_head,
server->connect_notify_list_tail,
npos);
* Task run to warn about missing calls to #GNUNET_SERVER_receive_done.
*
* @param cls our `struct GNUNET_SERVER_Client *` to process more requests from
- * @param tc scheduler context (unused)
*/
static void
-warn_no_receive_done (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc)
+warn_no_receive_done (void *cls)
{
struct GNUNET_SERVER_Client *client = cls;
client->warn_task =
GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES,
&warn_no_receive_done, client);
- if (0 == (GNUNET_SCHEDULER_REASON_SHUTDOWN & tc->reason))
- LOG (GNUNET_ERROR_TYPE_WARNING,
- _("Processing code for message of type %u did not call `GNUNET_SERVER_receive_done' after %s\n"),
- (unsigned int) client->warn_type,
- GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (client->warn_start), GNUNET_YES));
+ LOG (GNUNET_ERROR_TYPE_WARNING,
+ _("Processing code for message of type %u did not call `GNUNET_SERVER_receive_done' after %s\n"),
+ (unsigned int) client->warn_type,
+ GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (client->warn_start),
+ GNUNET_YES));
}
sender->warn_start = GNUNET_TIME_absolute_get ();
sender->warn_task =
GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES,
- &warn_no_receive_done, sender);
+ &warn_no_receive_done,
+ sender);
sender->warn_type = type;
}
sender->suspended++;
GNUNET_CONNECTION_receive (client->connection,
GNUNET_SERVER_MAX_MESSAGE_SIZE - 1,
GNUNET_TIME_absolute_get_remaining (end),
- &process_incoming, client);
+ &process_incoming,
+ client);
return;
}
if ( (NULL == buf) ||
* and process requests.
*
* @param cls our `struct GNUNET_SERVER_Client *` to process more requests from
- * @param tc scheduler context (unused)
*/
static void
-restart_processing (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc)
+restart_processing (void *cls)
{
struct GNUNET_SERVER_Client *client = cls;
* received a complete message.
*
* @param cls closure (struct GNUNET_SERVER_Handle)
- * @param client identification of the client (struct GNUNET_SERVER_Client*)
+ * @param client identification of the client (`struct GNUNET_SERVER_Client *`)
* @param message the actual message
*
* @return #GNUNET_OK on success, #GNUNET_SYSERR to stop further processing
*/
static int
-client_message_tokenizer_callback (void *cls, void *client,
+client_message_tokenizer_callback (void *cls,
+ void *client,
const struct GNUNET_MessageHeader *message)
{
struct GNUNET_SERVER_Handle *server = cls;
* @param server the server to use
* @param connection the connection to manage (client must
* stop using this connection from now on)
- * @return the client handle (client should call
- * "client_drop" on the return value eventually)
+ * @return the client handle
*/
struct GNUNET_SERVER_Client *
GNUNET_SERVER_connect_socket (struct GNUNET_SERVER_Handle *server,
client = GNUNET_new (struct GNUNET_SERVER_Client);
client->connection = connection;
- client->reference_count = 1;
client->server = server;
client->last_activity = GNUNET_TIME_absolute_get ();
client->idle_timeout = server->idle_timeout;
void *callback_cls)
{
struct NotifyList *n;
+ struct GNUNET_SERVER_Client *client;
n = GNUNET_new (struct NotifyList);
n->callback = callback;
GNUNET_CONTAINER_DLL_insert (server->connect_notify_list_head,
server->connect_notify_list_tail,
n);
+ for (client = server->clients_head; NULL != client; client = client->next)
+ callback (callback_cls, client);
}
*/
void
GNUNET_SERVER_disconnect_notify_cancel (struct GNUNET_SERVER_Handle *server,
- GNUNET_SERVER_DisconnectCallback
- callback, void *callback_cls)
+ GNUNET_SERVER_DisconnectCallback callback,
+ void *callback_cls)
{
struct NotifyList *pos;
/**
* Destroy the connection that is passed in via @a cls. Used
* as calling #GNUNET_CONNECTION_destroy from within a function
- * that was itself called from within 'process_notify' of
+ * that was itself called from within process_notify() of
* 'connection.c' is not allowed (see #2329).
*
* @param cls connection to destroy
- * @param tc scheduler context (unused)
*/
static void
-destroy_connection (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc)
+destroy_connection (void *cls)
{
struct GNUNET_CONNECTION_Handle *connection = cls;
server->clients_tail,
client);
if (NULL != server->mst_destroy)
- server->mst_destroy (server->mst_cls, client->mst);
+ server->mst_destroy (server->mst_cls,
+ client->mst);
else
GNUNET_SERVER_mst_destroy (client->mst);
client->mst = NULL;
for (n = server->disconnect_notify_list_head; NULL != n; n = n->next)
- n->callback (n->callback_cls, client);
+ n->callback (n->callback_cls,
+ client);
}
client->reference_count--;
if (client->reference_count > 0)
{
LOG (GNUNET_ERROR_TYPE_DEBUG,
- "RC still positive, not destroying everything.\n");
+ "RC of %p still positive, not destroying everything.\n",
+ client);
client->server = NULL;
return;
}
if (GNUNET_YES == client->in_process_client_buffer)
{
LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Still processing inputs, not destroying everything.\n");
+ "Still processing inputs of %p, not destroying everything.\n",
+ client);
return;
}
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "RC of %p now zero, destroying everything.\n",
+ client);
if (GNUNET_YES == client->persist)
GNUNET_CONNECTION_persist_ (client->connection);
if (NULL != client->th.cth)
GNUNET_SERVER_notify_transmit_ready (struct GNUNET_SERVER_Client *client,
size_t size,
struct GNUNET_TIME_Relative timeout,
- GNUNET_CONNECTION_TransmitReadyNotify
- callback, void *callback_cls)
+ GNUNET_CONNECTION_TransmitReadyNotify callback,
+ void *callback_cls)
{
if (NULL != client->th.callback)
return NULL;
LOG (GNUNET_ERROR_TYPE_DEBUG,
"GNUNET_SERVER_receive_done causes restart in reading from the socket\n");
GNUNET_assert (NULL == client->restart_task);
- client->restart_task = GNUNET_SCHEDULER_add_now (&restart_processing, client);
+ client->restart_task = GNUNET_SCHEDULER_add_now (&restart_processing,
+ client);
}