xmlrpc_DECREF(NULL) fix, clean source and show status of bug

Signed-off-by: Nikola Pajkovsky <npajkovs@redhat.com>

1 files changed, 195 insertions, 289 deletions

diff --git a/lib/Plugins/Bugzilla.cpp b/lib/Plugins/Bugzilla.cpp
index ac4ca36..03f00db 100644
--- a/lib/Plugins/Bugzilla.cpp
+++ b/lib/Plugins/Bugzilla.cpp
@@ -32,36 +32,20 @@
 #define XML_RPC_SUFFIX      "/xmlrpc.cgi"
 #define MAX_HOPPS            5
 
-static int32_t abrt_errno;
-
-typedef enum {
-    ABRTE_BUGZILLA_OK = 0,
-    ABRTE_BUGZILLA_NEW_BUG,                             /* 1 */
-    ABRTE_BUGZILLA_NO_DATA,                             /* 2 */
-    ABRTE_BUGZILLA_XMLRPC_ERROR,                        /* 3 */
-    ABRTE_BUGZILLA_XMLRPC_MISSING_MEMBER                /* 4 */
-}bugzilla_codes;
-
-
-static const char* abrt_strerror(bugzilla_codes code)
-{
-    return NULL;
-}
-
 /*
  *  TODO: npajkovs: better deallocation of xmlrpc value
  *        npajkovs: better gathering function which collects all information from bugzilla
  *        npajkovs: figure out how to deal with cloning bugs
  *        npajkovs: check if attachment was uploaded successul an if not try it again(max 3 times)
  *                  and if it still fails. retrun successful, but mention that attaching failed
- *        npajkovs: add new fce to add comments
+ *        npajkovs: add option to set comment privat
  */
 
 struct bug_info {
     const char* bug_status;
     const char* bug_resolution;
     const char* bug_reporter;
-    uint32_t bug_dup_id;
+    int32_t bug_dup_id;
     std::vector<const char*> bug_cc;
 };
 
@@ -75,6 +59,7 @@ static void bug_info_init(struct bug_info* bz)
     bz->bug_status = NULL;
     bz->bug_resolution = NULL;
     bz->bug_reporter = NULL;
+    bz->bug_dup_id = -1;
 }
 
 static void bug_info_destroy(struct bug_info* bz)
@@ -119,165 +104,139 @@ static int32_t am_i_in_cc(const struct bug_info* bz, const char* login)
 namespace {
 
 struct ctx: public abrt_xmlrpc_conn {
+    xmlrpc_env env;
+
     ctx(const char* url, bool no_ssl_verify): abrt_xmlrpc_conn(url, no_ssl_verify) {}
 
     bool check_cc_and_reporter(uint32_t bug_id, const char* login);
     void login(const char* login, const char* passwd);
     void logout();
 
-    const char* get_bug_status(xmlrpc_env* env, xmlrpc_value* result_xml);
-    const char* get_bug_resolution(xmlrpc_env* env, xmlrpc_value* result_xml);
-    const char* get_bug_reporter(xmlrpc_env* env, xmlrpc_value* result_xml);
-
-    xmlrpc_value* call_quicksearch_uuid(xmlrpc_env* env, const char* component, const char* uuid);
-    xmlrpc_value* get_cc_member(xmlrpc_env* env, xmlrpc_value* result_xml);
-    xmlrpc_value* get_member(xmlrpc_env* env, const char* member, xmlrpc_value* result_xml);
-
-    int32_t get_array_size(xmlrpc_env* env, xmlrpc_value* result_xml);
-    int32_t get_bug_id(xmlrpc_env* env, xmlrpc_value* result_xml);
-    int32_t get_bug_dup_id(xmlrpc_env* env, xmlrpc_value* result_xml);
-    int32_t get_bug_cc(xmlrpc_env* env, xmlrpc_value* result_xml, struct bug_info* bz);
-    int32_t add_plus_one_cc(xmlrpc_env* env, uint32_t bug_id, const char* login);
-    int32_t new_bug(xmlrpc_env* env, const map_crash_data_t& pCrashData);
-    int32_t add_attachments(xmlrpc_env* env, const char* bug_id_str, const map_crash_data_t& pCrashData);
-    int32_t get_bug_info(xmlrpc_env* env, struct bug_info* bz, uint32_t bug_id);
-    int32_t add_comment(xmlrpc_env* env, uint32_t bug_id, const char* comment);
+    const char* get_bug_status(xmlrpc_value* result_xml);
+    const char* get_bug_resolution(xmlrpc_value* result_xml);
+    const char* get_bug_reporter(xmlrpc_value* result_xml);
+
+    xmlrpc_value* call_quicksearch_uuid(const char* component, const char* uuid);
+    xmlrpc_value* get_cc_member(xmlrpc_value* result_xml);
+    xmlrpc_value* get_member(const char* member, xmlrpc_value* result_xml);
+
+    int32_t get_array_size(xmlrpc_value* result_xml);
+    int32_t get_bug_id(xmlrpc_value* result_xml);
+    int32_t get_bug_dup_id(xmlrpc_value* result_xml);
+    int32_t get_bug_cc(xmlrpc_value* result_xml, struct bug_info* bz);
+    int32_t add_plus_one_cc(uint32_t bug_id, const char* login);
+    int32_t new_bug(const map_crash_data_t& pCrashData);
+    int32_t add_attachments(const char* bug_id_str, const map_crash_data_t& pCrashData);
+    int32_t get_bug_info(struct bug_info* bz, uint32_t bug_id);
+    int32_t add_comment(uint32_t bug_id, const char* comment);
 };
 
-xmlrpc_value* ctx::get_member(xmlrpc_env* env, const char* member, xmlrpc_value* result_xml)
+xmlrpc_value* ctx::get_member(const char* member, xmlrpc_value* result_xml)
 {
     xmlrpc_value* cc_member = NULL;
-    xmlrpc_struct_find_value(env, result_xml, member, &cc_member);
-    if (env->fault_occurred)
-    {
-        abrt_errno = ABRTE_BUGZILLA_XMLRPC_ERROR;
+    xmlrpc_struct_find_value(&env, result_xml, member, &cc_member);
+    if (env.fault_occurred)
         return NULL;
-    }
-
-    if (cc_member)
-        return cc_member;
 
-    abrt_errno = ABRTE_BUGZILLA_XMLRPC_MISSING_MEMBER;
-    return NULL;
+    return cc_member;
 }
 
-int32_t ctx::get_array_size(xmlrpc_env* env, xmlrpc_value* result_xml)
+int32_t ctx::get_array_size(xmlrpc_value* result_xml)
 {
     // The only way this can fail is if 'bugs_member' is not actually an array XML-RPC value. So it is usually not worth checking 'env'.
-    int32_t size = xmlrpc_array_size(env, result_xml);
-    if (env->fault_occurred)
-    {
-        abrt_errno = ABRTE_BUGZILLA_XMLRPC_ERROR;
+    int32_t size = xmlrpc_array_size(&env, result_xml);
+    if (env.fault_occurred)
         return -1;
-    }
+
     return size;
 }
 
-int32_t ctx::get_bug_dup_id(xmlrpc_env* env, xmlrpc_value* result_xml)
+int32_t ctx::get_bug_dup_id(xmlrpc_value* result_xml)
 {
-    xmlrpc_value* dup_id = get_member(env, "dup_id", result_xml);
+    xmlrpc_value* dup_id = get_member("dup_id", result_xml);
     if (!dup_id)
         return -1;
 
-    xmlrpc_int dup_id_int = -1;
-    xmlrpc_read_int(env, dup_id, &dup_id_int);
+    xmlrpc_int32 dup_id_int = -1;
+    xmlrpc_read_int(&env, dup_id, &dup_id_int);
     xmlrpc_DECREF(dup_id);
-    if (env->fault_occurred)
-    {
-        abrt_errno = ABRTE_BUGZILLA_XMLRPC_ERROR;
+    if (env.fault_occurred)
         return -1;
-    }
-    VERB3 log("get dup_id: %i", dup_id_int);
-    abrt_errno = ABRTE_BUGZILLA_OK;
+
+    VERB3 log("got dup_id: %i", dup_id_int);
     return dup_id_int;
 }
 
-const char* ctx::get_bug_reporter(xmlrpc_env* env, xmlrpc_value* result_xml)
+const char* ctx::get_bug_reporter(xmlrpc_value* result_xml)
 {
-    xmlrpc_value* reporter_member = get_member(env, "reporter", result_xml);
+    xmlrpc_value* reporter_member = get_member("reporter", result_xml);
     if (!reporter_member)
         return NULL;
 
     const char* reporter = NULL;
-    xmlrpc_read_string(env, reporter_member, &reporter);
+    xmlrpc_read_string(&env, reporter_member, &reporter);
     xmlrpc_DECREF(reporter_member);
-
-    if (env->fault_occurred)
-    {
-        abrt_errno = ABRTE_BUGZILLA_XMLRPC_ERROR;
+    if (env.fault_occurred)
         return NULL;
-    }
 
     if (*reporter != '\0')
     {
-        VERB3 log("get bug reporter: %s", reporter);
-        abrt_errno = ABRTE_BUGZILLA_OK;
+        VERB3 log("got bug reporter: %s", reporter);
         return reporter;
     }
     free((void*)reporter);
-    abrt_errno = ABRTE_BUGZILLA_NO_DATA;
     return NULL;
 }
 
-const char* ctx::get_bug_resolution(xmlrpc_env* env, xmlrpc_value* result_xml)
+const char* ctx::get_bug_resolution(xmlrpc_value* result_xml)
 {
-    xmlrpc_value* bug_resolution = get_member(env, "resolution", result_xml);
+    xmlrpc_value* bug_resolution = get_member("resolution", result_xml);
     if (!bug_resolution)
         return NULL;
 
     const char* resolution_str = NULL;
-    xmlrpc_read_string(env, bug_resolution, &resolution_str);
+    xmlrpc_read_string(&env, bug_resolution, &resolution_str);
     xmlrpc_DECREF(bug_resolution);
-    if (env->fault_occurred)
-    {
-        abrt_errno = ABRTE_BUGZILLA_XMLRPC_ERROR;
+    if (env.fault_occurred)
         return NULL;
-    }
 
     if (*resolution_str != '\0')
     {
-        VERB3 log("get resolution: %s", resolution_str);
-        abrt_errno = ABRTE_BUGZILLA_OK;
+        VERB3 log("got resolution: %s", resolution_str);
         return resolution_str;
     }
     free((void*)resolution_str);
-    abrt_errno = ABRTE_BUGZILLA_NO_DATA;
     return NULL;
 }
 
-const char* ctx::get_bug_status(xmlrpc_env* env, xmlrpc_value* result_xml)
+const char* ctx::get_bug_status(xmlrpc_value* result_xml)
 {
-    xmlrpc_value* bug_status = get_member(env, "bug_status", result_xml);
+    xmlrpc_value* bug_status = get_member("bug_status", result_xml);
     if (!bug_status)
         return NULL;
 
     const char* status_str = NULL;
-    xmlrpc_read_string(env, bug_status, &status_str);
+    xmlrpc_read_string(&env, bug_status, &status_str);
     xmlrpc_DECREF(bug_status);
-    if (env->fault_occurred)
-    {
-        abrt_errno = ABRTE_BUGZILLA_XMLRPC_ERROR;
+    if (env.fault_occurred)
         return NULL;
-    }
 
     if (*status_str != '\0')
     {
-        VERB3 log("get bug_status: %s", status_str);
-        abrt_errno = ABRTE_BUGZILLA_OK;
+        VERB3 log("got bug_status: %s", status_str);
         return status_str;
     }
     free((void*)status_str);
-    abrt_errno = ABRTE_BUGZILLA_NO_DATA;
     return NULL;
 }
 
-int32_t ctx::get_bug_cc(xmlrpc_env* env, xmlrpc_value* result_xml, struct bug_info* bz)
+int32_t ctx::get_bug_cc(xmlrpc_value* result_xml, struct bug_info* bz)
 {
-    xmlrpc_value* cc_member = get_member(env, "cc", result_xml);
+    xmlrpc_value* cc_member = get_member("cc", result_xml);
     if (!cc_member)
         return -1;
 
-    int32_t array_size = xmlrpc_array_size(env, cc_member);
+    int32_t array_size = xmlrpc_array_size(&env, cc_member);
     if (array_size == -1)
         return -1;
 
@@ -288,22 +247,18 @@ int32_t ctx::get_bug_cc(xmlrpc_env* env, xmlrpc_value* result_xml, struct bug_in
     for (int32_t i = 0; i < array_size; i++)
     {
         xmlrpc_value* item = NULL;
-        xmlrpc_array_read_item(env, cc_member, i, &item);
-        if (env->fault_occurred)
-        {
-            abrt_errno = ABRTE_BUGZILLA_XMLRPC_ERROR;
+        xmlrpc_array_read_item(&env, cc_member, i, &item);
+        if (env.fault_occurred)
             return -1;
-        }
 
         if (item)
         {
             const char* cc = NULL;
-            xmlrpc_read_string(env, item, &cc);
+            xmlrpc_read_string(&env, item, &cc);
             xmlrpc_DECREF(item);
-            if (env->fault_occurred)
+            if (env.fault_occurred)
             {
                 xmlrpc_DECREF(cc_member);
-                abrt_errno = ABRTE_BUGZILLA_XMLRPC_ERROR;
                 return -1;
             }
 
@@ -321,102 +276,87 @@ int32_t ctx::get_bug_cc(xmlrpc_env* env, xmlrpc_value* result_xml, struct bug_in
     return real_read;
 }
 
-xmlrpc_value* ctx::call_quicksearch_uuid(xmlrpc_env* env, const char* component, const char* uuid)
+xmlrpc_value* ctx::call_quicksearch_uuid(const char* component, const char* uuid)
 {
     std::string query = ssprintf("ALL component:\"%s\" statuswhiteboard:\"%s\"", component, uuid);
 
     // fails only on memory allocation
-    xmlrpc_value* param = xmlrpc_build_value(env, "({s:s})", "quicksearch", query.c_str());
-    if (env->fault_occurred)
-    {
-        abrt_errno = ABRTE_BUGZILLA_XMLRPC_ERROR;
+    xmlrpc_value* param = xmlrpc_build_value(&env, "({s:s})", "quicksearch", query.c_str());
+    if (env.fault_occurred)
         return NULL;
-    }
 
     xmlrpc_value* result = NULL;
-    xmlrpc_client_call2(env, m_pClient, m_pServer_info, "Bug.search", param, &result);
+    xmlrpc_client_call2(&env, m_pClient, m_pServer_info, "Bug.search", param, &result);
     xmlrpc_DECREF(param);
-    if (env->fault_occurred)
-    {
-        abrt_errno = ABRTE_BUGZILLA_XMLRPC_ERROR;
+    if (env.fault_occurred)
         return NULL;
-    }
+
     return result;
 }
 
-int32_t ctx::get_bug_id(xmlrpc_env* env, xmlrpc_value* result_xml)
+int32_t ctx::get_bug_id(xmlrpc_value* result_xml)
 {
         xmlrpc_value* item = NULL;
-        xmlrpc_array_read_item(env, result_xml, 0, &item);
-        if (env->fault_occurred)
-        {
-            abrt_errno = ABRTE_BUGZILLA_XMLRPC_ERROR;
+        xmlrpc_array_read_item(&env, result_xml, 0, &item);
+        if (env.fault_occurred)
             return -1;
-        }
 
-        xmlrpc_value* bug = get_member(env, "bug_id", item);
+        xmlrpc_value* bug = get_member("bug_id", item);
         xmlrpc_DECREF(item);
         if (!bug)
             return -1;
 
-        xmlrpc_int bug_id = -1;
-        xmlrpc_read_int(env, bug, &bug_id);
+        xmlrpc_int32 bug_id = -1;
+        xmlrpc_read_int(&env, bug, &bug_id);
         xmlrpc_DECREF(bug);
-        if (env->fault_occurred)
-        {
-            abrt_errno = ABRTE_BUGZILLA_XMLRPC_ERROR;
+        if (env.fault_occurred)
             return -1;
-        }
-        log("Bug is already reported: %i", (int)bug_id);
-        update_client(_("Bug is already reported: %i"), (int)bug_id);
+
+        log("Bug is already reported: %i", bug_id);
+        update_client(_("Bug is already reported: %i"), bug_id);
 
         return bug_id;
 }
 
-int32_t ctx::add_plus_one_cc(xmlrpc_env* env, uint32_t bug_id, const char* login)
+int32_t ctx::add_plus_one_cc(uint32_t bug_id, const char* login)
 {
-    xmlrpc_value* param = xmlrpc_build_value(env, "({s:i,s:{s:(s)}})", "ids", bug_id, "updates", "add_cc", login);
-    if (env->fault_occurred)
-    {
-        abrt_errno = ABRTE_BUGZILLA_XMLRPC_ERROR;
+    xmlrpc_value* param = xmlrpc_build_value(&env, "({s:i,s:{s:(s)}})", "ids", bug_id, "updates", "add_cc", login);
+    if (env.fault_occurred)
         return -1;
-    }
 
     xmlrpc_value* result = NULL;
-    xmlrpc_client_call2(env, m_pClient, m_pServer_info, "Bug.update", param, &result);
+    xmlrpc_client_call2(&env, m_pClient, m_pServer_info, "Bug.update", param, &result);
     xmlrpc_DECREF(param);
-    if (env->fault_occurred)
-    {
-        abrt_errno = ABRTE_BUGZILLA_XMLRPC_ERROR;
+
+    if (result)
+        xmlrpc_DECREF(result);
+
+    if (env.fault_occurred)
         return -1;
-    }
 
-    xmlrpc_DECREF(result);
-    return ABRTE_BUGZILLA_OK;
+    return 0;
 }
 
-int32_t ctx::add_comment(xmlrpc_env* env, uint32_t bug_id, const char* comment)
+int32_t ctx::add_comment(uint32_t bug_id, const char* comment)
 {
-    xmlrpc_value* param = xmlrpc_build_value(env, "({s:i,s:{s:s}})", "ids", bug_id, "updates", "comment", comment);
-    if (env->fault_occurred)
-    {
-        abrt_errno = ABRTE_BUGZILLA_XMLRPC_ERROR;
+    xmlrpc_value* param = xmlrpc_build_value(&env, "({s:i,s:{s:s}})", "ids", bug_id, "updates", "comment", comment);
+    if (env.fault_occurred)
         return -1;
-    }
 
     xmlrpc_value* result = NULL;
-    xmlrpc_client_call2(env, m_pClient, m_pServer_info, "Bug.update", param, &result);
+    xmlrpc_client_call2(&env, m_pClient, m_pServer_info, "Bug.update", param, &result);
     xmlrpc_DECREF(param);
-    if (env->fault_occurred)
-    {
-        abrt_errno = ABRTE_BUGZILLA_XMLRPC_ERROR;
+
+    if (result)
+        xmlrpc_DECREF(result);
+
+    if (env.fault_occurred)
         return -1;
-    }
 
-    return ABRTE_BUGZILLA_OK;
+    return 0;
 }
 
-int32_t ctx::new_bug(xmlrpc_env* env, const map_crash_data_t& pCrashData)
+int32_t ctx::new_bug(const map_crash_data_t& pCrashData)
 {
 
     const std::string& package   = get_crash_data_item_content(pCrashData, FILENAME_PACKAGE);
@@ -441,7 +381,7 @@ int32_t ctx::new_bug(xmlrpc_env* env, const map_crash_data_t& pCrashData)
     std::string version;
     parse_release(release.c_str(), product, version);
 
-    xmlrpc_value* param = xmlrpc_build_value(env, "({s:s,s:s,s:s,s:s,s:s,s:s,s:s})",
+    xmlrpc_value* param = xmlrpc_build_value(&env, "({s:s,s:s,s:s,s:s,s:s,s:s,s:s})",
                                         "product", product.c_str(),
                                         "component", component.c_str(),
                                         "version", version.c_str(),
@@ -450,42 +390,33 @@ int32_t ctx::new_bug(xmlrpc_env* env, const map_crash_data_t& pCrashData)
                                         "status_whiteboard", status_whiteboard.c_str(),
                                         "platform", arch.c_str()
                               );
-    if (env->fault_occurred)
-    {
-        abrt_errno = ABRTE_BUGZILLA_XMLRPC_ERROR;
+    if (env.fault_occurred)
         return -1;
-    }
 
     xmlrpc_value* result = NULL;
-    xmlrpc_client_call2(env, m_pClient, m_pServer_info, "Bug.create", param, &result);
+    xmlrpc_client_call2(&env, m_pClient, m_pServer_info, "Bug.create", param, &result);
     xmlrpc_DECREF(param);
-    if (env->fault_occurred)
-    {
-        abrt_errno = ABRTE_BUGZILLA_XMLRPC_ERROR;
+    if (env.fault_occurred)
         return -1;
-    }
 
-    xmlrpc_value* id = get_member(env, "id", result);
+    xmlrpc_value* id = get_member("id", result);
     xmlrpc_DECREF(result);
     if (!id)
         return -1;
 
-    xmlrpc_int bug_id = -1;
-    xmlrpc_read_int(env, id, &bug_id);
-    if (env->fault_occurred)
-    {
-        xmlrpc_DECREF(id);
-        abrt_errno = ABRTE_BUGZILLA_XMLRPC_ERROR;
+    xmlrpc_int32 bug_id = -1;
+    xmlrpc_read_int(&env, id, &bug_id);
+    xmlrpc_DECREF(id);
+    if (env.fault_occurred)
         return -1;
-    }
+
     log("New bug id: %i", bug_id);
     update_client(_("New bug id: %i"), bug_id);
 
-    xmlrpc_DECREF(id);
     return bug_id;
 }
 
-int32_t ctx::add_attachments(xmlrpc_env* env, const char* bug_id_str, const map_crash_data_t& pCrashData)
+int32_t ctx::add_attachments(const char* bug_id_str, const map_crash_data_t& pCrashData)
 {
     xmlrpc_value* result = NULL;
 
@@ -500,7 +431,7 @@ int32_t ctx::add_attachments(xmlrpc_env* env, const char* bug_id_str, const map_
          && (content.length() > CD_TEXT_ATT_SIZE || itemname == FILENAME_BACKTRACE)
         ) {
             char *encoded64 = encode_base64(content.c_str(), content.length());
-            xmlrpc_value* param = xmlrpc_build_value(env, "(s{s:s,s:s,s:s,s:s})",
+            xmlrpc_value* param = xmlrpc_build_value(&env, "(s{s:s,s:s,s:s,s:s})",
                                               bug_id_str,
                                               "description", ("File: " + itemname).c_str(),
                                               "filename", itemname.c_str(),
@@ -508,70 +439,71 @@ int32_t ctx::add_attachments(xmlrpc_env* env, const char* bug_id_str, const map_
                                               "data", encoded64
                                       );
             free(encoded64);
-            if (env->fault_occurred)
-            {
-                abrt_errno = ABRTE_BUGZILLA_XMLRPC_ERROR;
+            if (env.fault_occurred)
                 return -1;
-            }
 
-            xmlrpc_client_call2(env, m_pClient, m_pServer_info, "bugzilla.addAttachment", param, &result);
+            xmlrpc_client_call2(&env, m_pClient, m_pServer_info, "bugzilla.addAttachment", param, &result);
             xmlrpc_DECREF(param);
+
             if (result)
                 xmlrpc_DECREF(result);
 
-            if (env->fault_occurred)
-            {
-                abrt_errno = ABRTE_BUGZILLA_XMLRPC_ERROR;
+            if (env.fault_occurred)
                 return -1;
-            }
         }
     }
-    return ABRTE_BUGZILLA_OK;
+    return 0;
 }
 
-int32_t ctx::get_bug_info(xmlrpc_env* env, struct bug_info* bz, uint32_t bug_id)
+int32_t ctx::get_bug_info(struct bug_info* bz, uint32_t bug_id)
 {
-    xmlrpc_value* param = xmlrpc_build_value(env, "(s)", to_string(bug_id).c_str());
-    if (env->fault_occurred)
-    {
-        abrt_errno = ABRTE_BUGZILLA_XMLRPC_ERROR;
+    xmlrpc_value* param = xmlrpc_build_value(&env, "(s)", to_string(bug_id).c_str());
+    if (env.fault_occurred)
         return -1;
-    }
 
     xmlrpc_value* result = NULL;
-    xmlrpc_client_call2(env, m_pClient, m_pServer_info, "bugzilla.getBug", param, &result);
+    xmlrpc_client_call2(&env, m_pClient, m_pServer_info, "bugzilla.getBug", param, &result);
     xmlrpc_DECREF(param);
-    if (env->fault_occurred)
-    {
-        abrt_errno = ABRTE_BUGZILLA_XMLRPC_ERROR;
+    if (env.fault_occurred)
         return -1;
-    }
 
     if (result)
     {
         // mandatory
-        bz->bug_status = get_bug_status(env, result);
+        bz->bug_status = get_bug_status(result);
         if (bz->bug_status == NULL)
             return -1;
 
-        // mandatory when bug status is CLOSED
-        bz->bug_resolution = get_bug_resolution(env, result);
-        if (abrt_errno == ABRTE_BUGZILLA_XMLRPC_ERROR)
+        // mandatory
+        bz->bug_reporter = get_bug_reporter(result);
+        if (bz->bug_reporter == NULL)
             return -1;
 
-        bz->bug_dup_id = get_bug_dup_id(env, result);
-        if (abrt_errno == ABRTE_BUGZILLA_XMLRPC_ERROR)
-            return -1;
+        // mandatory when bug status is CLOSED
+        if (strcmp(bz->bug_status, "CLOSED") == 0)
+        {
+            bz->bug_resolution = get_bug_resolution(result);
+            if ((env.fault_occurred) && (bz->bug_resolution == NULL))
+                return -1;
+        }
 
-        bz->bug_reporter = get_bug_reporter(env, result);
-        if (abrt_errno == ABRTE_BUGZILLA_XMLRPC_ERROR)
-            return -1;
+        // mandatory when bug status is CLOSED and resolution is DUPLICATE
+        if ((strcmp(bz->bug_status, "CLOSED") == 0)
+            && (strcmp(bz->bug_resolution, "DUPLICATE") == 0))
+        {
+            bz->bug_dup_id = get_bug_dup_id(result);
+            if (env.fault_occurred)
+                return -1;
+        }
 
-        get_bug_cc(env, result, bz);
-        if (abrt_errno == ABRTE_BUGZILLA_XMLRPC_ERROR)
+        get_bug_cc(result, bz);
+        if (env.fault_occurred)
             return -1;
+
         xmlrpc_DECREF(result);
+        return 0;
      }
+     return -1;
 }
 
 //-------------------------------------------------------------------
@@ -584,7 +516,6 @@ int32_t ctx::get_bug_info(xmlrpc_env* env, struct bug_info* bz, uint32_t bug_id)
 //TODO: need to rewrite
 void ctx::login(const char* login, const char* passwd)
 {
-    xmlrpc_env env;
     xmlrpc_env_init(&env);
 
     xmlrpc_value* param = xmlrpc_build_value(&env, "({s:s,s:s})", "login", login, "password", passwd);
@@ -607,7 +538,6 @@ void ctx::login(const char* login, const char* passwd)
 
 void ctx::logout()
 {
-    xmlrpc_env env;
     xmlrpc_env_init(&env);
 
     xmlrpc_value* param = xmlrpc_build_value(&env, "(s)", "");
@@ -616,6 +546,7 @@ void ctx::logout()
     xmlrpc_value* result = NULL;
     xmlrpc_client_call2(&env, m_pClient, m_pServer_info, "User.logout", param, &result);
     xmlrpc_DECREF(param);
+
     if (result)
         xmlrpc_DECREF(result);
 
@@ -667,14 +598,6 @@ std::string CReporterBugzilla::Report(const map_crash_data_t& pCrashData,
         NoSSLVerify = m_bNoSSLVerify;
     }
 
-    const std::string& component = get_crash_data_item_content(pCrashData, FILENAME_COMPONENT);
-    const std::string& uuid      = get_crash_data_item_content(pCrashData, CD_DUPHASH);
-
-    xmlrpc_env env;
-    xmlrpc_env_init(&env);
-
-    ctx bz_server(BugzillaXMLRPC.c_str(), NoSSLVerify);
-
     update_client(_("Logging into bugzilla..."));
     if ((Login == "") && (Password == ""))
     {
@@ -682,53 +605,49 @@ std::string CReporterBugzilla::Report(const map_crash_data_t& pCrashData,
         throw CABRTException(EXCEP_PLUGIN, _("Empty login and password. Please check Bugzilla.conf"));
     }
 
+    const std::string& component = get_crash_data_item_content(pCrashData, FILENAME_COMPONENT);
+    const std::string& uuid      = get_crash_data_item_content(pCrashData, CD_DUPHASH);
+
+    ctx bz_server(BugzillaXMLRPC.c_str(), NoSSLVerify);
+
     bz_server.login(Login.c_str(), Password.c_str());
-    update_client(_("Checking for duplicates..."));
 
-    xmlrpc_value* result = bz_server.call_quicksearch_uuid(&env, component.c_str(), uuid.c_str());
+    update_client(_("Checking for duplicates..."));
+    xmlrpc_value* result = bz_server.call_quicksearch_uuid(component.c_str(), uuid.c_str());
     if (!result)
     {
-        if (abrt_errno == ABRTE_BUGZILLA_XMLRPC_ERROR)
-            throw_if_xml_fault_occurred(&env);
-        else
-        {
-                // TODO: check ours returned value
-        }
+        throw_if_xml_fault_occurred(&bz_server.env);
     }
 
-    xmlrpc_value* all_bugs = bz_server.get_member(&env, "bugs", result);
+    xmlrpc_value* all_bugs = bz_server.get_member("bugs", result);
     xmlrpc_DECREF(result);
 
     if (!all_bugs)
     {
-        if (abrt_errno == ABRTE_BUGZILLA_XMLRPC_ERROR)
-            throw_if_xml_fault_occurred(&env);
-        else
-        {
-            // TODO: check ours returned value
-        }
+        throw_if_xml_fault_occurred(&bz_server.env);
+        throw CABRTException(EXCEP_PLUGIN, _("Missing mandatory member 'bugs'"));
     }
 
-    int32_t all_bugs_size = bz_server.get_array_size(&env, all_bugs);
-
+    int32_t all_bugs_size = bz_server.get_array_size(all_bugs);
     if (all_bugs_size == -1)
     {
-        if (abrt_errno == ABRTE_BUGZILLA_XMLRPC_ERROR)
-            throw_if_xml_fault_occurred(&env);
-        else
-        {
-            // TODO: check ours returned value
-        }
+        throw_if_xml_fault_occurred(&bz_server.env);
     }
     else if (all_bugs_size == 0) // Create new bug
     {
         update_client(_("Creating new bug..."));
-        bug_id = bz_server.new_bug(&env, pCrashData);
-        int32_t ret = bz_server.add_attachments(&env, to_string(bug_id).c_str(), pCrashData);
+        bug_id = bz_server.new_bug(pCrashData);
+        int32_t ret = bz_server.add_attachments(to_string(bug_id).c_str(), pCrashData);
+        if (ret == -1)
+        {
+            throw_if_xml_fault_occurred(&bz_server.env);
+        }
 
         update_client(_("Logging out..."));
         bz_server.logout();
 
+        std::string bug_status = "Status: NEW\n";
+        BugzillaURL = bug_status + BugzillaURL;
         BugzillaURL += "/show_bug.cgi?id=";
         BugzillaURL += to_string(bug_id);
         return BugzillaURL;
@@ -740,29 +659,19 @@ std::string CReporterBugzilla::Report(const map_crash_data_t& pCrashData,
     }
 
     // desicition based on state
-    bug_id = bz_server.get_bug_id(&env, all_bugs);
+    bug_id = bz_server.get_bug_id(all_bugs);
     xmlrpc_DECREF(all_bugs);
     if (bug_id == -1)
     {
-        if (abrt_errno == ABRTE_BUGZILLA_XMLRPC_ERROR)
-            throw_if_xml_fault_occurred(&env);
-        else
-        {
-            // TODO: check ours returned value
-        }
-
+        throw_if_xml_fault_occurred(&bz_server.env);
     }
 
     struct bug_info bz;
     bug_info_init(&bz);
-    if (bz_server.get_bug_info(&env, &bz, bug_id) == -1)
+    if (bz_server.get_bug_info(&bz, bug_id) == -1)
     {
-        if (abrt_errno == ABRTE_BUGZILLA_XMLRPC_ERROR)
-            throw_if_xml_fault_occurred(&env);
-        else
-        {
-            // TODO: check ours returned value
-        }
+        throw_if_xml_fault_occurred(&bz_server.env);
+        throw CABRTException(EXCEP_PLUGIN, _("get_bug_info() failed. Could not collect all mandatory information"));
     }
 
     int32_t original_bug_id = bug_id;
@@ -783,17 +692,14 @@ std::string CReporterBugzilla::Report(const map_crash_data_t& pCrashData,
             bug_info_destroy(&bz);
             bug_info_init(&bz);
 
-            if (bz_server.get_bug_info(&env, &bz, bug_id) == -1)
+            if (bz_server.get_bug_info(&bz, bug_id) == -1)
             {
-                if (abrt_errno == ABRTE_BUGZILLA_XMLRPC_ERROR)
+                if (bz_server.env.fault_occurred)
                 {
                     bug_info_destroy(&bz);
-                    throw_if_xml_fault_occurred(&env);
-                }
-                else
-                {
-                    // TODO: check ours returned value
+                    throw_if_xml_fault_occurred(&bz_server.env);
                 }
+                throw CABRTException(EXCEP_PLUGIN, _("get_bug_info() failed. Could not collect all mandatory information"));
             }
 
             // found a bug which is not CLOSED as DUPLICATE
@@ -809,19 +715,13 @@ std::string CReporterBugzilla::Report(const map_crash_data_t& pCrashData,
         {
             VERB2 log(_("Add %s to CC list"), Login.c_str());
             update_client(_("Add %s to CC list"), Login.c_str());
-            status = bz_server.add_plus_one_cc(&env, bug_id, Login.c_str());
+            status = bz_server.add_plus_one_cc(bug_id, Login.c_str());
         }
 
-        bug_info_destroy(&bz);
         if (status == -1)
         {
-            if (abrt_errno == ABRTE_BUGZILLA_XMLRPC_ERROR)
-                throw_if_xml_fault_occurred(&env);
-            else
-            {
-                // TODO: check ours returned value
-            }
-
+            bug_info_destroy(&bz);
+            throw_if_xml_fault_occurred(&bz_server.env);
         }
 
         std::string description = make_description_reproduce_comment(pCrashData);
@@ -829,27 +729,33 @@ std::string CReporterBugzilla::Report(const map_crash_data_t& pCrashData,
         {
             VERB3 log("Add new comment into bug(%d)", bug_id);
             update_client(_("Add new comment into bug(%d)"),bug_id);
-            if (bz_server.add_comment(&env, bug_id, description.c_str()) == -1)
+            if (bz_server.add_comment(bug_id, description.c_str()) == -1)
             {
-                if (abrt_errno == ABRTE_BUGZILLA_XMLRPC_ERROR)
-                    throw_if_xml_fault_occurred(&env);
-                else
-                {
-                    // TODO: check ours returned value
-                }
+                bug_info_destroy(&bz);
+                throw_if_xml_fault_occurred(&bz_server.env);
             }
         }
-
-        update_client(_("Logging out..."));
-        bz_server.logout();
-        BugzillaURL += "/show_bug.cgi?id=";
-        BugzillaURL += to_string(bug_id);
-        return BugzillaURL;
     }
 
     update_client(_("Logging out..."));
     bz_server.logout();
 
+    std::string bug_status;
+
+    std::string status = bz.bug_status;
+    if (bz.bug_resolution)
+    {
+        std::string resolution = bz.bug_resolution;
+        bug_status = "Status: " + status + " " + resolution + "\n";
+    }
+    else
+    {
+        bug_status = "Status: " + status + "\n";
+    }
+
+    bug_info_destroy(&bz);
+
+    BugzillaURL = bug_status + BugzillaURL;
     BugzillaURL += "/show_bug.cgi?id=";
     BugzillaURL += to_string(bug_id);
     return BugzillaURL;