This patch changes crash data to use C structures.

The smallest data element is:

struct crash_item { char *content; unsigned flags; };

where content is, eh, content, and flags is a bit flag field.

crash_data_t is a map of crash_item's, implemented as a pointer
to heap-allocated GHashTable.

vector_of_crash_data_t is a vector of crash_data_t's, implemented
as a pointer to heap-allocated GPtrArray.

Most operations have light wrappers around them to hide the nature
of the containers. For example, to free vector_of_crash_data,
you need to use free_vector_of_crash_data(ptr) instead of
open-coding g_ptr_array_free. The wrapper is thin.

The goal is not so much to hide the implementation, but more
to make it easier to use the correct function.

dbus (un)marshalling functions convert crash_item to three-element
array of strings, in order to keep compatibility with abrt-gui (python).
This can be changed later to use native representation.
crash_data_t and vector_of_crash_data_t are represented in
"natural" way, no funny stuff there.

Signed-off-by: Denys Vlasenko <dvlasenk@redhat.com>

26 files changed, 749 insertions, 458 deletions

diff --git a/src/applet/test_report.cpp b/src/applet/test_report.cpp
index b93b6759..92a5d0af 100644
--- a/src/applet/test_report.cpp
+++ b/src/applet/test_report.cpp
@@ -34,12 +34,13 @@ static char *do_log(char *log_line, void *param)
 
 int main(int argc, char** argv)
 {
-    map_crash_data_t cd;
+    crash_data_t *crash_data = new_crash_data();
 
-    add_to_crash_data(cd, "analyzer", "wow");
+    add_to_crash_data(crash_data, "analyzer", "wow");
     const char *event = "report";
 
-    struct dump_dir *dd = create_crash_dump_dir(cd);
+    struct dump_dir *dd = create_crash_dump_dir(crash_data);
+    free_crash_data(crash_data);
     if (!dd)
         return 1;
     char *dir_name = strdup(dd->dd_dir);
diff --git a/src/cli/CLI.cpp b/src/cli/CLI.cpp
index 64d629b8..fd8ec4f0 100644
--- a/src/cli/CLI.cpp
+++ b/src/cli/CLI.cpp
@@ -38,10 +38,10 @@ static char *localize_crash_time(const char *timestr)
 }
 
 /** Prints basic information about a crash to stdout. */
-static void print_crash(const map_crash_data_t &crash)
+static void print_crash(crash_data_t *crash_data)
 {
     /* Create a localized string from crash time. */
-    const char *timestr = get_crash_data_item_content(crash, FILENAME_TIME).c_str();
+    const char *timestr = get_crash_item_content_or_die(crash_data, FILENAME_TIME);
     const char *timeloc = localize_crash_time(timestr);
 
     printf(_("\tCrash dump : %s\n"
@@ -50,17 +50,18 @@ static void print_crash(const map_crash_data_t &crash)
              "\tExecutable : %s\n"
              "\tCrash Time : %s\n"
              "\tCrash Count: %s\n"),
-           get_crash_data_item_content(crash, CD_DUMPDIR).c_str(),
-           get_crash_data_item_content(crash, FILENAME_UID).c_str(),
-           get_crash_data_item_content(crash, FILENAME_PACKAGE).c_str(),
-           get_crash_data_item_content(crash, FILENAME_EXECUTABLE).c_str(),
+           get_crash_item_content_or_NULL(crash_data, CD_DUMPDIR),
+           get_crash_item_content_or_NULL(crash_data, FILENAME_UID),
+           get_crash_item_content_or_NULL(crash_data, FILENAME_PACKAGE),
+           get_crash_item_content_or_NULL(crash_data, FILENAME_EXECUTABLE),
            timeloc,
-           get_crash_data_item_content(crash, FILENAME_COUNT).c_str());
+           get_crash_item_content_or_NULL(crash_data, FILENAME_COUNT)
+    );
 
     free((void *)timeloc);
 
     /* Print the hostname if it's available. */
-    const char *hostname = get_crash_data_item_content_or_NULL(crash, FILENAME_HOSTNAME);
+    const char *hostname = get_crash_item_content_or_NULL(crash_data, FILENAME_HOSTNAME);
     if (hostname)
         printf(_("\tHostname   : %s\n"), hostname);
 }
@@ -70,14 +71,14 @@ static void print_crash(const map_crash_data_t &crash)
  * @param include_reported
  *   Do not skip entries marked as already reported.
  */
-static void print_crash_list(const vector_map_crash_data_t& crash_list, bool include_reported)
+static void print_crash_list(vector_of_crash_data_t *crash_list, bool include_reported)
 {
-    for (unsigned i = 0; i < crash_list.size(); ++i)
+    for (unsigned i = 0; i < crash_list->len; ++i)
     {
-        const map_crash_data_t& crash = crash_list[i];
+        crash_data_t *crash = get_crash_data(crash_list, i);
         if (!include_reported)
         {
-            const char *msg = get_crash_data_item_content_or_NULL(crash, FILENAME_MESSAGE);
+            const char *msg = get_crash_item_content_or_NULL(crash, FILENAME_MESSAGE);
             if (!msg || !msg[0])
                 continue;
         }
@@ -90,9 +91,9 @@ static void print_crash_list(const vector_map_crash_data_t& crash_list, bool inc
 /**
  * Prints full information about a crash
  */
-static void print_crash_info(const map_crash_data_t& crash, bool show_backtrace)
+static void print_crash_info(crash_data_t *crash_data, bool show_backtrace)
 {
-    const char *timestr = get_crash_data_item_content(crash, FILENAME_TIME).c_str();
+    const char *timestr = get_crash_item_content_or_die(crash_data, FILENAME_TIME);
     const char *timeloc = localize_crash_time(timestr);
 
     printf(_("Dump directory:     %s\n"
@@ -104,50 +105,51 @@ static void print_crash_info(const map_crash_data_t& crash, bool show_backtrace)
              "Executable:         %s\n"
              "System:             %s, kernel %s\n"
              "Reason:             %s\n"),
-           get_crash_data_item_content(crash, CD_DUMPDIR).c_str(),
+           get_crash_item_content_or_die(crash_data, CD_DUMPDIR),
            timeloc,
-           get_crash_data_item_content(crash, FILENAME_ANALYZER).c_str(),
-           get_crash_data_item_content(crash, FILENAME_COMPONENT).c_str(),
-           get_crash_data_item_content(crash, FILENAME_PACKAGE).c_str(),
-           get_crash_data_item_content(crash, FILENAME_CMDLINE).c_str(),
-           get_crash_data_item_content(crash, FILENAME_EXECUTABLE).c_str(),
-           get_crash_data_item_content(crash, FILENAME_RELEASE).c_str(),
-           get_crash_data_item_content(crash, FILENAME_KERNEL).c_str(),
-           get_crash_data_item_content(crash, FILENAME_REASON).c_str());
+           get_crash_item_content_or_die(crash_data, FILENAME_ANALYZER),
+           get_crash_item_content_or_die(crash_data, FILENAME_COMPONENT),
+           get_crash_item_content_or_die(crash_data, FILENAME_PACKAGE),
+           get_crash_item_content_or_die(crash_data, FILENAME_CMDLINE),
+           get_crash_item_content_or_die(crash_data, FILENAME_EXECUTABLE),
+           get_crash_item_content_or_die(crash_data, FILENAME_RELEASE),
+           get_crash_item_content_or_die(crash_data, FILENAME_KERNEL),
+           get_crash_item_content_or_die(crash_data, FILENAME_REASON)
+    );
 
     free((void *)timeloc);
 
     /* Print optional fields only if they are available */
 
     /* Coredump is not present in kerneloopses and Python exceptions. */
-    const char *coredump = get_crash_data_item_content_or_NULL(crash, FILENAME_COREDUMP);
+    const char *coredump = get_crash_item_content_or_NULL(crash_data, FILENAME_COREDUMP);
     if (coredump)
         printf(_("Coredump file:      %s\n"), coredump);
 
-    const char *rating = get_crash_data_item_content_or_NULL(crash, FILENAME_RATING);
+    const char *rating = get_crash_item_content_or_NULL(crash_data, FILENAME_RATING);
     if (rating)
         printf(_("Rating:             %s\n"), rating);
 
     /* Crash function is not present in kerneloopses, and before the full report is created.*/
-    const char *crash_function = get_crash_data_item_content_or_NULL(crash, FILENAME_CRASH_FUNCTION);
+    const char *crash_function = get_crash_item_content_or_NULL(crash_data, FILENAME_CRASH_FUNCTION);
     if (crash_function)
         printf(_("Crash function:     %s\n"), crash_function);
 
-    const char *hostname = get_crash_data_item_content_or_NULL(crash, FILENAME_HOSTNAME);
+    const char *hostname = get_crash_item_content_or_NULL(crash_data, FILENAME_HOSTNAME);
     if (hostname)
         printf(_("Hostname:           %s\n"), hostname);
 
-    const char *reproduce = get_crash_data_item_content_or_NULL(crash, FILENAME_REPRODUCE);
+    const char *reproduce = get_crash_item_content_or_NULL(crash_data, FILENAME_REPRODUCE);
     if (reproduce)
         printf(_("\nHow to reproduce:\n%s\n"), reproduce);
 
-    const char *comment = get_crash_data_item_content_or_NULL(crash, FILENAME_COMMENT);
+    const char *comment = get_crash_item_content_or_NULL(crash_data, FILENAME_COMMENT);
     if (comment)
         printf(_("\nComment:\n%s\n"), comment);
 
     if (show_backtrace)
     {
-        const char *backtrace = get_crash_data_item_content_or_NULL(crash, FILENAME_BACKTRACE);
+        const char *backtrace = get_crash_item_content_or_NULL(crash_data, FILENAME_BACKTRACE);
         if (backtrace)
             printf(_("\nBacktrace:\n%s\n"), backtrace);
     }
@@ -159,15 +161,17 @@ static void print_crash_info(const map_crash_data_t& crash, bool show_backtrace)
  */
 static char *guess_crash_id(const char *str)
 {
-    vector_map_crash_data_t ci = call_GetCrashInfos();
-    unsigned num_crashinfos = ci.size();
+    vector_of_crash_data_t *ci = call_GetCrashInfos();
+    unsigned num_crashinfos = ci->len;
     if (str[0] == '@') /* "--report @N" syntax */
     {
         unsigned position = xatoi_u(str + 1);
         if (position >= num_crashinfos)
             error_msg_and_die("There are only %u crash infos", num_crashinfos);
-        map_crash_data_t& info = ci[position];
-        return xstrdup(get_crash_data_item_content(info, CD_DUMPDIR).c_str());
+        crash_data_t *info = get_crash_data(ci, position);
+        char *res = xstrdup(get_crash_item_content_or_die(info, CD_DUMPDIR));
+        free_vector_of_crash_data(ci);
+        return res;
     }
 
     unsigned len = strlen(str);
@@ -175,8 +179,8 @@ static char *guess_crash_id(const char *str)
     char *result = NULL;
     for (ii = 0; ii < num_crashinfos; ii++)
     {
-        map_crash_data_t& info = ci[ii];
-        const char *this_dir = get_crash_data_item_content(info, CD_DUMPDIR).c_str();
+        crash_data_t *info = get_crash_data(ci, ii);
+        const char *this_dir = get_crash_item_content_or_die(info, CD_DUMPDIR);
         if (strncmp(str, this_dir, len) == 0)
         {
             if (result)
@@ -184,6 +188,7 @@ static char *guess_crash_id(const char *str)
             result = xstrdup(this_dir);
         }
     }
+    free_vector_of_crash_data(ci);
     if (!result)
         error_msg_and_die("Crash dump directory '%s' not found", str);
     return result;
@@ -353,8 +358,9 @@ int main(int argc, char** argv)
     {
         case OPT_GET_LIST:
         {
-            vector_map_crash_data_t ci = call_GetCrashInfos();
+            vector_of_crash_data_t *ci = call_GetCrashInfos();
             print_crash_list(ci, full);
+            free_vector_of_crash_data(ci);
             break;
         }
         case OPT_REPORT:
@@ -403,12 +409,12 @@ int main(int argc, char** argv)
             int old_logmode = logmode;
             logmode = 0;
 
-            map_crash_data_t crashData = call_CreateReport(crash_id);
-            if (crashData.empty()) /* no such crash_id */
+            crash_data_t *crash_data = call_CreateReport(crash_id);
+            if (!crash_data) /* no such crash_id */
             {
                 crash_id = guess_crash_id(crash_id);
-                crashData = call_CreateReport(crash_id);
-                if (crashData.empty())
+                crash_data = call_CreateReport(crash_id);
+                if (!crash_data)
                 {
                     error_msg("Crash '%s' not found", crash_id);
                     free((void *)crash_id);
@@ -420,7 +426,8 @@ int main(int argc, char** argv)
 
             logmode = old_logmode;
 
-            print_crash_info(crashData, backtrace);
+            print_crash_info(crash_data, backtrace);
+            free_crash_data(crash_data);
 
             break;
         }
diff --git a/src/cli/dbus.cpp b/src/cli/dbus.cpp
index f9271b85..6c98ec4e 100644
--- a/src/cli/dbus.cpp
+++ b/src/cli/dbus.cpp
@@ -121,7 +121,7 @@ static DBusMessage* send_get_reply_and_unref(DBusMessage* msg)
     }
 }
 
-vector_map_crash_data_t call_GetCrashInfos()
+vector_of_crash_data_t *call_GetCrashInfos()
 {
     DBusMessage* msg = new_call_msg(__func__ + 5);
     DBusMessage *reply = send_get_reply_and_unref(msg);
@@ -129,8 +129,8 @@ vector_map_crash_data_t call_GetCrashInfos()
     DBusMessageIter in_iter;
     dbus_message_iter_init(reply, &in_iter);
 
-    vector_map_crash_data_t argout;
-    int r = load_val(&in_iter, argout);
+    vector_of_crash_data_t *argout = NULL;
+    int r = load_vector_of_crash_data(&in_iter, &argout);
     if (r != ABRT_DBUS_LAST_FIELD) /* more values present, or bad type */
         error_msg_and_die("dbus call %s: return type mismatch", __func__ + 5);
 
@@ -138,7 +138,7 @@ vector_map_crash_data_t call_GetCrashInfos()
     return argout;
 }
 
-map_crash_data_t call_CreateReport(const char* crash_id)
+crash_data_t *call_CreateReport(const char* crash_id)
 {
     DBusMessage* msg = new_call_msg(__func__ + 5);
     dbus_message_append_args(msg,
@@ -150,8 +150,8 @@ map_crash_data_t call_CreateReport(const char* crash_id)
     DBusMessageIter in_iter;
     dbus_message_iter_init(reply, &in_iter);
 
-    map_crash_data_t argout;
-    int r = load_val(&in_iter, argout);
+    crash_data_t *argout = NULL;
+    int r = load_crash_data(&in_iter, &argout);
     if (r != ABRT_DBUS_LAST_FIELD) /* more values present, or bad type */
         error_msg_and_die("dbus call %s: return type mismatch", __func__ + 5);
 
@@ -159,7 +159,7 @@ map_crash_data_t call_CreateReport(const char* crash_id)
     return argout;
 }
 
-report_status_t call_Report(const map_crash_data_t& report,
+report_status_t call_Report(crash_data_t *report,
 			    const vector_string_t& reporters,
 			    GHashTable *plugins)
 {
@@ -168,7 +168,7 @@ report_status_t call_Report(const map_crash_data_t& report,
     dbus_message_iter_init_append(msg, &out_iter);
 
     /* parameter #1: report data */
-    store_val(&out_iter, report);
+    store_crash_data(&out_iter, report);
     /* parameter #2: reporters to use */
     store_val(&out_iter, reporters);
     /* parameter #3 (opt): plugin config */
diff --git a/src/cli/dbus.h b/src/cli/dbus.h
index b837869d..0d338d27 100644
--- a/src/cli/dbus.h
+++ b/src/cli/dbus.h
@@ -24,9 +24,9 @@
 
 extern DBusConnection* s_dbus_conn;
 
-vector_map_crash_data_t call_GetCrashInfos();
+vector_of_crash_data_t *call_GetCrashInfos();
 
-map_crash_data_t call_CreateReport(const char *crash_id);
+crash_data_t *call_CreateReport(const char *crash_id);
 
 /** Sends report using enabled Reporter plugins.
  * @param report
@@ -40,7 +40,7 @@ map_crash_data_t call_CreateReport(const char *crash_id);
  *  obtained by call_GetPluginSettings, otherwise the plugin might ignore
  *  the settings.
  */
-report_status_t call_Report(const map_crash_data_t& report,
+report_status_t call_Report(crash_data_t *report,
 			    const vector_string_t& reporters,
 			    GHashTable *plugins);
 
diff --git a/src/cli/report.cpp b/src/cli/report.cpp
index 88154d53..9ee37576 100644
--- a/src/cli/report.cpp
+++ b/src/cli/report.cpp
@@ -142,30 +142,30 @@ static void remove_comments_and_unescape(char *str)
  * Writes a field of crash report to a file.
  * Field must be writable.
  */
-static void write_crash_report_field(FILE *fp, const map_crash_data_t &report,
+static void write_crash_report_field(FILE *fp, crash_data_t *crash_data,
         const char *field, const char *description)
 {
-    const map_crash_data_t::const_iterator it = report.find(field);
-    if (it == report.end())
+    const struct crash_item *value = get_crash_data_item_or_NULL(crash_data, field);
+    if (!value)
     {
         // exit silently, all fields are optional for now
         //error_msg("Field %s not found", field);
         return;
     }
 
-    if (it->second[CD_TYPE] == CD_SYS)
+    if (value->flags & CD_FLAG_SYS)
     {
         error_msg("Cannot update field %s because it is a system value", field);
         return;
     }
 
-    fprintf(fp, "%s%s\n", FIELD_SEP, it->first.c_str());
+    fprintf(fp, "%s%s\n", FIELD_SEP, field);
 
     fprintf(fp, "%s\n", description);
-    if (it->second[CD_EDITABLE] != CD_ISEDITABLE)
+    if (!(value->flags & CD_FLAG_ISEDITABLE))
         fprintf(fp, _("# This field is read only\n"));
 
-    char *escaped_content = escape(it->second[CD_CONTENT].c_str());
+    char *escaped_content = escape(value->content);
     fprintf(fp, "%s\n", escaped_content);
     free(escaped_content);
 }
@@ -177,7 +177,7 @@ static void write_crash_report_field(FILE *fp, const map_crash_data_t &report,
  *  If the report is successfully stored to the file, a zero value is returned.
  *  On failure, nonzero value is returned.
  */
-static void write_crash_report(const map_crash_data_t &report, FILE *fp)
+static void write_crash_report(crash_data_t *report, FILE *fp)
 {
     fprintf(fp, "# Please check this report. Lines starting with '#' will be ignored.\n"
             "# Lines starting with '%%----' separate fields, please do not delete them.\n\n");
@@ -208,7 +208,7 @@ static void write_crash_report(const map_crash_data_t &report, FILE *fp)
  *  1 if the field was changed.
  *  Changes to read-only fields are ignored.
  */
-static int read_crash_report_field(const char *text, map_crash_data_t &report,
+static int read_crash_report_field(const char *text, crash_data_t *report,
         const char *field)
 {
     char separator[sizeof("\n" FIELD_SEP)-1 + strlen(field) + 2]; // 2 = '\n\0'
@@ -225,21 +225,21 @@ static int read_crash_report_field(const char *text, map_crash_data_t &report,
     else
         length = end - textfield;
 
-    const map_crash_data_t::iterator it = report.find(field);
-    if (it == report.end())
+    struct crash_item *value = get_crash_data_item_or_NULL(report, field);
+    if (!value)
     {
         error_msg("Field %s not found", field);
         return 0;
     }
 
-    if (it->second[CD_TYPE] == CD_SYS)
+    if (value->flags & CD_FLAG_SYS)
     {
         error_msg("Cannot update field %s because it is a system value", field);
         return 0;
     }
 
     // Do not change noneditable fields.
-    if (it->second[CD_EDITABLE] != CD_ISEDITABLE)
+    if (!(value->flags & CD_FLAG_ISEDITABLE))
         return 0;
 
     // Compare the old field contents with the new field contents.
@@ -248,16 +248,16 @@ static int read_crash_report_field(const char *text, map_crash_data_t &report,
     newvalue[length] = '\0';
     trim(newvalue);
 
-    char oldvalue[it->second[CD_CONTENT].length() + 1];
-    strcpy(oldvalue, it->second[CD_CONTENT].c_str());
+    char oldvalue[strlen(value->content) + 1];
+    strcpy(oldvalue, value->content);
     trim(oldvalue);
 
     // Return if no change in the contents detected.
-    int cmp = strcmp(newvalue, oldvalue);
-    if (!cmp)
+    if (strcmp(newvalue, oldvalue) == 0)
         return 0;
 
-    it->second[CD_CONTENT].assign(newvalue);
+    free(value->content);
+    value->content = xstrdup(newvalue);
     return 1;
 }
 
@@ -269,7 +269,7 @@ static int read_crash_report_field(const char *text, map_crash_data_t &report,
  *  1 if any field was changed.
  *  Changes to read-only fields are ignored.
  */
-static int read_crash_report(map_crash_data_t &report, const char *text)
+static int read_crash_report(crash_data_t *report, const char *text)
 {
     int result = 0;
     result |= read_crash_report_field(text, report, FILENAME_COMMENT);
@@ -292,13 +292,13 @@ static int read_crash_report(map_crash_data_t &report, const char *text)
  * Ensures that the fields needed for editor are present in the crash data.
  * Fields: comments, how to reproduce.
  */
-static void create_fields_for_editor(map_crash_data_t &crash_data)
+static void create_fields_for_editor(crash_data_t *crash_data)
 {
-    if (crash_data.find(FILENAME_COMMENT) == crash_data.end())
-        add_to_crash_data_ext(crash_data, FILENAME_COMMENT, CD_TXT, CD_ISEDITABLE, "");
+    if (!get_crash_data_item_or_NULL(crash_data, FILENAME_COMMENT))
+        add_to_crash_data_ext(crash_data, FILENAME_COMMENT, "", CD_FLAG_TXT + CD_FLAG_ISEDITABLE);
 
-    if (crash_data.find(FILENAME_REPRODUCE) == crash_data.end())
-        add_to_crash_data_ext(crash_data, FILENAME_REPRODUCE, CD_TXT, CD_ISEDITABLE, "1. \n2. \n3. \n");
+    if (!get_crash_data_item_or_NULL(crash_data, FILENAME_REPRODUCE))
+        add_to_crash_data_ext(crash_data, FILENAME_REPRODUCE, "1. \n2. \n3. \n", CD_FLAG_TXT + CD_FLAG_ISEDITABLE);
 }
 
 /**
@@ -342,7 +342,7 @@ static int launch_editor(const char *path)
  *  2 on failure, unable to create, open, or close temporary file
  *  3 on failure, cannot launch text editor
  */
-static int run_report_editor(map_crash_data_t &cr)
+static int run_report_editor(crash_data_t *crash_data)
 {
     /* Open a temporary file and write the crash report to it. */
     char filename[] = "/tmp/abrt-report.XXXXXX";
@@ -360,7 +360,7 @@ static int run_report_editor(map_crash_data_t &cr)
         return 2;
     }
 
-    write_crash_report(cr, fp);
+    write_crash_report(crash_data, fp);
 
     if (fclose(fp)) /* errno is set */
     {
@@ -405,7 +405,7 @@ static int run_report_editor(map_crash_data_t &cr)
 
     remove_comments_and_unescape(text);
     // Updates the crash report from the file text.
-    int report_changed = read_crash_report(cr, text);
+    int report_changed = read_crash_report(crash_data, text);
     free(text);
     if (report_changed)
         puts(_("\nThe report has been updated"));
@@ -587,27 +587,31 @@ int report(const char *crash_id, int flags)
     if (flags & CLI_REPORT_SILENT_IF_NOT_FOUND)
         logmode = 0;
     // Ask for an initial report.
-    map_crash_data_t cr = call_CreateReport(crash_id);
+    crash_data_t *crash_data = call_CreateReport(crash_id);
     logmode = old_logmode;
-    if (cr.size() == 0)
+    if (!crash_data || g_hash_table_size(crash_data) == 0)
     {
+        free_crash_data(crash_data);
         return -1;
     }
 
-    const char *rating_str = get_crash_data_item_content_or_NULL(cr, FILENAME_RATING);
+    const char *rating_str = get_crash_item_content_or_NULL(crash_data, FILENAME_RATING);
     unsigned rating = rating_str ? xatou(rating_str) : 4;
 
     /* Open text editor and give a chance to review the backtrace etc. */
     if (!(flags & CLI_REPORT_BATCH))
     {
-        create_fields_for_editor(cr);
-        int result = run_report_editor(cr);
+        create_fields_for_editor(crash_data);
+        int result = run_report_editor(crash_data);
         if (result != 0)
+        {
+            free_crash_data(crash_data);
             return result;
+        }
     }
 
     /* Get possible reporters associated with this particular crash. */
-    const char *events = get_crash_data_item_content_or_NULL(cr, CD_EVENTS);
+    const char *events = get_crash_item_content_or_NULL(crash_data, CD_EVENTS);
     vector_string_t reporters;
     if (events) while (*events)
     {
@@ -633,7 +637,7 @@ int report(const char *crash_id, int flags)
     if (flags & CLI_REPORT_BATCH)
     {
         puts(_("Reporting..."));
-        report_status_t r = call_Report(cr, reporters, reporters_settings);
+        report_status_t r = call_Report(crash_data, reporters, reporters_settings);
         report_status_t::iterator it = r.begin();
         while (it != r.end())
         {
@@ -668,7 +672,7 @@ int report(const char *crash_id, int flags)
                 {
                     puts(_("Reporting disabled because the backtrace is unusable"));
 
-                    const char *package = get_crash_data_item_content_or_NULL(cr, FILENAME_PACKAGE);
+                    const char *package = get_crash_item_content_or_NULL(crash_data, FILENAME_PACKAGE);
                     if (package && package[0])
                         printf(_("Please try to install debuginfo manually using the command: \"debuginfo-install %s\" and try again\n"), package);
 
@@ -688,7 +692,7 @@ int report(const char *crash_id, int flags)
             ask_for_missing_settings(it->c_str(), *settings);
 
             vector_string_t cur_reporter(1, *it);
-            report_status_t r = call_Report(cr, cur_reporter, reporters_settings);
+            report_status_t r = call_Report(crash_data, cur_reporter, reporters_settings);
             assert(r.size() == 1); /* one reporter --> one report status */
             vector_string_t &v = r.begin()->second;
             printf("%s: %s\n", r.begin()->first.c_str(), v[REPORT_STATUS_IDX_MSG].c_str());
@@ -699,6 +703,7 @@ int report(const char *crash_id, int flags)
     }
 
     g_hash_table_destroy(reporters_settings);
+    free_crash_data(crash_data);
     printf(_("Crash reported via %d report events (%d errors)\n"), plugins, errors);
     return errors != 0;
 }
diff --git a/src/daemon/CommLayerServerDBus.cpp b/src/daemon/CommLayerServerDBus.cpp
index 28d6ee05..14f132b3 100644
--- a/src/daemon/CommLayerServerDBus.cpp
+++ b/src/daemon/CommLayerServerDBus.cpp
@@ -144,11 +144,12 @@ static long get_remote_uid(DBusMessage* call, const char** ppSender = NULL)
 static int handle_GetCrashInfos(DBusMessage* call, DBusMessage* reply)
 {
     long unix_uid = get_remote_uid(call);
-    vector_map_crash_data_t argout1 = GetCrashInfos(unix_uid);
+    vector_of_crash_data_t *argout1 = GetCrashInfos(unix_uid);
 
     DBusMessageIter out_iter;
     dbus_message_iter_init_append(reply, &out_iter);
-    store_val(&out_iter, argout1);
+    store_vector_of_crash_data(&out_iter, argout1);
+    free_vector_of_crash_data(argout1);
 
     send_flush_and_unref(reply);
     return 0;
@@ -197,12 +198,12 @@ static int handle_CreateReport(DBusMessage* call, DBusMessage* reply)
     }
 
     long unix_uid = get_remote_uid(call);
-    map_crash_data_t report;
-    CreateReport(crash_id, unix_uid, /*force:*/ 0, report);
+    crash_data_t *report = NULL;
+    CreateReport(crash_id, unix_uid, /*force:*/ 0, &report);
 
     DBusMessageIter out_iter;
     dbus_message_iter_init_append(reply, &out_iter);
-    store_val(&out_iter, report);
+    store_crash_data(&out_iter, report);
 
     send_flush_and_unref(reply);
     return 0;
@@ -211,19 +212,28 @@ static int handle_CreateReport(DBusMessage* call, DBusMessage* reply)
 static int handle_Report(DBusMessage* call, DBusMessage* reply)
 {
     int r;
+    long unix_uid;
+    report_status_t argout1;
+    map_map_string_t user_conf_data;
+    vector_string_t events;
+    const char* comment = NULL;
+    const char* reproduce = NULL;
+    const char* errmsg = NULL;
     DBusMessageIter in_iter;
+
     dbus_message_iter_init(call, &in_iter);
 
-    map_crash_data_t argin1;
-    r = load_val(&in_iter, argin1);
+    crash_data_t *crash_data = NULL;
+    r = load_crash_data(&in_iter, &crash_data);
     if (r != ABRT_DBUS_MORE_FIELDS)
     {
         error_msg("dbus call %s: parameter type mismatch", __func__ + 7);
-        return -1;
+        r = -1;
+        goto ret;
     }
-    const char* comment = get_crash_data_item_content_or_NULL(argin1, FILENAME_COMMENT) ? : "";
-    const char* reproduce = get_crash_data_item_content_or_NULL(argin1, FILENAME_REPRODUCE) ? : "";
-    const char* errmsg = NULL;
+//TODO? get_crash_item_content_or_die_or_empty?
+    comment = get_crash_item_content_or_NULL(crash_data, FILENAME_COMMENT) ? : "";
+    reproduce = get_crash_item_content_or_NULL(crash_data, FILENAME_REPRODUCE) ? : "";
     if (strlen(comment) > LIMIT_MESSAGE)
     {
         errmsg = _("Comment is too long");
@@ -239,35 +249,35 @@ static int handle_Report(DBusMessage* call, DBusMessage* reply)
         if (!reply)
             die_out_of_memory();
         send_flush_and_unref(reply);
-        return 0;
+        r = 0;
+        goto ret;
     }
 
     /* Second parameter: list of events to run */
-    vector_string_t events;
     r = load_val(&in_iter, events);
     if (r == ABRT_DBUS_ERROR)
     {
         error_msg("dbus call %s: parameter type mismatch", __func__ + 7);
-        return -1;
+        r = -1;
+        goto ret;
     }
 
     /* Third parameter (optional): configuration data for plugins */
-    map_map_string_t user_conf_data;
     if (r == ABRT_DBUS_MORE_FIELDS)
     {
         r = load_val(&in_iter, user_conf_data);
         if (r != ABRT_DBUS_LAST_FIELD)
         {
             error_msg("dbus call %s: parameter type mismatch", __func__ + 7);
-            return -1;
+            r = -1;
+            goto ret;
         }
     }
 
-    long unix_uid = get_remote_uid(call);
-    report_status_t argout1;
+    unix_uid = get_remote_uid(call);
     try
     {
-        argout1 = Report(argin1, events, user_conf_data, unix_uid);
+        argout1 = Report(crash_data, events, user_conf_data, unix_uid);
     }
     catch (CABRTException &e)
     {
@@ -276,7 +286,8 @@ static int handle_Report(DBusMessage* call, DBusMessage* reply)
         if (!reply)
             die_out_of_memory();
         send_flush_and_unref(reply);
-        return 0;
+        r = 0;
+        goto ret;
     }
 
     DBusMessageIter out_iter;
@@ -284,7 +295,10 @@ static int handle_Report(DBusMessage* call, DBusMessage* reply)
     store_val(&out_iter, argout1);
 
     send_flush_and_unref(reply);
-    return 0;
+    r = 0;
+ ret:
+    free_crash_data(crash_data);
+    return r;
 }
 
 static int handle_DeleteDebugDump(DBusMessage* call, DBusMessage* reply)
diff --git a/src/daemon/Daemon.cpp b/src/daemon/Daemon.cpp
index 609b0b26..62bcdc68 100644
--- a/src/daemon/Daemon.cpp
+++ b/src/daemon/Daemon.cpp
@@ -55,15 +55,15 @@ using namespace std;
  * - signal: we got SIGTERM or SIGINT
  *
  * DBus methods we have:
- * - GetCrashInfos(): returns a vector_map_crash_data_t (vector_map_vector_string_t)
+ * - GetCrashInfos(): returns a vector_of_crash_data
  *      of crashes for given uid
  *      v[N]["executable"/"uid"/"kernel"/"backtrace"][N] = "contents"
  * - StartJob(crash_id,force): starts creating a report for /var/spool/abrt/DIR with this UID:UUID.
  *      Returns job id (uint64).
  *      After thread returns, when report creation thread has finished,
  *      JobDone() dbus signal is emitted.
- * - CreateReport(crash_id): returns map_crash_data_t (map_vector_string_t)
- * - Report(map_crash_data_t (map_vector_string_t[, map_map_string_t])):
+ * - CreateReport(crash_id): returns crash data (hash table of struct crash_item)
+ * - Report(crash_data[, map_map_string_t]):
  *      "Please report this crash": calls Report() of all registered reporter plugins.
  *      Returns report_status_t (map_vector_string_t) - the status of each call.
  *      2nd parameter is the contents of user's abrt.conf.
@@ -542,11 +542,11 @@ static gboolean handle_inotify_cb(GIOChannel *gio, GIOCondition condition, gpoin
         }
 
         char *fullname = NULL;
+        crash_data_t *crash_data = NULL;
         try
         {
             fullname = concat_path_file(DEBUG_DUMPS_DIR, name);
-            map_crash_data_t crashinfo;
-            mw_result_t res = LoadDebugDump(fullname, crashinfo);
+            mw_result_t res = LoadDebugDump(fullname, &crash_data);
             switch (res)
             {
                 case MW_OK:
@@ -557,24 +557,24 @@ static gboolean handle_inotify_cb(GIOChannel *gio, GIOCondition condition, gpoin
                 {
                     if (res != MW_OK)
                     {
-                        const char *first = get_crash_data_item_content_or_NULL(crashinfo, CD_DUMPDIR);
+                        const char *first = get_crash_item_content_or_NULL(crash_data, CD_DUMPDIR);
                         log("Deleting crash %s (dup of %s), sending dbus signal",
                                 strrchr(fullname, '/') + 1,
                                 strrchr(first, '/') + 1);
                         delete_crash_dump_dir(fullname);
                     }
 
-                    const char *uid_str = get_crash_data_item_content_or_NULL(crashinfo, FILENAME_UID);
-                    const char *inform_all = get_crash_data_item_content_or_NULL(crashinfo, FILENAME_INFORMALL);
+                    const char *uid_str = get_crash_item_content_or_NULL(crash_data, FILENAME_UID);
+                    const char *inform_all = get_crash_item_content_or_NULL(crash_data, FILENAME_INFORMALL);
 
                     if (inform_all && string_to_bool(inform_all))
                         uid_str = NULL;
                     char *crash_id = xasprintf("%s:%s",
-                                    get_crash_data_item_content_or_NULL(crashinfo, FILENAME_UID),
-                                    get_crash_data_item_content_or_NULL(crashinfo, FILENAME_UUID)
+                                    get_crash_item_content_or_NULL(crash_data, FILENAME_UID),
+                                    get_crash_item_content_or_NULL(crash_data, FILENAME_UUID)
                     );
                     /* Send dbus signal */
-                    g_pCommLayer->Crash(get_crash_data_item_content_or_NULL(crashinfo, FILENAME_PACKAGE),
+                    g_pCommLayer->Crash(get_crash_item_content_or_NULL(crash_data, FILENAME_PACKAGE),
                                     crash_id, //TODO: stop passing this param, it is unused
                                     fullname,
                                     uid_str
@@ -598,9 +598,11 @@ static gboolean handle_inotify_cb(GIOChannel *gio, GIOCondition condition, gpoin
         {
             free(fullname);
             free(buf);
+            free_crash_data(crash_data);
             throw;
         }
         free(fullname);
+        free_crash_data(crash_data);
     } /* while */
 
     free(buf);
diff --git a/src/daemon/Makefile.am b/src/daemon/Makefile.am
index 34c7aa7b..d25a21b1 100644
--- a/src/daemon/Makefile.am
+++ b/src/daemon/Makefile.am
@@ -52,6 +52,7 @@ abrt_server_CPPFLAGS = \
     -DDEBUG_INFO_DIR=\"$(DEBUG_INFO_DIR)\" \
     -DPLUGINS_LIB_DIR=\"$(PLUGINS_LIB_DIR)\" \
     -DPLUGINS_CONF_DIR=\"$(PLUGINS_CONF_DIR)\" \
+    $(GLIB_CFLAGS) \
     -D_GNU_SOURCE \
     -Wall -Werror
 abrt_server_LDADD = \
@@ -71,6 +72,7 @@ abrt_handle_crashdump_CPPFLAGS = \
     -DPLUGINS_LIB_DIR=\"$(PLUGINS_LIB_DIR)\" \
     -DPLUGINS_CONF_DIR=\"$(PLUGINS_CONF_DIR)\" \
     -DLIBEXEC_DIR=\"$(LIBEXEC_DIR)\" \
+    $(GLIB_CFLAGS) \
     -D_GNU_SOURCE \
     -Wall -Werror
 abrt_handle_crashdump_LDADD = \
diff --git a/src/daemon/MiddleWare.cpp b/src/daemon/MiddleWare.cpp
index 22e49620..6abf019e 100644
--- a/src/daemon/MiddleWare.cpp
+++ b/src/daemon/MiddleWare.cpp
@@ -43,8 +43,7 @@ CPluginManager* g_pPluginManager;
  * @param pCrashData A crash info.
  * @return It return results of operation. See mw_result_t.
  */
-static mw_result_t FillCrashInfo(const char *dump_dir_name,
-                        map_crash_data_t& pCrashData);
+static crash_data_t *FillCrashInfo(const char *dump_dir_name);
 
 /**
  * Transforms a debugdump directory to inner crash
@@ -52,13 +51,13 @@ static mw_result_t FillCrashInfo(const char *dump_dir_name,
  * @param dump_dir_name A debugdump dir containing all necessary data.
  * @param pCrashData A created crash report.
  */
-static bool DebugDumpToCrashReport(const char *dump_dir_name, map_crash_data_t& pCrashData)
+static crash_data_t *DebugDumpToCrashReport(const char *dump_dir_name)
 {
     VERB3 log(" DebugDumpToCrashReport('%s')", dump_dir_name);
 
     struct dump_dir *dd = dd_opendir(dump_dir_name, /*flags:*/ 0);
     if (!dd)
-        return false;
+        return NULL;
 
     static const char *const must_have_files[] = {
 	FILENAME_ARCHITECTURE,
@@ -76,21 +75,21 @@ static bool DebugDumpToCrashReport(const char *dump_dir_name, map_crash_data_t&
         {
             dd_close(dd);
             log("Important file '%s/%s' is missing", dump_dir_name, *v);
-            return false;
+            return NULL;
         }
         v++;
     }
 
-    load_crash_data_from_crash_dump_dir(dd, pCrashData);
+    crash_data_t *crash_data = load_crash_data_from_crash_dump_dir(dd);
     char *events = list_possible_events(dd, NULL, "");
     dd_close(dd);
 
-    add_to_crash_data_ext(pCrashData, CD_EVENTS, CD_SYS, CD_ISNOTEDITABLE, events);
+    add_to_crash_data_ext(crash_data, CD_EVENTS, events, CD_FLAG_SYS + CD_FLAG_ISNOTEDITABLE);
     free(events);
 
-    add_to_crash_data_ext(pCrashData, CD_DUMPDIR, CD_SYS, CD_ISNOTEDITABLE, dump_dir_name);
+    add_to_crash_data_ext(crash_data, CD_DUMPDIR, dump_dir_name, CD_FLAG_SYS + CD_FLAG_ISNOTEDITABLE);
 
-    return true;
+    return crash_data;
 }
 
 static char *do_log_and_update_client(char *log_line, void *param)
@@ -118,9 +117,11 @@ static char *do_log_and_update_client(char *log_line, void *param)
 static mw_result_t CreateCrashReport(const char *dump_dir_name,
                 long caller_uid,
                 int force,
-                map_crash_data_t& pCrashData)
+                crash_data_t **crash_data)
 {
-    VERB2 log("CreateCrashReport('%s',%ld,result)", dump_dir_name, caller_uid);
+    VERB2 log("CreateCrashReport('%s',%ld)", dump_dir_name, caller_uid);
+
+    *crash_data = NULL;
 
     struct dump_dir *dd = dd_opendir(dump_dir_name, /*flags:*/ 0);
     if (!dd)
@@ -165,7 +166,8 @@ static mw_result_t CreateCrashReport(const char *dump_dir_name,
         /* Do a load_crash_data_from_crash_dump_dir from (possibly updated)
          * crash dump dir
          */
-        if (!DebugDumpToCrashReport(dump_dir_name, pCrashData))
+        *crash_data = DebugDumpToCrashReport(dump_dir_name);
+        if (!*crash_data)
         {
             error_msg("Error loading crash data");
             r = MW_ERROR;
@@ -224,23 +226,22 @@ static char *do_log_and_save_line(char *log_line, void *param)
 
 // Do not trust client_report here!
 // dbus handler passes it from user without checking
-report_status_t Report(const map_crash_data_t& client_report,
+report_status_t Report(crash_data_t *client_report,
                        const vector_string_t& events,
                        const map_map_string_t& settings,
                        long caller_uid)
 {
     // Get ID fields
-    const char *UID = get_crash_data_item_content_or_NULL(client_report, FILENAME_UID);
-    const char *dump_dir_name = get_crash_data_item_content_or_NULL(client_report, CD_DUMPDIR);
+    const char *UID = get_crash_item_content_or_NULL(client_report, FILENAME_UID);
+    const char *dump_dir_name = get_crash_item_content_or_NULL(client_report, CD_DUMPDIR);
     if (!UID || !dump_dir_name)
     {
         throw CABRTException(EXCEP_ERROR, "Report(): UID or DUMPDIR is missing in client's report data");
     }
 
     // Retrieve corresponding stored record
-    map_crash_data_t stored_report;
-    mw_result_t r = FillCrashInfo(dump_dir_name, stored_report);
-    if (r != MW_OK)
+    crash_data_t *stored_report = FillCrashInfo(dump_dir_name);
+    if (!stored_report)
     {
         return report_status_t();
     }
@@ -249,18 +250,21 @@ report_status_t Report(const map_crash_data_t& client_report,
     if (caller_uid != 0   // not called by root
      && strcmp(to_string(caller_uid).c_str(), UID) != 0
     ) {
-        const char *inform_all = get_crash_data_item_content_or_NULL(stored_report, FILENAME_INFORMALL);
+        const char *inform_all = get_crash_item_content_or_NULL(stored_report, FILENAME_INFORMALL);
         if (!inform_all || !string_to_bool(inform_all))
+        {
+            free_crash_data(stored_report);
             throw CABRTException(EXCEP_ERROR, "Report(): user with uid %ld can't report crash %s",
                         caller_uid, dump_dir_name);
+        }
     }
 
     // Save comment, "how to reproduce", backtrace
 //TODO: we should iterate through stored_report and modify all
 //modifiable fields which have new data in client_report
-    const char *comment = get_crash_data_item_content_or_NULL(client_report, FILENAME_COMMENT);
-    const char *reproduce = get_crash_data_item_content_or_NULL(client_report, FILENAME_REPRODUCE);
-    const char *backtrace = get_crash_data_item_content_or_NULL(client_report, FILENAME_BACKTRACE);
+    const char *comment = get_crash_item_content_or_NULL(client_report, FILENAME_COMMENT);
+    const char *reproduce = get_crash_item_content_or_NULL(client_report, FILENAME_REPRODUCE);
+    const char *backtrace = get_crash_item_content_or_NULL(client_report, FILENAME_BACKTRACE);
     if (comment || reproduce || backtrace)
     {
         struct dump_dir *dd = dd_opendir(dump_dir_name, /*flags:*/ 0);
@@ -269,45 +273,47 @@ report_status_t Report(const map_crash_data_t& client_report,
             if (comment)
             {
                 dd_save_text(dd, FILENAME_COMMENT, comment);
-                add_to_crash_data_ext(stored_report, FILENAME_COMMENT, CD_TXT, CD_ISEDITABLE, comment);
+                add_to_crash_data_ext(stored_report, FILENAME_COMMENT, comment, CD_FLAG_TXT + CD_FLAG_ISEDITABLE);
             }
             if (reproduce)
             {
                 dd_save_text(dd, FILENAME_REPRODUCE, reproduce);
-                add_to_crash_data_ext(stored_report, FILENAME_REPRODUCE, CD_TXT, CD_ISEDITABLE, reproduce);
+                add_to_crash_data_ext(stored_report, FILENAME_REPRODUCE, reproduce, CD_FLAG_TXT + CD_FLAG_ISEDITABLE);
             }
             if (backtrace)
             {
                 dd_save_text(dd, FILENAME_BACKTRACE, backtrace);
-                add_to_crash_data_ext(stored_report, FILENAME_BACKTRACE, CD_TXT, CD_ISEDITABLE, backtrace);
+                add_to_crash_data_ext(stored_report, FILENAME_BACKTRACE, backtrace, CD_FLAG_TXT + CD_FLAG_ISEDITABLE);
             }
             dd_close(dd);
         }
     }
 
     /* Remove BIN filenames from stored_report if they are not present in client's data */
-    map_crash_data_t::const_iterator its = stored_report.begin();
-    while (its != stored_report.end())
+    GHashTableIter iter;
+    char *name;
+    struct crash_item *value;
+    g_hash_table_iter_init(&iter, stored_report);
+    while (g_hash_table_iter_next(&iter, (void**)&name, (void**)&value))
     {
-        if (its->second[CD_TYPE] == CD_BIN)
+        if (value->flags & CD_FLAG_BIN)
         {
-            std::string key = its->first;
-            if (get_crash_data_item_content_or_NULL(client_report, key.c_str()) == NULL)
+            if (get_crash_item_content_or_NULL(client_report, name) == NULL)
             {
                 /* client does not have it -> does not want it passed to events */
-                VERB3 log("Won't report BIN file %s:'%s'", key.c_str(), its->second[CD_CONTENT].c_str());
-                its++; /* move off the element we will erase */
-                stored_report.erase(key);
+                VERB3 log("Won't report BIN file %s:'%s'", name, value->content);
+                g_hash_table_iter_remove(&iter);
                 continue;
             }
         }
-        its++;
     }
 
     VERB3 {
         log_map_crash_data(client_report, " client_report");
         log_map_crash_data(stored_report, " stored_report");
     }
+    free_crash_data(stored_report);
+#define stored_report stored_report_must_not_be_used_below
 #define client_report client_report_must_not_be_used_below
 
     // Export overridden settings as environment variables
@@ -409,6 +415,7 @@ report_status_t Report(const map_crash_data_t& client_report,
     }
 
     return ret;
+#undef stored_report
 #undef client_report
 }
 
@@ -489,8 +496,7 @@ static char *do_log(char *log_line, void *param)
     return log_line;
 }
 
-mw_result_t LoadDebugDump(const char *dump_dir_name,
-                          map_crash_data_t& pCrashData)
+mw_result_t LoadDebugDump(const char *dump_dir_name, crash_data_t **crash_data)
 {
     mw_result_t res;
 
@@ -546,7 +552,7 @@ mw_result_t LoadDebugDump(const char *dump_dir_name,
         dump_dir_name = state.crash_dump_dup_name;
     }
 
-    /* Loads pCrashData (from the *first debugdump dir* if this one is a dup)
+    /* Loads crash_data (from the *first debugdump dir* if this one is a dup)
      * Returns:
      * MW_OCCURRED: "crash count is != 1" (iow: it is > 1 - dup)
      * MW_OK: "crash count is 1" (iow: this is a new crash, not a dup)
@@ -567,9 +573,10 @@ mw_result_t LoadDebugDump(const char *dump_dir_name,
         dd_save_text(dd, FILENAME_COUNT, new_count_str);
         dd_close(dd);
 
-        res = FillCrashInfo(dump_dir_name, pCrashData);
-        if (res == MW_OK)
+        *crash_data = FillCrashInfo(dump_dir_name);
+        if (*crash_data != NULL)
         {
+            res = MW_OK;
             if (count > 1)
             {
                 log("Crash dump is a duplicate of %s", dump_dir_name);
@@ -587,28 +594,27 @@ mw_result_t LoadDebugDump(const char *dump_dir_name,
     return res;
 }
 
-static mw_result_t FillCrashInfo(const char *dump_dir_name,
-                          map_crash_data_t& pCrashData)
+static crash_data_t *FillCrashInfo(const char *dump_dir_name)
 {
     struct dump_dir *dd = dd_opendir(dump_dir_name, /*flags:*/ 0);
     if (!dd)
-        return MW_ERROR;
+        return NULL;
 
-    load_crash_data_from_crash_dump_dir(dd, pCrashData);
+    crash_data_t *crash_data = load_crash_data_from_crash_dump_dir(dd);
     char *events = list_possible_events(dd, NULL, "");
     dd_close(dd);
 
-    add_to_crash_data_ext(pCrashData, CD_EVENTS, CD_SYS, CD_ISNOTEDITABLE, events);
+    add_to_crash_data_ext(crash_data, CD_EVENTS, events, CD_FLAG_SYS + CD_FLAG_ISNOTEDITABLE);
     free(events);
 
-    add_to_crash_data_ext(pCrashData, CD_DUMPDIR, CD_SYS, CD_ISNOTEDITABLE, dump_dir_name);
+    add_to_crash_data_ext(crash_data, CD_DUMPDIR, dump_dir_name, CD_FLAG_SYS + CD_FLAG_ISNOTEDITABLE);
 
-    return MW_OK;
+    return crash_data;
 }
 
-vector_map_crash_data_t GetCrashInfos(long caller_uid)
+vector_of_crash_data_t *GetCrashInfos(long caller_uid)
 {
-    vector_map_crash_data_t retval;
+    vector_of_crash_data_t *retval = new_vector_of_crash_data();
     log("Getting crash infos...");
 
     DIR *dir = opendir(DEBUG_DUMPS_DIR);
@@ -658,19 +664,15 @@ vector_map_crash_data_t GetCrashInfos(long caller_uid)
                 }
 
                 {
-                    map_crash_data_t info;
-                    mw_result_t res = FillCrashInfo(dump_dir_name, info);
-                    switch (res)
+                    crash_data_t *crash_data = FillCrashInfo(dump_dir_name);
+                    if (!crash_data)
+                    {
+                        error_msg("Dump directory %s doesn't exist or misses crucial files, deleting", dump_dir_name);
+                        delete_crash_dump_dir(dump_dir_name);
+                    }
+                    else
                     {
-                        case MW_OK:
-                            retval.push_back(info);
-                            break;
-                        case MW_ERROR:
-                            error_msg("Dump directory %s doesn't exist or misses crucial files, deleting", dump_dir_name);
-                            delete_crash_dump_dir(dump_dir_name);
-                            break;
-                        default:
-                            break;
+                        g_ptr_array_add(retval, crash_data);
                     }
                 }
  next:
@@ -695,14 +697,14 @@ vector_map_crash_data_t GetCrashInfos(long caller_uid)
  * StartJob dbus call already did all the processing, and we just retrieve
  * the result from dump directory, which is fast.
  */
-void CreateReport(const char* crash_id, long caller_uid, int force, map_crash_data_t& crashReport)
+void CreateReport(const char* crash_id, long caller_uid, int force, crash_data_t **crash_data)
 {
     /* FIXME: starting from here, any shared data must be protected with a mutex. */
-    mw_result_t res = CreateCrashReport(crash_id, caller_uid, force, crashReport);
+    mw_result_t res = CreateCrashReport(crash_id, caller_uid, force, crash_data);
     switch (res)
     {
         case MW_OK:
-            VERB2 log_map_crash_data(crashReport, "crashReport");
+            VERB2 log_map_crash_data(*crash_data, "crashReport");
             break;
         case MW_NOENT_ERROR:
             error_msg("Can't find crash with id '%s'", crash_id);
@@ -737,8 +739,8 @@ static void* create_report(void* arg)
     try
     {
         log("Creating report...");
-        map_crash_data_t crashReport;
-        CreateReport(thread_data->crash_id, thread_data->caller_uid, thread_data->force, crashReport);
+        crash_data_t *crash_data = NULL;
+        CreateReport(thread_data->crash_id, thread_data->caller_uid, thread_data->force, &crash_data);
         g_pCommLayer->JobDone(thread_data->peer);
     }
     catch (CABRTException& e)
diff --git a/src/daemon/MiddleWare.h b/src/daemon/MiddleWare.h
index 78c6a839..55c84c3b 100644
--- a/src/daemon/MiddleWare.h
+++ b/src/daemon/MiddleWare.h
@@ -71,7 +71,7 @@ void RunAction(const char *pActionDir,
  * @return
  *  A report status, which reporters ends successfuly with messages.
  */
-report_status_t Report(const map_crash_data_t& crash_data,
+report_status_t Report(crash_data_t *crash_data,
                        const vector_string_t& events,
                        const map_map_string_t& settings,
                        long caller_uid);
@@ -83,12 +83,11 @@ report_status_t Report(const map_crash_data_t& crash_data,
  * @param pCrashData A crash info.
  * @return It return results of operation. See mw_result_t.
  */
-mw_result_t LoadDebugDump(const char *dump_dir_name,
-                        map_crash_data_t& pCrashData);
+mw_result_t LoadDebugDump(const char *dump_dir_name, crash_data_t **crash_data);
 
-vector_map_crash_data_t GetCrashInfos(long caller_uid);
+vector_of_crash_data_t *GetCrashInfos(long caller_uid);
 int  CreateReportThread(const char* dump_dir_name, long caller_uid, int force, const char* pSender);
-void CreateReport(const char* dump_dir_name, long caller_uid, int force, map_crash_data_t&);
+void CreateReport(const char* dump_dir_name, long caller_uid, int force, crash_data_t **crash_data);
 int  DeleteDebugDump(const char *dump_dir_name, long caller_uid);
 
 void GetPluginsInfo(map_map_string_t &map_of_plugin_info);
diff --git a/src/hooks/Makefile.am b/src/hooks/Makefile.am
index 2f57d2e7..eedf1a60 100644
--- a/src/hooks/Makefile.am
+++ b/src/hooks/Makefile.am
@@ -10,6 +10,7 @@ abrt_hook_ccpp_CPPFLAGS = \
     -DDEBUG_DUMPS_DIR=\"$(DEBUG_DUMPS_DIR)\" \
     -DCONF_DIR=\"$(CONF_DIR)\" \
     -DVAR_RUN=\"$(VAR_RUN)\" \
+    $(GLIB_CFLAGS) \
     -D_GNU_SOURCE
 abrt_hook_ccpp_LDADD = \
     ../lib/libabrt.la
@@ -31,8 +32,7 @@ dumpoops_CPPFLAGS = \
 # build will succeed, but at runtime plugins do need ABRT*d*Utils
 dumpoops_LDADD = \
     ../lib/libabrt_daemon.la \
-    ../lib/libabrt.la \
-    $(GLIB_FLAGS)
+    ../lib/libabrt.la
 
 python_PYTHON = abrt.pth abrt_exception_handler.py
 EXTRA_DIST = abrt_exception_handler.py.in $(man_MANS)
diff --git a/src/include/abrt_crash_dump.h b/src/include/abrt_crash_dump.h
index fe924256..3a23285a 100644
--- a/src/include/abrt_crash_dump.h
+++ b/src/include/abrt_crash_dump.h
@@ -77,18 +77,10 @@ extern "C" {
 
 bool is_editable_file(const char *file_name);
 
+void log_map_crash_data(crash_data_t *crash_data, const char *pfx);
+
 #ifdef __cplusplus
 }
 #endif
 
-
-#ifdef __cplusplus
-
-typedef std::vector<map_crash_data_t> vector_map_crash_data_t;
-
-void log_map_crash_data(const map_crash_data_t& data, const char *name);
-
-#endif /* __cplusplus */
-
-
 #endif
diff --git a/src/include/abrtlib.h b/src/include/abrtlib.h
index cb2755b0..1fadd31a 100644
--- a/src/include/abrtlib.h
+++ b/src/include/abrtlib.h
@@ -237,10 +237,10 @@ std::string to_string(T x)
 void parse_args(const char *psArgs, vector_string_t& pArgs, int quote = -1);
 void parse_release(const char *pRelease, char **product, char **version);
 
-char* make_description_bz(const map_crash_data_t& pCrashData);
-char* make_description_reproduce_comment(const map_crash_data_t& pCrashData);
-char* make_description_logger(const map_crash_data_t& pCrashData);
-char* make_description_mailx(const map_crash_data_t& pCrashData);
+char* make_description_bz(crash_data_t *crash_data);
+char* make_description_reproduce_comment(crash_data_t *crash_data);
+char* make_description_logger(crash_data_t *crash_data);
+char* make_description_mailx(crash_data_t *crash_data);
 
 /**
  * Loads settings and stores it in second parameter. On success it
diff --git a/src/include/crash_dump.h b/src/include/crash_dump.h
index ab7835b4..10ddc885 100644
--- a/src/include/crash_dump.h
+++ b/src/include/crash_dump.h
@@ -19,54 +19,82 @@
 #ifndef CRASH_DUMP_H_
 #define CRASH_DUMP_H_
 
+#include <glib.h>
 
-// Crash data is a map of 3-element vectors of strings: type, editable, content
-#define CD_TYPE         0
-#define CD_EDITABLE     1
-#define CD_CONTENT      2
-
-// SYS - system value, should not be displayed
-// BIN - binary data
-// TXT - text data, can be displayed
-#define CD_SYS          "s"
-#define CD_BIN          "b"
-#define CD_TXT          "t"
-
-#define CD_ISEDITABLE    "y"
-#define CD_ISNOTEDITABLE "n"
+#ifdef __cplusplus
+extern "C" {
+#endif
 
 struct dump_dir;
 
-#ifdef __cplusplus
+enum {
+    CD_FLAG_SYS           = (1 << 0),
+    CD_FLAG_BIN           = (1 << 1),
+    CD_FLAG_TXT           = (1 << 2),
+    CD_FLAG_ISEDITABLE    = (1 << 3),
+    CD_FLAG_ISNOTEDITABLE = (1 << 4),
+};
 
-#include <map>
-#include <vector>
-#include <string>
+struct crash_item {
+    char    *content;
+    unsigned flags;
+};
+typedef struct crash_item crash_item;
 
 /* In-memory crash data structure and accessors */
 
-typedef std::map<std::string, std::vector<std::string> > map_crash_data_t;
+typedef GHashTable crash_data_t;
+
+crash_data_t *new_crash_data(void);
+
+static inline void free_crash_data(crash_data_t *crash_data)
+{
+    if (crash_data)
+        g_hash_table_destroy(crash_data);
+}
+
+void add_to_crash_data_ext(crash_data_t *crash_data,
+                const char *name,
+                const char *content,
+                unsigned flags);
+/* Uses CD_FLAG_TXT + CD_FLAG_ISNOTEDITABLE flags */
+void add_to_crash_data(crash_data_t *crash_data,
+                const char *name,
+                const char *content);
+
+static inline struct crash_item *get_crash_data_item_or_NULL(crash_data_t *crash_data, const char *key)
+{
+    return (struct crash_item *)g_hash_table_lookup(crash_data, key);
+}
+const char *get_crash_item_content_or_NULL(crash_data_t *crash_data, const char *key);
+/* Aborts if key is not found: */
+const char *get_crash_item_content_or_die(crash_data_t *crash_data, const char *key);
 
-void add_to_crash_data_ext(map_crash_data_t& pCrashData,
-                const char *pItem,
-                const char *pType,
-                const char *pEditable,
-                const char *pContent);
-/* Uses type:CD_TXT, editable:CD_ISNOTEDITABLE */
-void add_to_crash_data(map_crash_data_t& pCrashData,
-                const char *pItem,
-                const char *pContent);
 
-const char        *get_crash_data_item_content_or_NULL(const map_crash_data_t& crash_data, const char *key);
-/* Aborts if key is not found: */
-const std::string& get_crash_data_item_content(const map_crash_data_t& crash_data, const char *key);
+/* Vector of these structures */
+
+typedef GPtrArray vector_of_crash_data_t;
+
+static inline crash_data_t *get_crash_data(vector_of_crash_data_t *vector, unsigned i)
+{
+    return (crash_data_t *)g_ptr_array_index(vector, i);
+}
+
+vector_of_crash_data_t *new_vector_of_crash_data(void);
+static inline void free_vector_of_crash_data(vector_of_crash_data_t *vector)
+{
+    if (vector)
+        g_ptr_array_free(vector, TRUE);
+}
 
 
 /* Conversions between in-memory and on-disk formats */
 
-void load_crash_data_from_crash_dump_dir(struct dump_dir *dd, map_crash_data_t& data);
-struct dump_dir *create_crash_dump_dir(const map_crash_data_t& crash_data);
+crash_data_t *load_crash_data_from_crash_dump_dir(struct dump_dir *dd);
+struct dump_dir *create_crash_dump_dir(crash_data_t *crash_data);
 
+#ifdef __cplusplus
+}
 #endif
 
 #endif
diff --git a/src/lib/Makefile.am b/src/lib/Makefile.am
index a17df28e..cfcb9947 100644
--- a/src/lib/Makefile.am
+++ b/src/lib/Makefile.am
@@ -91,6 +91,7 @@ libabrt_daemon_la_CPPFLAGS = \
     -DPLUGINS_CONF_DIR=\"$(PLUGINS_CONF_DIR)\" \
     -DCONF_DIR=\"$(CONF_DIR)\" \
     -DVAR_RUN=\"$(VAR_RUN)\" \
+    $(GLIB_CFLAGS) \
     -D_GNU_SOURCE
 libabrt_daemon_la_LDFLAGS = \
     -version-info 0:1:0
@@ -108,6 +109,7 @@ libabrt_web_la_CPPFLAGS = \
     -DPLUGINS_CONF_DIR=\"$(PLUGINS_CONF_DIR)\" \
     -DCONF_DIR=\"$(CONF_DIR)\" \
     -DVAR_RUN=\"$(VAR_RUN)\" \
+    $(GLIB_CFLAGS) \
     $(CURL_CFLAGS) \
     $(LIBXML_CFLAGS) \
     $(XMLRPC_CFLAGS) $(XMLRPC_CLIENT_CFLAGS) \
@@ -115,6 +117,7 @@ libabrt_web_la_CPPFLAGS = \
 libabrt_web_la_LDFLAGS = \
     -version-info 0:1:0
 libabrt_web_la_LIBADD = \
+    $(GLIB_LIBS) \
     $(CURL_LIBS) \
     $(LIBXML_LIBS) \
     $(XMLRPC_LIBS) $(XMLRPC_CLIENT_LIBS)
diff --git a/src/lib/abrt_dbus.c b/src/lib/abrt_dbus.c
index 6bc155e3..2ba5fa12 100644
--- a/src/lib/abrt_dbus.c
+++ b/src/lib/abrt_dbus.c
@@ -156,6 +156,70 @@ void store_string(DBusMessageIter* iter, const char* val)
     free((char*)sanitized);
 }
 
+/* Helpers for storing crash_data */
+
+static void store_crash_item(DBusMessageIter* iter, struct crash_item *val)
+{
+    DBusMessageIter sub_iter;
+    if (!dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY, "s", &sub_iter))
+        die_out_of_memory();
+
+    /* Compat with python/cli:
+     * Crash item is represented in dbus as 3-element vector of strings:
+     * type, editable, content.
+     * This doesn't match daemon-side representation: { content, flags } struct
+     */
+    store_string(&sub_iter, (val->flags & CD_FLAG_SYS ? "s" : (val->flags & CD_FLAG_BIN ? "b" : "t")));
+    store_string(&sub_iter, (val->flags & CD_FLAG_ISEDITABLE ? "y" : "n"));
+    store_string(&sub_iter, val->content);
+
+    if (!dbus_message_iter_close_container(iter, &sub_iter))
+        die_out_of_memory();
+}
+void store_crash_data(DBusMessageIter* dbus_iter, crash_data_t *val)
+{
+    DBusMessageIter sub_iter;
+    /* crash_data is a map. map in dbus is an array of two element structs "({...})":
+     * "s" (string) for key and "as" for value (in this case, array of strings) */
+    if (!dbus_message_iter_open_container(dbus_iter, DBUS_TYPE_ARRAY, "{sas}", &sub_iter))
+        die_out_of_memory();
+
+    GHashTableIter iter;
+    char *name;
+    struct crash_item *value;
+    g_hash_table_iter_init(&iter, val);
+    while (g_hash_table_iter_next(&iter, (void**)&name, (void**)&value))
+    {
+        DBusMessageIter sub_sub_iter;
+        if (!dbus_message_iter_open_container(&sub_iter, DBUS_TYPE_DICT_ENTRY, NULL, &sub_sub_iter))
+            die_out_of_memory();
+        store_string(&sub_sub_iter, name);
+        store_crash_item(&sub_sub_iter, value);
+        if (!dbus_message_iter_close_container(&sub_iter, &sub_sub_iter))
+            die_out_of_memory();
+    }
+
+    if (!dbus_message_iter_close_container(dbus_iter, &sub_iter))
+        die_out_of_memory();
+}
+void store_vector_of_crash_data(DBusMessageIter* iter, vector_of_crash_data_t *val)
+{
+    DBusMessageIter sub_iter;
+    /* "array of maps". map in dbus is an array ("a") of two element structs "({...})":
+     * "s" (string) for key and "as" for value (in this case, array of strings) */
+    if (!dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY, "a{sas}", &sub_iter))
+        die_out_of_memory();
+
+    for (unsigned i = 0; i < val->len; i++)
+    {
+        crash_data_t *crash_data = get_crash_data(val, i);
+        store_crash_data(&sub_iter, crash_data);
+    }
+
+    if (!dbus_message_iter_close_container(iter, &sub_iter))
+        die_out_of_memory();
+}
+
 
 /*
  * Helpers for parsing DBus messages
@@ -217,6 +281,8 @@ int load_uint64(DBusMessageIter* iter, uint64_t *val)
 }
 int load_charp(DBusMessageIter* iter, const char** val)
 {
+    *val = NULL;
+
     int type = dbus_message_iter_get_arg_type(iter);
     if (type != DBUS_TYPE_STRING)
     {
@@ -228,6 +294,158 @@ int load_charp(DBusMessageIter* iter, const char** val)
     return dbus_message_iter_next(iter);
 }
 
+/* Helpers for loading crash_data */
+
+static int load_crash_item(DBusMessageIter* iter, struct crash_item *item)
+{
+    int type = dbus_message_iter_get_arg_type(iter);
+    if (type != DBUS_TYPE_ARRAY)
+    {
+        error_msg("array expected in dbus message, but not found ('%c')", type);
+        return -1;
+    }
+
+    /* Compat with python/cli:
+     * Crash item is represented in dbus as 3-element vector of strings:
+     * type, editable, content.
+     * This doesn't match daemon-side representation: { content, flags } struct
+     */
+
+    DBusMessageIter sub_iter;
+    dbus_message_iter_recurse(iter, &sub_iter);
+
+    const char *typestr;
+    int r = load_charp(&sub_iter, &typestr);
+    if (r != ABRT_DBUS_MORE_FIELDS)
+    {
+        error_msg("malformed crash_item element in dbus message");
+        return -1;
+    }
+    const char *editable;
+    r = load_charp(&sub_iter, &editable);
+    if (r != ABRT_DBUS_MORE_FIELDS)
+    {
+        error_msg("malformed crash_item element in dbus message");
+        return -1;
+    }
+    const char *content;
+    r = load_charp(&sub_iter, &content);
+    if (r != ABRT_DBUS_LAST_FIELD)
+    {
+        error_msg("malformed crash_item element in dbus message");
+        return -1;
+    }
+    item->flags = 0;
+    if (typestr[0] == 's') item->flags |= CD_FLAG_SYS;
+    if (typestr[0] == 'b') item->flags |= CD_FLAG_BIN;
+    if (typestr[0] == 't') item->flags |= CD_FLAG_TXT;
+    if (editable[0] == 'y') item->flags |= CD_FLAG_ISEDITABLE;
+    if (editable[0] == 'n') item->flags |= CD_FLAG_ISNOTEDITABLE;
+    item->content = xstrdup(content);
+    return 0;
+}
+int load_crash_data(DBusMessageIter* iter, crash_data_t **val)
+{
+    *val = NULL;
+
+    int type = dbus_message_iter_get_arg_type(iter);
+    if (type != DBUS_TYPE_ARRAY)
+    {
+        error_msg("array expected in dbus message, but not found ('%c')", type);
+        return -1;
+    }
+
+    crash_data_t *result = new_crash_data();
+
+    DBusMessageIter sub_iter;
+    dbus_message_iter_recurse(iter, &sub_iter);
+
+    bool next_exists;
+    int r;
+//int cnt = 0;
+    do {
+        type = dbus_message_iter_get_arg_type(&sub_iter);
+        if (type != DBUS_TYPE_DICT_ENTRY)
+        {
+            /* When the map has 0 elements, we see DBUS_TYPE_INVALID (on the first iteration) */
+            if (type == DBUS_TYPE_INVALID)
+                break;
+            error_msg("sub_iter type is not DBUS_TYPE_DICT_ENTRY (%c)!", type);
+            free_crash_data(result);
+            return -1;
+        }
+
+        DBusMessageIter sub_sub_iter;
+        dbus_message_iter_recurse(&sub_iter, &sub_sub_iter);
+
+        const char *key;
+        r = load_charp(&sub_sub_iter, &key);
+        if (r != ABRT_DBUS_MORE_FIELDS)
+        {
+            if (r == ABRT_DBUS_LAST_FIELD)
+                error_msg("malformed map element in dbus message");
+            free_crash_data(result);
+            return -1;
+        }
+        struct crash_item *value = xzalloc(sizeof(*value));
+        r = load_crash_item(&sub_sub_iter, value);
+        if (r != ABRT_DBUS_LAST_FIELD)
+        {
+            if (r == ABRT_DBUS_MORE_FIELDS)
+                error_msg("malformed map element in dbus message");
+            free(value);
+            free_crash_data(result);
+            return -1;
+        }
+        g_hash_table_replace(result, xstrdup(key), value);
+//cnt++;
+        next_exists = dbus_message_iter_next(&sub_iter);
+    } while (next_exists);
+//log("%s: %d elems", __func__, cnt);
+
+    *val = result;
+    return dbus_message_iter_next(iter); /* note: this can't fail (returns bool, thus never < 0) */
+}
+int load_vector_of_crash_data(DBusMessageIter* iter, vector_of_crash_data_t **val)
+{
+    *val = NULL;
+
+    int type = dbus_message_iter_get_arg_type(iter);
+    if (type != DBUS_TYPE_ARRAY)
+    {
+        error_msg("array expected in dbus message, but not found ('%c')", type);
+        return -1;
+    }
+
+    DBusMessageIter sub_iter;
+    dbus_message_iter_recurse(iter, &sub_iter);
+
+    vector_of_crash_data_t *result = new_vector_of_crash_data();
+
+    int r;
+//int cnt = 0;
+    /* When the vector has 0 elements, we see DBUS_TYPE_INVALID here */
+    type = dbus_message_iter_get_arg_type(&sub_iter);
+    if (type != DBUS_TYPE_INVALID)
+    {
+        do {
+            crash_data_t *cd = NULL;
+//cnt++;
+            r = load_crash_data(&sub_iter, &cd);
+            if (r < 0)
+            {
+                free_vector_of_crash_data(result);
+                return r;
+            }
+            g_ptr_array_add(result, cd);
+        } while (r == ABRT_DBUS_MORE_FIELDS);
+    }
+//log("%s: %d elems", __func__, cnt);
+
+    *val = result;
+    return dbus_message_iter_next(iter); /* note: this can't fail (returns bool, thus never < 0) */
+}
+
 
 /*
  * Glib integration machinery
diff --git a/src/lib/abrt_dbus.h b/src/lib/abrt_dbus.h
index 16b91d5b..b971280c 100644
--- a/src/lib/abrt_dbus.h
+++ b/src/lib/abrt_dbus.h
@@ -83,6 +83,8 @@ void store_uint32(DBusMessageIter* iter, uint32_t val);
 void store_int64(DBusMessageIter* iter, int64_t val);
 void store_uint64(DBusMessageIter* iter, uint64_t val);
 void store_string(DBusMessageIter* iter, const char* val);
+void store_crash_data(DBusMessageIter* iter, crash_data_t *val);
+void store_vector_of_crash_data(DBusMessageIter* iter, vector_of_crash_data_t *val);
 
 /*
  * Helpers for parsing DBus messages
@@ -104,6 +106,8 @@ int load_uint32(DBusMessageIter* iter, uint32_t *val);
 int load_int64(DBusMessageIter* iter, int64_t *val);
 int load_uint64(DBusMessageIter* iter, uint64_t *val);
 int load_charp(DBusMessageIter* iter, const char **val);
+int load_crash_data(DBusMessageIter* iter, crash_data_t **val);
+int load_vector_of_crash_data(DBusMessageIter* iter, vector_of_crash_data_t **val);
 
 #ifdef __cplusplus
 }
diff --git a/src/lib/crash_dump.cpp b/src/lib/crash_dump.cpp
index cca28021..73181c72 100644
--- a/src/lib/crash_dump.cpp
+++ b/src/lib/crash_dump.cpp
@@ -19,6 +19,70 @@
 #include "abrtlib.h"
 #include "abrt_crash_dump.h"
 
+static void free_crash_item(void *ptr)
+{
+    if (ptr)
+    {
+        struct crash_item *item = (struct crash_item *)ptr;
+        free(item->content);
+        free(item);
+    }
+}
+
+
+/* crash_data["name"] = { "content", CD_FLAG_foo_bits } */
+
+crash_data_t *new_crash_data(void)
+{
+    return g_hash_table_new_full(g_str_hash, g_str_equal,
+                 free, free_crash_item);
+}
+
+void add_to_crash_data_ext(crash_data_t *crash_data,
+                const char *name,
+                const char *content,
+                unsigned flags)
+{
+    struct crash_item *item = (struct crash_item *)xzalloc(sizeof(*item));
+    item->content = xstrdup(content);
+    item->flags = flags;
+    g_hash_table_replace(crash_data, xstrdup(name), item);
+}
+
+void add_to_crash_data(crash_data_t *crash_data,
+                const char *name,
+                const char *content)
+{
+    add_to_crash_data_ext(crash_data, name, content, CD_FLAG_TXT + CD_FLAG_ISNOTEDITABLE);
+}
+
+const char *get_crash_item_content_or_die(crash_data_t *crash_data, const char *key)
+{
+    struct crash_item *item = get_crash_data_item_or_NULL(crash_data, key);
+    if (!item)
+        error_msg_and_die("Error accessing crash data: no ['%s']", key);
+    return item->content;
+}
+
+const char *get_crash_item_content_or_NULL(crash_data_t *crash_data, const char *key)
+{
+    struct crash_item *item = get_crash_data_item_or_NULL(crash_data, key);
+    if (!item)
+        return NULL;
+    return item->content;
+}
+
+
+/* crash_data_vector[i] = { "name" = { "content", CD_FLAG_foo_bits } } */
+
+vector_of_crash_data_t *new_vector_of_crash_data(void)
+{
+    return g_ptr_array_new_with_free_func((void (*)(void*)) &free_crash_data);
+}
+
+
+/* Miscellaneous helpers */
+
 static const char *const editable_files[] = {
 	FILENAME_DESCRIPTION,
 	FILENAME_COMMENT    ,
@@ -42,36 +106,6 @@ bool is_editable_file(const char *file_name)
 	return is_editable(file_name, editable_files);
 }
 
-
-void add_to_crash_data_ext(map_crash_data_t& pCrashData,
-                const char *pItem,
-                const char *pType,
-                const char *pEditable,
-                const char *pContent)
-{
-	map_crash_data_t::iterator it = pCrashData.find(pItem);
-	if (it == pCrashData.end()) {
-		vector_string_t& v = pCrashData[pItem]; /* create empty vector */
-		v.push_back(pType);
-		v.push_back(pEditable);
-		v.push_back(pContent);
-		return;
-	}
-	vector_string_t& v = it->second;
-	while (v.size() < 3)
-		v.push_back("");
-	v[CD_TYPE]     = pType;
-	v[CD_EDITABLE] = pEditable;
-	v[CD_CONTENT]  = pContent;
-}
-
-void add_to_crash_data(map_crash_data_t& pCrashData,
-                const char *pItem,
-                const char *pContent)
-{
-	add_to_crash_data_ext(pCrashData, pItem, CD_TXT, CD_ISNOTEDITABLE, pContent);
-}
-
 static char* is_text_file(const char *name, ssize_t *sz)
 {
     /* We were using magic.h API to check for file being text, but it thinks
@@ -146,10 +180,11 @@ static char* is_text_file(const char *name, ssize_t *sz)
     return NULL; /* it's binary */
 }
 
-void load_crash_data_from_crash_dump_dir(struct dump_dir *dd, map_crash_data_t& data)
+crash_data_t *load_crash_data_from_crash_dump_dir(struct dump_dir *dd)
 {
     char *short_name;
     char *full_name;
+    crash_data_t *crash_data = new_crash_data();
 
     dd_init_next_file(dd);
     while (dd_get_next_file(dd, &short_name, &full_name))
@@ -163,11 +198,10 @@ void load_crash_data_from_crash_dump_dir(struct dump_dir *dd, map_crash_data_t&
             text = is_text_file(full_name, &sz);
             if (!text)
             {
-                add_to_crash_data_ext(data,
+                add_to_crash_data_ext(crash_data,
                         short_name,
-                        CD_BIN,
-                        CD_ISNOTEDITABLE,
-                        full_name
+                        full_name,
+                        CD_FLAG_BIN + CD_FLAG_ISNOTEDITABLE
                 );
 
                 free(short_name);
@@ -183,62 +217,30 @@ void load_crash_data_from_crash_dump_dir(struct dump_dir *dd, map_crash_data_t&
             content = dd_load_text(dd, short_name);
         free(text);
 
-        add_to_crash_data_ext(data,
+        add_to_crash_data_ext(crash_data,
                 short_name,
-                CD_TXT,
-                editable ? CD_ISEDITABLE : CD_ISNOTEDITABLE,
-                content
+                content,
+                (editable ? CD_FLAG_TXT + CD_FLAG_ISEDITABLE : CD_FLAG_TXT + CD_FLAG_ISNOTEDITABLE)
         );
         free(short_name);
         free(full_name);
         free(content);
     }
+    return crash_data;
 }
 
-static const std::string* helper_get_crash_data_item_content(const map_crash_data_t& crash_data, const char *key)
+void log_map_crash_data(crash_data_t *crash_data, const char *pfx)
 {
-	map_crash_data_t::const_iterator it = crash_data.find(key);
-	if (it == crash_data.end()) {
-		return NULL;
-	}
-	if (it->second.size() <= CD_CONTENT) {
-		return NULL;
-	}
-	return &it->second[CD_CONTENT];
-}
-
-const std::string& get_crash_data_item_content(const map_crash_data_t& crash_data, const char *key)
-{
-	const std::string* sp = helper_get_crash_data_item_content(crash_data, key);
-	if (sp == NULL) {
-		if (crash_data.find(key) == crash_data.end())
-			error_msg_and_die("Error accessing crash data: no ['%s']", key);
-		error_msg_and_die("Error accessing crash data: no ['%s'][%d]", key, CD_CONTENT);
-	}
-	return *sp;
-}
-
-const char *get_crash_data_item_content_or_NULL(const map_crash_data_t& crash_data, const char *key)
-{
-	const std::string* sp = helper_get_crash_data_item_content(crash_data, key);
-	if (!sp) {
-		return NULL;
-	}
-	return sp->c_str();
-}
-
-void log_map_crash_data(const map_crash_data_t& data, const char *name)
-{
-	map_crash_data_t::const_iterator it = data.begin();
-	while (it != data.end())
-	{
-		ssize_t sz = it->second.size();
-		log("%s[%s]:%s/%s/'%.20s'",
-			name, it->first.c_str(),
-			sz > 0 ? it->second[0].c_str() : "<NO [0]>",
-			sz > 1 ? it->second[1].c_str() : "<NO [1]>",
-			sz > 2 ? it->second[2].c_str() : "<NO [2]>"
-		);
-		it++;
-	}
+    GHashTableIter iter;
+    char *name;
+    struct crash_item *value;
+    g_hash_table_iter_init(&iter, crash_data);
+    while (g_hash_table_iter_next(&iter, (void**)&name, (void**)&value))
+    {
+        log("%s[%s]:'%s' 0x%x",
+                pfx, name,
+                value->content,
+                value->flags
+        );
+    }
 }
diff --git a/src/lib/create_crash_dump_dir.cpp b/src/lib/create_crash_dump_dir.cpp
index 0a74411b..c3125db6 100644
--- a/src/lib/create_crash_dump_dir.cpp
+++ b/src/lib/create_crash_dump_dir.cpp
@@ -21,7 +21,7 @@
 
 using namespace std;
 
-struct dump_dir *create_crash_dump_dir(const map_crash_data_t& crash_data)
+struct dump_dir *create_crash_dump_dir(crash_data_t *crash_data)
 {
     char *path = xasprintf(LOCALSTATEDIR"/run/abrt/tmp-%lu-%lu", (long)getpid(), (long)time(NULL));
     struct dump_dir *dd = dd_create(path, getuid());
@@ -29,28 +29,24 @@ struct dump_dir *create_crash_dump_dir(const map_crash_data_t& crash_data)
     if (!dd)
         return NULL;
 
-    map_crash_data_t::const_iterator its = crash_data.begin();
-    while (its != crash_data.end())
+    GHashTableIter iter;
+    char *name;
+    struct crash_item *value;
+    g_hash_table_iter_init(&iter, crash_data);
+    while (g_hash_table_iter_next(&iter, (void**)&name, (void**)&value))
     {
-        const char *name, *value;
-        name = its->first.c_str();
-
         if (name[0] == '.' || strchr(name, '/'))
         {
             error_msg("Crash data field name contains disallowed chars: '%s'", name);
             goto next;
         }
 
-//FIXME: what to do with CD_BINs??
-        /* Fields: CD_TYPE (is CD_SYS, CD_BIN or CD_TXT),
-         * CD_EDITABLE, CD_CONTENT */
-        if (its->second[CD_TYPE] == CD_BIN)
+//FIXME: what to do with CD_FLAG_BINs??
+        if (value->flags & CD_FLAG_BIN)
             goto next;
 
-        value = its->second[CD_CONTENT].c_str();
-        dd_save_text(dd, name, value);
- next:
-        its++;
+        dd_save_text(dd, name, value->content);
+ next: ;
     }
 
     return dd;
diff --git a/src/lib/make_descr.cpp b/src/lib/make_descr.cpp
index 5502b581..9234fc98 100644
--- a/src/lib/make_descr.cpp
+++ b/src/lib/make_descr.cpp
@@ -75,30 +75,32 @@ static const char *const blacklisted_items[] = {
     NULL
 };
 
-char* make_description_mailx(const map_crash_data_t & crash_data)
+char* make_description_mailx(crash_data_t *crash_data)
 {
     struct strbuf *buf_dsc = strbuf_new();
     struct strbuf *buf_additional_files = strbuf_new();
     struct strbuf *buf_duphash_file = strbuf_new();
     struct strbuf *buf_common_files = strbuf_new();
 
-    map_crash_data_t::const_iterator it;
-    for (it = crash_data.begin(); it != crash_data.end(); it++)
+    GHashTableIter iter;
+    char *name;
+    struct crash_item *value;
+    g_hash_table_iter_init(&iter, crash_data);
+    while (g_hash_table_iter_next(&iter, (void**)&name, (void**)&value))
     {
-        if (it->second[CD_TYPE] == CD_TXT)
+        if (value->flags & CD_FLAG_TXT)
         {
-            const char *itemname = it->first.c_str();
-            if ((strcmp(itemname, FILENAME_DUPHASH) != 0)
-             && (strcmp(itemname, FILENAME_ARCHITECTURE) != 0)
-             && (strcmp(itemname, FILENAME_KERNEL) != 0)
-             && (strcmp(itemname, FILENAME_PACKAGE) != 0)
+            if ((strcmp(name, FILENAME_DUPHASH) != 0)
+             && (strcmp(name, FILENAME_ARCHITECTURE) != 0)
+             && (strcmp(name, FILENAME_KERNEL) != 0)
+             && (strcmp(name, FILENAME_PACKAGE) != 0)
             ) {
-                strbuf_append_strf(buf_additional_files, "%s\n-----\n%s\n\n", itemname, it->second[CD_CONTENT].c_str());
+                strbuf_append_strf(buf_additional_files, "%s\n-----\n%s\n\n", name, value->content);
             }
-            else if (strcmp(itemname, FILENAME_DUPHASH) == 0)
-                strbuf_append_strf(buf_duphash_file, "%s\n-----\n%s\n\n", itemname, it->second[CD_CONTENT].c_str());
+            else if (strcmp(name, FILENAME_DUPHASH) == 0)
+                strbuf_append_strf(buf_duphash_file, "%s\n-----\n%s\n\n", name, value->content);
             else
-                strbuf_append_strf(buf_common_files, "%s\n-----\n%s\n\n", itemname, it->second[CD_CONTENT].c_str());
+                strbuf_append_strf(buf_common_files, "%s\n-----\n%s\n\n", name, value->content);
         }
     }
 
@@ -117,24 +119,26 @@ char* make_description_mailx(const map_crash_data_t & crash_data)
     return strbuf_free_nobuf(buf_dsc);
 }
 
-char* make_description_bz(const map_crash_data_t& pCrashData)
+char* make_description_bz(crash_data_t *crash_data)
 {
     struct strbuf *buf_dsc = strbuf_new();
     struct strbuf *buf_long_dsc = strbuf_new();
 
-    map_crash_data_t::const_iterator it = pCrashData.begin();
-    for (; it != pCrashData.end(); it++)
+    GHashTableIter iter;
+    char *name;
+    struct crash_item *value;
+    g_hash_table_iter_init(&iter, crash_data);
+    while (g_hash_table_iter_next(&iter, (void**)&name, (void**)&value))
     {
-        const char *itemname = it->first.c_str();
-        const char *type = it->second[CD_TYPE].c_str();
-        const char *content = it->second[CD_CONTENT].c_str();
-        if (strcmp(type, CD_TXT) == 0)
+        unsigned flags = value->flags;
+        const char *content = value->content;
+        if (flags & CD_FLAG_TXT)
         {
             /* Skip items we are not interested in */
             const char *const *bl = blacklisted_items;
             while (*bl)
             {
-                if (strcmp(itemname, *bl) == 0)
+                if (strcmp(name, *bl) == 0)
                     break;
                 bl++;
             }
@@ -151,7 +155,7 @@ char* make_description_bz(const map_crash_data_t& pCrashData)
                 add_content(&was_multiline,
                         &tmp,
 			/* "reproduce: blah" looks ugly, fixing: */
-                        (strcmp(itemname, FILENAME_REPRODUCE) == 0) ? "How to reproduce" : itemname,
+                        (strcmp(name, FILENAME_REPRODUCE) == 0) ? "How to reproduce" : name,
                         content
                 );
 
@@ -170,7 +174,7 @@ char* make_description_bz(const map_crash_data_t& pCrashData)
             } else {
                 bool was_multiline = 0;
                 char *dsc = NULL;
-                add_content(&was_multiline, &dsc, "Attached file", itemname);
+                add_content(&was_multiline, &dsc, "Attached file", name);
                 strbuf_append_str(buf_dsc, dsc);
                 free(dsc);
             }
@@ -189,25 +193,25 @@ char* make_description_bz(const map_crash_data_t& pCrashData)
     return strbuf_free_nobuf(buf_dsc);
 }
 
-char* make_description_logger(const map_crash_data_t& pCrashData)
+char* make_description_logger(crash_data_t *crash_data)
 {
     struct strbuf *buf_dsc = strbuf_new();
     struct strbuf *buf_long_dsc = strbuf_new();
 
-    map_crash_data_t::const_iterator it = pCrashData.begin();
-    for (; it != pCrashData.end(); it++)
+    GHashTableIter iter;
+    char *name;
+    struct crash_item *value;
+    g_hash_table_iter_init(&iter, crash_data);
+    while (g_hash_table_iter_next(&iter, (void**)&name, (void**)&value))
     {
-        const char *filename = it->first.c_str();
-        const char *type = it->second[CD_TYPE].c_str();
-        const char *content = it->second[CD_CONTENT].c_str();
-        if ((strcmp(type, CD_TXT) == 0)
-         || (strcmp(type, CD_BIN) == 0)
-        ) {
+        const char *content = value->content;
+        if (value->flags & (CD_FLAG_TXT|CD_FLAG_BIN))
+        {
             /* Skip items we are not interested in */
             const char *const *bl = blacklisted_items;
             while (*bl)
             {
-                if (filename == *bl)
+                if (name == *bl)
                     break;
                 bl++;
             }
@@ -218,7 +222,7 @@ char* make_description_logger(const map_crash_data_t& pCrashData)
 
             bool was_multiline = 0;
             char *tmp = NULL;
-            add_content(&was_multiline, &tmp, filename, content);
+            add_content(&was_multiline, &tmp, name, content);
 
             if (was_multiline)
             {
@@ -242,29 +246,27 @@ char* make_description_logger(const map_crash_data_t& pCrashData)
     return strbuf_free_nobuf(buf_dsc);
 }
 
-char* make_description_reproduce_comment(const map_crash_data_t& pCrashData)
+char* make_description_reproduce_comment(crash_data_t *crash_data)
 {
     char *repro = NULL;
     char *comment = NULL;
+    struct crash_item *value;
 
-    map_crash_data_t::const_iterator end = pCrashData.end();
-    map_crash_data_t::const_iterator it;
-
-    it = pCrashData.find(FILENAME_REPRODUCE);
-    if (it != end)
+    value = get_crash_data_item_or_NULL(crash_data, FILENAME_REPRODUCE);
+    if (value)
     {
-        if ((it->second[CD_CONTENT].size() > 0)
-            &&  (it->second[CD_CONTENT] != "1.\n2.\n3.\n"))
-        {
-            repro = xasprintf("\n\nHow to reproduce\n-----\n%s", it->second[CD_CONTENT].c_str());
+        if (value->content[0]
+         && strcmp(value->content, "1.\n2.\n3.\n") != 0
+        ) {
+            repro = xasprintf("\n\nHow to reproduce\n-----\n%s", value->content);
         }
     }
 
-    it = pCrashData.find(FILENAME_COMMENT);
-    if (it != end)
+    value = get_crash_data_item_or_NULL(crash_data, FILENAME_COMMENT);
+    if (value)
     {
-        if (it->second[CD_CONTENT].size() > 0)
-            comment = xasprintf("\n\nComment\n-----\n%s", it->second[CD_CONTENT].c_str());
+        if (value->content[0])
+            comment = xasprintf("\n\nComment\n-----\n%s", value->content);
     }
 
     if (!repro && !comment)
diff --git a/src/plugins/Makefile.am b/src/plugins/Makefile.am
index a7790e71..fb91fc1e 100644
--- a/src/plugins/Makefile.am
+++ b/src/plugins/Makefile.am
@@ -56,7 +56,8 @@ libCCpp_la_CPPFLAGS = -Wall -Werror \
     -I$(UTILS_PATH) \
     -DCCPP_HOOK_PATH=\"${libexecdir}/abrt-hook-ccpp\" \
     -DDEBUG_DUMPS_DIR=\"$(DEBUG_DUMPS_DIR)\" \
-    -DLOCALSTATEDIR='"$(localstatedir)"'
+    -DLOCALSTATEDIR='"$(localstatedir)"' \
+    $(GLIB_CFLAGS)
 #    -DHOSTILE_KERNEL
 
 # KerneloopsScanner
@@ -89,6 +90,7 @@ abrt_action_analyze_c_CPPFLAGS = \
     -DDEBUG_INFO_DIR=\"$(DEBUG_INFO_DIR)\" \
     -DPLUGINS_LIB_DIR=\"$(PLUGINS_LIB_DIR)\" \
     -DPLUGINS_CONF_DIR=\"$(PLUGINS_CONF_DIR)\" \
+    $(GLIB_CFLAGS) \
     -D_GNU_SOURCE \
     -Wall -Werror
 abrt_action_analyze_c_LDADD = \
@@ -107,6 +109,7 @@ abrt_action_analyze_python_CPPFLAGS = \
     -DDEBUG_INFO_DIR=\"$(DEBUG_INFO_DIR)\" \
     -DPLUGINS_LIB_DIR=\"$(PLUGINS_LIB_DIR)\" \
     -DPLUGINS_CONF_DIR=\"$(PLUGINS_CONF_DIR)\" \
+    $(GLIB_CFLAGS) \
     -D_GNU_SOURCE \
     -Wall -Werror
 abrt_action_analyze_python_LDADD = \
@@ -125,6 +128,7 @@ abrt_action_analyze_oops_CPPFLAGS = \
     -DDEBUG_INFO_DIR=\"$(DEBUG_INFO_DIR)\" \
     -DPLUGINS_LIB_DIR=\"$(PLUGINS_LIB_DIR)\" \
     -DPLUGINS_CONF_DIR=\"$(PLUGINS_CONF_DIR)\" \
+    $(GLIB_CFLAGS) \
     -D_GNU_SOURCE \
     -Wall -Werror
 abrt_action_analyze_oops_LDADD = \
@@ -143,6 +147,7 @@ abrt_action_generate_backtrace_CPPFLAGS = \
     -DDEBUG_INFO_DIR=\"$(DEBUG_INFO_DIR)\" \
     -DPLUGINS_LIB_DIR=\"$(PLUGINS_LIB_DIR)\" \
     -DPLUGINS_CONF_DIR=\"$(PLUGINS_CONF_DIR)\" \
+    $(GLIB_CFLAGS) \
     -D_GNU_SOURCE \
     -Wall -Werror
 abrt_action_generate_backtrace_LDADD = \
diff --git a/src/plugins/abrt-action-bugzilla.cpp b/src/plugins/abrt-action-bugzilla.cpp
index b396e453..b215735b 100644
--- a/src/plugins/abrt-action-bugzilla.cpp
+++ b/src/plugins/abrt-action-bugzilla.cpp
@@ -112,8 +112,8 @@ struct ctx: public abrt_xmlrpc_conn {
     xmlrpc_int32 get_bug_dup_id(xmlrpc_value* result_xml);
     void         get_bug_cc(xmlrpc_value* result_xml, struct bug_info* bz);
     int          add_plus_one_cc(xmlrpc_int32 bug_id, const char* login);
-    xmlrpc_int32 new_bug(const map_crash_data_t& pCrashData, int depend_on_bugno);
-    int          add_attachments(const char* bug_id_str, const map_crash_data_t& pCrashData);
+    xmlrpc_int32 new_bug(crash_data_t *crash_data, int depend_on_bugno);
+    int          add_attachments(const char* bug_id_str, crash_data_t *crash_data);
     int          get_bug_info(struct bug_info* bz, xmlrpc_int32 bug_id);
     int          add_comment(xmlrpc_int32 bug_id, const char* comment, bool is_private);
 
@@ -442,17 +442,17 @@ static const char *tainted_string(unsigned tainted)
     return taint_warnings[idx];
 }
 
-xmlrpc_int32 ctx::new_bug(const map_crash_data_t& pCrashData, int depend_on_bugno)
+xmlrpc_int32 ctx::new_bug(crash_data_t *crash_data, int depend_on_bugno)
 {
-    const char *package         = get_crash_data_item_content_or_NULL(pCrashData, FILENAME_PACKAGE);
-    const char *component       = get_crash_data_item_content_or_NULL(pCrashData, FILENAME_COMPONENT);
-    const char *release         = get_crash_data_item_content_or_NULL(pCrashData, FILENAME_RELEASE);
-    const char *arch            = get_crash_data_item_content_or_NULL(pCrashData, FILENAME_ARCHITECTURE);
-    const char *duphash         = get_crash_data_item_content_or_NULL(pCrashData, FILENAME_DUPHASH);
-    const char *reason          = get_crash_data_item_content_or_NULL(pCrashData, FILENAME_REASON);
-    const char *function        = get_crash_data_item_content_or_NULL(pCrashData, FILENAME_CRASH_FUNCTION);
-    const char *analyzer        = get_crash_data_item_content_or_NULL(pCrashData, FILENAME_ANALYZER);
-    const char *tainted_str     = get_crash_data_item_content_or_NULL(pCrashData, FILENAME_TAINTED);
+    const char *package         = get_crash_item_content_or_NULL(crash_data, FILENAME_PACKAGE);
+    const char *component       = get_crash_item_content_or_NULL(crash_data, FILENAME_COMPONENT);
+    const char *release         = get_crash_item_content_or_NULL(crash_data, FILENAME_RELEASE);
+    const char *arch            = get_crash_item_content_or_NULL(crash_data, FILENAME_ARCHITECTURE);
+    const char *duphash         = get_crash_item_content_or_NULL(crash_data, FILENAME_DUPHASH);
+    const char *reason          = get_crash_item_content_or_NULL(crash_data, FILENAME_REASON);
+    const char *function        = get_crash_item_content_or_NULL(crash_data, FILENAME_CRASH_FUNCTION);
+    const char *analyzer        = get_crash_item_content_or_NULL(crash_data, FILENAME_ANALYZER);
+    const char *tainted_str     = get_crash_item_content_or_NULL(crash_data, FILENAME_TAINTED);
 
     struct strbuf *buf_summary = strbuf_new();
     strbuf_append_strf(buf_summary, "[abrt] %s", package);
@@ -474,7 +474,7 @@ xmlrpc_int32 ctx::new_bug(const map_crash_data_t& pCrashData, int depend_on_bugn
 
     char *status_whiteboard = xasprintf("abrt_hash:%s", duphash);
 
-    char *bz_dsc = make_description_bz(pCrashData);
+    char *bz_dsc = make_description_bz(crash_data);
     char *full_dsc = xasprintf("abrt version: "VERSION"\n%s", bz_dsc);
     free(bz_dsc);
 
@@ -534,23 +534,24 @@ xmlrpc_int32 ctx::new_bug(const map_crash_data_t& pCrashData, int depend_on_bugn
     return bug_id;
 }
 
-int ctx::add_attachments(const char* bug_id_str, const map_crash_data_t& pCrashData)
+int ctx::add_attachments(const char* bug_id_str, crash_data_t *crash_data)
 {
-    map_crash_data_t::const_iterator it = pCrashData.begin();
-    for (; it != pCrashData.end(); it++)
+    GHashTableIter iter;
+    char *name;
+    struct crash_item *value;
+    g_hash_table_iter_init(&iter, crash_data);
+    while (g_hash_table_iter_next(&iter, (void**)&name, (void**)&value))
     {
-        const char *itemname = it->first.c_str();
-        const char *type = it->second[CD_TYPE].c_str();
-        const char *content = it->second[CD_CONTENT].c_str();
+        const char *content = value->content;
 
-        if ((strcmp(type, CD_TXT) == 0)
-         && (strlen(content) > CD_TEXT_ATT_SIZE || (strcmp(itemname, FILENAME_BACKTRACE) == 0))
+        if ((value->flags & CD_FLAG_TXT)
+         && (strlen(content) > CD_TEXT_ATT_SIZE || (strcmp(name, FILENAME_BACKTRACE) == 0))
         ) {
             char *encoded64 = encode_base64(content, strlen(content));
-            char *filename = xasprintf("File: %s", itemname);
+            char *filename = xasprintf("File: %s", name);
             xmlrpc_value* result = call("bugzilla.addAttachment", "(s{s:s,s:s,s:s,s:s})", bug_id_str,
                                         "description", filename,
-                                        "filename", itemname,
+                                        "filename", name,
                                         "contenttype", "text/plain",
                                         "data", encoded64
                                       );
@@ -644,8 +645,7 @@ static void report_to_bugzilla(
     {
         throw CABRTException(EXCEP_PLUGIN, _("Can't open '%s'"), dump_dir_name);
     }
-    map_crash_data_t pCrashData;
-    load_crash_data_from_crash_dump_dir(dd, pCrashData);
+    crash_data_t *crash_data = load_crash_data_from_crash_dump_dir(dd);
     dd_close(dd);
 
     const char *env;
@@ -674,9 +674,9 @@ static void report_to_bugzilla(
     env = getenv("Bugzilla_SSLVerify");
     ssl_verify = string_to_bool(env ? env : settings["SSLVerify"].c_str());
 
-    const char *component = get_crash_data_item_content_or_NULL(pCrashData, FILENAME_COMPONENT);
-    const char *duphash   = get_crash_data_item_content_or_NULL(pCrashData, FILENAME_DUPHASH);
-    const char *release   = get_crash_data_item_content_or_NULL(pCrashData, FILENAME_RELEASE);
+    const char *component = get_crash_item_content_or_NULL(crash_data, FILENAME_COMPONENT);
+    const char *duphash   = get_crash_item_content_or_NULL(crash_data, FILENAME_DUPHASH);
+    const char *release   = get_crash_item_content_or_NULL(crash_data, FILENAME_RELEASE);
 
     ctx bz_server(bugzilla_xmlrpc, ssl_verify);
 
@@ -773,7 +773,7 @@ static void report_to_bugzilla(
     else if (all_bugs_size == 0) // Create new bug
     {
         log(_("Creating a new bug..."));
-        bug_id = bz_server.new_bug(pCrashData, depend_on_bugno);
+        bug_id = bz_server.new_bug(crash_data, depend_on_bugno);
         if (bug_id < 0)
         {
             throw_if_xml_fault_occurred(&bz_server.env);
@@ -781,7 +781,7 @@ static void report_to_bugzilla(
         }
 
         log("Adding attachments to bug %d...", bug_id);
-        int ret = bz_server.add_attachments(to_string(bug_id).c_str(), pCrashData);
+        int ret = bz_server.add_attachments(to_string(bug_id).c_str(), crash_data);
         if (ret == -1)
         {
             throw_if_xml_fault_occurred(&bz_server.env);
@@ -855,13 +855,13 @@ static void report_to_bugzilla(
             throw_if_xml_fault_occurred(&bz_server.env);
         }
 
-        char *dsc = make_description_reproduce_comment(pCrashData);
+        char *dsc = make_description_reproduce_comment(crash_data);
         if (dsc)
         {
-            const char* package    = get_crash_data_item_content_or_NULL(pCrashData, FILENAME_PACKAGE);
-            const char* release    = get_crash_data_item_content_or_NULL(pCrashData, FILENAME_RELEASE);
-            const char* arch       = get_crash_data_item_content_or_NULL(pCrashData, FILENAME_ARCHITECTURE);
-            const char* is_private = get_crash_data_item_content_or_NULL(pCrashData, "is_private");
+            const char* package    = get_crash_item_content_or_NULL(crash_data, FILENAME_PACKAGE);
+            const char* release    = get_crash_item_content_or_NULL(crash_data, FILENAME_RELEASE);
+            const char* arch       = get_crash_item_content_or_NULL(crash_data, FILENAME_ARCHITECTURE);
+            const char* is_private = get_crash_item_content_or_NULL(crash_data, "is_private");
 
             char *full_dsc = xasprintf("Package: %s\n"
                                 "Architecture: %s\n"
@@ -895,6 +895,7 @@ static void report_to_bugzilla(
                 (int)bug_id
     );
 
+    free_crash_data(crash_data);
     bug_info_destroy(&bz);
 }
 
diff --git a/src/plugins/abrt-action-kerneloops.cpp b/src/plugins/abrt-action-kerneloops.cpp
index dea6df17..ac90abd7 100644
--- a/src/plugins/abrt-action-kerneloops.cpp
+++ b/src/plugins/abrt-action-kerneloops.cpp
@@ -91,11 +91,10 @@ static void report_to_kerneloops(
     if (!dd)
         exit(1); /* error msg is already logged */
 
-    map_crash_data_t pCrashData;
-    load_crash_data_from_crash_dump_dir(dd, pCrashData);
+    crash_data_t *crash_data = load_crash_data_from_crash_dump_dir(dd);
     dd_close(dd);
 
-    const char *backtrace = get_crash_data_item_content_or_NULL(pCrashData, FILENAME_BACKTRACE);
+    const char *backtrace = get_crash_item_content_or_NULL(crash_data, FILENAME_BACKTRACE);
     if (!backtrace)
         error_msg_and_die("Error sending kernel oops due to missing backtrace");
 
@@ -114,6 +113,8 @@ static void report_to_kerneloops(
     if (ret != CURLE_OK)
         error_msg_and_die("Kernel oops has not been sent due to %s", curl_easy_strerror(ret));
 
+    free_crash_data(crash_data);
+
     /* Server replies with:
      * 200 thank you for submitting the kernel oops information
      * RemoteIP: 34192fd15e34bf60fac6a5f01bba04ddbd3f0558
diff --git a/src/plugins/abrt-action-mailx.cpp b/src/plugins/abrt-action-mailx.cpp
index fa7fd8a0..824791fa 100644
--- a/src/plugins/abrt-action-mailx.cpp
+++ b/src/plugins/abrt-action-mailx.cpp
@@ -66,8 +66,7 @@ static void create_and_send_email(
     if (!dd)
         exit(1); /* error msg is already logged by dd_opendir */
 
-    map_crash_data_t pCrashData;
-    load_crash_data_from_crash_dump_dir(dd, pCrashData);
+    crash_data_t *crash_data = load_crash_data_from_crash_dump_dir(dd);
     dd_close(dd);
 
     char* env;
@@ -90,17 +89,20 @@ static void create_and_send_email(
     unsigned arg_size = 0;
     args = append_str_to_vector(args, arg_size, "/bin/mailx");
 
-    char *dsc = make_description_mailx(pCrashData);
+    char *dsc = make_description_mailx(crash_data);
 
     if (send_binary_data)
     {
-        map_crash_data_t::const_iterator it_cd;
-        for (it_cd = pCrashData.begin(); it_cd != pCrashData.end(); it_cd++)
+        GHashTableIter iter;
+        char *name;
+        struct crash_item *value;
+        g_hash_table_iter_init(&iter, crash_data);
+        while (g_hash_table_iter_next(&iter, (void**)&name, (void**)&value))
         {
-            if (it_cd->second[CD_TYPE] == CD_BIN)
+            if (value->flags & CD_FLAG_BIN)
             {
                 args = append_str_to_vector(args, arg_size, "-a");
-                args = append_str_to_vector(args, arg_size, it_cd->second[CD_CONTENT].c_str());
+                args = append_str_to_vector(args, arg_size, value->content);
             }
         }
     }
@@ -112,7 +114,7 @@ static void create_and_send_email(
     args = append_str_to_vector(args, arg_size, email_to);
 
     log(_("Sending an email..."));
-    const char *uid_str = get_crash_data_item_content_or_NULL(pCrashData, FILENAME_UID);
+    const char *uid_str = get_crash_item_content_or_NULL(crash_data, FILENAME_UID);
     exec_and_feed_input(xatoi_u(uid_str), dsc, args);
 
     free(dsc);
@@ -122,6 +124,8 @@ static void create_and_send_email(
     args -= arg_size;
     free(args);
 
+    free_crash_data(crash_data);
+
     log("Email was sent to: %s", email_to);
 }
 
diff --git a/src/plugins/abrt-action-print.cpp b/src/plugins/abrt-action-print.cpp
index 303c05f7..04d01de3 100644
--- a/src/plugins/abrt-action-print.cpp
+++ b/src/plugins/abrt-action-print.cpp
@@ -81,13 +81,13 @@ int main(int argc, char **argv)
         if (!dd)
             return 1; /* error message is already logged */
 
-        map_crash_data_t pCrashData;
-        load_crash_data_from_crash_dump_dir(dd, pCrashData);
+        crash_data_t *crash_data = load_crash_data_from_crash_dump_dir(dd);
         dd_close(dd);
 
-        char *dsc = make_description_logger(pCrashData);
+        char *dsc = make_description_logger(crash_data);
         fputs(dsc, stdout);
         free(dsc);
+        free_crash_data(crash_data);
     }
     catch (CABRTException& e)
     {
diff --git a/src/plugins/abrt-action-rhtsupport.cpp b/src/plugins/abrt-action-rhtsupport.cpp
index eb69489d..994c84f3 100644
--- a/src/plugins/abrt-action-rhtsupport.cpp
+++ b/src/plugins/abrt-action-rhtsupport.cpp
@@ -35,8 +35,7 @@ static void report_to_rhtsupport(
     if (!dd)
         exit(1); /* error msg is already logged by dd_opendir */
 
-    map_crash_data_t pCrashData;
-    load_crash_data_from_crash_dump_dir(dd, pCrashData);
+    crash_data_t *crash_data = load_crash_data_from_crash_dump_dir(dd);
     dd_close(dd);
 
     /* Gzipping e.g. 0.5gig coredump takes a while. Let client know what we are doing */
@@ -79,9 +78,9 @@ static void report_to_rhtsupport(
         goto ret;
     }
 
-    package  = get_crash_data_item_content_or_NULL(pCrashData, FILENAME_PACKAGE);
-    reason   = get_crash_data_item_content_or_NULL(pCrashData, FILENAME_REASON);
-    function = get_crash_data_item_content_or_NULL(pCrashData, FILENAME_CRASH_FUNCTION);
+    package  = get_crash_item_content_or_NULL(crash_data, FILENAME_PACKAGE);
+    reason   = get_crash_item_content_or_NULL(crash_data, FILENAME_REASON);
+    function = get_crash_item_content_or_NULL(crash_data, FILENAME_CRASH_FUNCTION);
 
     {
         struct strbuf *buf_summary = strbuf_new();
@@ -92,7 +91,7 @@ static void report_to_rhtsupport(
             strbuf_append_strf(buf_summary, ": %s", reason);
         summary = strbuf_free_nobuf(buf_summary);
 
-        char *bz_dsc = make_description_bz(pCrashData);
+        char *bz_dsc = make_description_bz(crash_data);
         dsc = xasprintf("abrt version: "VERSION"\n%s", bz_dsc);
         free(bz_dsc);
     }
@@ -124,21 +123,24 @@ static void report_to_rhtsupport(
     }
 
     {
-        map_crash_data_t::const_iterator it = pCrashData.begin();
-        for (; it != pCrashData.end(); it++)
+        GHashTableIter iter;
+        char *name;
+        struct crash_item *value;
+        g_hash_table_iter_init(&iter, crash_data);
+        while (g_hash_table_iter_next(&iter, (void**)&name, (void**)&value))
         {
-            if (it->first == FILENAME_COUNT) continue;
-            if (it->first == CD_DUMPDIR) continue;
-            if (it->first == FILENAME_INFORMALL) continue;
-            if (it->first == FILENAME_MESSAGE) continue; // plugin's status message (if we already reported it yesterday)
-            if (it->first == FILENAME_DESCRIPTION) continue; // package description
-
-            const char *content = it->second[CD_CONTENT].c_str();
-            if (it->second[CD_TYPE] == CD_TXT)
+            if (strcmp(name, FILENAME_COUNT) == 0) continue;
+            if (strcmp(name, CD_DUMPDIR) == 0) continue;
+            if (strcmp(name, FILENAME_INFORMALL) == 0) continue;
+            if (strcmp(name, FILENAME_MESSAGE) == 0) continue; // plugin's status message (if we already reported it yesterday)
+            if (strcmp(name, FILENAME_DESCRIPTION) == 0) continue; // package description
+
+            const char *content = value->content;
+            if (value->flags & CD_FLAG_TXT)
             {
-                reportfile_add_binding_from_string(file, it->first.c_str(), content);
+                reportfile_add_binding_from_string(file, name, content);
             }
-            else if (it->second[CD_TYPE] == CD_BIN)
+            else if (value->flags & CD_FLAG_BIN)
             {
                 const char *basename = strrchr(content, '/');
                 if (basename)
@@ -148,7 +150,7 @@ static void report_to_rhtsupport(
                 char *xml_name = concat_path_file("content", basename);
                 reportfile_add_binding_from_namedfile(file,
                         /*on_disk_filename */ content,
-                        /*binding_name     */ it->first.c_str(),
+                        /*binding_name     */ name,
                         /*recorded_filename*/ xml_name,
                         /*binary           */ 1);
                 if (tar_append_file(tar, (char*)content, xml_name) != 0)
@@ -248,6 +250,7 @@ static void report_to_rhtsupport(
     free(url);
     free(login);
     free(password);
+    free_crash_data(crash_data);
 
     if (errmsg)
         error_msg_and_die("%s", errmsg);