NNTPGrab - / - Diff - NNTPGrab

Revision 1843

+                      }
+                  }
                   static void
                   start_to_decode_if_necessary(NNTPCollection *collection, NNTPFile *file)
+                  {
                       /* Check if all parts belonging to this part are downloaded so we can start decoding it */
                       GList *list = file->parts;
                       gboolean complete_flag = TRUE;
                       while (list) {
                           NNTPPart *part = list->data;
                           if (part->now_downloading) {
                               file->file_is_downloading = TRUE;
                               complete_flag = FALSE;
+                          }
                           if (!part->downloaded) {
                               complete_flag = FALSE;
+                          }
                           list = g_list_next(list);
+                      }
                       /* All the parts are already downloaded? */
                       if (complete_flag && !file->now_decoding && !file->file_is_downloaded) {
                           DecoderData *decoder_data;
                           ng_plugin_emit_log_msg(NULL, NG_LOG_LEVEL_DEBUG, "File '%s' from collection '%s' is now ready to be decoded", file->subject, collection->collection_name);
                           file->now_decoding = TRUE;
                           nntpgrab_core_emit_file_state_changed(FALSE, collection->collection_name, file->subject, NULL, file->status, TASK_STATE_WAITING_FOR_DECODE);
                           file->status = TASK_STATE_WAITING_FOR_DECODE;
                           decoder_data = g_slice_new0(DecoderData);
                           decoder_data->collection = collection;
                           decoder_data->file = file;
                           //decoder_data->poolPar2verify = poolPar2verify;
                           //decoder_data->poolPar2repair = poolPar2repair;
                           //decoder_data->poolUnpack = poolUnpack;
                           file_ref(file);
                           collection_ref(collection);
                           decoder_thread_push_task(decoder_data);
+                      }
+                  }
                   static void
                   check_if_files_are_ready_to_be_decoded(void)
+                  {
                       GList *list;
                       g_static_mutex_lock(&mutex);
                       list = download_queue;
                       while (list) {
                           NNTPCollection *collection = list->data;
                           GList *list2;
                           list2 = collection->files;
                           while (list2) {
                               NNTPFile *file = list2->data;
                               start_to_decode_if_necessary(collection, file);
                               list2 = g_list_next(list2);
+                          }
                           list = g_list_next(list);
+                      }
                       g_static_mutex_unlock(&mutex);
+                  }
                   static gboolean
                   on_config_changed(Configuration *config, gpointer data)
+                  {
-...
                       if (!queue_rawfile_load(&download_queue, errmsg)) {
                           /* Ignore read errors for now */
+                          ;
                           g_free(*errmsg);
                           *errmsg = NULL;
+                      }
                       g_signal_connect(config, "config_changed", G_CALLBACK(on_config_changed), NULL);
-...
+                  }
                   gboolean
                   download_queue_get_next_part_to_download(NNTPCollection **collection, NNTPFile **file, NNTPPart **part, int server_id, gboolean *nothing_to_download)
                   download_queue_get_next_part_to_download(NNTPCollection **collection, NNTPFile **file, NNTPPart **part, int server_id, gboolean *nothing_to_download_or_active)
+                  {
                       GList *list;
                       static gboolean beenhere = FALSE;
                       g_return_val_if_fail(collection != NULL, FALSE);
                       g_return_val_if_fail(file != NULL, FALSE);
                       g_return_val_if_fail(part != NULL, FALSE);
                       g_return_val_if_fail(server_id >= 0, FALSE);
                       g_return_val_if_fail(nothing_to_download != NULL, FALSE);
                       g_return_val_if_fail(nothing_to_download_or_active != NULL, FALSE);
                       /* If we're here for the first time, check if there any decode-tasks ready */
                       if (!beenhere) {
                           beenhere = TRUE;
                           check_if_files_are_ready_to_be_decoded();
+                      }
                       ng_plugin_emit_log_msg(NULL, NG_LOG_LEVEL_INFO, "download_queue_get_next_part_to_download for server_id %i", server_id);
                       if (!server_positions[server_id].task_probably_ready) {
                           /* It's uncertain whether there's anything left do download */
                           *nothing_to_download = FALSE;
                       *nothing_to_download_or_active = TRUE;
                           return FALSE;
+                      }
                       *nothing_to_download = TRUE;
                       if (num_enabled_servers == 0) {
                           /* No enabled servers found, don't even bother checking the queue */
                           return FALSE;
-...
                       g_static_mutex_lock(&mutex);
                       if (!server_positions[server_id].task_probably_ready) {
                           /* It's uncertain whether there's anything left to download */
                           /* Do only a quick scan of the now_decoding flag */
                           goto check_decoded_state;
+                      }
                       /* Do we already have a cached position for this server? */
                       if (server_positions[server_id].collection_list) {
                           list = server_positions[server_id].collection_list;
-...
                           while (list2) {
                               GList *list3;
                               gboolean complete_flag;
                               *file = (NNTPFile *) list2->data;
-...
                                   continue;
+                              }
                               complete_flag = TRUE;
                               /* Do we already have a cached position for this server? */
                               if (server_positions[server_id].part_list) {
                                   list3 = server_positions[server_id].part_list;
-...
                                   *part = (NNTPPart *) list3->data;
                                   if ((*part)->now_downloading) {
                                       complete_flag = FALSE;
                                       *nothing_to_download = FALSE;
                                       *nothing_to_download_or_active = FALSE;
+                                  }
                                   if (!(*part)->downloaded) {
-...
                                           server_positions[server_id].collection_pos = g_list_index(download_queue, *collection);
                                           server_positions[server_id].file_pos = g_list_index((*collection)->files, *file);
                                           server_positions[server_id].part_pos = g_list_index((*file)->parts, *part);
                                           server_positions[server_id].task_probably_ready = TRUE;
                                           g_static_mutex_unlock(&mutex);
                                           *nothing_to_download = FALSE;
                                           *nothing_to_download_or_active = FALSE;
                                           file_ref(*file);
                                           collection_ref(*collection);
-...
+                                      }
                                       // Are all the servers already tried ?
                                       if ((is_server_enabled & (*part)->servers_already_tried) == is_server_enabled) {
                                           complete_flag = TRUE;
                                       } else {
                                           complete_flag = FALSE;
                                           *nothing_to_download = FALSE;
                                       if (!(is_server_enabled & (*part)->servers_already_tried) == is_server_enabled) {
                                           *nothing_to_download_or_active = FALSE;
+                                      }
+                                  }
                                   list3 = g_list_next(list3);
+                              }
                               // All the parts are already downloaded?
                               if (complete_flag && !(*file)->now_decoding) {
                                   DecoderData *decoder_data;
                               server_positions[server_id].part_list = NULL;
                                   ng_plugin_emit_log_msg(NULL, NG_LOG_LEVEL_DEBUG, "File '%s' from collection '%s' is now ready to be decoded", (*file)->subject, (*collection)->collection_name);
                               list2 = g_list_next(list2);
+                          }
                                   (*file)->now_decoding = TRUE;
                           server_positions[server_id].file_list = NULL;
                                   nntpgrab_core_emit_file_state_changed(FALSE, (*collection)->collection_name, (*file)->subject, NULL, (*file)->status, TASK_STATE_WAITING_FOR_DECODE);
                           list = g_list_next(list);
+                      }
                                   (*file)->status = TASK_STATE_WAITING_FOR_DECODE;
                   check_decoded_state:
                                   decoder_data = g_slice_new0(DecoderData);
                                   decoder_data->collection = (*collection);
                                   decoder_data->file = (*file);
                                   //decoder_data->poolPar2verify = poolPar2verify;
                                   //decoder_data->poolPar2repair = poolPar2repair;
                                   //decoder_data->poolUnpack = poolUnpack;
                       /* Make sure that there's nothing in the 'waiting for decode' state */
                       list = download_queue;
                       while (list) {
                           NNTPCollection *collection_tmp = (NNTPCollection *) list->data;
                           GList *list2;
                                   file_ref(*file);
                                   collection_ref(*collection);
                           // Is this collection being removed ?
                           if (collection_tmp->stop_flag) {
                               list = g_list_next(list);
                               continue;
+                          }
                                   decoder_thread_push_task(decoder_data);
                           list2 = collection_tmp->files_to_download;
                           while (list2) {
                               NNTPFile *file_tmp = (NNTPFile *) list2->data;
                               // Is this file being removed?
                               if (file_tmp->stop_flag) {
                                   list2 = g_list_next(list2);
                                   continue;
+                              }
                               if (file_tmp->now_decoding) {
                                   *nothing_to_download_or_active = FALSE;
+                              }
                               list2 = g_list_next(list2);
+                          }
                           list = g_list_next(list);
+                      }
                       if (*nothing_to_download_or_active == TRUE && server_positions[server_id].task_probably_ready == FALSE) {
                           /* There was no task ready for this server, so we skipped the tests for looking up new tasks
                            * and only checked if there any tasks being decoded at the moment. As there probably still
                            * are downloads going on, we need to reset the nothing_to_download_or_active flag to FALSE
                            * to avoid that the schedular gets paused */
                           *nothing_to_download_or_active = FALSE;
+                      }
                       *collection = NULL;
                       *file = NULL;
                       *part = NULL;
-...
                   void
                   download_queue_update_part_status(const char *servername, int connection_id, NNTPCollection *collection, NNTPFile *file, NNTPPart *part, int server_id, gboolean success, gboolean reset_to_zero, gboolean dont_retry_anymore)
+                  {
                       GList *list;
                       g_return_if_fail(servername != NULL);
                       g_return_if_fail(connection_id >= 0);
                       g_return_if_fail(collection != NULL);
-...
                       part->downloaded = success;
                       file->file_is_downloading = FALSE;
                       if (!file->file_is_new) {
                           file->file_is_changed = TRUE;
+                      }
                       if (success) {
                           nntpgrab_core_emit_part_done(FALSE, servername, connection_id, collection->collection_name, file->subject, part->part_num, part->size);
-...
                           update_server_position_cache_if_necessary(collection, file, part, server_id);
+                      }
                       // Are other threads downloading parts of this file ?
                       list = file->parts;
                       while (list) {
                           NNTPPart *part2 = list->data;
                           if (part2->now_downloading) {
                               file->file_is_downloading = TRUE;
+                          }
                           list = g_list_next(list);
+                      }
                       // Are all the servers already tried ?
                       /* Are all the servers already tried ? */
                       if (!success && dont_retry_anymore) {
                           gboolean all_servers_tried = TRUE;
-...
                               all_servers_tried = FALSE;
+                          }
                           nntpgrab_core_emit_part_failed(FALSE, servername,connection_id, collection->collection_name, file->subject, part->part_num, part->size, all_servers_tried);
                           nntpgrab_core_emit_part_failed(FALSE, servername, connection_id, collection->collection_name, file->subject, part->part_num, part->size, all_servers_tried);
                           if (all_servers_tried && !reset_to_zero) {
                               if (file->file_size_remaining < part->size) {
-...
+                          }
+                      }
                       start_to_decode_if_necessary(collection, file);
                       g_static_mutex_unlock(&collection->mutex);
+                  }
                   gboolean
                   download_queue_test_is_decoding_still_needed(NNTPCollection *collection, NNTPFile *file)
+                  {
                       g_return_val_if_fail(collection != NULL, FALSE);
                       g_return_val_if_fail(file != NULL, FALSE);
                       g_static_mutex_lock(&collection->mutex);
                       if (file->stop_flag) {
                           file->now_decoding = FALSE;
                           g_static_mutex_unlock(&collection->mutex);
                           file_unref(file);
                           collection_unref(collection);
                           return FALSE;
+                      }
                       g_static_mutex_unlock(&collection->mutex);
                       return TRUE;
+                  }
                   void
                   download_queue_about_to_start_decoding(NNTPCollection *collection, NNTPFile *file)
+                  {
                       g_return_if_fail(collection != NULL);
                       g_return_if_fail(file != NULL);
                       nntpgrab_core_emit_file_state_changed(FALSE, collection->collection_name, file->subject, NULL, file->status, TASK_STATE_DECODING);
                       g_static_mutex_lock(&collection->mutex);
                       file->status = TASK_STATE_DECODING;
                       g_static_mutex_unlock(&collection->mutex);
+                  }
                   void
                   download_queue_mark_file_as_decoded_and_unref(NNTPCollection *collection, NNTPFile *file, const char *real_filename, NGTaskState status)
+                  {
                       g_return_if_fail(collection != NULL);
                       g_return_if_fail(file != NULL);
                       /* real_filename can be NULL */
                       g_static_mutex_lock(&collection->mutex);
                       /* Was the task restarted while the decoding was busy? */
                       if (!file->now_decoding) {
                           /* Yes it was, forget the status update */
                           goto out;
+                      }
                       if (status == TASK_STATE_FINISHED_COMPLETE || status == TASK_STATE_FINISHED_INCOMPLETE) {
                           g_return_if_fail(real_filename != NULL);
                           /* Update the real filename */
                           strncpy((char*) file->real_filename, real_filename, sizeof(file->real_filename) - 1);
                           if (file->file_type == NNTP_FILE_TYPE_UNKNOWN) {
                               /* Check the extension again. It might have changed now that the decoding is finished */
                               file->file_type = nntpgrab_utils_get_file_type_of_filename(file->real_filename);
+                          }
                           file->file_is_downloaded = TRUE;
                       } else if (status == TASK_STATE_WAITING_FOR_DECODE) {
                           /* The decoder wants us to re-queue the file. Probably some temporary error occurs (like disk full) */
+                      }
                       nntpgrab_core_emit_file_state_changed(FALSE, collection->collection_name, file->subject, file->real_filename, file->status, status);
                       file->status = status;
                       file->now_decoding = FALSE;
                   out:
                       g_static_mutex_unlock(&collection->mutex);
                       download_queue_test_is_collection_downloaded(collection);
                       file_unref(file);
                       collection_unref(collection);
+                  }
                   static gboolean
                   test_is_subject_already_in_collection(NNTPCollection *collection, const char *subject)
+                  {
-...
+                              }
                               file->position = g_list_index(collection->files, file) + 1;
                               file->file_is_new = TRUE;
                               nntpgrab_core_emit_file_added(FALSE, collection->collection_name, file->subject, file->poster, file->stamp, file->file_size, collection->total_size, collection->total_size_remaining, file->status, file->num_parts, file->groups);
-...
                                       // The poster wasn't set for this collection yet
                                       strncpy(collection->poster, file->poster, sizeof(collection->poster) - 1);
                                       nntpgrab_core_emit_collection_modified(FALSE, collection_name, collection->poster);
                                       if (!collection->collection_is_new) {
                                           collection->collection_is_changed = TRUE;
+                                      }
+                                  }
                               } else {
                                   // Some other file contained a different poster, reset to empty
                                   if (strcmp(collection->poster, file->poster)) {
                                       memset(collection->poster, 0, sizeof(collection->poster));
                                       nntpgrab_core_emit_collection_modified(FALSE, collection_name, collection->poster);
                                       if (!collection->collection_is_new) {
                                           collection->collection_is_changed = TRUE;
+                                      }
+                                  }
+                              }
-...
                       } else {
                           collection->total_size_remaining = 0;
+                      }
                       collection->collection_is_new = TRUE;
                       file->file_is_new = TRUE;
                       file->position = 1;
                       nntpgrab_core_emit_file_added(FALSE, collection->collection_name, file->subject, file->poster, file->stamp, file->file_size, collection->total_size, collection->total_size_remaining, file->status, file->num_parts, file->groups);
-...
                       gboolean ret;
                       NNTPFile *file;
                       GList *list;
                   #ifndef DOWNLOAD_QUEUE_DONT_SET_TMP_FILENAME
                       char *tmp;
                       char *tmp2;
                   #endif
                       GHashTable *hashtable;
                       char collection_name_copy[256];          /* This parameter needs to be of the same size as defined in base/collections.h! */
-...
                       file->file_size = file_size;
                       file->file_size_remaining = file_size;
                   #ifndef DOWNLOAD_QUEUE_DONT_SET_TMP_FILENAME
                       tmp = tempnam(opts.temp_directory, NULL);
                       tmp2 = g_path_get_basename(tmp);
                       strncpy((char *) file->tmp_filename, tmp2, sizeof(file->tmp_filename));
                       g_free(tmp2);
                       free(tmp);                  // Don't use g_free here as tempnam is a libc function!
                   #endif
                       // Detect the file type and the par2 blocks
                       if (!nntpgrab_utils_strip_subject(file->subject, NULL, NULL, NULL, NULL, NULL, &file->file_type, &file->par2_start_num, &file->par2_num_blocks, NULL, &file->num_parts)) {
-...
                                                   // The poster wasn't set for this collection yet
                                                   strncpy(collection->poster, file->poster, sizeof(collection->poster) - 1);
                                                   nntpgrab_core_emit_collection_modified(FALSE, collection_name_copy, collection->poster);
                                                   if (!collection->collection_is_new) {
                                                       collection->collection_is_changed = TRUE;
+                                                  }
+                                              }
                                           } else {
                                               // Some other file contained a different poster, reset to empty
                                               if (strcmp(collection->poster, file->poster)) {
                                                   memset(collection->poster, 0, sizeof(collection->poster));
                                                   nntpgrab_core_emit_collection_modified(FALSE, collection_name_copy, collection->poster);
                                                   if (!collection->collection_is_new) {
                                                       collection->collection_is_changed = TRUE;
+                                                  }
+                                              }
+                                          }
-...
                       int pos_last_file_to_download;
                       NNTPCollection *collection;
                       char collection_name_copy[256];          /* This parameter needs to be of the same size as defined in base/collections.h! */
                       int i;
                       g_return_val_if_fail(collection_name != NULL, FALSE);
                       /* subject can be NULL */
-...
                                       collection->total_size_remaining += file->file_size - file->file_size_remaining - filesize_remaining_active;
                                       file->file_size_remaining = file->file_size - filesize_remaining_active;
                                       if (!file->file_is_new) {
                                           file->file_is_changed = TRUE;
+                                      }
                                       nntpgrab_core_emit_file_state_changed(FALSE, collection_name_copy, file->subject, NULL, file->status, TASK_STATE_WAITING_FOR_DOWNLOAD);
                                       file->status = TASK_STATE_WAITING_FOR_DOWNLOAD;
-...
                                           download_thread_awaken_if_needed();
                                           /* We can't rely on the contents of the server positions cache, so reset it */
                                           for (i = 0; i < MAX_NNTP_SERVERS; i++) {
                                               reset_server_positions(i);
+                                          }
                                           return TRUE;
+                                      }
+                                  }
-...
                                   download_thread_awaken_if_needed();
                                   /* We can't rely on the contents of the server positions cache, so reset it */
                                   for (i = 0; i < MAX_NNTP_SERVERS; i++) {
                                       reset_server_positions(i);
+                                  }
                                   return TRUE;
+                              }
+                          }
-...
                           if (file_tmp->position != i) {
                               file_tmp->position = i;
                               file_tmp->position_is_changed = TRUE;
+                          }
                           i++;
-...
                               if (file_tmp->position != i) {
                                   file_tmp->position = i;
                                   file_tmp->position_is_changed = TRUE;
+                              }
                               i++;
-...
                               download_queue = g_list_remove(download_queue, collection_src);
                               download_queue = g_list_insert(download_queue, collection_src, new_position);
                               collection_src->collection_is_changed = TRUE;
                               if (orig_position < new_position) {
                                   /* Update the collections FROM the original position on */
                                   NNTPCollection *collection = g_list_nth_data(download_queue, orig_position);
                                   collection->collection_is_changed = TRUE;
+                              }
                               break;
+                          }

                   gboolean     download_queue_destroy(char **errmsg);
                   void         download_queue_reset_all_server_positions(void);
                   gboolean     download_queue_save(char **errmsg);
                   gboolean     download_queue_get_next_part_to_download(NNTPCollection **collection, NNTPFile **file, NNTPPart **part, int server_id, gboolean *nothing_to_download);
                   gboolean     download_queue_get_next_part_to_download(NNTPCollection **collection, NNTPFile **file, NNTPPart **part, int server_id, gboolean *nothing_to_download_or_active);
                   void         download_queue_update_part_status(const char *servername, int connection_id, NNTPCollection *collection, NNTPFile *file, NNTPPart *part, int server_id, gboolean success, gboolean reset_to_zero, gboolean dont_retry_anymore);
                   gboolean     download_queue_test_is_decoding_still_needed(NNTPCollection *collection, NNTPFile *file);
                   void         download_queue_about_to_start_decoding(NNTPCollection *collection, NNTPFile *file);
                   void         download_queue_mark_file_as_decoded_and_unref(NNTPCollection *collection, NNTPFile *file, const char *real_filename, NGTaskState status);
                   gboolean     download_queue_add_file_to_queue(const char *collection_name, const char *subject, const char *poster, time_t stamp, nguint64 file_size, NGList *groups, NGList *parts, char **errmsg);
                   gboolean     download_queue_del_file_from_queue(const char *collection_name, const char *subject, char **errmsg);
                   gboolean     download_queue_restart_file(const char *collection_name, const char *subject, char **errmsg);

trunk/nntpgrab_core/nntpgrab_internal.h (revision 1843)
22	22	#include
23	23
24	24	#include "nntpgrab_types.h"
25		#include "collections.h"
26	25
27	26	void core_signals_clear_stack(void);
28	27

                   #include "nntpgrab.h"
                   #include "nntpgrab_internal.h"
                   #include "decoder_thread.h"
                   #include "collection_alloc.h"
                   #include "download_thread.h"
                   #include "download_queue.h"
                   #include "nntpgrab_plugin.h"
-...
                   static NGConfigOpts opts;
                   static NNTPGrabDecoderRes
                   decoder_thread_decode_file(const char *collection_name, NNTPFile *file, int *saved_errno, char **errmsg)
                   decoder_thread_decode_file(const char *collection_name, NNTPFile *file, char **real_filename, int *saved_errno, char **errmsg)
+                  {
                       NNTPGrabDecoderRes retval;
-...
                       ng_plugin_emit_log_msg(NULL, NG_LOG_LEVEL_INFO, _("Trying to decode file with from collection '%s' with subject = '%s'"), collection_name, file->subject);
                       g_return_val_if_fail(ng_plugin_call(NULL, "decode_file", collection_name, file, opts.temp_directory, opts.download_directory, saved_errno, errmsg, &retval), FALSE);
                       g_return_val_if_fail(ng_plugin_call(NULL, "decode_file", collection_name, file, opts.temp_directory, opts.download_directory, real_filename, saved_errno, errmsg, &retval), FALSE);
                       ng_plugin_emit_log_msg(NULL, NG_LOG_LEVEL_INFO, _("Decoder returned %i"), retval);
-...
                           ng_plugin_emit_log_msg(NULL, NG_LOG_LEVEL_INFO, "Decoder error: %s", *errmsg);
+                      }
                       // The filename got updated, check the extension again
                       if (retval != DECODER_RESULT_ERROR &&
                           retval != DECODER_RESULT_NO_PARTS_AVAIL &&
                           file->file_type == NNTP_FILE_TYPE_UNKNOWN) {
                           file->file_type = nntpgrab_utils_get_file_type_of_filename(file->real_filename);
+                      }
                       return retval;
+                  }
-...
                       int saved_errno = 0;
                       static time_t last_timestamp = 0;
                       NNTPGrabDecoderRes res;
                       char *real_filename = NULL;
                       char *errmsg = NULL;
                       NGTaskState state;
                       // Do we still need to decode?
                       g_static_mutex_lock(&decoder_data->collection->mutex);
                       if (abort_flag || decoder_data->file->stop_flag) {
                           decoder_data->file->now_decoding = FALSE;
                           g_static_mutex_unlock(&decoder_data->collection->mutex);
                           file_unref(decoder_data->file);
                           collection_unref(decoder_data->collection);
                       /* Do we still need to decode? */
                       if (abort_flag || !download_queue_test_is_decoding_still_needed(decoder_data->collection, decoder_data->file)) {
                           g_slice_free(DecoderData, decoder_data);
                           return;
+                      }
                       g_static_mutex_unlock(&decoder_data->collection->mutex);
                       nntpgrab_core_emit_file_state_changed(FALSE, decoder_data->collection->collection_name, decoder_data->file->subject, NULL, decoder_data->file->status, TASK_STATE_DECODING);
                       download_queue_about_to_start_decoding(decoder_data->collection, decoder_data->file);
                       g_static_mutex_lock(&decoder_data->collection->mutex);
                       decoder_data->file->status = TASK_STATE_DECODING;
                       g_static_mutex_unlock(&decoder_data->collection->mutex);
                       // Perform the actual decoding
                       if ((res = decoder_thread_decode_file(decoder_data->collection->collection_name, decoder_data->file, &saved_errno, &errmsg)) == DECODER_RESULT_ERROR) {
                       if ((res = decoder_thread_decode_file(decoder_data->collection->collection_name, decoder_data->file, &real_filename, &saved_errno, &errmsg)) == DECODER_RESULT_ERROR) {
                           if (saved_errno == ENOSPC) {
                               // No free space available, stop the schedular
                               if (errmsg) {
-...
                               /* Skip any already queued decodes because of the error */
                               abort_flag = TRUE;
                               g_static_mutex_lock(&decoder_data->collection->mutex);
                               decoder_data->file->now_decoding = FALSE;
                               nntpgrab_core_emit_file_state_changed(FALSE, decoder_data->collection->collection_name, decoder_data->file->subject, NULL, decoder_data->file->status, TASK_STATE_WAITING_FOR_DECODE);
                               decoder_data->file->status = TASK_STATE_WAITING_FOR_DECODE;
                               g_static_mutex_unlock(&decoder_data->collection->mutex);
                               file_unref(decoder_data->file);
                               collection_unref(decoder_data->collection);
                               download_queue_mark_file_as_decoded_and_unref(decoder_data->collection, decoder_data->file, NULL, TASK_STATE_WAITING_FOR_DECODE);
                               g_slice_free(DecoderData, decoder_data);
                               return;
-...
                               /* Skip any already queued decodes because of the error */
                               abort_flag = TRUE;
                               g_static_mutex_lock(&decoder_data->collection->mutex);
                               decoder_data->file->now_decoding = FALSE;
                               nntpgrab_core_emit_file_state_changed(FALSE, decoder_data->collection->collection_name, decoder_data->file->subject, NULL, decoder_data->file->status, TASK_STATE_WAITING_FOR_DECODE);
                               decoder_data->file->status = TASK_STATE_WAITING_FOR_DECODE;
                               g_static_mutex_unlock(&decoder_data->collection->mutex);
                               file_unref(decoder_data->file);
                               collection_unref(decoder_data->collection);
                               download_queue_mark_file_as_decoded_and_unref(decoder_data->collection, decoder_data->file, NULL, TASK_STATE_WAITING_FOR_DECODE);
                               g_slice_free(DecoderData, decoder_data);
                               return;
+                          }
+                      }
                       // Mark the file as completed
                       g_static_mutex_lock(&decoder_data->collection->mutex);
                       /* Mark the file as completed */
                       switch(res) {
                           case DECODER_RESULT_INCOMPLETE:
                               state = TASK_STATE_FINISHED_INCOMPLETE;
                               break;
                       if (!decoder_data->file->file_is_new) {
                           decoder_data->file->file_is_changed = TRUE;
+                      }
                           case DECODER_RESULT_NO_PARTS_AVAIL:
                               state = TASK_STATE_FINISHED_NO_PARTS_AVAIL;
                               break;
                       // Was the task restarted while the decoding was busy?
                       if (decoder_data->file->now_decoding) {
                           // Nope, mark the file decode as completed
                           NGTaskState state;
                           case DECODER_RESULT_ERROR:
                               state = TASK_STATE_WAITING_FOR_DECODE;
                               break;
                           decoder_data->file->file_is_downloaded = TRUE;
                           decoder_data->file->now_decoding = FALSE;
                           switch(res) {
                               case DECODER_RESULT_INCOMPLETE:
                                   state = TASK_STATE_FINISHED_INCOMPLETE;
                                   break;
                               case DECODER_RESULT_NO_PARTS_AVAIL:
                                   state = TASK_STATE_FINISHED_NO_PARTS_AVAIL;
                                   break;
                               case DECODER_RESULT_ERROR:
                                   state = TASK_STATE_WAITING_FOR_DECODE;
                                   break;
                               default:
                               case DECODER_RESULT_COMPLETE:
                                   state = TASK_STATE_FINISHED_COMPLETE;
                                   break;
+                          }
                           nntpgrab_core_emit_file_state_changed(FALSE, decoder_data->collection->collection_name, decoder_data->file->subject, decoder_data->file->real_filename, decoder_data->file->status, state);
                           decoder_data->file->status = state;
                           default:
                           case DECODER_RESULT_COMPLETE:
                               state = TASK_STATE_FINISHED_COMPLETE;
                               break;
+                      }
                       g_static_mutex_unlock(&decoder_data->collection->mutex);
                       download_queue_test_is_collection_downloaded(decoder_data->collection);
                       file_unref(decoder_data->file);
                       collection_unref(decoder_data->collection);
                       download_queue_mark_file_as_decoded_and_unref(decoder_data->collection, decoder_data->file, real_filename, state);
                       g_slice_free(DecoderData, decoder_data);
                       if (real_filename) {
                           g_free(real_filename);
+                      }
                       // Save the download queue only when there has been some time between now and the previous time we've decoded something
                       if (time(NULL) > last_timestamp + 60) {

                                       break;
                                   case TASK_STATE_WAITING_FOR_DOWNLOAD:
                                       active_file->file_is_downloaded = FALSE;
                                       break;
                                   case TASK_STATE_FINISHED_COMPLETE:
                                   case TASK_STATE_FINISHED_INCOMPLETE:
                                   case TASK_STATE_FINISHED_NO_PARTS_AVAIL:

                   /*
                       Copyright (C) 2005-2011  Erik van Pienbroek
                       This program is free software; you can redistribute it and/or modify
                       it under the terms of the GNU General Public License as published by
                       the Free Software Foundation; either version 2 of the License, or
                       (at your option) any later version.
                       This program is distributed in the hope that it will be useful,
                       but WITHOUT ANY WARRANTY; without even the implied warranty of
                       MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
                       GNU General Public License for more details.
                       You should have received a copy of the GNU General Public License
                       along with this program; if not, write to the Free Software
                       Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
                   */
                   #include
                   #include
                   #include
                   #include "common.h"
                   #include "nntpgrab_utils.h"
                   #include "download_queue.h"
                   static Configuration *config = NULL;
                   /* Fake placeholders */
                   void
                   ng_plugin_emit_log_msg(NGPlugin *plugin_data, NGLogLevel log_level, const char *format, ...)
+                  {
                       va_list args;
                       char msg[1024];
                       va_start(args, format);
                       memset(msg, 0, sizeof(msg));
                       vsnprintf(msg, sizeof(msg) - 1, format, args);
                       va_end(args);
                       g_test_message("%s", msg);
+                  }
                   typedef void* DecoderData;
                   void
                   decoder_thread_push_task(DecoderData *task)
+                  {
+                  }
                   NntpgrabCore *
                   get_core(void)
+                  {
                       return NULL;
+                  }
                   void
                   download_thread_awaken_if_needed(void)
+                  {
+                  }
                   ngboolean
                   ng_plugin_emit_internal_event(const char *event_name, ...)
+                  {
                       return TRUE;
+                  }
                   /* Helper functions */
                   static NGList *
                   generate_part_list(guint64 *file_size)
+                  {
                       NNTPPart *part;
                       NGList *list;
                       g_return_val_if_fail(file_size != NULL, NULL);
                       *file_size = 0;
                       part = g_slice_new0(NNTPPart);
                       strncpy((char *) part->message_id, "", sizeof(part->message_id));
                       part->size = 258374;
                       part->part_num = 1;
                       *file_size += part->size;
                       list = ng_list_append(NULL, part);
                       part = g_slice_new0(NNTPPart);
                       strncpy((char *) part->message_id, "", sizeof(part->message_id));
                       part->size = 258436;
                       part->part_num = 2;
                       *file_size += part->size;
                       list = ng_list_append(list, part);
                       part = g_slice_new0(NNTPPart);
                       strncpy((char *) part->message_id, "", sizeof(part->message_id));
                       part->size = 258498;
                       part->part_num = 3;
                       *file_size += part->size;
                       list = ng_list_append(list, part);
                       part = g_slice_new0(NNTPPart);
                       strncpy((char *) part->message_id, "", sizeof(part->message_id));
                       part->size = 258448;
                       part->part_num = 4;
                       *file_size += part->size;
                       list = ng_list_append(list, part);
                       return list;
+                  }
                   void
                   free_part_list(NGList *parts)
+                  {
                       NGList *list = parts;
                       while (list) {
                           g_slice_free(NNTPPart, list->data);
                           list = ng_list_next(list);
+                      }
                       ng_list_free(parts);
+                  }
                   void
                   free_group_list(NGList *groups)
+                  {
                       NGList *list = groups;
                       while (list) {
                           g_free(list->data);
                           list = ng_list_next(list);
+                      }
                       ng_list_free(groups);
+                  }
                   /* Testcases */
                   static void
                   test_download_queue_add_file_to_queue(void)
+                  {
                       char *errmsg = NULL;
                       NGList *list_parts;
                       NGList *list_groups;
                       char *collection_name;
                       char *subject;
                       char *poster;
                       time_t stamp;
                       guint64 file_size = 0;
                       GError *err = NULL;
                       char *filename_expected;
                       char *filename_real;
                       char *contents_expected;
                       char *contents_real;
                       /* Add a single file to the download queue */
                       collection_name = "some collection";
                       subject = "some subject";
                       poster = "some poster";
                       stamp = 1185657196;
                       list_parts = generate_part_list(&file_size);
                       list_groups = ng_list_append(NULL, g_strdup("alt.binaries.x"));
                       list_groups = ng_list_append(list_groups, g_strdup("alt.binaries.nl"));
                       if (!download_queue_add_file_to_queue(collection_name, subject, poster, stamp, file_size, list_groups, list_parts, &errmsg)) {
                           FAIL_TEST("Unable to add file to download queue: %s\n", errmsg);
+                      }
                       free_part_list(list_parts);
                       free_group_list(list_groups);
                       if (!download_queue_save(&errmsg)) {
                           FAIL_TEST("Unable to save download queue: %s\n", errmsg);
                           g_free(errmsg);
                           return;
+                      }
                       /* Verify the contents of the download queue file */
                       filename_expected = "download_queue_with_1_file.db";
                       if (!g_file_get_contents(filename_expected, &contents_expected, NULL, &err)) {
                           FAIL_TEST("Unable to read contents of '%s': %s\n", filename_expected, err->message);
                           g_error_free(err);
                           return;
+                      }
                       filename_real = get_location_of_download_queue();
                       if (!g_file_get_contents(filename_real, &contents_real, NULL, &err)) {
                           FAIL_TEST("Unable to read contents of '%s': %s\n", filename_real, err->message);
                           g_free(contents_expected);
                           g_free(filename_real);
                           g_error_free(err);
                           return;
+                      }
                       g_free(filename_real);
                       g_assert_cmpstr(contents_expected, ==, contents_real);
                       g_free(contents_expected);
                       g_free(contents_real);
+                  }
                   static void
                   test_download_queue_restart_file(void)
+                  {
                       char *collection_name;
                       char *subject;
                       char *errmsg = NULL;
                       g_test_message("Now trying to restart file which was added in the add_item_to_queue testcase");
                       collection_name = "some collection";
                       subject = "some subject";
                       if (!download_queue_restart_file(collection_name, subject, &errmsg)) {
                           FAIL_TEST("Unable to remove file from download queue: %s\n", errmsg);
+                      }
                       g_test_message("Now trying to restart a non-existant file");
                       if (!download_queue_restart_file("non-existant", subject, &errmsg)) {
                           /* This is good */
                           g_free(errmsg);
                       } else {
                           FAIL_TEST("download_queue_restart_file returned TRUE, while FALSE was expected");
                           return;
+                      }
                       /* Verify the contents of the download queue file */
+                  }
                   static void
                   test_download_queue_del_file_from_queue(void)
+                  {
                       char *collection_name;
                       char *subject;
                       char *errmsg = NULL;
                       GError *err = NULL;
                       char *filename_real;
                       char *contents_real = NULL;
                       g_test_message("Now trying to remove file which was added in the add_item_to_queue testcase");
                       collection_name = "some collection";
                       subject = "some subject";
                       if (!download_queue_del_file_from_queue(collection_name, subject, &errmsg)) {
                           FAIL_TEST("Unable to remove file from download queue: %s\n", errmsg);
                           g_free(errmsg);
                           return;
+                      }
                       g_test_message("Now trying to remove a non-existant file");
                       if (!download_queue_del_file_from_queue("non-existant", subject, &errmsg)) {
                           /* This is good */
                           g_free(errmsg);
                       } else {
                           FAIL_TEST("download_queue_del_file_from_queue returned TRUE, while FALSE was expected");
                           return;
+                      }
                       if (!download_queue_save(&errmsg)) {
                           FAIL_TEST("Unable to save download queue: %s\n", errmsg);
                           g_free(errmsg);
                           return;
+                      }
                       /* Verify the contents of the download queue file */
                       filename_real = get_location_of_download_queue();
                       if (!g_file_get_contents(filename_real, &contents_real, NULL, &err)) {
                           FAIL_TEST("Unable to read contents of '%s': %s\n", filename_real, err->message);
                           g_free(filename_real);
                           g_error_free(err);
                           return;
+                      }
                       g_free(filename_real);
                       g_assert_cmpstr("", ==, contents_real);
                       g_free(contents_real);
+                  }
                   static void
                   test_download_queue_get_next_part_to_download_setup(void *data, gconstpointer user_data)
+                  {
                       int i;
                       char *errmsg = NULL;
                       char *collection_name = "some collection";
                       for (i = 1; i <= 10; i++) {
                           char *subject;
                           char *poster;
                           time_t stamp;
                           guint64 file_size = 0;
                           NGList *list_parts;
                           NGList *list_groups;
                           subject = g_strdup_printf("file %i", i);
                           poster = "some poster";
                           stamp = 1185657196;
                           list_parts = generate_part_list(&file_size);
                           list_groups = ng_list_append(NULL, g_strdup("alt.binaries.x"));
                           list_groups = ng_list_append(list_groups, g_strdup("alt.binaries.nl"));
                           if (!download_queue_add_file_to_queue(collection_name, subject, poster, stamp, file_size, list_groups, list_parts, &errmsg)) {
                               FAIL_TEST("Unable to add file to download queue: %s\n", errmsg);
                               g_free(errmsg);
                               return;
+                          }
                           free_part_list(list_parts);
                           free_group_list(list_groups);
                           g_free(subject);
+                      }
+                  }
                   static void
                   test_download_queue_get_next_part_to_download_setup_no_servers(void *data, gconstpointer user_data)
+                  {
                       g_assert(configuration_get_avail_servers(config) == NULL);
                       test_download_queue_get_next_part_to_download_setup(data, user_data);
+                  }
                   static void
                   test_download_queue_get_next_part_to_download_setup_one_server_before(void *data, gconstpointer user_data)
+                  {
                       char *errmsg = NULL;
                       NGConfigServer server;
                       g_assert(configuration_get_avail_servers(config) == NULL);
                       memset(&server, 0, sizeof(server));
                       strcpy(server.servername, "server1");
                       strcpy(server.hostname, "host1");
                       server.port = 119;
                       server.enabled = TRUE;
                       server.max_threads = 3;
                       if (!configuration_add_server(config, server, &errmsg)) {
                           FAIL_TEST("Unable to add server: %s\n", errmsg);
                           g_free(errmsg);
                           return;
+                      }
                       test_download_queue_get_next_part_to_download_setup(data, user_data);
+                  }
                   static void
                   test_download_queue_get_next_part_to_download_setup_one_server_after(void *data, gconstpointer user_data)
+                  {
                       char *errmsg = NULL;
                       NGConfigServer server;
                       g_assert(configuration_get_avail_servers(config) == NULL);
                       memset(&server, 0, sizeof(server));
                       strcpy(server.servername, "server1");
                       strcpy(server.hostname, "host1");
                       server.port = 119;
                       server.enabled = TRUE;
                       server.max_threads = 1;
                       test_download_queue_get_next_part_to_download_setup(data, user_data);
                       if (!configuration_add_server(config, server, &errmsg)) {
                           FAIL_TEST("Unable to add server: %s\n", errmsg);
                           g_free(errmsg);
                           return;
+                      }
+                  }
                   static void
                   test_download_queue_get_next_part_to_download_teardown(void *data, gconstpointer user_data)
+                  {
                       int i;
                       char *errmsg = NULL;
                       char *collection_name = "some collection";
                       for (i = 1; i <= 10; i++) {
                           char *subject;
                           subject = g_strdup_printf("file %i", i);
                           if (!download_queue_del_file_from_queue(collection_name, subject, &errmsg)) {
                               FAIL_TEST("Unable to remove file from download queue: %s\n", errmsg);
                               g_free(errmsg);
                               return;
+                          }
                           g_free(subject);
+                      }
+                  }
                   static void
                   test_download_queue_get_next_part_to_download_teardown_no_servers(void *data, gconstpointer user_data)
+                  {
                       g_assert(configuration_get_avail_servers(config) == NULL);
                       test_download_queue_get_next_part_to_download_teardown(data, user_data);
+                  }
                   static void
                   test_download_queue_get_next_part_to_download_teardown_one_server(void *data, gconstpointer user_data)
+                  {
                       char *errmsg = NULL;
                       g_assert(configuration_get_avail_servers(config) != NULL);
                       test_download_queue_get_next_part_to_download_teardown(data, user_data);
                       if (!configuration_del_server(config, "server1", &errmsg)) {
                           FAIL_TEST("Unable to remove server: %s\n", errmsg);
                           g_free(errmsg);
                           return;
+                      }
+                  }
                   static void
                   test_download_queue_get_next_part_to_download_no_servers(void *data, gconstpointer user_data)
+                  {
                       NNTPCollection *collection = NULL;
                       NNTPFile *file = NULL;
                       NNTPPart *part = NULL;
                       gboolean nothing_to_download = FALSE;
                       /* There are no servers configured at the moment, so a request for the next part for server_id 0
                        * should return FALSE and nothing_do_download should be TRUE */
                       if (!download_queue_get_next_part_to_download(&collection, &file, &part, 0, ¬hing_to_download)) {
                           g_assert_cmpint(nothing_to_download, ==, 1);
                           g_assert(collection == NULL);
                           g_assert(file == NULL);
                           g_assert(part == NULL);
                       } else {
                           FAIL_TEST("download_queue_get_next_part_to_download returned TRUE while it isn't expected");
+                      }
+                  }
                   static void
                   test_download_queue_get_next_part_to_download_one_server_all_available(void *data, gconstpointer user_data)
+                  {
                       /* There should be 10 files with 4 parts each in the download queue now
                        * Assume for this testcase that all parts are available on the server */
                       int i, j;
                       NNTPCollection *prev_collection = NULL;
                       NNTPFile *prev_file = NULL;
                       NNTPCollection *collection = NULL;
                       NNTPFile *file = NULL;
                       NNTPPart *part = NULL;
                       gboolean nothing_to_download_or_active = FALSE;
                       GList *list, *files = NULL;
                       for (i = 0; i < 10; i++) {
                           prev_file = NULL;
                           for (j = 0; j < 4; j++) {
                               /* There 1 server configured at the moment, so a request for the next part for server_id 0
                                * should return TRUE and nothing_do_download should_or_active be FALSE */
                               if (!download_queue_get_next_part_to_download(&collection, &file, &part, 0, ¬hing_to_download_or_active)) {
                                   g_test_message("nothing_to_download = %i", nothing_to_download_or_active);
                                   FAIL_TEST("download_queue_get_next_part_to_download returned FALSE while it isn't expected");
                                   return;
                               } else {
                                   g_assert_cmpint(nothing_to_download_or_active, ==, FALSE);
                                   g_assert(collection != NULL);
                                   g_assert(file != NULL);
                                   g_assert(part != NULL);
                                   if (prev_collection == NULL) {
                                       prev_collection = collection;
                                   } else {
                                       g_assert(prev_collection == collection);
+                                  }
                                   if (prev_file == NULL) {
                                       prev_file = file;
                                       files = g_list_append(files, file);
                                   } else {
                                       g_assert(prev_file == file);
+                                  }
+                              }
                               /* Update the status of the part so that everything got completed succesfully */
                               download_queue_update_part_status("server1", 0, collection, file, part, 0, TRUE, FALSE, FALSE);
                               collection = NULL;
                               file = NULL;
                               part = NULL;
+                          }
+                      }
                       /* We processed all files now. If we try to request another part it should indicate that there's nothing to download anymore */
                       if (!download_queue_get_next_part_to_download(&collection, &file, &part, 0, ¬hing_to_download_or_active)) {
                           /* Nothing is returned which is good */
                           /* The flag nothing_to_download_or_active should be FALSE as all files are downloaded, but not decoded yet */
                           g_assert_cmpint(nothing_to_download_or_active, ==, FALSE);
                           g_assert(collection == NULL);
                           g_assert(file == NULL);
                           g_assert(part == NULL);
                       } else {
                           FAIL_TEST("download_queue_get_next_part_to_download returned TRUE while it isn't expected");
                           return;
+                      }
                       /* Mark all files as finished (downloaded+decoded) */
                       list = files;
                       while (list) {
                           file = (NNTPFile*) list->data;
                           file->file_is_downloaded = TRUE;
                           file->now_decoding = FALSE;
                           file->status = TASK_STATE_FINISHED_COMPLETE;
                           list = g_list_next(list);
+                      }
                       g_list_free(files);
                       /* Verify that nothing_to_download_or_active is TRUE now */
                       if (!download_queue_get_next_part_to_download(&collection, &file, &part, 0, ¬hing_to_download_or_active)) {
                           /* Nothing is returned which is good */
                           g_assert_cmpint(nothing_to_download_or_active, ==, TRUE);
                           g_assert(collection == NULL);
                           g_assert(file == NULL);
                           g_assert(part == NULL);
                       } else {
                           FAIL_TEST("download_queue_get_next_part_to_download returned TRUE while it isn't expected");
                           return;
+                      }
+                  }
                   int
                   main(int argc, char **argv)
+                  {
                       int ret;
                       char *errmsg = NULL;
                       g_type_init();
                       g_test_init(&argc, &argv, NULL);
                       g_test_bug_base("https://www.nntpgrab.nl/issues/");
                       initialize_tests();
                       /* Base initialisation for download queue operations */
                       if (!(config = configuration_new(&errmsg, NULL))) {
                           g_error("Unable to initialize configuration. Unable to continue download queue tests: %s\n", errmsg);
+                      }
                       if (!download_queue_init(config, &errmsg)) {
                           g_error("Unable to initialize download queue. Unable to continue download queue tests: %s\n", errmsg);
+                      }
                       /* Add the various testcases */
                       g_test_add_func("/download_queue/add_file_to_queue", test_download_queue_add_file_to_queue);
                       g_test_add_func("/download_queue/restart_file", test_download_queue_restart_file);
                       g_test_add_func("/download_queue/del_file_from_queue", test_download_queue_del_file_from_queue);
                       g_test_add("/download_queue/get_next_part_to_download/no_servers", void, NULL,
                                  test_download_queue_get_next_part_to_download_setup_no_servers,
                                  test_download_queue_get_next_part_to_download_no_servers,
                                  test_download_queue_get_next_part_to_download_teardown_no_servers);
                       g_test_add("/download_queue/get_next_part_to_download/one_server/before/all_available", void, NULL,
                                  test_download_queue_get_next_part_to_download_setup_one_server_before,
                                  test_download_queue_get_next_part_to_download_one_server_all_available,
                                  test_download_queue_get_next_part_to_download_teardown_one_server);
                       g_test_add("/download_queue/get_next_part_to_download/one_server/after/all_available", void, NULL,
                                  test_download_queue_get_next_part_to_download_setup_one_server_after,
                                  test_download_queue_get_next_part_to_download_one_server_all_available,
                                  test_download_queue_get_next_part_to_download_teardown_one_server);
                       /* Perform the tests */
                       ret = g_test_run();
                       /* Cleanup */
                       if (!download_queue_destroy(&errmsg)) {
                           g_error("Unable to destroy download queue: %s\n", &errmsg);
+                      }
                       configuration_destroy(config);
                       cleanup_tests();
                       return ret;
+                  }

                   # Valgrind error suppression file
                   # ============================= libc ==================================
+                  {
                      ld.so initialization + selinux
                      Memcheck:Leak
                      ...
                      fun:_dl_init
                      obj:/lib/ld-*.so
+                  }
+                  {
                      dlopen initialization, triggered by handle-leak-debug code
                      Memcheck:Leak
                      ...
                      fun:__libc_dlopen_mode
                      fun:init
                      fun:backtrace
                      fun:handle_leak_debug_bt
                      fun:dynamic_ensure_handle
                      fun:tp_handle_ensure
+                  }
                   # default.supp has these for 2.10, but they're too specific
+                  {
                      Debian libc6 (2.10.x, 2.11.x) stripped dynamic linker
                      Memcheck:Cond
                      fun:index
                      fun:expand_dynamic_string_token
                      fun:_dl_map_object
                      fun:map_doit
                      fun:_dl_catch_error
                      fun:do_preload
                      fun:dl_main
                      fun:_dl_sysdep_start
                      fun:_dl_start
                      obj:/lib/ld-*.so
+                  }
+                  {
                      Debian libc6 (2.9.x - 2.11.x) stripped dynamic linker
                      Memcheck:Cond
                      fun:_dl_relocate_object
                      fun:dl_main
                      fun:_dl_sysdep_start
                      fun:_dl_start
                      obj:/lib/ld-*.so
+                  }
+                  {
                      ld.so initialization on glibc 2.9
                      Memcheck:Cond
                      fun:strlen
                      fun:_dl_init_paths
                      fun:dl_main
                      fun:_dl_sysdep_start
                      fun:_dl_start
                      obj:/lib/ld-2.9.so
+                  }
                   # ======================= libselinux on Debian amd64 =====================
+                  {
                      I have no idea what SELinux is doing but it's not my problem
                      Memcheck:Cond
                      ...
                      obj:/lib/libselinux.so.1
                      obj:/lib/libselinux.so.1
                      obj:/lib/libselinux.so.1
+                  }
+                  {
                      I have no idea what SELinux is doing but it's not my problem
                      Memcheck:Value8
                      ...
                      obj:/lib/libselinux.so.1
                      obj:/lib/libselinux.so.1
                      obj:/lib/libselinux.so.1
+                  }
+                  {
                      I have no idea what SELinux is doing but it's not my problem
                      Memcheck:Leak
                      ...
                      obj:/lib/libselinux.so.1
                      obj:/lib/libselinux.so.1
                      obj:/lib/libselinux.so.1
+                  }
                   # ============================= GLib ==================================
+                  {
                      g_set_prgname copies its argument
                      Memcheck:Leak
                      ...
                      fun:g_set_prgname
+                  }
+                  {
                      one g_get_charset per child^Wprocess
                      Memcheck:Leak
                      ...
                      fun:g_get_charset
+                  }
+                  {
                      one g_get_home_dir per process

... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff