formatting

1 files changed, 169 insertions, 226 deletions

diff --git a/src/fs/gnunet-auto-share.c b/src/fs/gnunet-auto-share.c
index bb14ac7e8..ba28c5c23 100644
--- a/src/fs/gnunet-auto-share.c
+++ b/src/fs/gnunet-auto-share.c
@@ -11,7 +11,7 @@
      WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      Affero General Public License for more details.
-    
+
      You should have received a copy of the GNU Affero General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
@@ -167,9 +167,11 @@ get_state_file ()
   char *ret;
 
   GNUNET_asprintf (&ret,
-                   "%s%s.auto-share",
-                   dir_name,
-                   (DIR_SEPARATOR == dir_name[strlen(dir_name)-1]) ? "" : DIR_SEPARATOR_STR);
+                   "%s%s.auto-share",
+                   dir_name,
+                   (DIR_SEPARATOR == dir_name[strlen (dir_name) - 1])
+                     ? ""
+                     : DIR_SEPARATOR_STR);
   return ret;
 }
 
@@ -198,39 +200,36 @@ load_state ()
     goto error;
   while (n-- > 0)
   {
-    if ( (GNUNET_OK !=
-          GNUNET_BIO_read_string (rh, "filename", &fn, 1024)) ||
-         (GNUNET_OK !=
-          GNUNET_BIO_read (rh, "id", &id, sizeof (struct GNUNET_HashCode))) )
+    if ((GNUNET_OK != GNUNET_BIO_read_string (rh, "filename", &fn, 1024)) ||
+        (GNUNET_OK !=
+         GNUNET_BIO_read (rh, "id", &id, sizeof (struct GNUNET_HashCode))))
       goto error;
     wi = GNUNET_new (struct WorkItem);
     wi->id = id;
     wi->filename = fn;
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Loaded serialization ID for `%s' is `%s'\n",
-                wi->filename,
-                GNUNET_h2s (&id));
+                "Loaded serialization ID for `%s' is `%s'\n",
+                wi->filename,
+                GNUNET_h2s (&id));
     fn = NULL;
-    GNUNET_CRYPTO_hash (wi->filename,
-                        strlen (wi->filename),
-                        &id);
+    GNUNET_CRYPTO_hash (wi->filename, strlen (wi->filename), &id);
     GNUNET_break (GNUNET_OK ==
-                  GNUNET_CONTAINER_multihashmap_put (work_finished,
-                                                     &id,
-                                                     wi,
-                                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+                  GNUNET_CONTAINER_multihashmap_put (
+                    work_finished,
+                    &id,
+                    wi,
+                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
   }
-  if (GNUNET_OK ==
-      GNUNET_BIO_read_close (rh, &emsg))
+  if (GNUNET_OK == GNUNET_BIO_read_close (rh, &emsg))
     return;
   rh = NULL;
- error:
+error:
   GNUNET_free_non_null (fn);
   if (NULL != rh)
     (void) GNUNET_BIO_read_close (rh, &emsg);
   GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-              _("Failed to load state: %s\n"),
-              emsg);
+              _ ("Failed to load state: %s\n"),
+              emsg);
   GNUNET_free_non_null (emsg);
 }
 
@@ -244,23 +243,18 @@ load_state ()
  * @return #GNUNET_OK to continue to iterate (if write worked)
  */
 static int
-write_item (void *cls,
-            const struct GNUNET_HashCode *key,
-            void *value)
+write_item (void *cls, const struct GNUNET_HashCode *key, void *value)
 {
   struct GNUNET_BIO_WriteHandle *wh = cls;
   struct WorkItem *wi = value;
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Saving serialization ID of file `%s' with value `%s'\n",
-              wi->filename,
-              GNUNET_h2s (&wi->id));
-  if ( (GNUNET_OK !=
-        GNUNET_BIO_write_string (wh, wi->filename)) ||
-       (GNUNET_OK !=
-        GNUNET_BIO_write (wh,
-                          &wi->id,
-                          sizeof (struct GNUNET_HashCode))) )
+              "Saving serialization ID of file `%s' with value `%s'\n",
+              wi->filename,
+              GNUNET_h2s (&wi->id));
+  if ((GNUNET_OK != GNUNET_BIO_write_string (wh, wi->filename)) ||
+      (GNUNET_OK !=
+       GNUNET_BIO_write (wh, &wi->id, sizeof (struct GNUNET_HashCode))))
     return GNUNET_SYSERR; /* write error, abort iteration */
   return GNUNET_OK;
 }
@@ -282,28 +276,25 @@ save_state ()
   if (NULL == wh)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                _("Failed to save state to file %s\n"),
-                fn);
+                _ ("Failed to save state to file %s\n"),
+                fn);
     GNUNET_free (fn);
     return;
   }
-  if (GNUNET_OK !=
-      GNUNET_BIO_write_int32 (wh, n))
+  if (GNUNET_OK != GNUNET_BIO_write_int32 (wh, n))
   {
     (void) GNUNET_BIO_write_close (wh);
     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                _("Failed to save state to file %s\n"),
-                fn);
+                _ ("Failed to save state to file %s\n"),
+                fn);
     GNUNET_free (fn);
     return;
   }
-  (void) GNUNET_CONTAINER_multihashmap_iterate (work_finished,
-                                                &write_item,
-                                                wh);
+  (void) GNUNET_CONTAINER_multihashmap_iterate (work_finished, &write_item, wh);
   if (GNUNET_OK != GNUNET_BIO_write_close (wh))
     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                _("Failed to save state to file %s\n"),
-                fn);
+                _ ("Failed to save state to file %s\n"),
+                fn);
   GNUNET_free (fn);
 }
 
@@ -319,8 +310,7 @@ do_stop_task (void *cls)
   do_shutdown = GNUNET_YES;
   if (NULL != publish_proc)
   {
-    GNUNET_OS_process_kill (publish_proc,
-                            SIGKILL);
+    GNUNET_OS_process_kill (publish_proc, SIGKILL);
     return;
   }
   if (NULL != run_task)
@@ -357,25 +347,22 @@ maint_child_death (void *cls)
   const struct GNUNET_SCHEDULER_TaskContext *tc;
 
   run_task = NULL;
-  pr = GNUNET_DISK_pipe_handle (sigpipe,
-                                GNUNET_DISK_PIPE_END_READ);
+  pr = GNUNET_DISK_pipe_handle (sigpipe, GNUNET_DISK_PIPE_END_READ);
   tc = GNUNET_SCHEDULER_get_task_context ();
   if (0 == (tc->reason & GNUNET_SCHEDULER_REASON_READ_READY))
   {
     /* shutdown scheduled us, someone else will kill child,
        we should just try again */
-    run_task =
-      GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
-                                      pr,
-                                      &maint_child_death, wi);
+    run_task = GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
+                                               pr,
+                                               &maint_child_death,
+                                               wi);
     return;
   }
   /* consume the signal */
   GNUNET_break (0 < GNUNET_DISK_file_read (pr, &c, sizeof (c)));
 
-  ret = GNUNET_OS_process_status (publish_proc,
-                                  &type,
-                                  &code);
+  ret = GNUNET_OS_process_status (publish_proc, &type, &code);
   GNUNET_assert (GNUNET_SYSERR != ret);
   if (GNUNET_NO == ret)
   {
@@ -383,10 +370,10 @@ maint_child_death (void *cls)
        Well, let's declare it spurious (kernel bug?) and keep rolling.
     */
     GNUNET_break (0);
-    run_task =
-      GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
-                                      pr,
-                                      &maint_child_death, wi);
+    run_task = GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
+                                               pr,
+                                               &maint_child_death,
+                                               wi);
     return;
   }
   GNUNET_assert (GNUNET_OK == ret);
@@ -400,26 +387,22 @@ maint_child_death (void *cls)
     GNUNET_free (wi);
     return;
   }
-  if ( (GNUNET_OS_PROCESS_EXITED == type) &&
-       (0 == code) )
+  if ((GNUNET_OS_PROCESS_EXITED == type) && (0 == code))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                _("Publication of `%s' done\n"),
-                wi->filename);
-    GNUNET_CRYPTO_hash (wi->filename,
-                        strlen (wi->filename),
-                        &key);
+                _ ("Publication of `%s' done\n"),
+                wi->filename);
+    GNUNET_CRYPTO_hash (wi->filename, strlen (wi->filename), &key);
     GNUNET_break (GNUNET_OK ==
-                  GNUNET_CONTAINER_multihashmap_put (work_finished,
-                                                     &key,
-                                                     wi,
-                                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+                  GNUNET_CONTAINER_multihashmap_put (
+                    work_finished,
+                    &key,
+                    wi,
+                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
   }
   else
   {
-    GNUNET_CONTAINER_DLL_insert_tail (work_head,
-                                      work_tail,
-                                      wi);
+    GNUNET_CONTAINER_DLL_insert_tail (work_head, work_tail, wi);
   }
   save_state ();
   schedule_next_task ();
@@ -434,14 +417,15 @@ static void
 sighandler_child_death ()
 {
   static char c;
-  int old_errno = errno;        /* back-up errno */
-
-  GNUNET_break (1 ==
-                GNUNET_DISK_file_write (GNUNET_DISK_pipe_handle
-                                        (sigpipe,
-                                         GNUNET_DISK_PIPE_END_WRITE),
-                                        &c, sizeof (c)));
-  errno = old_errno;            /* restore errno */
+  int old_errno = errno; /* back-up errno */
+
+  GNUNET_break (
+    1 ==
+    GNUNET_DISK_file_write (GNUNET_DISK_pipe_handle (sigpipe,
+                                                     GNUNET_DISK_PIPE_END_WRITE),
+                            &c,
+                            sizeof (c)));
+  errno = old_errno; /* restore errno */
 }
 
 
@@ -463,9 +447,7 @@ work (void *cls)
 
   run_task = NULL;
   wi = work_head;
-  GNUNET_CONTAINER_DLL_remove (work_head,
-                               work_tail,
-                               wi);
+  GNUNET_CONTAINER_DLL_remove (work_head, work_tail, wi);
   argc = 0;
   argv[argc++] = "gnunet-publish";
   if (verbose)
@@ -476,47 +458,41 @@ work (void *cls)
     argv[argc++] = "-d";
   argv[argc++] = "-c";
   argv[argc++] = cfg_filename;
-  GNUNET_snprintf (anon_level, sizeof (anon_level),
-                   "%u", anonymity_level);
+  GNUNET_snprintf (anon_level, sizeof (anon_level), "%u", anonymity_level);
   argv[argc++] = "-a";
   argv[argc++] = anon_level;
-  GNUNET_snprintf (content_prio, sizeof (content_prio),
-                   "%u", content_priority);
+  GNUNET_snprintf (content_prio, sizeof (content_prio), "%u", content_priority);
   argv[argc++] = "-p";
   argv[argc++] = content_prio;
-  GNUNET_snprintf (repl_level, sizeof (repl_level),
-                   "%u", replication_level);
+  GNUNET_snprintf (repl_level, sizeof (repl_level), "%u", replication_level);
   argv[argc++] = "-r";
   argv[argc++] = repl_level;
   argv[argc++] = wi->filename;
   argv[argc] = NULL;
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              _("Publishing `%s'\n"),
-              wi->filename);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, _ ("Publishing `%s'\n"), wi->filename);
   GNUNET_assert (NULL == publish_proc);
   publish_proc = GNUNET_OS_start_process_vap (GNUNET_YES,
-                                              0, NULL, NULL, NULL,
-                                              "gnunet-publish",
-                                              argv);
+                                              0,
+                                              NULL,
+                                              NULL,
+                                              NULL,
+                                              "gnunet-publish",
+                                              argv);
   if (NULL == publish_proc)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("Failed to run `%s'\n"),
-                "gnunet-publish");
-    GNUNET_CONTAINER_DLL_insert (work_head,
-                                 work_tail,
-                                 wi);
-    run_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES,
-                                             &work,
-                                             NULL);
+                _ ("Failed to run `%s'\n"),
+                "gnunet-publish");
+    GNUNET_CONTAINER_DLL_insert (work_head, work_tail, wi);
+    run_task =
+      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES, &work, NULL);
     return;
   }
-  pr = GNUNET_DISK_pipe_handle (sigpipe,
-                                GNUNET_DISK_PIPE_END_READ);
-  run_task =
-    GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
-                                    pr,
-                                    &maint_child_death, wi);
+  pr = GNUNET_DISK_pipe_handle (sigpipe, GNUNET_DISK_PIPE_END_READ);
+  run_task = GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
+                                             pr,
+                                             &maint_child_death,
+                                             wi);
 }
 
 
@@ -529,8 +505,7 @@ work (void *cls)
  * @return #GNUNET_OK (always)
  */
 static int
-determine_id (void *cls,
-              const char *filename)
+determine_id (void *cls, const char *filename)
 {
   struct GNUNET_HashCode *id = cls;
   struct stat sbuf;
@@ -539,44 +514,30 @@ determine_id (void *cls,
 
   if (0 != STAT (filename, &sbuf))
   {
-    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
-                              "stat",
-                              filename);
+    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "stat", filename);
     return GNUNET_OK;
   }
-  GNUNET_CRYPTO_hash (filename,
-                      strlen (filename),
-                      &fx[0]);
-  if (!S_ISDIR (sbuf.st_mode))
+  GNUNET_CRYPTO_hash (filename, strlen (filename), &fx[0]);
+  if (! S_ISDIR (sbuf.st_mode))
   {
     uint64_t fattr[2];
 
     fattr[0] = GNUNET_htonll (sbuf.st_size);
     fattr[0] = GNUNET_htonll (sbuf.st_mtime);
 
-    GNUNET_CRYPTO_hash (fattr,
-                        sizeof (fattr),
-                        &fx[1]);
+    GNUNET_CRYPTO_hash (fattr, sizeof (fattr), &fx[1]);
   }
   else
   {
-    memset (&fx[1],
-            1,
-            sizeof (struct GNUNET_HashCode));
-    GNUNET_DISK_directory_scan (filename,
-                                &determine_id,
-                                &fx[1]);
+    memset (&fx[1], 1, sizeof (struct GNUNET_HashCode));
+    GNUNET_DISK_directory_scan (filename, &determine_id, &fx[1]);
   }
   /* use hash here to make hierarchical structure distinct from
      all files on the same level */
-  GNUNET_CRYPTO_hash (fx,
-                      sizeof (fx),
-                      &ft);
+  GNUNET_CRYPTO_hash (fx, sizeof (fx), &ft);
   /* use XOR here so that order of the files in the directory
      does not matter! */
-  GNUNET_CRYPTO_hash_xor (&ft,
-                          id,
-                          id);
+  GNUNET_CRYPTO_hash_xor (&ft, id, id);
   return GNUNET_OK;
 }
 
@@ -591,8 +552,7 @@ determine_id (void *cls,
  * @return #GNUNET_OK to continue to iterate, #GNUNET_SYSERR during shutdown
  */
 static int
-add_file (void *cls,
-          const char *filename)
+add_file (void *cls, const char *filename)
 {
   struct WorkItem *wi;
   struct GNUNET_HashCode key;
@@ -600,29 +560,21 @@ add_file (void *cls,
 
   if (GNUNET_YES == do_shutdown)
     return GNUNET_SYSERR;
-  if ( (NULL != strstr (filename,
-                      "/.auto-share")) ||
-       (NULL != strstr (filename,
-                        "\\.auto-share")) )
+  if ((NULL != strstr (filename, "/.auto-share")) ||
+      (NULL != strstr (filename, "\\.auto-share")))
     return GNUNET_OK; /* skip internal file */
-  GNUNET_CRYPTO_hash (filename,
-                      strlen (filename),
-                      &key);
-  wi = GNUNET_CONTAINER_multihashmap_get (work_finished,
-                                          &key);
+  GNUNET_CRYPTO_hash (filename, strlen (filename), &key);
+  wi = GNUNET_CONTAINER_multihashmap_get (work_finished, &key);
   memset (&id, 0, sizeof (struct GNUNET_HashCode));
   determine_id (&id, filename);
   if (NULL != wi)
   {
-    if (0 == memcmp (&id,
-                     &wi->id,
-                     sizeof (struct GNUNET_HashCode)))
+    if (0 == memcmp (&id, &wi->id, sizeof (struct GNUNET_HashCode)))
       return GNUNET_OK; /* skip: we did this one already */
     /* contents changed, need to re-do the directory... */
-    GNUNET_assert (GNUNET_YES ==
-                   GNUNET_CONTAINER_multihashmap_remove (work_finished,
-                                                         &key,
-                                                         wi));
+    GNUNET_assert (
+      GNUNET_YES ==
+      GNUNET_CONTAINER_multihashmap_remove (work_finished, &key, wi));
   }
   else
   {
@@ -630,9 +582,7 @@ add_file (void *cls,
     wi->filename = GNUNET_strdup (filename);
   }
   wi->id = id;
-  GNUNET_CONTAINER_DLL_insert (work_head,
-                               work_tail,
-                               wi);
+  GNUNET_CONTAINER_DLL_insert (work_head, work_tail, wi);
   if (GNUNET_YES == do_shutdown)
     return GNUNET_SYSERR;
   return GNUNET_OK;
@@ -649,9 +599,7 @@ scan (void *cls)
 {
   run_task = NULL;
   start_time = GNUNET_TIME_absolute_get ();
-  (void) GNUNET_DISK_directory_scan (dir_name,
-                                     &add_file,
-                                     NULL);
+  (void) GNUNET_DISK_directory_scan (dir_name, &add_file, NULL);
   schedule_next_task ();
 }
 
@@ -673,18 +621,13 @@ schedule_next_task ()
        on how long it took to scan */
     delay = GNUNET_TIME_absolute_get_duration (start_time);
     delay = GNUNET_TIME_relative_saturating_multiply (delay, 100);
-    delay = GNUNET_TIME_relative_min (delay,
-                                      MAX_DELAY);
-    delay = GNUNET_TIME_relative_max (delay,
-                                      MIN_DELAY);
-    run_task = GNUNET_SCHEDULER_add_delayed (delay,
-                                             &scan,
-                                             NULL);
+    delay = GNUNET_TIME_relative_min (delay, MAX_DELAY);
+    delay = GNUNET_TIME_relative_max (delay, MIN_DELAY);
+    run_task = GNUNET_SCHEDULER_add_delayed (delay, &scan, NULL);
   }
   else
   {
-    run_task = GNUNET_SCHEDULER_add_now (&work,
-                                         NULL);
+    run_task = GNUNET_SCHEDULER_add_now (&work, NULL);
   }
 }
 
@@ -704,27 +647,23 @@ run (void *cls,
      const struct GNUNET_CONFIGURATION_Handle *c)
 {
   /* check arguments */
-  if ( (NULL == args[0]) ||
-       (NULL != args[1]) ||
-       (GNUNET_YES !=
-        GNUNET_DISK_directory_test (args[0],
-                                    GNUNET_YES)) )
+  if ((NULL == args[0]) || (NULL != args[1]) ||
+      (GNUNET_YES != GNUNET_DISK_directory_test (args[0], GNUNET_YES)))
   {
-    printf (_("You must specify one and only one directory name for automatic publication.\n"));
+    printf (_ (
+      "You must specify one and only one directory name for automatic publication.\n"));
     ret = -1;
     return;
   }
   cfg_filename = GNUNET_strdup (cfgfile);
   cfg = c;
   dir_name = args[0];
-  work_finished = GNUNET_CONTAINER_multihashmap_create (1024,
-                                                        GNUNET_NO);
+  work_finished = GNUNET_CONTAINER_multihashmap_create (1024, GNUNET_NO);
   load_state ();
   run_task = GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_IDLE,
-                                                 &scan,
-                                                 NULL);
-  GNUNET_SCHEDULER_add_shutdown (&do_stop_task,
-                                 NULL);
+                                                 &scan,
+                                                 NULL);
+  GNUNET_SCHEDULER_add_shutdown (&do_stop_task, NULL);
 }
 
 
@@ -737,9 +676,7 @@ run (void *cls,
  * @return #GNUNET_OK to continue to iterate
  */
 static int
-free_item (void *cls,
-           const struct GNUNET_HashCode *key,
-           void *value)
+free_item (void *cls, const struct GNUNET_HashCode *key, void *value)
 {
   struct WorkItem *wi = value;
 
@@ -762,68 +699,74 @@ main (int argc, char *const *argv)
   struct GNUNET_GETOPT_CommandLineOption options[] = {
 
     GNUNET_GETOPT_option_uint ('a',
-                                   "anonymity",
-                                   "LEVEL",
-                                   gettext_noop ("set the desired LEVEL of sender-anonymity"),
-                                   &anonymity_level),
-
-    GNUNET_GETOPT_option_flag ('d',
-                                  "disable-creation-time",
-                                  gettext_noop ("disable adding the creation time to the metadata of the uploaded file"),
-                                  &do_disable_creation_time),
-
-    GNUNET_GETOPT_option_flag ('D',
-                                  "disable-extractor",
-                                  gettext_noop ("do not use libextractor to add keywords or metadata"),
-                                  &disable_extractor),
+                               "anonymity",
+                               "LEVEL",
+                               gettext_noop (
+                                 "set the desired LEVEL of sender-anonymity"),
+                               &anonymity_level),
+
+    GNUNET_GETOPT_option_flag (
+      'd',
+      "disable-creation-time",
+      gettext_noop (
+        "disable adding the creation time to the metadata of the uploaded file"),
+      &do_disable_creation_time),
+
+    GNUNET_GETOPT_option_flag (
+      'D',
+      "disable-extractor",
+      gettext_noop ("do not use libextractor to add keywords or metadata"),
+      &disable_extractor),
 
     GNUNET_GETOPT_option_uint ('p',
-                                   "priority",
-                                   "PRIORITY",
-                                   gettext_noop ("specify the priority of the content"),
-                                   &content_priority),
+                               "priority",
+                               "PRIORITY",
+                               gettext_noop (
+                                 "specify the priority of the content"),
+                               &content_priority),
 
     GNUNET_GETOPT_option_uint ('r',
-                                   "replication",
-                                   "LEVEL",
-                                   gettext_noop ("set the desired replication LEVEL"),
-                                   &replication_level),
+                               "replication",
+                               "LEVEL",
+                               gettext_noop (
+                                 "set the desired replication LEVEL"),
+                               &replication_level),
 
     GNUNET_GETOPT_option_verbose (&verbose),
 
-    GNUNET_GETOPT_OPTION_END
-  };
+    GNUNET_GETOPT_OPTION_END};
   struct WorkItem *wi;
   int ok;
   struct GNUNET_SIGNAL_Context *shc_chld;
 
-  if (GNUNET_OK !=
-      GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
+  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
     return 2;
-  sigpipe = GNUNET_DISK_pipe (GNUNET_NO, GNUNET_NO,
-                              GNUNET_NO, GNUNET_NO);
+  sigpipe = GNUNET_DISK_pipe (GNUNET_NO, GNUNET_NO, GNUNET_NO, GNUNET_NO);
   GNUNET_assert (NULL != sigpipe);
   shc_chld =
-    GNUNET_SIGNAL_handler_install (GNUNET_SIGCHLD,
-                                   &sighandler_child_death);
-  ok = (GNUNET_OK ==
-        GNUNET_PROGRAM_run (argc, argv,
-                            "gnunet-auto-share [OPTIONS] FILENAME",
-                            gettext_noop
-                            ("Automatically publish files from a directory on GNUnet"),
-                            options, &run, NULL)) ? ret : 1;
+    GNUNET_SIGNAL_handler_install (GNUNET_SIGCHLD, &sighandler_child_death);
+  ok =
+    (GNUNET_OK ==
+     GNUNET_PROGRAM_run (
+       argc,
+       argv,
+       "gnunet-auto-share [OPTIONS] FILENAME",
+       gettext_noop ("Automatically publish files from a directory on GNUnet"),
+       options,
+       &run,
+       NULL))
+      ? ret
+      : 1;
   if (NULL != work_finished)
   {
     (void) GNUNET_CONTAINER_multihashmap_iterate (work_finished,
-                                                  &free_item,
-                                                  NULL);
+                                                  &free_item,
+                                                  NULL);
     GNUNET_CONTAINER_multihashmap_destroy (work_finished);
   }
   while (NULL != (wi = work_head))
   {
-    GNUNET_CONTAINER_DLL_remove (work_head,
-                                 work_tail,
-                                 wi);
+    GNUNET_CONTAINER_DLL_remove (work_head, work_tail, wi);
     GNUNET_free (wi->filename);
     GNUNET_free (wi);
   }
@@ -833,7 +776,7 @@ main (int argc, char *const *argv)
   sigpipe = NULL;
   GNUNET_free_non_null (cfg_filename);
   cfg_filename = NULL;
-  GNUNET_free ((void*) argv);
+  GNUNET_free ((void *) argv);
   return ok;
 }