#endif
-#define LOG(kind,...) GNUNET_log_from (kind, "util", __VA_ARGS__)
+#define LOG(kind,...) GNUNET_log_from (kind, "util-service", __VA_ARGS__)
-#define LOG_STRERROR(kind,syscall) GNUNET_log_from_strerror (kind, "util", syscall)
+#define LOG_STRERROR(kind,syscall) GNUNET_log_from_strerror (kind, "util-service", syscall)
-#define LOG_STRERROR_FILE(kind,syscall,filename) GNUNET_log_from_strerror_file (kind, "util", syscall, filename)
+#define LOG_STRERROR_FILE(kind,syscall,filename) GNUNET_log_from_strerror_file (kind, "util-service", syscall, filename)
/**
/**
* Message handlers to use for all clients.
*/
- const struct GNUNET_MQ_MessageHandler *handlers;
+ struct GNUNET_MQ_MessageHandler *handlers;
/**
* Closure for @e task.
*/
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.
* 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
GNUNET_SCHEDULER_add_shutdown (&service_shutdown,
sh);
GNUNET_SERVICE_resume (sh);
- sh->service_init_cb (sh->cb_cls,
- sh->cfg,
- sh);
+
+ if (-1 != sh->ready_confirm_fd)
+ {
+ GNUNET_break (1 == WRITE (sh->ready_confirm_fd, ".", 1));
+ GNUNET_break (0 == CLOSE (sh->ready_confirm_fd));
+ sh->ready_confirm_fd = -1;
+ }
+
+ if (NULL != sh->service_init_cb)
+ sh->service_init_cb (sh->cb_cls,
+ sh->cfg,
+ sh);
}
if (GNUNET_YES == abstract)
un->sun_path[0] = '\0';
#endif
-#if HAVE_SOCKADDR_IN_SIN_LEN
+#if HAVE_SOCKADDR_UN_SUN_LEN
un->sun_len = (u_char) sizeof (struct sockaddr_un);
#endif
*saddrs = (struct sockaddr *) un;
{
/* listen only on inherited sockets if we have any */
struct GNUNET_NETWORK_Handle **ls;
-
+
for (ls = lsocks; NULL != *ls; ls++)
{
struct ServiceListenContext *slc;
slc->sh = sh;
slc->listen_socket = open_listen_socket (addrs[i],
addrlens[i]);
- GNUNET_break (NULL != slc->listen_socket);
+ 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->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->match_gid
+ = GNUNET_CONFIGURATION_get_value_yesno (sh->cfg,
sh->service_name,
"UNIX_MATCH_GID");
process_acl4 (&sh->v4_denied,
}
+/**
+ * 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;
+ sh->handlers = GNUNET_MQ_copy_handlers (handlers);
+ if (GNUNET_OK != setup_service (sh))
+ {
+ GNUNET_free_non_null (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_non_null (srv->handlers);
+ GNUNET_free (srv);
+}
+
+
/**
* Creates the "main" function for a GNUnet service. You
* should almost always use the #GNUNET_SERVICE_MAIN macro
sh.connect_cb = connect_cb;
sh.disconnect_cb = disconnect_cb;
sh.cb_cls = cls;
- sh.handlers = handlers;
+ sh.handlers = GNUNET_MQ_copy_handlers (handlers);
sh.service_name = service_name;
/* setup subsystems */
"Skewing clock by %dll ms\n",
clock_offset);
}
+ GNUNET_RESOLVER_connect (sh.cfg);
+
/* actually run service */
err = 0;
GNUNET_SCHEDULER_run (&service_main,
}
}
#endif
+ teardown_service (&sh);
+ GNUNET_free_non_null (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;
- 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);
- }
-
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;
}
}
+/**
+ * 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;
+ }
+ }
+ if (0 == client->msg_pos)
+ {
+ GNUNET_MQ_impl_send_in_flight (client->mq);
+ }
+ client->msg_pos += ret;
+ if (left > ret)
+ {
+ GNUNET_assert (NULL == client->drop_task);
+ 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);
+}
+
+
/**
* Signature of functions implementing the sending functionality of a
* message queue.
*
* @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;
+
+ if (NULL != client->drop_task)
+ return; /* we're going down right now, do not try to send */
+ GNUNET_assert (NULL == client->send_task);
+
+ LOG (GNUNET_ERROR_TYPE_INFO,
+ "Sending message of type %u and size %u to client\n",
+ ntohs (msg->type), ntohs (msg->size));
+
+ 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;
- // FIXME: stop transmission! (must be possible, otherwise
- // we must have told MQ that the message was sent!)
+ GNUNET_assert (0 == client->msg_pos);
+ client->msg = NULL;
+ GNUNET_SCHEDULER_cancel (client->send_task);
+ client->send_task = NULL;
}
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);
}
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
+ client->warn_task
= GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES,
&warn_no_client_continue,
client);
*
* @param 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,
{
struct GNUNET_SERVICE_Client *client = cls;
+ LOG (GNUNET_ERROR_TYPE_INFO,
+ "Received message of type %u and size %u from client\n",
+ ntohs (message->type), ntohs (message->size));
+
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;
}
if (GNUNET_SYSERR == ret)
{
/* client closed connection (or IO error) */
- GNUNET_assert (GNUNET_NO == client->needs_continue);
- GNUNET_SERVICE_client_drop (client);
+ if (NULL == client->drop_task)
+ {
+ GNUNET_assert (GNUNET_NO == client->needs_continue);
+ GNUNET_SERVICE_client_drop (client);
+ }
return;
}
if (GNUNET_NO == ret)
client);
client->mst = GNUNET_MST_create (&service_client_mst_cb,
client);
- client->user_context = sh->connect_cb (sh->cb_cls,
- client,
- client->mq);
+ if (NULL != sh->connect_cb)
+ 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
struct sockaddr_storage sa;
socklen_t addrlen;
int ok;
-
+
addrlen = sizeof (sa);
sock = GNUNET_NETWORK_socket_accept (slc->listen_socket,
(struct sockaddr *) &sa,
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);
+ 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;
+
+ c->drop_task = NULL;
+ GNUNET_assert (NULL == c->send_task);
+ GNUNET_assert (NULL == c->recv_task);
+ GNUNET_assert (NULL == c->warn_task);
+ 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_assert (0);
+ return;
+ }
GNUNET_CONTAINER_DLL_remove (sh->clients_head,
sh->clients_tail,
c);
- sh->disconnect_cb (sh->cb_cls,
- c,
- c->user_context);
+ if (NULL != sh->disconnect_cb)
+ sh->disconnect_cb (sh->cb_cls,
+ c,
+ c->user_context);
if (NULL != c->warn_task)
{
GNUNET_SCHEDULER_cancel (c->warn_task);
GNUNET_SCHEDULER_cancel (c->send_task);
c->send_task = NULL;
}
- 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);
+ 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 */
projects / oweals / gnunet.git / blobdiff