2 This file is part of GNUnet.
3 Copyright (C) 2016 GNUnet e.V.
5 GNUnet is free software: you can redistribute it and/or modify it
6 under the terms of the GNU Affero General Public License as published
7 by the Free Software Foundation, either version 3 of the License,
8 or (at your option) any later version.
10 GNUnet is distributed in the hope that it will be useful, but
11 WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Affero General Public License for more details.
15 You should have received a copy of the GNU Affero General Public License
16 along with this program. If not, see <http://www.gnu.org/licenses/>.
18 SPDX-License-Identifier: AGPL3.0-or-later
22 * @file util/service_new.c
23 * @brief functions related to starting services (redesign)
24 * @author Christian Grothoff
25 * @author Florian Dold
28 #include "gnunet_util_lib.h"
29 #include "gnunet_protocols.h"
30 #include "gnunet_constants.h"
31 #include "gnunet_resolver_service.h"
40 #define LOG(kind,...) GNUNET_log_from (kind, "util-service", __VA_ARGS__)
42 #define LOG_STRERROR(kind,syscall) GNUNET_log_from_strerror (kind, "util-service", syscall)
44 #define LOG_STRERROR_FILE(kind,syscall,filename) GNUNET_log_from_strerror_file (kind, "util-service", syscall, filename)
48 * Information the service tracks per listen operation.
50 struct ServiceListenContext
56 struct ServiceListenContext *next;
61 struct ServiceListenContext *prev;
64 * Service this listen context belongs to.
66 struct GNUNET_SERVICE_Handle *sh;
69 * Socket we are listening on.
71 struct GNUNET_NETWORK_Handle *listen_socket;
74 * Task scheduled to do the listening.
76 struct GNUNET_SCHEDULER_Task *listen_task;
82 * Reasons why we might be suspended.
87 * We are running normally.
89 SUSPEND_STATE_NONE = 0,
92 * Application requested it.
94 SUSPEND_STATE_APP = 1,
97 * OS ran out of file descriptors.
99 SUSPEND_STATE_EMFILE = 2,
102 * Both reasons, APP and EMFILE apply.
104 SUSPEND_STATE_APP_AND_EMFILE = 3,
107 * Suspension because service was permanently shutdown.
109 SUSPEND_STATE_SHUTDOWN = 4
114 * Handle to a service.
116 struct GNUNET_SERVICE_Handle
121 const struct GNUNET_CONFIGURATION_Handle *cfg;
124 * Name of our service.
126 const char *service_name;
129 * Main service-specific task to run.
131 GNUNET_SERVICE_InitCallback service_init_cb;
134 * Function to call when clients connect.
136 GNUNET_SERVICE_ConnectHandler connect_cb;
139 * Function to call when clients disconnect / are disconnected.
141 GNUNET_SERVICE_DisconnectHandler disconnect_cb;
144 * Closure for @e service_init_cb, @e connect_cb, @e disconnect_cb.
149 * DLL of listen sockets used to accept new connections.
151 struct ServiceListenContext *slc_head;
154 * DLL of listen sockets used to accept new connections.
156 struct ServiceListenContext *slc_tail;
159 * Our clients, kept in a DLL.
161 struct GNUNET_SERVICE_Client *clients_head;
164 * Our clients, kept in a DLL.
166 struct GNUNET_SERVICE_Client *clients_tail;
169 * Message handlers to use for all clients.
171 struct GNUNET_MQ_MessageHandler *handlers;
174 * Closure for @e task.
179 * IPv4 addresses that are not allowed to connect.
181 struct GNUNET_STRINGS_IPv4NetworkPolicy *v4_denied;
184 * IPv6 addresses that are not allowed to connect.
186 struct GNUNET_STRINGS_IPv6NetworkPolicy *v6_denied;
189 * IPv4 addresses that are allowed to connect (if not
190 * set, all are allowed).
192 struct GNUNET_STRINGS_IPv4NetworkPolicy *v4_allowed;
195 * IPv6 addresses that are allowed to connect (if not
196 * set, all are allowed).
198 struct GNUNET_STRINGS_IPv6NetworkPolicy *v6_allowed;
201 * Do we require a matching UID for UNIX domain socket connections?
202 * #GNUNET_NO means that the UID does not have to match (however,
203 * @e match_gid may still impose other access control checks).
208 * Do we require a matching GID for UNIX domain socket connections?
209 * Ignored if @e match_uid is #GNUNET_YES. Note that this is about
210 * checking that the client's UID is in our group OR that the
211 * client's GID is our GID. If both "match_gid" and @e match_uid are
212 * #GNUNET_NO, all users on the local system have access.
217 * Are we suspended, and if so, why?
219 enum SuspendReason suspend_state;
224 enum GNUNET_SERVICE_Options options;
227 * If we are daemonizing, this FD is set to the
228 * pipe to the parent. Send '.' if we started
229 * ok, '!' if not. -1 if we are not daemonizing.
231 int ready_confirm_fd;
234 * Overall success/failure of the service start.
239 * If #GNUNET_YES, consider unknown message types an error where the
240 * client is disconnected.
247 * Handle to a client that is connected to a service.
249 struct GNUNET_SERVICE_Client
255 struct GNUNET_SERVICE_Client *next;
260 struct GNUNET_SERVICE_Client *prev;
263 * Service that this client belongs to.
265 struct GNUNET_SERVICE_Handle *sh;
268 * Socket of this client.
270 struct GNUNET_NETWORK_Handle *sock;
273 * Message queue for the client.
275 struct GNUNET_MQ_Handle *mq;
278 * Tokenizer we use for processing incoming data.
280 struct GNUNET_MessageStreamTokenizer *mst;
283 * Task that warns about missing calls to
284 * #GNUNET_SERVICE_client_continue().
286 struct GNUNET_SCHEDULER_Task *warn_task;
289 * Task run to finish dropping the client after the stack has
292 struct GNUNET_SCHEDULER_Task *drop_task;
295 * Task that receives data from the client to
296 * pass it to the handlers.
298 struct GNUNET_SCHEDULER_Task *recv_task;
301 * Task that transmit data to the client.
303 struct GNUNET_SCHEDULER_Task *send_task;
306 * Pointer to the message to be transmitted by @e send_task.
308 const struct GNUNET_MessageHeader *msg;
311 * User context value, value returned from
312 * the connect callback.
317 * Time when we last gave a message from this client
318 * to the application.
320 struct GNUNET_TIME_Absolute warn_start;
323 * Current position in @e msg at which we are transmitting.
328 * Persist the file handle for this client no matter what happens,
329 * force the OS to close once the process actually dies. Should only
330 * be used in special cases!
335 * Is this client a 'monitor' client that should not be counted
336 * when deciding on destroying the server during soft shutdown?
337 * (see also #GNUNET_SERVICE_start)
342 * Are we waiting for the application to call #GNUNET_SERVICE_client_continue()?
347 * Type of last message processed (for warn_no_receive_done).
354 * Check if any of the clients we have left are unrelated to
357 * @param sh service to check clients for
358 * @return #GNUNET_YES if we have non-monitoring clients left
361 have_non_monitor_clients (struct GNUNET_SERVICE_Handle *sh)
363 for (struct GNUNET_SERVICE_Client *client = sh->clients_head;
365 client = client->next)
367 if (client->is_monitor)
376 * Suspend accepting connections from the listen socket temporarily.
377 * Resume activity using #do_resume.
379 * @param sh service to stop accepting connections.
380 * @param sr reason for suspending accepting connections
383 do_suspend (struct GNUNET_SERVICE_Handle *sh,
384 enum SuspendReason sr)
386 struct ServiceListenContext *slc;
388 GNUNET_assert (0 == (sh->suspend_state & sr));
389 sh->suspend_state |= sr;
390 for (slc = sh->slc_head; NULL != slc; slc = slc->next)
392 if (NULL != slc->listen_task)
394 GNUNET_SCHEDULER_cancel (slc->listen_task);
395 slc->listen_task = NULL;
402 * Shutdown task triggered when a service should be terminated.
403 * This considers active clients and the service options to see
404 * how this specific service is to be terminated, and depending
405 * on this proceeds with the shutdown logic.
407 * @param cls our `struct GNUNET_SERVICE_Handle`
410 service_shutdown (void *cls)
412 struct GNUNET_SERVICE_Handle *sh = cls;
416 case GNUNET_SERVICE_OPTION_NONE:
417 GNUNET_SERVICE_shutdown (sh);
419 case GNUNET_SERVICE_OPTION_MANUAL_SHUTDOWN:
420 /* This task should never be run if we are using
421 the manual shutdown. */
424 case GNUNET_SERVICE_OPTION_SOFT_SHUTDOWN:
425 if (0 == (sh->suspend_state & SUSPEND_STATE_SHUTDOWN))
427 SUSPEND_STATE_SHUTDOWN);
428 if (GNUNET_NO == have_non_monitor_clients (sh))
429 GNUNET_SERVICE_shutdown (sh);
436 * Check if the given IP address is in the list of IP addresses.
438 * @param list a list of networks
439 * @param add the IP to check (in network byte order)
440 * @return #GNUNET_NO if the IP is not in the list, #GNUNET_YES if it it is
443 check_ipv4_listed (const struct GNUNET_STRINGS_IPv4NetworkPolicy *list,
444 const struct in_addr *add)
451 while ( (0 != list[i].network.s_addr) ||
452 (0 != list[i].netmask.s_addr) )
454 if ((add->s_addr & list[i].netmask.s_addr) ==
455 (list[i].network.s_addr & list[i].netmask.s_addr))
464 * Check if the given IP address is in the list of IP addresses.
466 * @param list a list of networks
467 * @param ip the IP to check (in network byte order)
468 * @return #GNUNET_NO if the IP is not in the list, #GNUNET_YES if it it is
471 check_ipv6_listed (const struct GNUNET_STRINGS_IPv6NetworkPolicy *list,
472 const struct in6_addr *ip)
476 struct in6_addr zero;
482 sizeof (struct in6_addr));
485 while (0 != memcmp (&zero,
487 sizeof (struct in6_addr)))
489 for (j = 0; j < sizeof (struct in6_addr) / sizeof (int); j++)
490 if (((((int *) ip)[j] & ((int *) &list[i].netmask)[j])) !=
491 (((int *) &list[i].network)[j] & ((int *) &list[i].netmask)[j]))
503 * Task run when we are ready to transmit data to the
506 * @param cls the `struct GNUNET_SERVICE_Client *` to send to
511 struct GNUNET_SERVICE_Client *client = cls;
516 LOG (GNUNET_ERROR_TYPE_DEBUG,
517 "service: sending message with type %u",
518 ntohs(client->msg->type));
521 client->send_task = NULL;
522 buf = (const char *) client->msg;
523 left = ntohs (client->msg->size) - client->msg_pos;
524 ret = GNUNET_NETWORK_socket_send (client->sock,
525 &buf[client->msg_pos],
527 GNUNET_assert (ret <= (ssize_t) left);
530 LOG (GNUNET_ERROR_TYPE_DEBUG,
532 GNUNET_MQ_inject_error (client->mq,
533 GNUNET_MQ_ERROR_WRITE);
538 if ( (EAGAIN == errno) ||
547 GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING,
549 LOG (GNUNET_ERROR_TYPE_DEBUG,
550 "socket send returned with error code %i",
552 GNUNET_MQ_inject_error (client->mq,
553 GNUNET_MQ_ERROR_WRITE);
557 if (0 == client->msg_pos)
559 GNUNET_MQ_impl_send_in_flight (client->mq);
561 client->msg_pos += ret;
562 if (left > (size_t) ret)
564 GNUNET_assert (NULL == client->drop_task);
566 = GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL,
572 GNUNET_MQ_impl_send_continue (client->mq);
577 * Signature of functions implementing the sending functionality of a
580 * @param mq the message queue
581 * @param msg the message to send
582 * @param impl_state our `struct GNUNET_SERVICE_Client *`
585 service_mq_send (struct GNUNET_MQ_Handle *mq,
586 const struct GNUNET_MessageHeader *msg,
589 struct GNUNET_SERVICE_Client *client = impl_state;
592 if (NULL != client->drop_task)
593 return; /* we're going down right now, do not try to send */
594 GNUNET_assert (NULL == client->send_task);
595 LOG (GNUNET_ERROR_TYPE_DEBUG,
596 "Sending message of type %u and size %u to client\n",
602 = GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL,
610 * Implementation function that cancels the currently sent message.
612 * @param mq message queue
613 * @param impl_state state specific to the implementation
616 service_mq_cancel (struct GNUNET_MQ_Handle *mq,
619 struct GNUNET_SERVICE_Client *client = impl_state;
622 GNUNET_assert (0 == client->msg_pos);
624 GNUNET_SCHEDULER_cancel (client->send_task);
625 client->send_task = NULL;
630 * Generic error handler, called with the appropriate
631 * error code and the same closure specified at the creation of
633 * Not every message queue implementation supports an error handler.
635 * @param cls closure with our `struct GNUNET_SERVICE_Client`
636 * @param error error code
639 service_mq_error_handler (void *cls,
640 enum GNUNET_MQ_Error error)
642 struct GNUNET_SERVICE_Client *client = cls;
643 struct GNUNET_SERVICE_Handle *sh = client->sh;
645 if ( (GNUNET_MQ_ERROR_NO_MATCH == error) &&
646 (GNUNET_NO == sh->require_found) )
648 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
649 "No handler for message of type %u found\n",
650 (unsigned int) client->warn_type);
651 GNUNET_SERVICE_client_continue (client);
652 return; /* ignore error */
654 GNUNET_SERVICE_client_drop (client);
659 * Task run to warn about missing calls to #GNUNET_SERVICE_client_continue().
661 * @param cls our `struct GNUNET_SERVICE_Client *` to process more requests from
664 warn_no_client_continue (void *cls)
666 struct GNUNET_SERVICE_Client *client = cls;
668 GNUNET_break (0 != client->warn_type); /* type should never be 0 here, as we don't use 0 */
670 = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES,
671 &warn_no_client_continue,
673 LOG (GNUNET_ERROR_TYPE_WARNING,
674 _("Processing code for message of type %u did not call `GNUNET_SERVICE_client_continue' after %s\n"),
675 (unsigned int) client->warn_type,
676 GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (client->warn_start),
682 * Functions with this signature are called whenever a
683 * complete message is received by the tokenizer for a client.
685 * Do not call #GNUNET_MST_destroy() from within
686 * the scope of this callback.
688 * @param cls closure with the `struct GNUNET_SERVICE_Client *`
689 * @param message the actual message
690 * @return #GNUNET_OK on success, #GNUNET_SYSERR if the client was dropped
693 service_client_mst_cb (void *cls,
694 const struct GNUNET_MessageHeader *message)
696 struct GNUNET_SERVICE_Client *client = cls;
698 LOG (GNUNET_ERROR_TYPE_DEBUG,
699 "Received message of type %u and size %u from client\n",
700 ntohs (message->type),
701 ntohs (message->size));
702 GNUNET_assert (GNUNET_NO == client->needs_continue);
703 client->needs_continue = GNUNET_YES;
704 client->warn_type = ntohs (message->type);
705 client->warn_start = GNUNET_TIME_absolute_get ();
706 GNUNET_assert (NULL == client->warn_task);
708 = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES,
709 &warn_no_client_continue,
711 GNUNET_MQ_inject_message (client->mq,
713 if (NULL != client->drop_task)
714 return GNUNET_SYSERR;
720 * A client sent us data. Receive and process it. If we are done,
721 * reschedule this task.
723 * @param cls the `struct GNUNET_SERVICE_Client` that sent us data.
726 service_client_recv (void *cls)
728 struct GNUNET_SERVICE_Client *client = cls;
731 client->recv_task = NULL;
732 ret = GNUNET_MST_read (client->mst,
736 if (GNUNET_SYSERR == ret)
738 /* client closed connection (or IO error) */
739 if (NULL == client->drop_task)
741 GNUNET_assert (GNUNET_NO == client->needs_continue);
742 GNUNET_SERVICE_client_drop (client);
746 if (GNUNET_NO == ret)
747 return; /* more messages in buffer, wait for application
748 to be done processing */
749 GNUNET_assert (GNUNET_OK == ret);
750 if (GNUNET_YES == client->needs_continue)
752 if (NULL != client->recv_task)
754 /* MST needs more data, re-schedule read job */
756 = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
758 &service_client_recv,
764 * We have successfully accepted a connection from a client. Now
765 * setup the client (with the scheduler) and tell the application.
767 * @param sh service that accepted the client
768 * @param sock socket associated with the client
771 start_client (struct GNUNET_SERVICE_Handle *sh,
772 struct GNUNET_NETWORK_Handle *csock)
774 struct GNUNET_SERVICE_Client *client;
776 client = GNUNET_new (struct GNUNET_SERVICE_Client);
777 GNUNET_CONTAINER_DLL_insert (sh->clients_head,
781 client->sock = csock;
782 client->mq = GNUNET_MQ_queue_for_callbacks (&service_mq_send,
787 &service_mq_error_handler,
789 client->mst = GNUNET_MST_create (&service_client_mst_cb,
791 if (NULL != sh->connect_cb)
792 client->user_context = sh->connect_cb (sh->cb_cls,
795 GNUNET_MQ_set_handlers_closure (client->mq,
796 client->user_context);
798 = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
800 &service_client_recv,
806 * We have a client. Accept the incoming socket(s) (and reschedule
809 * @param cls the `struct ServiceListenContext` of the ready listen socket
812 accept_client (void *cls)
814 struct ServiceListenContext *slc = cls;
815 struct GNUNET_SERVICE_Handle *sh = slc->sh;
817 slc->listen_task = NULL;
820 struct GNUNET_NETWORK_Handle *sock;
821 const struct sockaddr_in *v4;
822 const struct sockaddr_in6 *v6;
823 struct sockaddr_storage sa;
827 addrlen = sizeof (sa);
828 sock = GNUNET_NETWORK_socket_accept (slc->listen_socket,
829 (struct sockaddr *) &sa,
835 SUSPEND_STATE_EMFILE);
836 else if (EAGAIN != errno)
837 GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING,
841 switch (sa.ss_family)
844 GNUNET_assert (addrlen == sizeof (struct sockaddr_in));
845 v4 = (const struct sockaddr_in *) &sa;
846 ok = ( ( (NULL == sh->v4_allowed) ||
847 (check_ipv4_listed (sh->v4_allowed,
849 ( (NULL == sh->v4_denied) ||
850 (! check_ipv4_listed (sh->v4_denied,
854 GNUNET_assert (addrlen == sizeof (struct sockaddr_in6));
855 v6 = (const struct sockaddr_in6 *) &sa;
856 ok = ( ( (NULL == sh->v6_allowed) ||
857 (check_ipv6_listed (sh->v6_allowed,
859 ( (NULL == sh->v6_denied) ||
860 (! check_ipv6_listed (sh->v6_denied,
861 &v6->sin6_addr)) ) );
865 ok = GNUNET_OK; /* controlled using file-system ACL now */
869 LOG (GNUNET_ERROR_TYPE_WARNING,
870 _("Unknown address family %d\n"),
876 LOG (GNUNET_ERROR_TYPE_DEBUG,
877 "Service rejected incoming connection from %s due to policy.\n",
878 GNUNET_a2s ((const struct sockaddr *) &sa,
880 GNUNET_break (GNUNET_OK ==
881 GNUNET_NETWORK_socket_close (sock));
884 LOG (GNUNET_ERROR_TYPE_DEBUG,
885 "Service accepted incoming connection from %s.\n",
886 GNUNET_a2s ((const struct sockaddr *) &sa,
888 start_client (slc->sh,
892 = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
900 * Resume accepting connections from the listen socket.
902 * @param sh service to resume accepting connections.
903 * @param sr reason that is no longer causing the suspension,
904 * or #SUSPEND_STATE_NONE on first startup
907 do_resume (struct GNUNET_SERVICE_Handle *sh,
908 enum SuspendReason sr)
910 struct ServiceListenContext *slc;
912 GNUNET_assert ( (SUSPEND_STATE_NONE == sr) ||
913 (0 != (sh->suspend_state & sr)) );
914 sh->suspend_state -= sr;
915 if (SUSPEND_STATE_NONE != sh->suspend_state)
917 for (slc = sh->slc_head; NULL != slc; slc = slc->next)
919 GNUNET_assert (NULL == slc->listen_task);
921 = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
930 * First task run by any service. Initializes our shutdown task,
931 * starts the listening operation on our listen sockets and launches
932 * the custom logic of the application service.
934 * @param cls our `struct GNUNET_SERVICE_Handle`
937 service_main (void *cls)
939 struct GNUNET_SERVICE_Handle *sh = cls;
941 if (GNUNET_SERVICE_OPTION_MANUAL_SHUTDOWN != sh->options)
942 GNUNET_SCHEDULER_add_shutdown (&service_shutdown,
947 if (-1 != sh->ready_confirm_fd)
949 GNUNET_break (1 == WRITE (sh->ready_confirm_fd, ".", 1));
950 GNUNET_break (0 == CLOSE (sh->ready_confirm_fd));
951 sh->ready_confirm_fd = -1;
954 if (NULL != sh->service_init_cb)
955 sh->service_init_cb (sh->cb_cls,
962 * Parse an IPv4 access control list.
964 * @param ret location where to write the ACL (set)
965 * @param sh service context to use to get the configuration
966 * @param option name of the ACL option to parse
967 * @return #GNUNET_SYSERR on parse error, #GNUNET_OK on success (including
971 process_acl4 (struct GNUNET_STRINGS_IPv4NetworkPolicy **ret,
972 struct GNUNET_SERVICE_Handle *sh,
977 if (! GNUNET_CONFIGURATION_have_value (sh->cfg,
984 GNUNET_break (GNUNET_OK ==
985 GNUNET_CONFIGURATION_get_value_string (sh->cfg,
989 if (NULL == (*ret = GNUNET_STRINGS_parse_ipv4_policy (opt)))
991 LOG (GNUNET_ERROR_TYPE_WARNING,
992 _("Could not parse IPv4 network specification `%s' for `%s:%s'\n"),
997 return GNUNET_SYSERR;
1005 * Parse an IPv6 access control list.
1007 * @param ret location where to write the ACL (set)
1008 * @param sh service context to use to get the configuration
1009 * @param option name of the ACL option to parse
1010 * @return #GNUNET_SYSERR on parse error, #GNUNET_OK on success (including
1011 * no ACL configured)
1014 process_acl6 (struct GNUNET_STRINGS_IPv6NetworkPolicy **ret,
1015 struct GNUNET_SERVICE_Handle *sh,
1020 if (! GNUNET_CONFIGURATION_have_value (sh->cfg,
1027 GNUNET_break (GNUNET_OK ==
1028 GNUNET_CONFIGURATION_get_value_string (sh->cfg,
1032 if (NULL == (*ret = GNUNET_STRINGS_parse_ipv6_policy (opt)))
1034 LOG (GNUNET_ERROR_TYPE_WARNING,
1035 _("Could not parse IPv6 network specification `%s' for `%s:%s'\n"),
1040 return GNUNET_SYSERR;
1048 * Add the given UNIX domain path as an address to the
1049 * list (as the first entry).
1051 * @param saddrs array to update
1052 * @param saddrlens where to store the address length
1053 * @param unixpath path to add
1054 * @param abstract #GNUNET_YES to add an abstract UNIX domain socket. This
1055 * parameter is ignore on systems other than LINUX
1058 add_unixpath (struct sockaddr **saddrs,
1059 socklen_t *saddrlens,
1060 const char *unixpath,
1064 struct sockaddr_un *un;
1066 un = GNUNET_new (struct sockaddr_un);
1067 un->sun_family = AF_UNIX;
1068 strncpy (un->sun_path,
1070 sizeof (un->sun_path) - 1);
1072 if (GNUNET_YES == abstract)
1073 un->sun_path[0] = '\0';
1075 #if HAVE_SOCKADDR_UN_SUN_LEN
1076 un->sun_len = (u_char) sizeof (struct sockaddr_un);
1078 *saddrs = (struct sockaddr *) un;
1079 *saddrlens = sizeof (struct sockaddr_un);
1081 /* this function should never be called
1082 * unless AF_UNIX is defined! */
1089 * Get the list of addresses that a server for the given service
1092 * @param service_name name of the service
1093 * @param cfg configuration (which specifies the addresses)
1094 * @param addrs set (call by reference) to an array of pointers to the
1095 * addresses the server should bind to and listen on; the
1096 * array will be NULL-terminated (on success)
1097 * @param addr_lens set (call by reference) to an array of the lengths
1098 * of the respective `struct sockaddr` struct in the @a addrs
1099 * array (on success)
1100 * @return number of addresses found on success,
1101 * #GNUNET_SYSERR if the configuration
1102 * did not specify reasonable finding information or
1103 * if it specified a hostname that could not be resolved;
1104 * #GNUNET_NO if the number of addresses configured is
1105 * zero (in this case, `*addrs` and `*addr_lens` will be
1109 get_server_addresses (const char *service_name,
1110 const struct GNUNET_CONFIGURATION_Handle *cfg,
1111 struct sockaddr ***addrs,
1112 socklen_t **addr_lens)
1115 struct GNUNET_NETWORK_Handle *desc;
1116 unsigned long long port;
1118 struct addrinfo hints;
1119 struct addrinfo *res;
1120 struct addrinfo *pos;
1121 struct addrinfo *next;
1126 struct sockaddr **saddrs;
1127 socklen_t *saddrlens;
1133 if (GNUNET_CONFIGURATION_have_value (cfg,
1137 if (GNUNET_SYSERR ==
1139 GNUNET_CONFIGURATION_get_value_yesno (cfg,
1142 return GNUNET_SYSERR;
1145 disablev6 = GNUNET_NO;
1149 /* probe IPv6 support */
1150 desc = GNUNET_NETWORK_socket_create (PF_INET6,
1155 if ( (ENOBUFS == errno) ||
1156 (ENOMEM == errno) ||
1157 (ENFILE == errno) ||
1160 LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR,
1162 return GNUNET_SYSERR;
1164 LOG (GNUNET_ERROR_TYPE_INFO,
1165 _("Disabling IPv6 support for service `%s', failed to create IPv6 socket: %s\n"),
1168 disablev6 = GNUNET_YES;
1172 GNUNET_break (GNUNET_OK ==
1173 GNUNET_NETWORK_socket_close (desc));
1179 if (GNUNET_CONFIGURATION_have_value (cfg,
1184 GNUNET_CONFIGURATION_get_value_number (cfg,
1189 LOG (GNUNET_ERROR_TYPE_ERROR,
1190 _("Require valid port number for service `%s' in configuration!\n"),
1195 LOG (GNUNET_ERROR_TYPE_ERROR,
1196 _("Require valid port number for service `%s' in configuration!\n"),
1198 return GNUNET_SYSERR;
1202 if (GNUNET_CONFIGURATION_have_value (cfg,
1206 GNUNET_break (GNUNET_OK ==
1207 GNUNET_CONFIGURATION_get_value_string (cfg,
1216 abstract = GNUNET_NO;
1219 GNUNET_CONFIGURATION_have_value (cfg,
1223 GNUNET_CONFIGURATION_get_value_filename (cfg,
1227 (0 < strlen (unixpath)))
1229 /* probe UNIX support */
1230 struct sockaddr_un s_un;
1232 if (strlen (unixpath) >= sizeof (s_un.sun_path))
1234 LOG (GNUNET_ERROR_TYPE_WARNING,
1235 _("UNIXPATH `%s' too long, maximum length is %llu\n"),
1237 (unsigned long long) sizeof (s_un.sun_path));
1238 unixpath = GNUNET_NETWORK_shorten_unixpath (unixpath);
1239 LOG (GNUNET_ERROR_TYPE_INFO,
1240 _("Using `%s' instead\n"),
1244 abstract = GNUNET_CONFIGURATION_get_value_yesno (cfg,
1246 "USE_ABSTRACT_SOCKETS");
1247 if (GNUNET_SYSERR == abstract)
1248 abstract = GNUNET_NO;
1250 if ( (GNUNET_YES != abstract) &&
1252 GNUNET_DISK_directory_create_for_file (unixpath)) )
1253 GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR,
1257 if (NULL != unixpath)
1259 desc = GNUNET_NETWORK_socket_create (AF_UNIX,
1264 if ((ENOBUFS == errno) ||
1265 (ENOMEM == errno) ||
1266 (ENFILE == errno) ||
1269 LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR,
1271 GNUNET_free_non_null (hostname);
1272 GNUNET_free (unixpath);
1273 return GNUNET_SYSERR;
1275 LOG (GNUNET_ERROR_TYPE_INFO,
1276 _("Disabling UNIX domain socket support for service `%s', failed to create UNIX domain socket: %s\n"),
1279 GNUNET_free (unixpath);
1284 GNUNET_break (GNUNET_OK ==
1285 GNUNET_NETWORK_socket_close (desc));
1291 if ((0 == port) && (NULL == unixpath))
1293 LOG (GNUNET_ERROR_TYPE_ERROR,
1294 _("Have neither PORT nor UNIXPATH for service `%s', but one is required\n"),
1296 GNUNET_free_non_null (hostname);
1297 return GNUNET_SYSERR;
1301 saddrs = GNUNET_new_array (2,
1303 saddrlens = GNUNET_new_array (2,
1305 add_unixpath (saddrs,
1309 GNUNET_free_non_null (unixpath);
1310 GNUNET_free_non_null (hostname);
1312 *addr_lens = saddrlens;
1316 if (NULL != hostname)
1318 LOG (GNUNET_ERROR_TYPE_DEBUG,
1319 "Resolving `%s' since that is where `%s' will bind to.\n",
1324 sizeof (struct addrinfo));
1326 hints.ai_family = AF_INET;
1327 hints.ai_protocol = IPPROTO_TCP;
1328 if ((0 != (ret = getaddrinfo (hostname,
1334 LOG (GNUNET_ERROR_TYPE_ERROR,
1335 _("Failed to resolve `%s': %s\n"),
1337 gai_strerror (ret));
1338 GNUNET_free (hostname);
1339 GNUNET_free_non_null (unixpath);
1340 return GNUNET_SYSERR;
1344 while (NULL != (pos = next))
1346 next = pos->ai_next;
1348 (pos->ai_family == AF_INET6) )
1354 LOG (GNUNET_ERROR_TYPE_ERROR,
1355 _("Failed to find %saddress for `%s'.\n"),
1356 disablev6 ? "IPv4 " : "",
1359 GNUNET_free (hostname);
1360 GNUNET_free_non_null (unixpath);
1361 return GNUNET_SYSERR;
1364 if (NULL != unixpath)
1366 saddrs = GNUNET_new_array (resi + 1,
1368 saddrlens = GNUNET_new_array (resi + 1,
1371 if (NULL != unixpath)
1373 add_unixpath (saddrs,
1380 while (NULL != (pos = next))
1382 next = pos->ai_next;
1384 (AF_INET6 == pos->ai_family) )
1386 if ( (IPPROTO_TCP != pos->ai_protocol) &&
1387 (0 != pos->ai_protocol) )
1388 continue; /* not TCP */
1389 if ( (SOCK_STREAM != pos->ai_socktype) &&
1390 (0 != pos->ai_socktype) )
1391 continue; /* huh? */
1392 LOG (GNUNET_ERROR_TYPE_DEBUG,
1393 "Service `%s' will bind to `%s'\n",
1395 GNUNET_a2s (pos->ai_addr,
1397 if (AF_INET == pos->ai_family)
1399 GNUNET_assert (sizeof (struct sockaddr_in) == pos->ai_addrlen);
1400 saddrlens[i] = pos->ai_addrlen;
1401 saddrs[i] = GNUNET_malloc (saddrlens[i]);
1402 GNUNET_memcpy (saddrs[i],
1405 ((struct sockaddr_in *) saddrs[i])->sin_port = htons (port);
1409 GNUNET_assert (AF_INET6 == pos->ai_family);
1410 GNUNET_assert (sizeof (struct sockaddr_in6) == pos->ai_addrlen);
1411 saddrlens[i] = pos->ai_addrlen;
1412 saddrs[i] = GNUNET_malloc (saddrlens[i]);
1413 GNUNET_memcpy (saddrs[i],
1416 ((struct sockaddr_in6 *) saddrs[i])->sin6_port = htons (port);
1420 GNUNET_free (hostname);
1426 /* will bind against everything, just set port */
1431 if (NULL != unixpath)
1434 saddrs = GNUNET_new_array (resi + 1,
1436 saddrlens = GNUNET_new_array (resi + 1,
1438 if (NULL != unixpath)
1440 add_unixpath (saddrs,
1446 saddrlens[i] = sizeof (struct sockaddr_in);
1447 saddrs[i] = GNUNET_malloc (saddrlens[i]);
1448 #if HAVE_SOCKADDR_IN_SIN_LEN
1449 ((struct sockaddr_in *) saddrs[i])->sin_len = saddrlens[i];
1451 ((struct sockaddr_in *) saddrs[i])->sin_family = AF_INET;
1452 ((struct sockaddr_in *) saddrs[i])->sin_port = htons (port);
1458 if (NULL != unixpath)
1460 saddrs = GNUNET_new_array (resi + 1,
1462 saddrlens = GNUNET_new_array (resi + 1,
1465 if (NULL != unixpath)
1467 add_unixpath (saddrs,
1473 saddrlens[i] = sizeof (struct sockaddr_in6);
1474 saddrs[i] = GNUNET_malloc (saddrlens[i]);
1475 #if HAVE_SOCKADDR_IN_SIN_LEN
1476 ((struct sockaddr_in6 *) saddrs[i])->sin6_len = saddrlens[0];
1478 ((struct sockaddr_in6 *) saddrs[i])->sin6_family = AF_INET6;
1479 ((struct sockaddr_in6 *) saddrs[i])->sin6_port = htons (port);
1481 saddrlens[i] = sizeof (struct sockaddr_in);
1482 saddrs[i] = GNUNET_malloc (saddrlens[i]);
1483 #if HAVE_SOCKADDR_IN_SIN_LEN
1484 ((struct sockaddr_in *) saddrs[i])->sin_len = saddrlens[1];
1486 ((struct sockaddr_in *) saddrs[i])->sin_family = AF_INET;
1487 ((struct sockaddr_in *) saddrs[i])->sin_port = htons (port);
1490 GNUNET_free_non_null (unixpath);
1492 *addr_lens = saddrlens;
1499 * Read listen sockets from the parent process (ARM).
1501 * @param sh service context to initialize
1502 * @return NULL-terminated array of sockets on success,
1503 * NULL if not ok (must bind yourself)
1505 static struct GNUNET_NETWORK_Handle **
1506 receive_sockets_from_parent (struct GNUNET_SERVICE_Handle *sh)
1508 static struct GNUNET_NETWORK_Handle **lsocks;
1509 const char *env_buf;
1515 env_buf = getenv ("GNUNET_OS_READ_LSOCKS");
1516 if ( (NULL == env_buf) ||
1517 (strlen (env_buf) <= 0) )
1519 /* Using W32 API directly here, because this pipe will
1520 * never be used outside of this function, and it's just too much of a bother
1521 * to create a GNUnet API that boxes a HANDLE (the way it is done with socks)
1523 lsocks_pipe = (HANDLE) strtoul (env_buf,
1526 if ( (0 == lsocks_pipe) ||
1527 (INVALID_HANDLE_VALUE == lsocks_pipe))
1536 ret = ReadFile (lsocks_pipe,
1542 (sizeof (count) != rd) ||
1545 lsocks = GNUNET_new_array (count + 1,
1546 struct GNUNET_NETWORK_Handle *);
1549 for (i = 0; i < count; i++)
1551 WSAPROTOCOL_INFOA pi;
1555 ret = ReadFile (lsocks_pipe,
1561 (sizeof (size) != rd) ||
1562 (sizeof (pi) != size) )
1564 ret = ReadFile (lsocks_pipe,
1570 (sizeof (pi) != rd))
1572 s = WSASocketA (pi.iAddressFamily,
1577 WSA_FLAG_OVERLAPPED);
1578 lsocks[i] = GNUNET_NETWORK_socket_box_native (s);
1579 if (NULL == lsocks[i])
1581 else if (i == count - 1)
1586 lsocks[count] = NULL;
1590 CloseHandle (lsocks_pipe);
1594 LOG (GNUNET_ERROR_TYPE_ERROR,
1595 _("Could not access a pre-bound socket, will try to bind myself\n"));
1596 for (i = 0; (i < count) && (NULL != lsocks[i]); i++)
1597 GNUNET_break (GNUNET_OK ==
1598 GNUNET_NETWORK_socket_close (lsocks[i]));
1599 GNUNET_free (lsocks);
1608 * Create and initialize a listen socket for the server.
1610 * @param server_addr address to listen on
1611 * @param socklen length of @a server_addr
1612 * @return NULL on error, otherwise the listen socket
1614 static struct GNUNET_NETWORK_Handle *
1615 open_listen_socket (const struct sockaddr *server_addr,
1618 struct GNUNET_NETWORK_Handle *sock;
1622 switch (server_addr->sa_family)
1625 port = ntohs (((const struct sockaddr_in *) server_addr)->sin_port);
1628 port = ntohs (((const struct sockaddr_in6 *) server_addr)->sin6_port);
1638 sock = GNUNET_NETWORK_socket_create (server_addr->sa_family,
1643 LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR,
1648 /* bind the socket */
1649 if (GNUNET_OK != GNUNET_NETWORK_socket_bind (sock,
1654 if (EADDRINUSE != errno)
1656 /* we don't log 'EADDRINUSE' here since an IPv4 bind may
1657 * fail if we already took the port on IPv6; if both IPv4 and
1658 * IPv6 binds fail, then our caller will log using the
1659 * errno preserved in 'eno' */
1660 LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR,
1663 LOG (GNUNET_ERROR_TYPE_ERROR,
1664 _("`%s' failed for port %d (%s).\n"),
1667 (AF_INET == server_addr->sa_family) ? "IPv4" : "IPv6");
1673 LOG (GNUNET_ERROR_TYPE_WARNING,
1674 _("`%s' failed for port %d (%s): address already in use\n"),
1676 (AF_INET == server_addr->sa_family) ? "IPv4" : "IPv6");
1677 else if (AF_UNIX == server_addr->sa_family)
1679 LOG (GNUNET_ERROR_TYPE_WARNING,
1680 _("`%s' failed for `%s': address already in use\n"),
1682 GNUNET_a2s (server_addr, socklen));
1685 GNUNET_break (GNUNET_OK ==
1686 GNUNET_NETWORK_socket_close (sock));
1690 if (GNUNET_OK != GNUNET_NETWORK_socket_listen (sock,
1693 LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR,
1695 GNUNET_break (GNUNET_OK ==
1696 GNUNET_NETWORK_socket_close (sock));
1701 LOG (GNUNET_ERROR_TYPE_DEBUG,
1702 "Server starts to listen on port %u.\n",
1709 * Setup service handle
1711 * Configuration may specify:
1712 * - PORT (where to bind to for TCP)
1713 * - UNIXPATH (where to bind to for UNIX domain sockets)
1714 * - DISABLEV6 (disable support for IPv6, otherwise we use dual-stack)
1715 * - BINDTO (hostname or IP address to bind to, otherwise we take everything)
1716 * - ACCEPT_FROM (only allow connections from specified IPv4 subnets)
1717 * - ACCEPT_FROM6 (only allow connections from specified IPv6 subnets)
1718 * - REJECT_FROM (disallow allow connections from specified IPv4 subnets)
1719 * - REJECT_FROM6 (disallow allow connections from specified IPv6 subnets)
1721 * @param sh service context to initialize
1722 * @return #GNUNET_OK if configuration succeeded
1725 setup_service (struct GNUNET_SERVICE_Handle *sh)
1728 struct GNUNET_NETWORK_Handle **lsocks;
1736 if (GNUNET_CONFIGURATION_have_value
1741 if (GNUNET_SYSERR ==
1743 GNUNET_CONFIGURATION_get_value_yesno (sh->cfg,
1747 LOG (GNUNET_ERROR_TYPE_ERROR,
1748 _("Specified value for `%s' of service `%s' is invalid\n"),
1751 return GNUNET_SYSERR;
1755 tolerant = GNUNET_NO;
1760 if ( (NULL != (nfds = getenv ("LISTEN_FDS"))) &&
1766 (cnt < FD_SETSIZE) &&
1767 (cnt + 4 < FD_SETSIZE) )
1769 lsocks = GNUNET_new_array (cnt + 1,
1770 struct GNUNET_NETWORK_Handle *);
1773 flags = fcntl (3 + cnt,
1776 (0 != (flags & FD_CLOEXEC)) ||
1778 (lsocks[cnt] = GNUNET_NETWORK_socket_box_native (3 + cnt))))
1780 LOG (GNUNET_ERROR_TYPE_ERROR,
1781 _("Could not access pre-bound socket %u, will try to bind myself\n"),
1782 (unsigned int) 3 + cnt);
1784 while (NULL != lsocks[cnt])
1785 GNUNET_break (GNUNET_OK ==
1786 GNUNET_NETWORK_socket_close (lsocks[cnt++]));
1787 GNUNET_free (lsocks);
1792 unsetenv ("LISTEN_FDS");
1795 if (NULL != getenv ("GNUNET_OS_READ_LSOCKS"))
1797 lsocks = receive_sockets_from_parent (sh);
1798 putenv ("GNUNET_OS_READ_LSOCKS=");
1804 /* listen only on inherited sockets if we have any */
1805 struct GNUNET_NETWORK_Handle **ls;
1807 for (ls = lsocks; NULL != *ls; ls++)
1809 struct ServiceListenContext *slc;
1811 slc = GNUNET_new (struct ServiceListenContext);
1813 slc->listen_socket = *ls;
1814 GNUNET_CONTAINER_DLL_insert (sh->slc_head,
1818 GNUNET_free (lsocks);
1822 struct sockaddr **addrs;
1823 socklen_t *addrlens;
1826 num = get_server_addresses (sh->service_name,
1830 if (GNUNET_SYSERR == num)
1831 return GNUNET_SYSERR;
1833 for (int i = 0; i < num; i++)
1835 struct ServiceListenContext *slc;
1837 slc = GNUNET_new (struct ServiceListenContext);
1839 slc->listen_socket = open_listen_socket (addrs[i],
1841 GNUNET_free (addrs[i]);
1842 if (NULL == slc->listen_socket)
1844 GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
1849 GNUNET_CONTAINER_DLL_insert (sh->slc_head,
1853 GNUNET_free_non_null (addrlens);
1854 GNUNET_free_non_null (addrs);
1856 (NULL == sh->slc_head) )
1858 /* All attempts to bind failed, hard failure */
1859 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1860 _("Could not bind to any of the ports I was supposed to, refusing to run!\n"));
1861 return GNUNET_SYSERR;
1865 sh->require_found = tolerant ? GNUNET_NO : GNUNET_YES;
1867 = GNUNET_CONFIGURATION_get_value_yesno (sh->cfg,
1871 = GNUNET_CONFIGURATION_get_value_yesno (sh->cfg,
1874 process_acl4 (&sh->v4_denied,
1877 process_acl4 (&sh->v4_allowed,
1880 process_acl6 (&sh->v6_denied,
1883 process_acl6 (&sh->v6_allowed,
1891 * Get the name of the user that'll be used
1892 * to provide the service.
1894 * @param sh service context
1895 * @return value of the 'USERNAME' option
1898 get_user_name (struct GNUNET_SERVICE_Handle *sh)
1903 GNUNET_CONFIGURATION_get_value_filename (sh->cfg,
1915 * @param sh service context
1916 * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
1919 set_user_id (struct GNUNET_SERVICE_Handle *sh)
1923 if (NULL == (user = get_user_name (sh)))
1924 return GNUNET_OK; /* keep */
1929 pws = getpwnam (user);
1932 LOG (GNUNET_ERROR_TYPE_ERROR,
1933 _("Cannot obtain information about user `%s': %s\n"),
1935 errno == 0 ? _("No such user") : STRERROR (errno));
1937 return GNUNET_SYSERR;
1939 if ( (0 != setgid (pws->pw_gid)) ||
1940 (0 != setegid (pws->pw_gid)) ||
1942 (0 != initgroups (user,
1945 (0 != setuid (pws->pw_uid)) ||
1946 (0 != seteuid (pws->pw_uid)))
1948 if ((0 != setregid (pws->pw_gid,
1950 (0 != setreuid (pws->pw_uid,
1953 LOG (GNUNET_ERROR_TYPE_ERROR,
1954 _("Cannot change user/group to `%s': %s\n"),
1958 return GNUNET_SYSERR;
1968 * Get the name of the file where we will
1969 * write the PID of the service.
1971 * @param sh service context
1972 * @return name of the file for the process ID
1975 get_pid_file_name (struct GNUNET_SERVICE_Handle *sh)
1980 GNUNET_CONFIGURATION_get_value_filename (sh->cfg,
1990 * Delete the PID file that was created by our parent.
1992 * @param sh service context
1995 pid_file_delete (struct GNUNET_SERVICE_Handle *sh)
1997 char *pif = get_pid_file_name (sh);
2000 return; /* no PID file */
2001 if (0 != UNLINK (pif))
2002 LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING,
2010 * Detach from terminal.
2012 * @param sh service context
2013 * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
2016 detach_terminal (struct GNUNET_SERVICE_Handle *sh)
2023 if (0 != PIPE (filedes))
2025 LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR,
2027 return GNUNET_SYSERR;
2032 LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR,
2034 return GNUNET_SYSERR;
2041 GNUNET_break (0 == CLOSE (filedes[1]));
2043 if (1 != READ (filedes[0],
2046 LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING,
2054 LOG (GNUNET_ERROR_TYPE_INFO,
2055 _("Service process failed to initialize\n"));
2058 LOG (GNUNET_ERROR_TYPE_INFO,
2059 _("Service process could not initialize server function\n"));
2062 LOG (GNUNET_ERROR_TYPE_INFO,
2063 _("Service process failed to report status\n"));
2066 exit (1); /* child reported error */
2068 GNUNET_break (0 == CLOSE (0));
2069 GNUNET_break (0 == CLOSE (1));
2070 GNUNET_break (0 == CLOSE (filedes[0]));
2071 nullfd = OPEN ("/dev/null",
2074 return GNUNET_SYSERR;
2075 /* set stdin/stdout to /dev/null */
2076 if ( (dup2 (nullfd, 0) < 0) ||
2077 (dup2 (nullfd, 1) < 0) )
2079 LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR,
2081 (void) CLOSE (nullfd);
2082 return GNUNET_SYSERR;
2084 (void) CLOSE (nullfd);
2085 /* Detach from controlling terminal */
2088 LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR,
2090 sh->ready_confirm_fd = filedes[1];
2092 /* FIXME: we probably need to do something else
2093 * elsewhere in order to fork the process itself... */
2101 * Tear down the service, closing the listen sockets and
2104 * @param sh handle to the service to tear down.
2107 teardown_service (struct GNUNET_SERVICE_Handle *sh)
2109 struct ServiceListenContext *slc;
2111 GNUNET_free_non_null (sh->v4_denied);
2112 GNUNET_free_non_null (sh->v6_denied);
2113 GNUNET_free_non_null (sh->v4_allowed);
2114 GNUNET_free_non_null (sh->v6_allowed);
2115 while (NULL != (slc = sh->slc_head))
2117 GNUNET_CONTAINER_DLL_remove (sh->slc_head,
2120 if (NULL != slc->listen_task)
2121 GNUNET_SCHEDULER_cancel (slc->listen_task);
2122 GNUNET_break (GNUNET_OK ==
2123 GNUNET_NETWORK_socket_close (slc->listen_socket));
2130 * Function to return link to AGPL source upon request.
2132 * @param cls closure with the identification of the client
2133 * @param msg AGPL request
2136 return_agpl (void *cls,
2137 const struct GNUNET_MessageHeader *msg)
2139 struct GNUNET_SERVICE_Client *client = cls;
2140 struct GNUNET_MQ_Handle *mq;
2141 struct GNUNET_MQ_Envelope *env;
2142 struct GNUNET_MessageHeader *res;
2146 slen = strlen (GNUNET_AGPL_URL) + 1;
2147 env = GNUNET_MQ_msg_extra (res,
2148 GNUNET_MESSAGE_TYPE_RESPONSE_AGPL,
2153 mq = GNUNET_SERVICE_client_get_mq (client);
2156 GNUNET_SERVICE_client_continue (client);
2161 * Low-level function to start a service if the scheduler
2162 * is already running. Should only be used directly in
2165 * The function will launch the service with the name @a service_name
2166 * using the @a service_options to configure its shutdown
2167 * behavior. When clients connect or disconnect, the respective
2168 * @a connect_cb or @a disconnect_cb functions will be called. For
2169 * messages received from the clients, the respective @a handlers will
2170 * be invoked; for the closure of the handlers we use the return value
2171 * from the @a connect_cb invocation of the respective client.
2173 * Each handler MUST call #GNUNET_SERVICE_client_continue() after each
2174 * message to receive further messages from this client. If
2175 * #GNUNET_SERVICE_client_continue() is not called within a short
2176 * time, a warning will be logged. If delays are expected, services
2177 * should call #GNUNET_SERVICE_client_disable_continue_warning() to
2178 * disable the warning.
2180 * Clients sending invalid messages (based on @a handlers) will be
2181 * dropped. Additionally, clients can be dropped at any time using
2182 * #GNUNET_SERVICE_client_drop().
2184 * The service must be stopped using #GNUNET_SERVICE_stop().
2186 * @param service_name name of the service to run
2187 * @param cfg configuration to use
2188 * @param connect_cb function to call whenever a client connects
2189 * @param disconnect_cb function to call whenever a client disconnects
2190 * @param cls closure argument for @a connect_cb and @a disconnect_cb
2191 * @param handlers NULL-terminated array of message handlers for the service,
2192 * the closure will be set to the value returned by
2193 * the @a connect_cb for the respective connection
2194 * @return NULL on error
2196 struct GNUNET_SERVICE_Handle *
2197 GNUNET_SERVICE_start (const char *service_name,
2198 const struct GNUNET_CONFIGURATION_Handle *cfg,
2199 GNUNET_SERVICE_ConnectHandler connect_cb,
2200 GNUNET_SERVICE_DisconnectHandler disconnect_cb,
2202 const struct GNUNET_MQ_MessageHandler *handlers)
2204 struct GNUNET_SERVICE_Handle *sh;
2206 sh = GNUNET_new (struct GNUNET_SERVICE_Handle);
2207 sh->service_name = service_name;
2209 sh->connect_cb = connect_cb;
2210 sh->disconnect_cb = disconnect_cb;
2212 sh->handlers = GNUNET_MQ_copy_handlers2 (handlers,
2215 if (GNUNET_OK != setup_service (sh))
2217 GNUNET_free_non_null (sh->handlers);
2222 SUSPEND_STATE_NONE);
2228 * Stops a service that was started with #GNUNET_SERVICE_start().
2230 * @param srv service to stop
2233 GNUNET_SERVICE_stop (struct GNUNET_SERVICE_Handle *srv)
2235 struct GNUNET_SERVICE_Client *client;
2237 GNUNET_SERVICE_suspend (srv);
2238 while (NULL != (client = srv->clients_head))
2239 GNUNET_SERVICE_client_drop (client);
2240 teardown_service (srv);
2241 GNUNET_free_non_null (srv->handlers);
2247 * Creates the "main" function for a GNUnet service. You
2248 * should almost always use the #GNUNET_SERVICE_MAIN macro
2249 * instead of calling this function directly (except
2250 * for ARM, which should call this function directly).
2252 * The function will launch the service with the name @a service_name
2253 * using the @a service_options to configure its shutdown
2254 * behavior. Once the service is ready, the @a init_cb will be called
2255 * for service-specific initialization. @a init_cb will be given the
2256 * service handler which can be used to control the service's
2257 * availability. When clients connect or disconnect, the respective
2258 * @a connect_cb or @a disconnect_cb functions will be called. For
2259 * messages received from the clients, the respective @a handlers will
2260 * be invoked; for the closure of the handlers we use the return value
2261 * from the @a connect_cb invocation of the respective client.
2263 * Each handler MUST call #GNUNET_SERVICE_client_continue() after each
2264 * message to receive further messages from this client. If
2265 * #GNUNET_SERVICE_client_continue() is not called within a short
2266 * time, a warning will be logged. If delays are expected, services
2267 * should call #GNUNET_SERVICE_client_disable_continue_warning() to
2268 * disable the warning.
2270 * Clients sending invalid messages (based on @a handlers) will be
2271 * dropped. Additionally, clients can be dropped at any time using
2272 * #GNUNET_SERVICE_client_drop().
2274 * @param argc number of command-line arguments in @a argv
2275 * @param argv array of command-line arguments
2276 * @param service_name name of the service to run
2277 * @param options options controlling shutdown of the service
2278 * @param service_init_cb function to call once the service is ready
2279 * @param connect_cb function to call whenever a client connects
2280 * @param disconnect_cb function to call whenever a client disconnects
2281 * @param cls closure argument for @a service_init_cb, @a connect_cb and @a disconnect_cb
2282 * @param handlers NULL-terminated array of message handlers for the service,
2283 * the closure will be set to the value returned by
2284 * the @a connect_cb for the respective connection
2285 * @return 0 on success, non-zero on error
2288 GNUNET_SERVICE_run_ (int argc,
2290 const char *service_name,
2291 enum GNUNET_SERVICE_Options options,
2292 GNUNET_SERVICE_InitCallback service_init_cb,
2293 GNUNET_SERVICE_ConnectHandler connect_cb,
2294 GNUNET_SERVICE_DisconnectHandler disconnect_cb,
2296 const struct GNUNET_MQ_MessageHandler *handlers)
2298 struct GNUNET_SERVICE_Handle sh;
2300 char *opt_cfg_filename;
2305 unsigned long long skew_offset;
2306 unsigned long long skew_variance;
2307 long long clock_offset;
2308 struct GNUNET_CONFIGURATION_Handle *cfg;
2312 struct GNUNET_GETOPT_CommandLineOption service_options[] = {
2313 GNUNET_GETOPT_option_cfgfile (&opt_cfg_filename),
2314 GNUNET_GETOPT_option_flag ('d',
2316 gettext_noop ("do daemonize (detach from terminal)"),
2318 GNUNET_GETOPT_option_help (NULL),
2319 GNUNET_GETOPT_option_loglevel (&loglev),
2320 GNUNET_GETOPT_option_logfile (&logfile),
2321 GNUNET_GETOPT_option_version (PACKAGE_VERSION " " VCS_VERSION),
2322 GNUNET_GETOPT_OPTION_END
2329 xdg = getenv ("XDG_CONFIG_HOME");
2331 GNUNET_asprintf (&cfg_filename,
2335 GNUNET_OS_project_data_get ()->config_file);
2337 cfg_filename = GNUNET_strdup (GNUNET_OS_project_data_get ()->user_config_file);
2338 sh.ready_confirm_fd = -1;
2339 sh.options = options;
2340 sh.cfg = cfg = GNUNET_CONFIGURATION_create ();
2341 sh.service_init_cb = service_init_cb;
2342 sh.connect_cb = connect_cb;
2343 sh.disconnect_cb = disconnect_cb;
2345 sh.handlers = GNUNET_MQ_copy_handlers (handlers);
2346 sh.service_name = service_name;
2348 /* setup subsystems */
2351 opt_cfg_filename = NULL;
2353 ret = GNUNET_GETOPT_run (service_name,
2357 if (GNUNET_SYSERR == ret)
2359 if (GNUNET_NO == ret)
2364 if (GNUNET_OK != GNUNET_log_setup (service_name,
2371 if (NULL != opt_cfg_filename)
2374 GNUNET_DISK_file_test (opt_cfg_filename)) ||
2376 GNUNET_CONFIGURATION_load (cfg,
2377 opt_cfg_filename)) )
2379 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
2380 _("Malformed configuration file `%s', exit ...\n"),
2388 GNUNET_DISK_file_test (cfg_filename))
2390 if (GNUNET_SYSERR ==
2391 GNUNET_CONFIGURATION_load (cfg,
2394 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
2395 _("Malformed configuration file `%s', exit ...\n"),
2402 if (GNUNET_SYSERR ==
2403 GNUNET_CONFIGURATION_load (cfg,
2406 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
2407 _("Malformed configuration, exit ...\n"));
2412 if (GNUNET_OK != setup_service (&sh))
2414 if ( (1 == do_daemonize) &&
2415 (GNUNET_OK != detach_terminal (&sh)) )
2420 if (GNUNET_OK != set_user_id (&sh))
2422 LOG (GNUNET_ERROR_TYPE_DEBUG,
2423 "Service `%s' runs with configuration from `%s'\n",
2425 (NULL != opt_cfg_filename) ? opt_cfg_filename : cfg_filename);
2427 GNUNET_CONFIGURATION_get_value_number (sh.cfg,
2432 GNUNET_CONFIGURATION_get_value_number (sh.cfg,
2437 clock_offset = skew_offset - skew_variance;
2438 GNUNET_TIME_set_offset (clock_offset);
2439 LOG (GNUNET_ERROR_TYPE_DEBUG,
2440 "Skewing clock by %dll ms\n",
2443 GNUNET_RESOLVER_connect (sh.cfg);
2445 /* actually run service */
2447 GNUNET_SCHEDULER_run (&service_main,
2450 if (1 == do_daemonize)
2451 pid_file_delete (&sh);
2454 if (-1 != sh.ready_confirm_fd)
2456 if (1 != WRITE (sh.ready_confirm_fd,
2459 LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING,
2461 GNUNET_break (0 == CLOSE (sh.ready_confirm_fd));
2468 GNUNET_CONFIGURATION_have_value (sh.cfg,
2472 GNUNET_CONFIGURATION_get_value_string (sh.cfg,
2480 GAUGER (service_name,
2484 GNUNET_free (counter);
2488 teardown_service (&sh);
2489 GNUNET_free_non_null (sh.handlers);
2490 GNUNET_SPEEDUP_stop_ ();
2491 GNUNET_CONFIGURATION_destroy (cfg);
2492 GNUNET_free_non_null (logfile);
2493 GNUNET_free_non_null (loglev);
2494 GNUNET_free (cfg_filename);
2495 GNUNET_free_non_null (opt_cfg_filename);
2497 return err ? GNUNET_SYSERR : sh.ret;
2502 * Suspend accepting connections from the listen socket temporarily.
2503 * Resume activity using #GNUNET_SERVICE_resume.
2505 * @param sh service to stop accepting connections.
2508 GNUNET_SERVICE_suspend (struct GNUNET_SERVICE_Handle *sh)
2516 * Resume accepting connections from the listen socket.
2518 * @param sh service to resume accepting connections.
2521 GNUNET_SERVICE_resume (struct GNUNET_SERVICE_Handle *sh)
2529 * Task run to resume receiving data from the client after
2530 * the client called #GNUNET_SERVICE_client_continue().
2532 * @param cls our `struct GNUNET_SERVICE_Client`
2535 resume_client_receive (void *cls)
2537 struct GNUNET_SERVICE_Client *c = cls;
2540 c->recv_task = NULL;
2541 /* first, check if there is still something in the buffer */
2542 ret = GNUNET_MST_next (c->mst,
2544 if (GNUNET_SYSERR == ret)
2546 if (NULL == c->drop_task)
2547 GNUNET_SERVICE_client_drop (c);
2550 if (GNUNET_NO == ret)
2551 return; /* done processing, wait for more later */
2552 GNUNET_assert (GNUNET_OK == ret);
2553 if (GNUNET_YES == c->needs_continue)
2554 return; /* #GNUNET_MST_next() did give a message to the client */
2555 /* need to receive more data from the network first */
2556 if (NULL != c->recv_task)
2559 = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
2561 &service_client_recv,
2567 * Continue receiving further messages from the given client.
2568 * Must be called after each message received.
2570 * @param c the client to continue receiving from
2573 GNUNET_SERVICE_client_continue (struct GNUNET_SERVICE_Client *c)
2575 GNUNET_assert (NULL == c->drop_task);
2576 GNUNET_assert (GNUNET_YES == c->needs_continue);
2577 GNUNET_assert (NULL == c->recv_task);
2578 c->needs_continue = GNUNET_NO;
2579 if (NULL != c->warn_task)
2581 GNUNET_SCHEDULER_cancel (c->warn_task);
2582 c->warn_task = NULL;
2585 = GNUNET_SCHEDULER_add_now (&resume_client_receive,
2591 * Disable the warning the server issues if a message is not
2592 * acknowledged in a timely fashion. Use this call if a client is
2593 * intentionally delayed for a while. Only applies to the current
2596 * @param c client for which to disable the warning
2599 GNUNET_SERVICE_client_disable_continue_warning (struct GNUNET_SERVICE_Client *c)
2601 GNUNET_break (NULL != c->warn_task);
2602 if (NULL != c->warn_task)
2604 GNUNET_SCHEDULER_cancel (c->warn_task);
2605 c->warn_task = NULL;
2611 * Asynchronously finish dropping the client.
2613 * @param cls the `struct GNUNET_SERVICE_Client`.
2616 finish_client_drop (void *cls)
2618 struct GNUNET_SERVICE_Client *c = cls;
2619 struct GNUNET_SERVICE_Handle *sh = c->sh;
2621 c->drop_task = NULL;
2622 GNUNET_assert (NULL == c->send_task);
2623 GNUNET_assert (NULL == c->recv_task);
2624 GNUNET_assert (NULL == c->warn_task);
2625 GNUNET_MST_destroy (c->mst);
2626 GNUNET_MQ_destroy (c->mq);
2627 if (GNUNET_NO == c->persist)
2629 GNUNET_break (GNUNET_OK ==
2630 GNUNET_NETWORK_socket_close (c->sock));
2631 if ( (0 != (SUSPEND_STATE_EMFILE & sh->suspend_state)) &&
2632 (0 == (SUSPEND_STATE_SHUTDOWN & sh->suspend_state)) )
2634 SUSPEND_STATE_EMFILE);
2638 GNUNET_NETWORK_socket_free_memory_only_ (c->sock);
2641 if ( (0 != (SUSPEND_STATE_SHUTDOWN & sh->suspend_state)) &&
2642 (GNUNET_NO == have_non_monitor_clients (sh)) )
2643 GNUNET_SERVICE_shutdown (sh);
2648 * Ask the server to disconnect from the given client. This is the
2649 * same as returning #GNUNET_SYSERR within the check procedure when
2650 * handling a message, wexcept that it allows dropping of a client even
2651 * when not handling a message from that client. The `disconnect_cb`
2652 * will be called on @a c even if the application closes the connection
2653 * using this function.
2655 * @param c client to disconnect now
2658 GNUNET_SERVICE_client_drop (struct GNUNET_SERVICE_Client *c)
2660 struct GNUNET_SERVICE_Handle *sh = c->sh;
2662 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2663 "Client dropped: %p (MQ: %p)\n",
2668 void *backtrace_array[MAX_TRACE_DEPTH];
2669 int num_backtrace_strings = backtrace (backtrace_array, MAX_TRACE_DEPTH);
2670 char **backtrace_strings =
2671 backtrace_symbols (backtrace_array,
2672 t->num_backtrace_strings);
2673 for (unsigned int i = 0; i < num_backtrace_strings; i++)
2674 LOG (GNUNET_ERROR_TYPE_DEBUG,
2675 "client drop trace %u: %s\n",
2677 backtrace_strings[i]);
2680 if (NULL != c->drop_task)
2682 /* asked to drop twice! */
2686 GNUNET_CONTAINER_DLL_remove (sh->clients_head,
2689 if (NULL != sh->disconnect_cb)
2690 sh->disconnect_cb (sh->cb_cls,
2693 if (NULL != c->warn_task)
2695 GNUNET_SCHEDULER_cancel (c->warn_task);
2696 c->warn_task = NULL;
2698 if (NULL != c->recv_task)
2700 GNUNET_SCHEDULER_cancel (c->recv_task);
2701 c->recv_task = NULL;
2703 if (NULL != c->send_task)
2705 GNUNET_SCHEDULER_cancel (c->send_task);
2706 c->send_task = NULL;
2708 c->drop_task = GNUNET_SCHEDULER_add_now (&finish_client_drop,
2714 * Explicitly stops the service.
2716 * @param sh server to shutdown
2719 GNUNET_SERVICE_shutdown (struct GNUNET_SERVICE_Handle *sh)
2721 struct GNUNET_SERVICE_Client *client;
2723 if (0 == (sh->suspend_state & SUSPEND_STATE_SHUTDOWN))
2725 SUSPEND_STATE_SHUTDOWN);
2726 while (NULL != (client = sh->clients_head))
2727 GNUNET_SERVICE_client_drop (client);
2732 * Set the 'monitor' flag on this client. Clients which have been
2733 * marked as 'monitors' won't prevent the server from shutting down
2734 * once #GNUNET_SERVICE_stop_listening() has been invoked. The idea is
2735 * that for "normal" clients we likely want to allow them to process
2736 * their requests; however, monitor-clients are likely to 'never'
2737 * disconnect during shutdown and thus will not be considered when
2738 * determining if the server should continue to exist after
2739 * shutdown has been triggered.
2741 * @param c client to mark as a monitor
2744 GNUNET_SERVICE_client_mark_monitor (struct GNUNET_SERVICE_Client *c)
2746 c->is_monitor = GNUNET_YES;
2747 if ( (0 != (SUSPEND_STATE_SHUTDOWN & c->sh->suspend_state) &&
2748 (GNUNET_NO == have_non_monitor_clients (c->sh)) ) )
2749 GNUNET_SERVICE_shutdown (c->sh);
2754 * Set the persist option on this client. Indicates that the
2755 * underlying socket or fd should never really be closed. Used for
2756 * indicating process death.
2758 * @param c client to persist the socket (never to be closed)
2761 GNUNET_SERVICE_client_persist (struct GNUNET_SERVICE_Client *c)
2763 c->persist = GNUNET_YES;
2768 * Obtain the message queue of @a c. Convenience function.
2770 * @param c the client to continue receiving from
2771 * @return the message queue of @a c
2773 struct GNUNET_MQ_Handle *
2774 GNUNET_SERVICE_client_get_mq (struct GNUNET_SERVICE_Client *c)
2780 /* end of service_new.c */