Merge branch 'master' of gnunet.org:gnunet
[oweals/gnunet.git] / src / util / test_service.c
1 /*
2      This file is part of GNUnet.
3      Copyright (C) 2009, 2013, 2016 GNUnet e.V.
4
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.
9
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.
14     
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/>.
17
18      SPDX-License-Identifier: AGPL3.0-or-later
19 */
20 /**
21  * @file util/test_service.c
22  * @brief tests for service.c
23  * @author Christian Grothoff
24  */
25 #include "platform.h"
26 #include "gnunet_util_lib.h"
27
28 /**
29  * Message type we use for testing.
30  */
31 #define MY_TYPE 256
32
33 #define TIMEOUT GNUNET_TIME_UNIT_SECONDS
34
35 static int global_ret = 1;
36
37 static struct GNUNET_MQ_Handle *mq;
38
39 /**
40  * Timeout task.
41  */
42 static struct GNUNET_SCHEDULER_Task *tt;
43
44
45 static void
46 handle_recv (void *cls,
47              const struct GNUNET_MessageHeader *message)
48 {
49   struct GNUNET_SERVICE_Client *client = cls;
50   
51   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
52               "Received client message...\n");
53   GNUNET_SERVICE_client_continue (client);
54   global_ret = 2;
55   if (NULL != mq)
56   {
57     GNUNET_MQ_destroy (mq);
58     mq = NULL;
59   }
60 }
61
62
63 /**
64  * Function called when the client connects to the service.
65  *
66  * @param cls the name of the service
67  * @param c connecting client
68  * @param mq message queue to talk to the client
69  * @return @a c so we have the client handle in the future
70  */
71 static void *
72 connect_cb (void *cls,
73             struct GNUNET_SERVICE_Client *c,
74             struct GNUNET_MQ_Handle *mq)
75 {
76   /* FIXME: in the future, do something with mq
77      to test sending messages to the client! */
78   return c;
79 }
80
81
82 /**
83  * Function called when the client disconnects.
84  *
85  * @param cls our service name
86  * @param c disconnecting client
87  * @param internal_cls must match @a c
88  */ 
89 static void
90 disconnect_cb (void *cls,
91                struct GNUNET_SERVICE_Client *c,
92                void *internal_cls)
93 {
94   GNUNET_assert (c == internal_cls);
95   if (2 == global_ret)
96   {
97     GNUNET_SCHEDULER_shutdown ();
98     global_ret = 0;
99     if (NULL != tt)
100     {
101       GNUNET_SCHEDULER_cancel (tt);
102       tt = NULL;
103     }
104   }
105 }
106
107
108 static void
109 timeout_task (void *cls)
110 {
111   tt = NULL;
112   if (NULL != mq)
113   {
114     GNUNET_MQ_destroy (mq);
115     mq = NULL;
116   }
117   global_ret = 33;
118   GNUNET_SCHEDULER_shutdown ();
119 }
120
121
122 /**
123  * Initialization function of the service.  Starts
124  * a client to connect to the service.
125  *
126  * @param cls the name of the service (const char *)
127  * @param cfg the configuration we use
128  * @param sh handle to the service
129  */
130 static void
131 service_init (void *cls,
132               const struct GNUNET_CONFIGURATION_Handle *cfg,
133               struct GNUNET_SERVICE_Handle *sh)
134 {
135   const char *service_name = cls;
136   struct GNUNET_MQ_Envelope *env;
137   struct GNUNET_MessageHeader *msg;
138
139   GNUNET_assert (NULL == tt);
140   tt = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
141                                      &timeout_task,
142                                      NULL);
143   mq = GNUNET_CLIENT_connect (cfg,
144                               service_name,
145                               NULL,
146                               NULL,
147                               NULL);
148   GNUNET_assert (NULL != mq);
149   env = GNUNET_MQ_msg (msg,
150                        MY_TYPE);
151   GNUNET_MQ_send (mq,
152                   env);
153 }
154
155
156 /**
157  * Main method, starts the service and initiates
158  * the running of the test.
159  *
160  * @param sname name of the service to run
161  */
162 static int
163 check (const char *sname)
164 {
165   struct GNUNET_MQ_MessageHandler myhandlers[] = {
166     GNUNET_MQ_hd_fixed_size (recv,
167                              MY_TYPE,
168                              struct GNUNET_MessageHeader,
169                              NULL),
170     GNUNET_MQ_handler_end ()
171   };
172   char *const argv[] = {
173     (char *) sname,
174     "-c",
175     "test_service_data.conf",
176     NULL
177   };
178   
179   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
180               "Starting `%s' service\n",
181               sname);
182   global_ret = 1;
183   GNUNET_assert (0 ==
184                  GNUNET_SERVICE_run_ (3,
185                                       argv,
186                                       sname,
187                                       GNUNET_SERVICE_OPTION_NONE,
188                                       &service_init,
189                                       &connect_cb,
190                                       &disconnect_cb,
191                                       (void *) sname,
192                                       myhandlers));
193   return global_ret;
194 }
195
196
197 int
198 main (int argc,
199       char *argv[])
200 {
201   int ret = 0;
202   struct GNUNET_NETWORK_Handle *s = NULL;
203
204   GNUNET_log_setup ("test-service",
205                     "WARNING",
206                     NULL);
207   ret += check ("test_service");
208   ret += check ("test_service");
209 #ifndef MINGW
210   s = GNUNET_NETWORK_socket_create (PF_INET6,
211                                     SOCK_STREAM,
212                                     0);
213 #endif
214   if (NULL == s)
215   {
216     if ( (errno == ENOBUFS) ||
217          (errno == ENOMEM) ||
218          (errno == ENFILE) ||
219          (errno == EACCES) )
220     {
221       GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
222                            "socket");
223       return 1;
224     }
225     FPRINTF (stderr,
226              "IPv6 support seems to not be available (%s), not testing it!\n",
227              strerror (errno));
228   }
229   else
230   {
231     GNUNET_break (GNUNET_OK ==
232                   GNUNET_NETWORK_socket_close (s));
233     ret += check ("test_service6");
234   }
235   return ret;
236 }
237
238 /* end of test_service.c */