NNTPGrab

/* 

    Copyright (C) 2005-2010  Erik van Pienbroek

    This program is free software; you can redistribute it and/or modify

    it under the terms of the GNU General Public License as published by

    the Free Software Foundation; either version 2 of the License, or

    (at your option) any later version.

    This program is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License

    along with this program; if not, write to the Free Software

    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

*/

#include 

#include 

#include 

#ifdef HAVE_SOUP

#include 

#endif

#ifdef HAVE_SOUP_GNOME

#include 

#endif

#include "nntpgrab_utils.h"

#include "nntpgrab_types.h"

#define URI "https://www.nntpgrab.nl/onlinesearch/search.php"

#ifdef HAVE_SOUP

static void authenticate_cb(SoupSession *session, SoupMessage *msg, SoupAuth *auth, gboolean retrying, gpointer user_data)

{

    soup_auth_authenticate(auth, "guest", "guest");

}

#endif

ngboolean

nntpgrab_utils_nzbcreator_check_api_version(ngboolean *api_okay, char **errmsg)

{

#ifdef HAVE_SOUP

    int result = 0;

    SoupSession *session;

    SoupMessage *msg;

    GError *err = NULL;

    NGList *list;

    g_return_val_if_fail(api_okay != NULL, FALSE);

    session = soup_session_sync_new();

#ifdef HAVE_SOUP_GNOME

    /* Enable proxy support when using GNOME 2.26.0 or higher */

    soup_session_add_feature_by_type(session, SOUP_TYPE_GNOME_FEATURES_2_26);

#endif

#ifdef HAVE_SOUP_GZIP

    /* Enable gzip compression */

    soup_session_add_feature_by_type(session, SOUP_TYPE_CONTENT_DECODER);

#endif

    g_signal_connect (session, "authenticate", G_CALLBACK(authenticate_cb), NULL);

    msg = soup_xmlrpc_request_new(URI, "getProtocolVersion", G_TYPE_INVALID);

    soup_session_send_message(session, msg);

    if (!SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) {

        if (errmsg) {

            *errmsg = g_strdup(msg->reason_phrase);

        }

        g_object_unref(msg);

        g_object_unref(session);

        return FALSE;

    }

    if (!soup_xmlrpc_extract_method_response(msg->response_body->data, msg->response_body->length, &err, G_TYPE_INT, &result)) {

        if (err) {

            if (errmsg) {

                *errmsg = g_strdup(err->message);

            }

            g_error_free(err);

        }

        g_object_unref(msg);

        g_object_unref(session);

        return FALSE;

    }

    g_object_unref(msg);

    g_object_unref(session);

    if (result == 20110613) {

        *api_okay = TRUE;

    } else {

        *api_okay = FALSE;

    }

    return TRUE;

#else

    if (errmsg) {

        *errmsg = g_strdup(_("Support for the Online Search hasn't been enabled in this build. Please rebuild NNTPGrab to enable this feature"));

    }

    return FALSE;

#endif

}

void

nntpgrab_utils_nzbcreator_free_groups(NGList *groups)

{

    NGList *list = groups;

    while (list) {

        g_slice_free(NZBCreatorGroup, list->data);

        list = ng_list_next(list);

    }

    ng_list_free(groups);

}

NGList *

nntpgrab_utils_nzbcreator_get_all_groups(char **errmsg)

{

    NGList *ret = NULL;

#ifndef HAVE_SOUP

    if (errmsg) {

        *errmsg = g_strdup(_("Support for the Online Search hasn't been enabled in this build. Please rebuild NNTPGrab to enable this feature"));

    }

#else

    SoupSession *session = soup_session_sync_new();

    SoupMessage *msg = soup_xmlrpc_request_new(URI, "getListOfAvailableGroups", G_TYPE_INVALID);

    GError *err = NULL;

    int i;

    GValueArray *result = NULL;

    GHashTable *group_arr = NULL;

#ifdef SOUP_TYPE_GNOME_FEATURES_2_26

    /* Enable proxy support when using GNOME 2.26.0 or higher */

    soup_session_add_feature_by_type(session, SOUP_TYPE_GNOME_FEATURES_2_26);

#endif

#ifdef HAVE_SOUP_GZIP

    /* Enable gzip compression */

    soup_session_add_feature_by_type(session, SOUP_TYPE_CONTENT_DECODER);

#endif

    g_signal_connect (session, "authenticate", G_CALLBACK(authenticate_cb), NULL);

    soup_session_send_message(session, msg);

    if (!SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) {

        if (errmsg) {

            *errmsg = g_strdup_printf("Server returned unknown error: %s (%i)", msg->reason_phrase, msg->status_code);

        }

        g_object_unref(msg);

        g_object_unref(session);

        return NULL;

    }

    if (!soup_xmlrpc_extract_method_response(msg->response_body->data, msg->response_body->length, &err, G_TYPE_VALUE_ARRAY, &result)) {

        if (errmsg) {

            if (err) {

                *errmsg = g_strdup_printf("Unable to parse reply: %s", err->message);

            } else {

                *errmsg = g_strdup_printf(__FILE__ ":%i Unable to parse reply from server. See the console for more details", __LINE__);

            }

        }

        if (err) {

            g_error_free(err);

        }

        g_object_unref(msg);

        g_object_unref(session);

        return NULL;

    }

    for (i = 0; i < result->n_values; i++) {

        NZBCreatorGroup *group;

        char *groupname = NULL;

        int group_id = -1;

        if (!soup_value_array_get_nth(result, i, G_TYPE_HASH_TABLE, &group_arr)) {

            g_warning(__FILE__ ":%i Unable to parse values", __LINE__);

            continue;

        }

        if (!soup_value_hash_lookup_vals(group_arr, "group_id", G_TYPE_INT, &group_id, "newsgroup", G_TYPE_STRING, &groupname, NULL)) {

            g_warning(__FILE__ ":%i Unable to parse values", __LINE__);

            g_hash_table_destroy(group_arr);

            continue;

        }

        group = g_slice_new0(NZBCreatorGroup);

        strncpy(group->newsgroup, groupname, sizeof(group->newsgroup) - 1);

        group->group_id = group_id;

        ret = ng_list_append(ret, group);

    }

    g_value_array_free(result);

    g_object_unref(msg);

    g_object_unref(session);

#endif

    return ret;

}

void

nntpgrab_utils_nzbcreator_free_result(NZBCreatorSearchResult *result)

{

    NGList *list;

    list = result->collections;

    while (list) {

        g_slice_free(NZBCreatorCollection, list->data);

        list = ng_list_next(list);

    }

    g_list_free((GList*) result->collections);

    g_slice_free(NZBCreatorSearchResult, result);

}

NZBCreatorSearchResult *

nntpgrab_utils_nzbcreator_perform_search(NZBCreatorSearchOpts opts, char **errmsg)

{

    NZBCreatorSearchResult *result = NULL;

#ifndef HAVE_SOUP

    if (errmsg) {

        *errmsg = g_strdup(_("Support for the Online Search hasn't been enabled in this build. Please rebuild NNTPGrab to enable this feature"));

    }

#else

    SoupSession *session;

    SoupMessage *msg;

    GHashTable *args;

    GError *err = NULL;

    GHashTable *rpc_result = NULL;

    GValueArray *matches = NULL;

    int i;

    g_return_val_if_fail(strlen(opts.query) > 0, FALSE);

    g_return_val_if_fail(opts.max_age <= 150, FALSE);

    g_return_val_if_fail(opts.percentage_complete <= 100, FALSE);

    session = soup_session_sync_new();

#ifdef SOUP_TYPE_GNOME_FEATURES_2_26

    /* Enable proxy support when using GNOME 2.26.0 or higher */

    soup_session_add_feature_by_type(session, SOUP_TYPE_GNOME_FEATURES_2_26);

#endif

#ifdef HAVE_SOUP_GZIP

    /* Enable gzip compression */

    soup_session_add_feature_by_type(session, SOUP_TYPE_CONTENT_DECODER);

#endif

    g_signal_connect (session, "authenticate", G_CALLBACK(authenticate_cb), NULL);

    args = soup_value_hash_new_with_vals(   "query", G_TYPE_STRING, opts.query,

                                            "search_only_in", G_TYPE_INT, opts.search_only_in,

                                            "max_age", G_TYPE_INT, opts.max_age,

                                            NULL);

    if (strlen(opts.username) > 0 && strlen(opts.password) > 0) {

        soup_value_hash_insert(args, "username", G_TYPE_STRING, opts.username);

        soup_value_hash_insert(args, "password", G_TYPE_STRING, opts.password);

    }

    if (opts.minimal_file_size > 0) {

        /* Libsoup doesn't support 64bit integers as XML-RPC parameters */

        char *tmp = g_strdup_printf("%"G_GUINT64_FORMAT, opts.minimal_file_size);

        soup_value_hash_insert(args, "minimal_file_size", G_TYPE_STRING, tmp);

        g_free(tmp);

    }

    if (opts.maximal_file_size > 0) {

        char *tmp = g_strdup_printf("%"G_GUINT64_FORMAT, opts.maximal_file_size);

        soup_value_hash_insert(args, "maximal_file_size", G_TYPE_STRING, tmp);

        g_free(tmp);

    }

    if (opts.percentage_complete > 0) {

        soup_value_hash_insert(args, "percentage_complete", G_TYPE_INT, opts.percentage_complete);

    }

    if (opts.group_to_search > 0) {

        soup_value_hash_insert(args, "group_to_search", G_TYPE_INT, opts.group_to_search);

    }

    if (opts.file_type != NNTP_FILE_TYPE_UNKNOWN) {

        soup_value_hash_insert(args, "file_type", G_TYPE_INT, opts.file_type);

    }

    msg = soup_xmlrpc_request_new(URI, "performSearch", G_TYPE_HASH_TABLE, args, G_TYPE_INVALID);

    soup_session_send_message(session, msg);

    g_hash_table_destroy(args);

    if (!SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) {

        if (errmsg) {

            *errmsg = g_strdup_printf("Server returned unknown error: %s (%i)", msg->reason_phrase, msg->status_code);

        }

        g_object_unref(msg);

        g_object_unref(session);

        return NULL;

    }

    if (!soup_xmlrpc_extract_method_response(msg->response_body->data, msg->response_body->length, &err, G_TYPE_HASH_TABLE, &rpc_result)) {

        if (errmsg) {

            if (err) {

                *errmsg = g_strdup_printf("Unable to parse reply: %s", err->message);

            } else {

                *errmsg = g_strdup_printf(__FILE__ ":%i Unable to parse reply from server. See the console for more details", __LINE__);

            }

        }

        if (err) {

            g_error_free(err);

        }

        g_object_unref(msg);

        g_object_unref(session);

        return NULL;

    }

    result = g_slice_new0(NZBCreatorSearchResult);

    if (!soup_value_hash_lookup_vals(rpc_result,    "number_of_hits", G_TYPE_INT, &result->number_of_hits,

                                                    "number_of_results", G_TYPE_INT, &result->number_of_results,

                                                    "matches", G_TYPE_VALUE_ARRAY, &matches,

                                                    NULL)) {

        g_warning(__FILE__ ":%i Unable to parse values", __LINE__);

        g_slice_free(NZBCreatorSearchResult, result);

        g_hash_table_destroy(rpc_result);

        g_object_unref(msg);

        g_object_unref(session);

        return NULL;

    }

    for (i = 0; i < matches->n_values; i++) {

        NZBCreatorCollection *collection;

        GHashTable *hash_collection = NULL;

        int collection_id = 0;

        char *collection_name;

        char *short_collection_name;

        char *poster;

        char *newsgroup;

        int stamp = 0;

        int num_parts_found = -1;

        int num_parts_expected = -1;

        /* gint64 */guint total_size = -1;

        int complete_percentage = 0;

        int num_regular_files = 0;

        int num_par2_files = 0;

        int first_file_id = -1;

        if (!soup_value_array_get_nth(matches, i, G_TYPE_HASH_TABLE, &hash_collection)) {

            g_warning(__FILE__ ":%i Unable to parse values", __LINE__);

            continue;

        }

        if (!soup_value_hash_lookup_vals(hash_collection,   "collection_id", G_TYPE_INT, &collection_id,

                                                            "collection_name", G_TYPE_STRING, &collection_name,

                                                            "short_collection_name", G_TYPE_STRING, &short_collection_name,

                                                            "poster", G_TYPE_STRING, &poster,

                                                            "total_size", G_TYPE_INT, &total_size,       // FIXME: possible overflow!

                                                            "newsgroup", G_TYPE_STRING, &newsgroup,

                                                            "stamp", G_TYPE_INT, &stamp,

                                                            "num_parts_found", G_TYPE_INT, &num_parts_found,

                                                            "num_parts_expected", G_TYPE_INT, &num_parts_expected,

                                                            "complete_percentage", G_TYPE_INT, &complete_percentage,

                                                            "num_regular_files", G_TYPE_INT, &num_regular_files,

                                                            "num_par2_files", G_TYPE_INT, &num_par2_files,

                                                            "first_file_id", G_TYPE_INT, &first_file_id,

                                                            NULL)) {

            g_warning(__FILE__ ":%i Unable to parse values", __LINE__);

            g_hash_table_destroy(hash_collection);

            continue;

        }

        collection = g_slice_new0(NZBCreatorCollection);

        collection->collection_id = collection_id;

        strncpy(collection->collection_name, collection_name, sizeof(collection->collection_name) - 1);

        strncpy(collection->short_collection_name, short_collection_name, sizeof(collection->short_collection_name) - 1);

        strncpy(collection->poster, poster, sizeof(collection->poster) - 1);

        collection->total_size = total_size;

        strncpy(collection->newsgroup, newsgroup, sizeof(collection->newsgroup) - 1);

        collection->stamp = (time_t) stamp;

        collection->num_parts_found = num_parts_found;

        collection->num_parts_expected = num_parts_expected;

        collection->complete_percentage = complete_percentage;

        collection->num_regular_files = num_regular_files;

        collection->num_par2_files = num_par2_files;

        collection->first_file_id = first_file_id;

        result->collections = ng_list_append(result->collections, collection);

    }

    g_hash_table_destroy(rpc_result);

    g_object_unref(msg);

    g_object_unref(session);

#endif

    return result;

}

NGList *

nntpgrab_utils_nzbcreator_retrieve_collection_details(ngint64 collection_id, time_t stamp, char **errmsg)

{

    NGList *result = NULL;

#ifndef HAVE_SOUP

    if (errmsg) {

        *errmsg = g_strdup(_("Support for the Online Search hasn't been enabled in this build. Please rebuild NNTPGrab to enable this feature"));

    }

#else

    SoupSession *session;

    SoupMessage *msg;

    GHashTable *args;

    GError *err = NULL;

    GHashTable *rpc_result = NULL;

    GValueArray *matches = NULL;

    int i;

    g_return_val_if_fail(collection_id > 0, FALSE);

    session = soup_session_sync_new();

#ifdef SOUP_TYPE_GNOME_FEATURES_2_26

    /* Enable proxy support when using GNOME 2.26.0 or higher */

    soup_session_add_feature_by_type(session, SOUP_TYPE_GNOME_FEATURES_2_26);

#endif

#ifdef HAVE_SOUP_GZIP

    /* Enable gzip compression */

    soup_session_add_feature_by_type(session, SOUP_TYPE_CONTENT_DECODER);

#endif

    g_signal_connect (session, "authenticate", G_CALLBACK(authenticate_cb), NULL);

    args = soup_value_hash_new_with_vals("collection_id", G_TYPE_INT, (int) collection_id,

                                         "stamp", G_TYPE_INT, (int) stamp,

                                         NULL);

    msg = soup_xmlrpc_request_new(URI, "retrieveCollectionDetails", G_TYPE_HASH_TABLE, args, G_TYPE_INVALID);

    soup_session_send_message(session, msg);

    g_hash_table_destroy(args);

    if (!SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) {

        if (errmsg) {

            *errmsg = g_strdup_printf("Server returned unknown error: %s (%i)", msg->reason_phrase, msg->status_code);

        }

        g_object_unref(msg);

        g_object_unref(session);

        return NULL;

    }

    if (!soup_xmlrpc_extract_method_response(msg->response_body->data, msg->response_body->length, &err, G_TYPE_VALUE_ARRAY, &matches)) {

        if (errmsg) {

            if (err) {

                *errmsg = g_strdup_printf("Unable to parse reply: %s", err->message);

            } else {

                *errmsg = g_strdup_printf(__FILE__ ":%i Unable to parse reply from server:\n%s", __LINE__, msg->response_body->data);

            }

        }

        if (err) {

            g_error_free(err);

        }

        g_object_unref(msg);

        g_object_unref(session);

        return NULL;

    }

    for (i = 0; i < matches->n_values; i++) {

        NZBCreatorFile *file;

        GHashTable *hash_file = NULL;

        /* gint64 */gint file_id = -1;

        char *subject = NULL;

        char *poster = NULL;

        int num_parts_found = -1;

        int num_parts_expected = -1;

        int file_type = NNTP_FILE_TYPE_UNKNOWN;

        /* gint64 */gint file_size = -1;

        int complete_percentage = 0;

        int stamp;

        if (!soup_value_array_get_nth(matches, i, G_TYPE_HASH_TABLE, &hash_file)) {

            g_warning(__FILE__ ":%i Unable to parse values", __LINE__);

            continue;

        }

        if (!soup_value_hash_lookup_vals(hash_file, "file_id", G_TYPE_INT, &file_id,            // FIXME: possible overflow!

                                                    "subject", G_TYPE_STRING, &subject,

                                                    "poster", G_TYPE_STRING, &poster,

                                                    "num_parts_found", G_TYPE_INT, &num_parts_found,

                                                    "num_parts_expected", G_TYPE_INT, &num_parts_expected,

                                                    "file_type", G_TYPE_INT, &file_type,

                                                    "file_size", G_TYPE_INT, &file_size,        // FIXME: possible overflow!

                                                    "stamp", G_TYPE_INT, &stamp,

                                                    "complete_percentage", G_TYPE_INT, &complete_percentage,

                                                    NULL)) {

            g_warning(__FILE__ ":%i Unable to parse values", __LINE__);

            continue;

        }

        file = g_slice_new0(NZBCreatorFile);

        file->file_id = file_id;

        strncpy(file->subject, subject, sizeof(file->subject) - 1);

        strncpy(file->poster, poster, sizeof(file->poster) - 1);

        file->num_parts_found = num_parts_found;

        file->num_parts_expected = num_parts_expected;

        file->file_type = (NNTPFileType) file_type;

        file->file_size = file_size;

        file->stamp = (time_t) stamp;

        file->complete_percentage = complete_percentage;

        result = ng_list_append(result, file);

    }

    g_object_unref(msg);

    g_object_unref(session);

#endif

    return result;

}

void nntpgrab_utils_nzbcreator_free_collection_details(NGList *files)

{

    NGList *list;

    list = files;

    while (list) {

        g_slice_free(NZBCreatorFile, list->data);

        list = ng_list_next(list);

    }

    g_list_free((GList*) files);

}

char *

nntpgrab_utils_nzbcreator_generate_NZB(NGList *file_ids, char **errmsg)

{

    char *result = NULL;

#ifndef HAVE_SOUP

    if (errmsg) {

        *errmsg = g_strdup(_("Support for the Online Search hasn't been enabled in this build. Please rebuild NNTPGrab to enable this feature"));

    }

#else

    SoupSession *session;

    SoupMessage *msg;

    GError *err = NULL;

    GValueArray *args = NULL;

    NGList *list;

    args = soup_value_array_new();

    list = file_ids;

    while (list) {

        soup_value_array_append(args, G_TYPE_INT, GPOINTER_TO_INT(list->data));

        list = ng_list_next(list);

    }

    session = soup_session_sync_new();

#ifdef HAVE_SOUP_GNOME

    /* Enable proxy support when using GNOME 2.26.0 or higher */

    soup_session_add_feature_by_type(session, SOUP_TYPE_GNOME_FEATURES_2_26);

#endif

#ifdef HAVE_SOUP_GZIP

    /* Enable gzip compression */

    soup_session_add_feature_by_type(session, SOUP_TYPE_CONTENT_DECODER);

#endif

    g_signal_connect (session, "authenticate", G_CALLBACK(authenticate_cb), NULL);

    msg = soup_xmlrpc_request_new(URI, "generateNZB", G_TYPE_VALUE_ARRAY, args, G_TYPE_INVALID);

    soup_session_send_message(session, msg);

    g_value_array_free(args);

    if (!SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) {

        if (errmsg) {

            *errmsg = g_strdup_printf("Server returned unknown error: %s (%i)", msg->reason_phrase, msg->status_code);

        }

        g_object_unref(msg);

        g_object_unref(session);

        return NULL;

    }

    if (!soup_xmlrpc_extract_method_response(msg->response_body->data, msg->response_body->length, &err, G_TYPE_STRING, &result)) {

        if (errmsg) {

            if (err) {

                *errmsg = g_strdup_printf("Unable to parse reply: %s", err->message);

            } else {

                *errmsg = g_strdup_printf(__FILE__ ":%i Unable to parse reply from server. See the console for more details", __LINE__);

            }

        }

        if (err) {

            g_error_free(err);

        }

        g_object_unref(msg);

        g_object_unref(session);

        return NULL;

    }

    g_object_unref(msg);

    g_object_unref(session);

#endif

    return result;

}