9ecdea7e5ef8dba29048889df2eced605938716a
[oweals/gnunet.git] / src / regex / gnunet-regex-profiler.c
1 /*
2      This file is part of GNUnet.
3      (C) 2011 - 2013 Christian Grothoff (and other contributing authors)
4
5      GNUnet is free software; you can redistribute it and/or modify
6      it under the terms of the GNU General Public License as published
7      by the Free Software Foundation; either version 3, or (at your
8      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      General Public License for more details.
14
15      You should have received a copy of the GNU General Public License
16      along with GNUnet; see the file COPYING.  If not, write to the
17      Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18      Boston, MA 02111-1307, USA.
19 */
20
21 /**
22  * @file regex/gnunet-regex-profiler.c
23  * @brief Regex profiler for testing distributed regex use.
24  * @author Bartlomiej Polot
25  * @author Maximilian Szengel
26  *
27  */
28
29 #include <string.h>
30
31 #include "platform.h"
32 #include "gnunet_applications.h"
33 #include "gnunet_util_lib.h"
34 #include "gnunet_regex_lib.h"
35 #include "gnunet_arm_service.h"
36 #include "gnunet_dht_service.h"
37 #include "gnunet_testbed_service.h"
38
39 #define FIND_TIMEOUT \
40         GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 90)
41 #define SEARCHES_IN_PARALLEL 5
42
43 /**
44  * DLL of operations
45  */
46 struct DLLOperation
47 {
48   /**
49    * The testbed operation handle
50    */
51   struct GNUNET_TESTBED_Operation *op;
52
53   /**
54    * Closure
55    */
56   void *cls;
57
58   /**
59    * The next pointer for DLL
60    */
61   struct DLLOperation *next;
62
63   /**
64    * The prev pointer for DLL
65    */
66   struct DLLOperation *prev;
67 };
68
69
70 /**
71  * Available states during profiling
72  */
73 enum State
74 {
75   /**
76    * Initial state
77    */
78   STATE_INIT = 0,
79
80   /**
81    * Starting slaves
82    */
83   STATE_SLAVES_STARTING,
84
85   /**
86    * Creating peers
87    */
88   STATE_PEERS_CREATING,
89
90   /**
91    * Starting peers
92    */
93   STATE_PEERS_STARTING,
94
95   /**
96    * Linking peers
97    */
98   STATE_PEERS_LINKING,
99
100   /**
101    * Matching strings against announced regexes
102    */
103   STATE_SEARCH_REGEX,
104
105   /**
106    * Destroying peers; we can do this as the controller takes care of stopping a
107    * peer if it is running
108    */
109   STATE_PEERS_DESTROYING
110 };
111
112
113 /**
114  * Peer handles.
115  */
116 struct RegexPeer
117 {
118   /**
119    * Peer id.
120    */
121   unsigned int id;
122
123   /**
124    * Peer configuration handle.
125    */
126   struct GNUNET_CONFIGURATION_Handle *cfg;
127
128   /**
129    * The actual testbed peer handle.
130    */
131   struct GNUNET_TESTBED_Peer *peer_handle;
132
133   /**
134    * Host on which the peer is running.
135    */
136   struct GNUNET_TESTBED_Host *host_handle;
137
138   /**
139    * Filename of the peer's policy file.
140    */
141   char *policy_file;
142
143   /**
144    * Peer's search string.
145    */
146   const char *search_str;
147
148   /**
149    * Set to GNUNET_YES if the peer successfully matched the above
150    * search string. GNUNET_NO if the string could not be matched
151    * during the profiler run. GNUNET_SYSERR if the string matching
152    * timed out. Undefined if search_str is NULL
153    */
154   int search_str_matched;
155
156   /**
157    * Peer's ARM handle.
158    */
159   struct GNUNET_ARM_Handle *arm_handle;
160
161   /**
162    * Peer's DHT handle.
163    */
164   struct GNUNET_DHT_Handle *dht_handle;
165
166   /**
167    * Handle to a running regex search.
168    */
169    struct GNUNET_REGEX_search_handle *search_handle;
170
171   /**
172    * Testbed operation handle for the ARM and DHT services.
173    */
174   struct GNUNET_TESTBED_Operation *op_handle;
175
176   /**
177    * Peers's statistics handle.
178    */
179   struct GNUNET_STATISTICS_Handle *stats_handle;
180
181   /**
182    * Testbed operation handle for the statistics service.
183    */
184   struct GNUNET_TESTBED_Operation *stats_op_handle;
185
186   /**
187    * The starting time of a profiling step.
188    */
189   struct GNUNET_TIME_Absolute prof_start_time;
190
191   /**
192    * Operation timeout
193    */
194   GNUNET_SCHEDULER_TaskIdentifier timeout;
195 };
196
197
198 /**
199  * An array of hosts loaded from the hostkeys file
200  */
201 static struct GNUNET_TESTBED_Host **hosts;
202
203 /**
204  * Array of peer handles used to pass to
205  * GNUNET_TESTBED_overlay_configure_topology
206  */
207 static struct GNUNET_TESTBED_Peer **peer_handles;
208
209 /**
210  * The array of peers; we fill this as the peers are given to us by the testbed
211  */
212 static struct RegexPeer *peers;
213
214 /**
215  * Host registration handle
216  */
217 static struct GNUNET_TESTBED_HostRegistrationHandle *reg_handle;
218
219 /**
220  * Handle to the master controller process
221  */
222 static struct GNUNET_TESTBED_ControllerProc *mc_proc;
223
224 /**
225  * Handle to the master controller
226  */
227 static struct GNUNET_TESTBED_Controller *mc;
228
229 /**
230  * Handle to global configuration
231  */
232 static struct GNUNET_CONFIGURATION_Handle *cfg;
233
234 /**
235  * Head of the operations list
236  */
237 static struct DLLOperation *dll_op_head;
238
239 /**
240  * Tail of the operations list
241  */
242 static struct DLLOperation *dll_op_tail;
243
244 /**
245  * Peer linking - topology operation
246  */
247 static struct GNUNET_TESTBED_Operation *topology_op;
248
249 /**
250  * The handle for whether a host is habitable or not
251  */
252 struct GNUNET_TESTBED_HostHabitableCheckHandle **hc_handles;
253
254 /**
255  * Abort task identifier
256  */
257 static GNUNET_SCHEDULER_TaskIdentifier abort_task;
258
259 /**
260  * Shutdown task identifier
261  */
262 static GNUNET_SCHEDULER_TaskIdentifier shutdown_task;
263
264 /**
265  * Host registration task identifier
266  */
267 static GNUNET_SCHEDULER_TaskIdentifier register_hosts_task;
268
269 /**
270  * Global event mask for all testbed events
271  */
272 static uint64_t event_mask;
273
274 /**
275  * The starting time of a profiling step
276  */
277 static struct GNUNET_TIME_Absolute prof_start_time;
278
279 /**
280  * Duration profiling step has taken
281  */
282 static struct GNUNET_TIME_Relative prof_time;
283
284 /**
285  * Number of peers to be started by the profiler
286  */
287 static unsigned int num_peers;
288
289 /**
290  * Number of hosts in the hosts array
291  */
292 static unsigned int num_hosts;
293
294 /**
295  * Factor of number of links. num_links = num_peers * linking_factor.
296  */
297 static unsigned int linking_factor;
298
299 /**
300  * Number of random links to be established between peers
301  */
302 static unsigned int num_links;
303
304 /**
305  * Number of connect operations that have failed, candidates to retry
306  */
307 static unsigned int retry_links;
308
309 /**
310  * Global testing status
311  */
312 static int result;
313
314 /**
315  * current state of profiling
316  */
317 enum State state;
318
319 /**
320  * Folder where policy files are stored.
321  */
322 static char * policy_dir;
323
324 /**
325  * Search strings.
326  */
327 static char **search_strings;
328
329 /**
330  * Number of search strings.
331  */
332 static int num_search_strings;
333
334 /**
335  * How many searches are running in parallel
336  */
337 static unsigned int parallel_searches;
338
339 /**
340  * Number of peers found with search strings.
341  */
342 static unsigned int peers_found;
343
344 /**
345  * Index of peer to start next announce/search.
346  */
347 static unsigned int next_search;
348
349 /**
350  * Search task identifier
351  */
352 static GNUNET_SCHEDULER_TaskIdentifier search_task;
353
354 /**
355  * Search timeout task identifier.
356  */
357 static GNUNET_SCHEDULER_TaskIdentifier search_timeout_task;
358
359 /**
360  * Search timeout in seconds.
361  */
362 static struct GNUNET_TIME_Relative search_timeout_time = { 60000 };
363
364 /**
365  * How long do we wait before starting the search?
366  * Default: 1 m.
367  */
368 static struct GNUNET_TIME_Relative search_delay = { 60000 };
369
370 /**
371  * File to log statistics to.
372  */
373 static struct GNUNET_DISK_FileHandle *data_file;
374
375 /**
376  * Filename to log statistics to.
377  */
378 static char *data_filename;
379
380 /**
381  * Maximal path compression length.
382  */
383 static unsigned int max_path_compression;
384
385 /**
386  * Prefix used for regex announcing. We need to prefix the search
387  * strings with it, in order to find something.
388  */
389 static char * regex_prefix;
390
391 /**
392  * What's the maximum regex reannounce period.
393  */
394 static struct GNUNET_TIME_Relative reannounce_period_max;
395
396
397 /******************************************************************************/
398 /******************************  DECLARATIONS  ********************************/
399 /******************************************************************************/
400
401 /**
402  * DHT connect callback.
403  *
404  * @param cls internal peer id.
405  * @param op operation handle.
406  * @param ca_result connect adapter result.
407  * @param emsg error message.
408  */
409 static void
410 dht_connect_cb (void *cls, struct GNUNET_TESTBED_Operation *op,
411                 void *ca_result, const char *emsg);
412
413 /**
414  * DHT connect adapter.
415  *
416  * @param cls not used.
417  * @param cfg configuration handle.
418  *
419  * @return
420  */
421 static void *
422 dht_ca (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg);
423
424
425 /**
426  * Adapter function called to destroy a connection to
427  * the DHT service
428  *
429  * @param cls closure
430  * @param op_result service handle returned from the connect adapter
431  */
432 static void
433 dht_da (void *cls, void *op_result);
434
435
436 /**
437  * Function called by testbed once we are connected to stats
438  * service. Get the statistics for the services of interest.
439  *
440  * @param cls the 'struct RegexPeer' for which we connected to stats
441  * @param op connect operation handle
442  * @param ca_result handle to stats service
443  * @param emsg error message on failure
444  */
445 static void
446 stats_connect_cb (void *cls,
447                   struct GNUNET_TESTBED_Operation *op,
448                   void *ca_result,
449                   const char *emsg);
450
451
452 /**
453  * Task to collect all statistics from s, will shutdown the
454  * profiler, when done.
455  *
456  * @param cls NULL
457  * @param tc the task context
458  */
459 static void
460 do_collect_stats (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
461
462
463 /**
464  * Start announcing the next regex in the DHT.
465  *
466  * @param cls Index of the next peer in the peers array.
467  * @param tc TaskContext.
468  */
469 static void
470 announce_next_regex (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
471
472
473 /******************************************************************************/
474 /********************************  SHUTDOWN  **********************************/
475 /******************************************************************************/
476
477
478 /**
479  * Shutdown nicely
480  *
481  * @param cls NULL
482  * @param tc the task context
483  */
484 static void
485 do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
486 {
487   struct DLLOperation *dll_op;
488   struct RegexPeer *peer;
489   unsigned int nhost;
490   unsigned int peer_cnt;
491   unsigned int search_str_cnt;
492   char output_buffer[512];
493   size_t size;
494
495   shutdown_task = GNUNET_SCHEDULER_NO_TASK;
496   if (GNUNET_SCHEDULER_NO_TASK != abort_task)
497     GNUNET_SCHEDULER_cancel (abort_task);
498   if (NULL != hc_handles)
499   {
500     for (nhost = 0; nhost < num_hosts; nhost++)
501       if (NULL != hc_handles[nhost])
502         GNUNET_TESTBED_is_host_habitable_cancel (hc_handles[nhost]);
503     GNUNET_free (hc_handles);
504     hc_handles = NULL;
505   }
506   if (GNUNET_SCHEDULER_NO_TASK != register_hosts_task)
507     GNUNET_SCHEDULER_cancel (register_hosts_task);
508
509   for (peer_cnt = 0; peer_cnt < num_peers; peer_cnt++)
510   {
511     peer = &peers[peer_cnt];
512
513     if (GNUNET_YES != peer->search_str_matched && NULL != data_file)
514     {
515       prof_time = GNUNET_TIME_absolute_get_duration (peer->prof_start_time);
516       size =
517         GNUNET_snprintf (output_buffer,
518                          sizeof (output_buffer),
519                          "%p Search string not found: %s (%d)\n%p On peer: %u (%p)\n%p With policy file: %s\n%p After: %s\n",
520                          peer, peer->search_str, peer->search_str_matched,
521                          peer, peer->id, peer,
522                          peer, peer->policy_file,
523                          peer,
524                          GNUNET_STRINGS_relative_time_to_string (prof_time,
525                                                                  GNUNET_NO));
526       if (size != GNUNET_DISK_file_write (data_file, output_buffer, size))
527         GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Unable to write to file!\n");
528     }
529
530     if (NULL != peers[peer_cnt].op_handle)
531       GNUNET_TESTBED_operation_done (peers[peer_cnt].op_handle);
532     if (NULL != peers[peer_cnt].stats_op_handle)
533       GNUNET_TESTBED_operation_done (peers[peer_cnt].stats_op_handle);
534   }
535
536   if (NULL != data_file)
537     GNUNET_DISK_file_close (data_file);
538
539   for (search_str_cnt = 0;
540        search_str_cnt < num_search_strings && NULL != search_strings;
541        search_str_cnt++)
542   {
543     GNUNET_free_non_null (search_strings[search_str_cnt]);
544   }
545   GNUNET_free_non_null (search_strings);
546
547   if (NULL != reg_handle)
548     GNUNET_TESTBED_cancel_registration (reg_handle);
549   if (NULL != topology_op)
550     GNUNET_TESTBED_operation_done (topology_op);
551   for (nhost = 0; nhost < num_hosts; nhost++)
552     if (NULL != hosts[nhost])
553       GNUNET_TESTBED_host_destroy (hosts[nhost]);
554   GNUNET_free_non_null (hosts);
555
556   while (NULL != (dll_op = dll_op_head))
557   {
558     GNUNET_TESTBED_operation_done (dll_op->op);
559     GNUNET_CONTAINER_DLL_remove (dll_op_head, dll_op_tail, dll_op);
560     GNUNET_free (dll_op);
561   }
562   if (NULL != mc)
563     GNUNET_TESTBED_controller_disconnect (mc);
564   if (NULL != mc_proc)
565     GNUNET_TESTBED_controller_stop (mc_proc);
566   if (NULL != cfg)
567     GNUNET_CONFIGURATION_destroy (cfg);
568
569   GNUNET_SCHEDULER_shutdown (); /* Stop scheduler to shutdown testbed run */
570 }
571
572
573 /**
574  * abort task to run on test timed out
575  *
576  * @param cls NULL
577  * @param tc the task context
578  */
579 static void
580 do_abort (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
581 {
582   unsigned long i = (unsigned long) cls;
583
584   GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Aborting %lu...\n", i);
585   abort_task = GNUNET_SCHEDULER_NO_TASK;
586   result = GNUNET_SYSERR;
587   if (GNUNET_SCHEDULER_NO_TASK != shutdown_task)
588     GNUNET_SCHEDULER_cancel (shutdown_task);
589   shutdown_task = GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
590 }
591
592
593 /******************************************************************************/
594 /*********************  STATISTICS SERVICE CONNECTIONS  ***********************/
595 /******************************************************************************/
596
597 /**
598  * Adapter function called to establish a connection to
599  * statistics service.
600  *
601  * @param cls closure
602  * @param cfg configuration of the peer to connect to; will be available until
603  *          GNUNET_TESTBED_operation_done() is called on the operation returned
604  *          from GNUNET_TESTBED_service_connect()
605  * @return service handle to return in 'op_result', NULL on error
606  */
607 static void *
608 stats_ca (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
609 {
610   return GNUNET_STATISTICS_create ("<driver>", cfg);
611 }
612
613
614 /**
615  * Adapter function called to destroy a connection to
616  * statistics service.
617  *
618  * @param cls closure
619  * @param op_result service handle returned from the connect adapter
620  */
621 static void
622 stats_da (void *cls, void *op_result)
623 {
624   struct RegexPeer *peer = cls;
625
626   GNUNET_assert (op_result == peer->stats_handle);
627
628   GNUNET_STATISTICS_destroy (peer->stats_handle, GNUNET_NO);
629   peer->stats_handle = NULL;
630 }
631
632
633 /**
634  * Process statistic values. Write all values to global 'data_file', if present.
635  *
636  * @param cls closure
637  * @param subsystem name of subsystem that created the statistic
638  * @param name the name of the datum
639  * @param value the current value
640  * @param is_persistent GNUNET_YES if the value is persistent, GNUNET_NO if not
641  * @return GNUNET_OK to continue, GNUNET_SYSERR to abort iteration
642  */
643 static int
644 stats_iterator (void *cls, const char *subsystem, const char *name,
645                 uint64_t value, int is_persistent)
646 {
647   struct RegexPeer *peer = cls;
648   char output_buffer[512];
649   size_t size;
650
651   if (NULL == data_file)
652   {
653     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
654                 "%p -> %s [%s]: %llu\n",
655                 peer, subsystem, name, value);
656     return GNUNET_OK;
657   }
658   size =
659     GNUNET_snprintf (output_buffer,
660                      sizeof (output_buffer),
661                      "%p [%s] %llu %s\n",
662                      peer,
663                      subsystem, value, name);
664   if (size != GNUNET_DISK_file_write (data_file, output_buffer, size))
665     GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Unable to write to file!\n");
666
667   return GNUNET_OK;
668 }
669
670
671 /**
672  * Stats callback. Finish the stats testbed operation and when all stats have
673  * been iterated, shutdown the profiler.
674  *
675  * @param cls closure
676  * @param success GNUNET_OK if statistics were
677  *        successfully obtained, GNUNET_SYSERR if not.
678  */
679 static void
680 stats_cb (void *cls,
681           int success)
682 {
683   static unsigned int peer_cnt;
684   struct RegexPeer *peer = cls;
685
686   if (GNUNET_OK != success)
687   {
688     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
689                 "Getting statistics for peer %u failed!\n",
690                 peer->id);
691     return;
692   }
693
694   GNUNET_assert (NULL != peer->stats_op_handle);
695
696   GNUNET_TESTBED_operation_done (peer->stats_op_handle);
697   peer->stats_op_handle = NULL;
698
699   peer_cnt++;
700   peer = &peers[peer_cnt];
701
702   if (peer_cnt == num_peers)
703   {
704     struct GNUNET_TIME_Relative delay = { 100 };
705     shutdown_task = GNUNET_SCHEDULER_add_delayed (delay, &do_shutdown, NULL);
706   }
707   else
708   {
709     peer->stats_op_handle =
710       GNUNET_TESTBED_service_connect (NULL,
711                                       peer->peer_handle,
712                                       "statistics",
713                                       &stats_connect_cb,
714                                       peer,
715                                       &stats_ca,
716                                       &stats_da,
717                                       peer);
718   }
719 }
720
721
722 /**
723  * Function called by testbed once we are connected to stats
724  * service. Get the statistics for the services of interest.
725  *
726  * @param cls the 'struct RegexPeer' for which we connected to stats
727  * @param op connect operation handle
728  * @param ca_result handle to stats service
729  * @param emsg error message on failure
730  */
731 static void
732 stats_connect_cb (void *cls,
733                   struct GNUNET_TESTBED_Operation *op,
734                   void *ca_result,
735                   const char *emsg)
736 {
737   struct RegexPeer *peer = cls;
738
739   if (NULL == ca_result || NULL != emsg)
740   {
741     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
742                 "Failed to connect to statistics service on peer %u: %s\n",
743                 peer->id, emsg);
744
745     peer->stats_handle = NULL;
746     return;
747   }
748
749   peer->stats_handle = ca_result;
750
751   if (NULL == GNUNET_STATISTICS_get (peer->stats_handle, NULL, NULL,
752                                      GNUNET_TIME_UNIT_FOREVER_REL,
753                                      &stats_cb,
754                                      &stats_iterator, peer))
755   {
756     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
757                 "Could not get statistics of peer %u!\n", peer->id);
758   }
759 }
760
761
762 /**
763  * Task to collect all statistics from all peers, will shutdown the
764  * profiler, when done.
765  *
766  * @param cls NULL
767  * @param tc the task context
768  */
769 static void
770 do_collect_stats (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
771 {
772   struct RegexPeer *peer = &peers[0];
773
774   GNUNET_assert (NULL != peer->peer_handle);
775
776   peer->stats_op_handle =
777     GNUNET_TESTBED_service_connect (NULL,
778                                     peer->peer_handle,
779                                     "statistics",
780                                     &stats_connect_cb,
781                                     peer,
782                                     &stats_ca,
783                                     &stats_da,
784                                     peer);
785 }
786
787
788 /******************************************************************************/
789 /************************   REGEX FIND CONNECTIONS   **************************/
790 /******************************************************************************/
791
792
793 /**
794  * Start searching for the next string in the DHT.
795  *
796  * @param cls Index of the next peer in the peers array.
797  * @param tc TaskContext.
798  */
799 static void
800 find_string (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
801
802
803 /**
804  * Method called when we've found a peer that announced a regex
805  * that matches our search string. Now get the statistics.
806  *
807  * @param cls Closure provided in GNUNET_REGEX_search.
808  * @param id Peer providing a regex that matches the string.
809  * @param get_path Path of the get request.
810  * @param get_path_length Lenght of get_path.
811  * @param put_path Path of the put request.
812  * @param put_path_length Length of the put_path.
813  */
814 static void
815 regex_found_handler (void *cls,
816                      const struct GNUNET_PeerIdentity *id,
817                      const struct GNUNET_PeerIdentity *get_path,
818                      unsigned int get_path_length,
819                      const struct GNUNET_PeerIdentity *put_path,
820                      unsigned int put_path_length)
821 {
822   struct RegexPeer *peer = cls;
823   char output_buffer[512];
824   size_t size;
825
826   if (GNUNET_YES == peer->search_str_matched)
827   {
828     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
829                 "String %s on peer %u already matched!\n",
830                 peer->search_str, peer->id);
831     return;
832   }
833
834   peers_found++;
835   parallel_searches--;
836
837   if (GNUNET_SCHEDULER_NO_TASK != peer->timeout)
838   {
839     GNUNET_SCHEDULER_cancel (peer->timeout);
840     peer->timeout = GNUNET_SCHEDULER_NO_TASK;
841     GNUNET_SCHEDULER_add_now (&announce_next_regex, NULL);
842   }
843
844   if (NULL == id)
845   {
846     // FIXME not possible right now
847     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
848                 "String matching timed out for string %s on peer %u (%i/%i)\n",
849                 peer->search_str, peer->id, peers_found, num_search_strings);
850     peer->search_str_matched = GNUNET_SYSERR;
851   }
852   else
853   {
854     prof_time = GNUNET_TIME_absolute_get_duration (peer->prof_start_time);
855
856     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
857                 "String %s found on peer %u after %s (%i/%i) (%u||)\n",
858                 peer->search_str, peer->id,
859                 GNUNET_STRINGS_relative_time_to_string (prof_time, GNUNET_NO),
860                 peers_found, num_search_strings, parallel_searches);
861
862     peer->search_str_matched = GNUNET_YES;
863
864     if (NULL != data_file)
865     {
866       size =
867         GNUNET_snprintf (output_buffer,
868                          sizeof (output_buffer),
869                          "%p Peer: %u\n%p Host: %s\n%p Policy file: %s\n"
870                          "%p Search string: %s\n%p Search duration: %s\n\n",
871                          peer, peer->id,
872                          peer,
873                          GNUNET_TESTBED_host_get_hostname (peer->host_handle),
874                          peer, peer->policy_file,
875                          peer, peer->search_str,
876                          peer,
877                          GNUNET_STRINGS_relative_time_to_string (prof_time,
878                                                                  GNUNET_NO));
879
880       if (size != GNUNET_DISK_file_write (data_file, output_buffer, size))
881         GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Unable to write to file!\n");
882     }
883   }
884
885   GNUNET_TESTBED_operation_done (peer->op_handle);
886   peer->op_handle = NULL;
887
888   if (peers_found == num_search_strings)
889   {
890     prof_time = GNUNET_TIME_absolute_get_duration (prof_start_time);
891     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
892                 "All strings successfully matched in %s\n",
893                 GNUNET_STRINGS_relative_time_to_string (prof_time, GNUNET_NO));
894
895     if (GNUNET_SCHEDULER_NO_TASK != search_timeout_task)
896       GNUNET_SCHEDULER_cancel (search_timeout_task);
897
898     GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Collecting stats and shutting down.\n");
899     GNUNET_SCHEDULER_add_now (&do_collect_stats, NULL);
900   }
901 }
902
903
904 /**
905  * Connect by string timeout task. This will cancel the profiler after the
906  * specified timeout 'search_timeout'.
907  *
908  * @param cls NULL
909  * @param tc the task context
910  */
911 static void
912 search_timeout (void *cls,
913                               const struct GNUNET_SCHEDULER_TaskContext * tc)
914 {
915   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
916               "Finding matches to all strings did not succeed after %s.\n",
917               GNUNET_STRINGS_relative_time_to_string (search_timeout_time,
918                                                       GNUNET_NO));
919   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
920               "Found %i of %i strings\n", peers_found, num_search_strings);
921
922   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
923               "Search timed out after %s."
924               "Collecting stats and shutting down.\n", 
925               GNUNET_STRINGS_relative_time_to_string (search_timeout_time,
926                                                       GNUNET_NO));
927
928   GNUNET_SCHEDULER_add_now (&do_collect_stats, NULL);
929 }
930
931
932 /**
933  * Search timed out. It might still complete in the future,
934  * but we should start another one.
935  *
936  * @param cls Index of the next peer in the peers array.
937  * @param tc TaskContext.
938  */
939 static void
940 find_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
941 {
942   struct RegexPeer *p = cls;
943
944   p->timeout = GNUNET_SCHEDULER_NO_TASK;
945
946   if ((tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
947     return;
948   GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
949               "Searching for string \"%s\" on peer %d timed out. Starting new search.\n",
950               p->search_str,
951               p->id);
952   GNUNET_SCHEDULER_add_now (&announce_next_regex, NULL);
953 }
954
955
956 /**
957  * Start searching for a string in the DHT.
958  *
959  * @param cls Index of the next peer in the peers array.
960  * @param tc TaskContext.
961  */
962 static void
963 find_string (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
964 {
965   unsigned int search_peer = (unsigned int) (long) cls;
966
967   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) ||
968       search_peer >= num_search_strings)
969     return;
970
971   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
972               "Searching for string \"%s\" on peer %d with file %s (%u||)\n",
973               peers[search_peer].search_str,
974               search_peer,
975               peers[search_peer].policy_file,
976               parallel_searches);
977
978   peers[search_peer].op_handle =
979     GNUNET_TESTBED_service_connect (NULL,
980                                     peers[search_peer].peer_handle,
981                                     "dht",
982                                     &dht_connect_cb,
983                                     &peers[search_peer],
984                                     &dht_ca,
985                                     &dht_da,
986                                     &peers[search_peer]);
987   GNUNET_assert (NULL != peers[search_peer].op_handle);
988   peers[search_peer].timeout = GNUNET_SCHEDULER_add_delayed (FIND_TIMEOUT,
989                                                           &find_timeout,
990                                                           &peers[search_peer]);
991 }
992
993
994 /**
995  * ARM connect adapter. Opens a connection to the ARM service.
996  *
997  * @param cls Closure (peer).
998  * @param cfg Configuration handle.
999  *
1000  * @return
1001  */
1002 static void *
1003 arm_ca (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
1004 {
1005   struct RegexPeer *peer = cls;
1006
1007   peer->arm_handle = GNUNET_ARM_connect (cfg, NULL, NULL);
1008
1009   return peer->arm_handle;
1010 }
1011
1012
1013 /**
1014  * Adapter function called to destroy a connection to the ARM service.
1015  *
1016  * @param cls Closure (peer).
1017  * @param op_result Service handle returned from the connect adapter.
1018  */
1019 static void
1020 arm_da (void *cls, void *op_result)
1021 {
1022   struct RegexPeer *peer = (struct RegexPeer *) cls;
1023
1024   GNUNET_assert (peer->arm_handle == op_result);
1025
1026   if (NULL != peer->arm_handle)
1027   {
1028     GNUNET_ARM_disconnect_and_free (peer->arm_handle);
1029     peer->arm_handle = NULL;
1030   }
1031 }
1032
1033 /**
1034  * Finish and free the operation used to start the regex daemon.
1035  * operation_done calls ARM_disconnect, which cannot happen inside an
1036  * ARM callback.
1037  *
1038  * @param cls Closure (Peer info)
1039  * @param tc TaskContext
1040  */
1041 static void
1042 arm_op_done (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
1043 {
1044   struct RegexPeer *peer = (struct RegexPeer *) cls;
1045
1046   GNUNET_TESTBED_operation_done (peer->op_handle);
1047   peer->op_handle = NULL;
1048 }
1049
1050
1051 /**
1052  * Callback called when arm has started the daemon we asked for.
1053  * 
1054  * @param cls           Closure ().
1055  * @param arm           Arm handle.
1056  * @param rs            Status of the request.
1057  * @param service       Service we asked to start (deamon).
1058  * @param result        Result of the request.
1059  */
1060 static void
1061 arm_start_cb (void *cls, struct GNUNET_ARM_Handle *arm,
1062     enum GNUNET_ARM_RequestStatus rs, const char *service,
1063     enum GNUNET_ARM_Result result)
1064 {
1065   struct RegexPeer *peer = (struct RegexPeer *) cls;
1066
1067   if (rs != GNUNET_ARM_REQUEST_SENT_OK)
1068   {
1069     GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "ARM request was not sent: %u\n", rs);
1070     GNUNET_abort ();
1071   }
1072   switch (result)
1073   {
1074       /**
1075        * Asked to start it, but it's already starting.
1076        */
1077     case GNUNET_ARM_RESULT_IS_STARTING_ALREADY:
1078       GNUNET_break (0); /* Shouldn't be starting, however it's not fatal. */
1079       /* fallthrough */
1080
1081       /**
1082        * Service is currently being started (due to client request).
1083        */
1084     case GNUNET_ARM_RESULT_STARTING:
1085       GNUNET_SCHEDULER_add_now (&arm_op_done, peer);
1086
1087       {
1088         unsigned long search_peer;
1089         unsigned int i;
1090         unsigned int me;
1091
1092         me = peer - peers;
1093
1094         /* Find a peer to look for a string matching the regex announced */
1095         search_peer = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
1096                                                 num_peers);
1097         for (i = 0; peers[search_peer].search_str != NULL; i++)
1098         {
1099           search_peer = (search_peer + 1) % num_peers;
1100           if (i > num_peers)
1101             GNUNET_abort (); /* we ran out of peers, must be a bug */
1102         }
1103         peers[search_peer].search_str = search_strings[me];
1104         peers[search_peer].search_str_matched = GNUNET_NO;
1105         GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply(
1106                                         reannounce_period_max,
1107                                         2),
1108                                       &find_string,
1109                                       (void *) search_peer);
1110       }
1111       if (next_search >= num_peers &&
1112           GNUNET_SCHEDULER_NO_TASK == search_timeout_task)
1113       {
1114         GNUNET_log (GNUNET_ERROR_TYPE_INFO, "All daemons started.\n");
1115         /* FIXME start GLOBAL timeout to abort experiment */
1116         search_timeout_task = GNUNET_SCHEDULER_add_delayed (search_timeout_time,
1117                                                             &search_timeout,
1118                                                             NULL);
1119       }
1120       break;
1121
1122     default:
1123       GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "ARM returned %d\n", result);
1124       GNUNET_abort ();
1125   }
1126 }
1127
1128 /**
1129  * ARM connect callback. Called when we are connected to the arm service for
1130  * the peer in 'cls'. If successfull we start the regex deamon to start
1131  * announcing the regex of this peer.
1132  *
1133  * @param cls internal peer id.
1134  * @param op operation handle.
1135  * @param ca_result connect adapter result.
1136  * @param emsg error message.
1137  */
1138 static void
1139 arm_connect_cb (void *cls, struct GNUNET_TESTBED_Operation *op,
1140                 void *ca_result, const char *emsg)
1141 {
1142   struct RegexPeer *peer = (struct RegexPeer *) cls;
1143
1144   if (NULL != emsg || NULL == op || NULL == ca_result)
1145   {
1146     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "ARM connect failed: %s\n", emsg);
1147     GNUNET_abort ();
1148   }
1149
1150   GNUNET_assert (NULL != peer->arm_handle);
1151   GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[]%p - ()%p\n", peer->op_handle, op);
1152   GNUNET_assert (peer->op_handle == op);
1153   GNUNET_assert (peer->arm_handle == ca_result);
1154
1155   GNUNET_ARM_request_service_start (ca_result, "regexprofiler",
1156                                     GNUNET_OS_INHERIT_STD_NONE,
1157                                     GNUNET_TIME_UNIT_FOREVER_REL,
1158                                     arm_start_cb, cls);
1159 }
1160
1161
1162 /**
1163  * Task to start the daemons on each peer so that the regexes are announced
1164  * into the DHT.
1165  *
1166  * @param cls NULL
1167  * @param tc the task context
1168  */
1169 static void
1170 do_announce (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
1171 {
1172   unsigned int i;
1173
1174   GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Starting announce.\n");
1175
1176   for (i = 0; i < SEARCHES_IN_PARALLEL; i++)
1177   {
1178     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
1179                 "  scheduling announce %u\n",
1180                 i);
1181     (void) GNUNET_SCHEDULER_add_now (&announce_next_regex, NULL);
1182   }
1183 }
1184
1185
1186 /**
1187  * Start announcing the next regex in the DHT.
1188  *
1189  * @param cls Closure (unused).
1190  * @param tc TaskContext.
1191  */
1192 static void
1193 announce_next_regex (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
1194 {
1195   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) ||
1196             next_search >= num_peers)
1197     return;
1198
1199   /* First connect to arm service, then announce. Next
1200    * a nnounce will be in arm_connect_cb */
1201   GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Starting daemon %u\n", next_search);
1202   peers[next_search].op_handle =
1203     GNUNET_TESTBED_service_connect (NULL,
1204                                     peers[next_search].peer_handle,
1205                                     "arm",
1206                                     &arm_connect_cb,
1207                                     &peers[next_search],
1208                                     &arm_ca,
1209                                     &arm_da,
1210                                     &peers[next_search]);
1211   next_search++;
1212   parallel_searches++;
1213 }
1214
1215 /**
1216  * DHT connect callback. Called when we are connected to the dht service for
1217  * the peer in 'cls'. If successfull we connect to the stats service of this
1218  * peer and then try to match the search string of this peer.
1219  *
1220  * @param cls internal peer id.
1221  * @param op operation handle.
1222  * @param ca_result connect adapter result.
1223  * @param emsg error message.
1224  */
1225 static void
1226 dht_connect_cb (void *cls, struct GNUNET_TESTBED_Operation *op,
1227                 void *ca_result, const char *emsg)
1228 {
1229   struct RegexPeer *peer = (struct RegexPeer *) cls;
1230
1231   if (NULL != emsg || NULL == op || NULL == ca_result)
1232   {
1233     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "DHT connect failed: %s\n", emsg);
1234     GNUNET_abort ();
1235   }
1236
1237   GNUNET_assert (NULL != peer->dht_handle);
1238   GNUNET_assert (peer->op_handle == op);
1239   GNUNET_assert (peer->dht_handle == ca_result);
1240
1241   peer->search_str_matched = GNUNET_NO;
1242   peer->search_handle = GNUNET_REGEX_search (peer->dht_handle,
1243                                              peer->search_str,
1244                                              &regex_found_handler, peer,
1245                                              NULL);
1246   peer->prof_start_time = GNUNET_TIME_absolute_get ();
1247 }
1248
1249
1250 /**
1251  * DHT connect adapter. Opens a connection to the dht service.
1252  *
1253  * @param cls Closure (peer).
1254  * @param cfg Configuration handle.
1255  *
1256  * @return
1257  */
1258 static void *
1259 dht_ca (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
1260 {
1261   struct RegexPeer *peer = cls;
1262
1263   peer->dht_handle = GNUNET_DHT_connect (cfg, 32);
1264
1265   return peer->dht_handle;
1266 }
1267
1268
1269 /**
1270  * Adapter function called to destroy a connection to the dht service.
1271  *
1272  * @param cls Closure (peer).
1273  * @param op_result Service handle returned from the connect adapter.
1274  */
1275 static void
1276 dht_da (void *cls, void *op_result)
1277 {
1278   struct RegexPeer *peer = (struct RegexPeer *) cls;
1279
1280   GNUNET_assert (peer->dht_handle == op_result);
1281
1282   if (NULL != peer->search_handle)
1283   {
1284     GNUNET_REGEX_search_cancel (peer->search_handle);
1285     peer->search_handle = NULL;
1286   }
1287
1288   if (NULL != peer->dht_handle)
1289   {
1290     GNUNET_DHT_disconnect (peer->dht_handle);
1291     peer->dht_handle = NULL;
1292   }
1293 }
1294
1295
1296 /******************************************************************************/
1297 /***************************  TESTBED PEER SETUP  *****************************/
1298 /******************************************************************************/
1299
1300
1301 /**
1302  * Configure the peer overlay topology.
1303  *
1304  * @param cls NULL
1305  * @param tc the task context
1306  */
1307 static void
1308 do_configure_topology (void *cls,
1309                        const struct GNUNET_SCHEDULER_TaskContext * tc)
1310 {
1311   /*
1312     if (0 == linking_factor)
1313     linking_factor = 1;
1314     num_links = linking_factor * num_peers;
1315   */
1316   /* num_links = num_peers - 1; */
1317   num_links = linking_factor;
1318
1319   /* Do overlay connect */
1320   prof_start_time = GNUNET_TIME_absolute_get ();
1321   topology_op =
1322     GNUNET_TESTBED_overlay_configure_topology (NULL, num_peers, peer_handles,
1323                                                NULL,
1324                                                NULL,
1325                                                NULL,
1326                                                GNUNET_TESTBED_TOPOLOGY_ERDOS_RENYI,
1327                                                num_links,
1328                                                GNUNET_TESTBED_TOPOLOGY_RETRY_CNT,
1329                                                (unsigned int) 0,
1330                                                GNUNET_TESTBED_TOPOLOGY_OPTION_END);
1331   if (NULL == topology_op)
1332   {
1333     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1334                 "Cannot create topology, op handle was NULL\n");
1335     GNUNET_assert (0);
1336   }
1337 }
1338
1339
1340 /**
1341  * Functions of this signature are called when a peer has been successfully
1342  * started or stopped.
1343  *
1344  * @param cls the closure from GNUNET_TESTBED_peer_start/stop()
1345  * @param emsg NULL on success; otherwise an error description
1346  */
1347 static void
1348 peer_churn_cb (void *cls, const char *emsg)
1349 {
1350   struct DLLOperation *dll_op = cls;
1351   struct GNUNET_TESTBED_Operation *op;
1352   static unsigned int started_peers;
1353   unsigned int peer_cnt;
1354
1355   op = dll_op->op;
1356   GNUNET_CONTAINER_DLL_remove (dll_op_head, dll_op_tail, dll_op);
1357   GNUNET_free (dll_op);
1358   if (NULL != emsg)
1359   {
1360     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1361          _("An operation has failed while starting peers: %s\n"), emsg);
1362     GNUNET_TESTBED_operation_done (op);
1363     if (GNUNET_SCHEDULER_NO_TASK != abort_task)
1364       GNUNET_SCHEDULER_cancel (abort_task);
1365     abort_task = GNUNET_SCHEDULER_add_now (&do_abort, (void*) __LINE__);
1366     return;
1367   }
1368   GNUNET_TESTBED_operation_done (op);
1369   if (++started_peers == num_peers)
1370   {
1371     prof_time = GNUNET_TIME_absolute_get_duration (prof_start_time);
1372     GNUNET_log (GNUNET_ERROR_TYPE_INFO, 
1373                 "All peers started successfully in %s\n",
1374                 GNUNET_STRINGS_relative_time_to_string (prof_time, GNUNET_NO));
1375     result = GNUNET_OK;
1376
1377     peer_handles = GNUNET_malloc (sizeof (struct GNUNET_TESTBED_Peer *) * num_peers);
1378     for (peer_cnt = 0; peer_cnt < num_peers; peer_cnt++)
1379       peer_handles[peer_cnt] = peers[peer_cnt].peer_handle;
1380
1381     state = STATE_PEERS_LINKING;
1382     GNUNET_SCHEDULER_add_now (&do_configure_topology, NULL);
1383   }
1384 }
1385
1386
1387 /**
1388  * Functions of this signature are called when a peer has been successfully
1389  * created
1390  *
1391  * @param cls the closure from GNUNET_TESTBED_peer_create()
1392  * @param peer the handle for the created peer; NULL on any error during
1393  *          creation
1394  * @param emsg NULL if peer is not NULL; else MAY contain the error description
1395  */
1396 static void
1397 peer_create_cb (void *cls, struct GNUNET_TESTBED_Peer *peer, const char *emsg)
1398 {
1399   struct DLLOperation *dll_op = cls;
1400   struct RegexPeer *peer_ptr;
1401   static unsigned int created_peers;
1402   unsigned int peer_cnt;
1403
1404   if (NULL != emsg)
1405   {
1406     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1407          _("Creating a peer failed. Error: %s\n"), emsg);
1408     GNUNET_TESTBED_operation_done (dll_op->op);
1409     GNUNET_CONTAINER_DLL_remove (dll_op_head, dll_op_tail, dll_op);
1410     GNUNET_free (dll_op);
1411     if (GNUNET_SCHEDULER_NO_TASK != abort_task)
1412       GNUNET_SCHEDULER_cancel (abort_task);
1413     abort_task = GNUNET_SCHEDULER_add_now (&do_abort, (void*) __LINE__);
1414     return;
1415   }
1416
1417   peer_ptr = dll_op->cls;
1418   GNUNET_assert (NULL == peer_ptr->peer_handle);
1419   GNUNET_CONFIGURATION_destroy (peer_ptr->cfg);
1420   peer_ptr->cfg = NULL;
1421   peer_ptr->peer_handle = peer;
1422   GNUNET_TESTBED_operation_done (dll_op->op);
1423   GNUNET_CONTAINER_DLL_remove (dll_op_head, dll_op_tail, dll_op);
1424   GNUNET_free (dll_op);
1425
1426   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peer %i created on host %s\n",
1427               peer_ptr->id,
1428               GNUNET_TESTBED_host_get_hostname (peer_ptr->host_handle));
1429
1430   if (++created_peers == num_peers)
1431   {
1432     prof_time = GNUNET_TIME_absolute_get_duration (prof_start_time);
1433     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
1434                 "All peers created successfully in %s\n",
1435                 GNUNET_STRINGS_relative_time_to_string (prof_time, GNUNET_NO));
1436     /* Now peers are to be started */
1437     state = STATE_PEERS_STARTING;
1438     prof_start_time = GNUNET_TIME_absolute_get ();
1439     for (peer_cnt = 0; peer_cnt < num_peers; peer_cnt++)
1440     {
1441       dll_op = GNUNET_malloc (sizeof (struct DLLOperation));
1442       dll_op->op = GNUNET_TESTBED_peer_start (dll_op,
1443                                               peers[peer_cnt].peer_handle,
1444                                               &peer_churn_cb, dll_op);
1445       GNUNET_CONTAINER_DLL_insert_tail (dll_op_head, dll_op_tail, dll_op);
1446     }
1447   }
1448 }
1449
1450
1451 /**
1452  * Function called with a filename for each file in the policy directory. Create
1453  * a peer for each filename and update the peer's configuration to include the
1454  * max_path_compression specified as a command line argument as well as the
1455  * policy_file for this peer. The gnunet-service-regexprofiler service is
1456  * automatically started on this peer. The service reads the configurration and
1457  * announces the regexes stored in the policy file 'filename'.
1458  *
1459  * @param cls closure
1460  * @param filename complete filename (absolute path)
1461  * @return GNUNET_OK to continue to iterate,
1462  *  GNUNET_SYSERR to abort iteration with error!
1463  */
1464 static int
1465 policy_filename_cb (void *cls, const char *filename)
1466 {
1467   static unsigned int peer_cnt;
1468   struct DLLOperation *dll_op;
1469   struct RegexPeer *peer = &peers[peer_cnt];
1470
1471   GNUNET_assert (NULL != peer);
1472
1473   peer->policy_file = GNUNET_strdup (filename);
1474
1475   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
1476               "Creating peer %i on host %s for policy file %s\n",
1477               peer->id, GNUNET_TESTBED_host_get_hostname (peer->host_handle),
1478               filename);
1479
1480   /* Set configuration options specific for this peer
1481      (max_path_compression and policy_file */
1482   peer->cfg = GNUNET_CONFIGURATION_dup (cfg);
1483   GNUNET_CONFIGURATION_set_value_number (peer->cfg, "REGEXPROFILER",
1484                                          "MAX_PATH_COMPRESSION",
1485                                          (unsigned long long)
1486                                          max_path_compression);
1487   GNUNET_CONFIGURATION_set_value_string (peer->cfg, "REGEXPROFILER",
1488                                          "POLICY_FILE", filename);
1489
1490   dll_op = GNUNET_malloc (sizeof (struct DLLOperation));
1491   dll_op->cls = &peers[peer_cnt];
1492   dll_op->op = GNUNET_TESTBED_peer_create (mc,
1493                                            peer->host_handle,
1494                                            peer->cfg,
1495                                            &peer_create_cb,
1496                                            dll_op);
1497   GNUNET_CONTAINER_DLL_insert_tail (dll_op_head, dll_op_tail, dll_op);
1498
1499   peer_cnt++;
1500
1501   return GNUNET_OK;
1502 }
1503
1504
1505 /**
1506  * Controller event callback.
1507  *
1508  * @param cls NULL
1509  * @param event the controller event
1510  */
1511 static void
1512 controller_event_cb (void *cls,
1513                      const struct GNUNET_TESTBED_EventInformation *event)
1514 {
1515   struct DLLOperation *dll_op;
1516   struct GNUNET_TESTBED_Operation *op;
1517   int ret;
1518
1519   switch (state)
1520   {
1521   case STATE_SLAVES_STARTING:
1522     switch (event->type)
1523     {
1524     case GNUNET_TESTBED_ET_OPERATION_FINISHED:
1525       {
1526         static unsigned int slaves_started;
1527         unsigned int peer_cnt;
1528
1529         dll_op = event->op_cls;
1530         GNUNET_CONTAINER_DLL_remove (dll_op_head, dll_op_tail, dll_op);
1531         GNUNET_free (dll_op);
1532         op = event->op;
1533         if (NULL != event->details.operation_finished.emsg)
1534         {
1535           GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1536                _("An operation has failed while starting slaves\n"));
1537           GNUNET_TESTBED_operation_done (op);
1538           if (GNUNET_SCHEDULER_NO_TASK != abort_task)
1539             GNUNET_SCHEDULER_cancel (abort_task);
1540           abort_task = GNUNET_SCHEDULER_add_now (&do_abort, (void*) __LINE__);
1541           return;
1542         }
1543         GNUNET_TESTBED_operation_done (op);
1544         /* Proceed to start peers */
1545         if (++slaves_started == num_hosts - 1)
1546         {
1547           GNUNET_log (GNUNET_ERROR_TYPE_INFO,
1548                       "All slaves started successfully\n");
1549
1550           state = STATE_PEERS_CREATING;
1551           prof_start_time = GNUNET_TIME_absolute_get ();
1552
1553           if (-1 == (ret = GNUNET_DISK_directory_scan (policy_dir,
1554                                                        NULL,
1555                                                        NULL)))
1556           {
1557             GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1558                         _("No files found in `%s'\n"),
1559                         policy_dir);
1560             GNUNET_SCHEDULER_shutdown ();
1561             return;
1562           }
1563           num_peers = (unsigned int) ret;
1564           peers = GNUNET_malloc (sizeof (struct RegexPeer) * num_peers);
1565
1566           /* Initialize peers */
1567           for (peer_cnt = 0; peer_cnt < num_peers; peer_cnt++)
1568           {
1569             struct RegexPeer *peer = &peers[peer_cnt];
1570             peer->id = peer_cnt;
1571             peer->policy_file = NULL;
1572             /* Do not start peers on hosts[0] (master controller) */
1573             peer->host_handle = hosts[1 + (peer_cnt % (num_hosts -1))];
1574             peer->dht_handle = NULL;
1575             peer->search_handle = NULL;
1576             peer->stats_handle = NULL;
1577             peer->stats_op_handle = NULL;
1578             peer->search_str = NULL;
1579             peer->search_str_matched = GNUNET_NO;
1580           }
1581
1582           GNUNET_DISK_directory_scan (policy_dir,
1583                                       &policy_filename_cb,
1584                                       NULL);
1585         }
1586       }
1587       break;
1588     default:
1589       GNUNET_assert (0);
1590     }
1591     break;
1592   case STATE_PEERS_STARTING:
1593     switch (event->type)
1594     {
1595     case GNUNET_TESTBED_ET_OPERATION_FINISHED:
1596       /* Control reaches here when peer start fails */
1597     case GNUNET_TESTBED_ET_PEER_START:
1598       /* we handle peer starts in peer_churn_cb */
1599       break;
1600     default:
1601       GNUNET_assert (0);
1602     }
1603     break;
1604   case STATE_PEERS_LINKING:
1605    switch (event->type)
1606    {
1607      static unsigned int established_links;
1608    case GNUNET_TESTBED_ET_OPERATION_FINISHED:
1609      /* Control reaches here when a peer linking operation fails */
1610      if (NULL != event->details.operation_finished.emsg)
1611      {
1612        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1613                    _("An operation has failed while linking\n"));
1614        printf ("F%u/%u(%s)",
1615                retry_links + 1, established_links + 1, 
1616                event->details.operation_finished.emsg);
1617        fflush (stdout);
1618        retry_links++;
1619      }
1620      /* We do no retries, consider this link as established */
1621      /* break; */
1622    case GNUNET_TESTBED_ET_CONNECT:
1623    {
1624      char output_buffer[1024];
1625      size_t size;
1626
1627      if (0 == established_links)
1628        GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Establishing links .");
1629      else
1630      {
1631        printf (".");fflush (stdout);
1632      }
1633      if (++established_links == num_links)
1634      {
1635        prof_time = GNUNET_TIME_absolute_get_duration (prof_start_time);
1636        GNUNET_log (GNUNET_ERROR_TYPE_INFO,
1637                    "%u links established in %s\n",
1638                    num_links,
1639                    GNUNET_STRINGS_relative_time_to_string (prof_time,
1640                                                            GNUNET_NO));
1641        prof_time = GNUNET_TIME_relative_divide(prof_time, num_links);
1642        GNUNET_log (GNUNET_ERROR_TYPE_INFO,
1643                    "Average of %s per connection\n",
1644                    GNUNET_STRINGS_relative_time_to_string (prof_time,
1645                                                            GNUNET_NO));
1646        result = GNUNET_OK;
1647        GNUNET_free (peer_handles);
1648
1649        if (NULL != data_file)
1650        {
1651          size =
1652            GNUNET_snprintf (output_buffer,
1653                             sizeof (output_buffer),
1654                             "# of peers: %u\n# of links established: %u\n"
1655                             "Time to establish links: %s\n"
1656                             "Linking failures: %u\n"
1657                             "path compression length: %u\n"
1658                             "# of search strings: %u\n",
1659                             num_peers,
1660                             (established_links - retry_links),
1661                             GNUNET_STRINGS_relative_time_to_string (prof_time,
1662                                                                     GNUNET_NO),
1663                             retry_links,
1664                             max_path_compression,
1665                             num_search_strings);
1666
1667          if (size != GNUNET_DISK_file_write (data_file, output_buffer, size))
1668            GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Unable to write to file!\n");
1669        }
1670
1671        GNUNET_log (GNUNET_ERROR_TYPE_INFO,
1672                    "\nWaiting %s before starting to announce.\n",
1673                    GNUNET_STRINGS_relative_time_to_string (search_delay,
1674                                                            GNUNET_NO));
1675        state = STATE_SEARCH_REGEX;
1676        search_task = GNUNET_SCHEDULER_add_delayed (search_delay,
1677                                                    &do_announce, NULL);
1678      }
1679    }
1680    break;
1681    default:
1682      GNUNET_assert (0);
1683    }
1684    break;
1685   case STATE_SEARCH_REGEX:
1686   {
1687     /* Handled in service connect callback */
1688     break;
1689   }
1690   default:
1691     switch (state)
1692     {
1693     case STATE_PEERS_CREATING:
1694       GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to create peer\n");
1695       break;
1696     default:
1697       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1698                   "Unexpected controller_cb with state %i!\n", state);
1699     }
1700     GNUNET_assert (0);
1701   }
1702 }
1703
1704
1705 /**
1706  * Task to register all hosts available in the global host list.
1707  *
1708  * @param cls NULL
1709  * @param tc the scheduler task context
1710  */
1711 static void
1712 register_hosts (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
1713
1714
1715 /**
1716  * Callback which will be called to after a host registration succeeded or failed
1717  *
1718  * @param cls the closure
1719  * @param emsg the error message; NULL if host registration is successful
1720  */
1721 static void
1722 host_registration_completion (void *cls, const char *emsg)
1723 {
1724   reg_handle = NULL;
1725   if (NULL != emsg)
1726   {
1727     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1728                 _("Host registration failed for a host. Error: %s\n"), emsg);
1729     if (GNUNET_SCHEDULER_NO_TASK != abort_task)
1730       GNUNET_SCHEDULER_cancel (abort_task);
1731     abort_task = GNUNET_SCHEDULER_add_now (&do_abort, (void*) __LINE__);
1732     return;
1733   }
1734   register_hosts_task = GNUNET_SCHEDULER_add_now (&register_hosts, NULL);
1735 }
1736
1737
1738 /**
1739  * Task to register all hosts available in the global host list.
1740  *
1741  * @param cls NULL
1742  * @param tc the scheduler task context
1743  */
1744 static void
1745 register_hosts (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
1746 {
1747   struct DLLOperation *dll_op;
1748   static unsigned int reg_host;
1749   unsigned int slave;
1750
1751   register_hosts_task = GNUNET_SCHEDULER_NO_TASK;
1752   if (reg_host == num_hosts - 1)
1753   {
1754     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
1755                 "All hosts successfully registered\n");
1756     /* Start slaves */
1757     state = STATE_SLAVES_STARTING;
1758     for (slave = 1; slave < num_hosts; slave++)
1759     {
1760       dll_op = GNUNET_malloc (sizeof (struct DLLOperation));
1761       dll_op->op = GNUNET_TESTBED_controller_link (dll_op,
1762                                                    mc,
1763                                                    hosts[slave],
1764                                                    hosts[0],
1765                                                    cfg,
1766                                                    GNUNET_YES);
1767       GNUNET_CONTAINER_DLL_insert_tail (dll_op_head, dll_op_tail, dll_op);
1768     }
1769     return;
1770   }
1771   reg_handle = GNUNET_TESTBED_register_host (mc, hosts[++reg_host],
1772                                              host_registration_completion,
1773                                              NULL);
1774 }
1775
1776
1777 /**
1778  * Callback to signal successfull startup of the controller process.
1779  *
1780  * @param cls the closure from GNUNET_TESTBED_controller_start()
1781  * @param config the configuration with which the controller has been started;
1782  *          NULL if status is not GNUNET_OK
1783  * @param status GNUNET_OK if the startup is successfull; GNUNET_SYSERR if not,
1784  *          GNUNET_TESTBED_controller_stop() shouldn't be called in this case
1785  */
1786 static void
1787 status_cb (void *cls, const struct GNUNET_CONFIGURATION_Handle *config, int status)
1788 {
1789   if (GNUNET_SCHEDULER_NO_TASK != abort_task)
1790     GNUNET_SCHEDULER_cancel (abort_task);
1791   if (GNUNET_OK != status)
1792   {
1793     mc_proc = NULL;
1794     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Oh, dear!\n");
1795     abort_task = GNUNET_SCHEDULER_add_now (&do_abort, (void*) __LINE__);
1796     return;
1797   }
1798   event_mask = 0;
1799   event_mask |= (1LL << GNUNET_TESTBED_ET_PEER_START);
1800   event_mask |= (1LL << GNUNET_TESTBED_ET_PEER_STOP);
1801   event_mask |= (1LL << GNUNET_TESTBED_ET_CONNECT);
1802   event_mask |= (1LL << GNUNET_TESTBED_ET_DISCONNECT);
1803   event_mask |= (1LL << GNUNET_TESTBED_ET_OPERATION_FINISHED);
1804   mc = GNUNET_TESTBED_controller_connect (hosts[0], event_mask,
1805                                           &controller_event_cb, NULL);
1806   if (NULL == mc)
1807   {
1808     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1809                 _("Unable to connect to master controller -- Check config\n"));
1810     abort_task = GNUNET_SCHEDULER_add_now (&do_abort, (void*) __LINE__);
1811     return;
1812   }
1813   register_hosts_task = GNUNET_SCHEDULER_add_now (&register_hosts, NULL);
1814   abort_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
1815                                              &do_abort, (void*) __LINE__);
1816 }
1817
1818
1819 /**
1820  * Load search strings from given filename. One search string per line.
1821  *
1822  * @param filename filename of the file containing the search strings.
1823  * @param strings set of strings loaded from file. Caller needs to free this
1824  *                if number returned is greater than zero.
1825  * @param limit upper limit on the number of strings read from the file
1826  * @return number of strings found in the file. GNUNET_SYSERR on error.
1827  */
1828 static int
1829 load_search_strings (const char *filename, char ***strings, unsigned int limit)
1830 {
1831   char *data;
1832   char *buf;
1833   uint64_t filesize;
1834   unsigned int offset;
1835   int str_cnt;
1836   unsigned int i;
1837
1838   if (NULL == filename)
1839   {
1840     return GNUNET_SYSERR;
1841   }
1842
1843   if (GNUNET_YES != GNUNET_DISK_file_test (filename))
1844   {
1845     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1846                 "Could not find search strings file %s\n", filename);
1847     return GNUNET_SYSERR;
1848   }
1849   if (GNUNET_OK != GNUNET_DISK_file_size (filename, &filesize, GNUNET_YES, GNUNET_YES))
1850     filesize = 0;
1851   if (0 == filesize)
1852   {
1853     GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Search strings file %s is empty.\n", filename);
1854     return GNUNET_SYSERR;
1855   }
1856   data = GNUNET_malloc (filesize);
1857   if (filesize != GNUNET_DISK_fn_read (filename, data, filesize))
1858   {
1859     GNUNET_free (data);
1860     GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Could not read search strings file %s.\n",
1861          filename);
1862     return GNUNET_SYSERR;
1863   }
1864   buf = data;
1865   offset = 0;
1866   str_cnt = 0;
1867   while (offset < (filesize - 1) && str_cnt < limit)
1868   {
1869     offset++;
1870     if (((data[offset] == '\n')) && (buf != &data[offset]))
1871     {
1872       data[offset] = '\0';
1873       str_cnt++;
1874       buf = &data[offset + 1];
1875     }
1876     else if ((data[offset] == '\n') || (data[offset] == '\0'))
1877       buf = &data[offset + 1];
1878   }
1879   *strings = GNUNET_malloc (sizeof (char *) * str_cnt);
1880   offset = 0;
1881   for (i = 0; i < str_cnt; i++)
1882   {
1883     GNUNET_asprintf (&(*strings)[i], "%s%s", regex_prefix, &data[offset]);
1884     offset += strlen (&data[offset]) + 1;
1885   }
1886   GNUNET_free (data);
1887   return str_cnt;
1888 }
1889
1890
1891 /**
1892  * Callbacks of this type are called by GNUNET_TESTBED_is_host_habitable to
1893  * inform whether the given host is habitable or not. The Handle returned by
1894  * GNUNET_TESTBED_is_host_habitable() is invalid after this callback is called
1895  *
1896  * @param cls NULL
1897  * @param host the host whose status is being reported; will be NULL if the host
1898  *          given to GNUNET_TESTBED_is_host_habitable() is NULL
1899  * @param status GNUNET_YES if it is habitable; GNUNET_NO if not
1900  */
1901 static void 
1902 host_habitable_cb (void *cls, const struct GNUNET_TESTBED_Host *host, int status)
1903 {
1904   struct GNUNET_TESTBED_HostHabitableCheckHandle **hc_handle = cls;
1905   static unsigned int hosts_checked;
1906
1907   *hc_handle = NULL;
1908   if (GNUNET_NO == status)
1909   {
1910     if ((NULL != host) && (NULL != GNUNET_TESTBED_host_get_hostname (host)))
1911       GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Host %s cannot start testbed\n"),
1912                   GNUNET_TESTBED_host_get_hostname (host));
1913     else
1914       GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Testbed cannot be started on localhost\n"));
1915     GNUNET_SCHEDULER_cancel (abort_task);
1916     abort_task = GNUNET_SCHEDULER_add_now (&do_abort, (void*) __LINE__);
1917     return;
1918   }
1919   hosts_checked++;
1920   /* printf (_("\rChecked %u hosts"), hosts_checked); */
1921   /* fflush (stdout); */
1922   if (hosts_checked < num_hosts)
1923     return;
1924   /* printf (_("\nAll hosts can start testbed. Creating peers\n")); */
1925   GNUNET_free (hc_handles);
1926   hc_handles = NULL;
1927   mc_proc = 
1928       GNUNET_TESTBED_controller_start (GNUNET_TESTBED_host_get_hostname
1929                                        (hosts[0]),
1930                                        hosts[0],
1931                                        status_cb,
1932                                        NULL);
1933 }
1934
1935
1936 /**
1937  * Main function that will be run by the scheduler.
1938  *
1939  * @param cls closure
1940  * @param args remaining command-line arguments
1941  * @param cfgfile name of the configuration file used (for saving, can be NULL!)
1942  * @param config configuration
1943  */
1944 static void
1945 run (void *cls, char *const *args, const char *cfgfile,
1946      const struct GNUNET_CONFIGURATION_Handle *config)
1947 {
1948   unsigned int nhost;
1949   unsigned int nsearchstrs;
1950
1951   if (NULL == args[0])
1952   {
1953     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1954                 _("No hosts-file specified on command line. Exiting.\n"));
1955     return;
1956   }
1957   if (NULL == args[1])
1958   {
1959     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1960                 _("No policy directory specified on command line. Exiting.\n"));
1961     return;
1962   }
1963   num_hosts = GNUNET_TESTBED_hosts_load_from_file (args[0], config, &hosts);
1964   if (0 == num_hosts)
1965   {
1966     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1967                 _("No hosts loaded. Need at least one host\n"));
1968     return;
1969   }
1970   GNUNET_log (GNUNET_ERROR_TYPE_INFO, 
1971               _("Checking whether given hosts can start testbed."
1972                 "Please wait\n"));
1973   hc_handles = GNUNET_malloc (sizeof (struct
1974                                       GNUNET_TESTBED_HostHabitableCheckHandle *) 
1975                               * num_hosts);
1976   for (nhost = 0; nhost < num_hosts; nhost++)
1977   {
1978     hc_handles[nhost] = GNUNET_TESTBED_is_host_habitable (hosts[nhost], config,
1979                                                           &host_habitable_cb,
1980                                                           &hc_handles[nhost]);
1981     if (NULL == hc_handles[nhost])
1982     {
1983       int i;
1984
1985       GNUNET_break (0);
1986       for (i = 0; i <= nhost; i++)
1987         if (NULL != hc_handles[i])
1988           GNUNET_TESTBED_is_host_habitable_cancel (hc_handles[i]);
1989       GNUNET_free (hc_handles);
1990       hc_handles = NULL;
1991       break;
1992     }
1993   }
1994   if (num_hosts != nhost)
1995   {
1996     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Exiting\n"));
1997     shutdown_task = GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
1998     return;
1999   }
2000   if (NULL == config)
2001   {
2002     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
2003                 _("No configuration file given. Exiting\n"));
2004     shutdown_task = GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
2005     return;
2006   }
2007
2008   if (GNUNET_OK !=
2009       GNUNET_CONFIGURATION_get_value_string (config, "REGEXPROFILER", "REGEX_PREFIX",
2010                                              &regex_prefix))
2011   {
2012     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
2013                 _("Configuration option \"regex_prefix\" missing. Exiting\n"));
2014     shutdown_task = GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
2015     return;
2016   }
2017
2018   if ( (NULL != data_filename) &&
2019        (NULL == (data_file =
2020                  GNUNET_DISK_file_open (data_filename,
2021                                         GNUNET_DISK_OPEN_READWRITE |
2022                                         GNUNET_DISK_OPEN_TRUNCATE |
2023                                         GNUNET_DISK_OPEN_CREATE,
2024                                         GNUNET_DISK_PERM_USER_READ |
2025                                         GNUNET_DISK_PERM_USER_WRITE))) )
2026     GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR,
2027                               "open",
2028                               data_filename);
2029   if (GNUNET_YES != GNUNET_DISK_directory_test (args[1], GNUNET_YES))
2030   {
2031     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
2032                 _("Specified policies directory does not exist. Exiting.\n"));
2033     shutdown_task = GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
2034     return;
2035   }
2036   policy_dir = args[1];
2037   if (GNUNET_YES != GNUNET_DISK_file_test (args[2]))
2038   {
2039     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
2040                 _("No search strings file given. Exiting.\n"));
2041     shutdown_task = GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
2042     return;
2043   }
2044   nsearchstrs = load_search_strings (args[2], &search_strings, num_search_strings);
2045   if (num_search_strings != nsearchstrs)
2046   {
2047     num_search_strings = nsearchstrs;
2048     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
2049                 _("Error loading search strings."
2050                   "Given file does not contain enough strings. Exiting.\n"));
2051     shutdown_task = GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
2052     return;
2053   }
2054   if (0 >= num_search_strings || NULL == search_strings)
2055   {
2056     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
2057                 _("Error loading search strings. Exiting.\n"));
2058     shutdown_task = GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
2059     return;
2060   }
2061   cfg = GNUNET_CONFIGURATION_dup (config);
2062   if (GNUNET_OK !=
2063       GNUNET_CONFIGURATION_get_value_time (cfg, "REGEXPROFILER",
2064                                            "REANNOUNCE_PERIOD_MAX",
2065                                            &reannounce_period_max))
2066   {
2067     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, 
2068                 "reannounce_period_max not given. Using 10 minutes.\n");
2069     reannounce_period_max =
2070       GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 10);
2071   }
2072   unsigned int i;
2073   for (i = 0; i < num_search_strings; i++)
2074     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "search string: %s\n", search_strings[i]);
2075   abort_task =
2076       GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
2077                                     (GNUNET_TIME_UNIT_SECONDS, 5), &do_abort,
2078                                     (void*) __LINE__);
2079 }
2080
2081
2082 /**
2083  * Main function.
2084  *
2085  * @param argc argument count
2086  * @param argv argument values
2087  * @return 0 on success
2088  */
2089 int
2090 main (int argc, char *const *argv)
2091 {
2092   static const struct GNUNET_GETOPT_CommandLineOption options[] = {
2093     {'d', "details", "FILENAME",
2094      gettext_noop ("name of the file for writing statistics"),
2095      1, &GNUNET_GETOPT_set_string, &data_filename},
2096     {'n', "num-links", "COUNT",
2097       gettext_noop ("create COUNT number of random links between peers"),
2098       GNUNET_YES, &GNUNET_GETOPT_set_uint, &linking_factor },
2099     {'t', "matching-timeout", "TIMEOUT",
2100       gettext_noop ("wait TIMEOUT before considering a string match as failed"),
2101       GNUNET_YES, &GNUNET_GETOPT_set_relative_time, &search_timeout_time
2102         },
2103     {'s', "search-delay", "DELAY",
2104       gettext_noop ("wait DELAY before starting string search"),
2105       GNUNET_YES, &GNUNET_GETOPT_set_relative_time, &search_delay },
2106     {'a', "num-search-strings", "COUNT",
2107       gettext_noop ("number of search strings to read from search strings file"),
2108       GNUNET_YES, &GNUNET_GETOPT_set_uint, &num_search_strings },
2109     {'p', "max-path-compression", "MAX_PATH_COMPRESSION",
2110      gettext_noop ("maximum path compression length"),
2111      1, &GNUNET_GETOPT_set_uint, &max_path_compression},
2112     GNUNET_GETOPT_OPTION_END
2113   };
2114   int ret;
2115
2116   if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
2117     return 2;
2118
2119   result = GNUNET_SYSERR;
2120   ret =
2121       GNUNET_PROGRAM_run (argc, argv,
2122                           "gnunet-regex-profiler [OPTIONS] hosts-file policy-dir search-strings-file",
2123                           _("Profiler for regex"),
2124                           options, &run, NULL);
2125
2126   if (GNUNET_OK != ret)
2127     return ret;
2128   if (GNUNET_OK != result)
2129     return 1;
2130   return 0;
2131 }