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 

#include 

#ifndef _MSC_VER

#include 

#endif

#ifdef WIN32

#include 

#include 

#include 

#include 

#include 

#else

#include 

#include 

#include 

#include 

#endif

#include 

#include 

#include "nntpgrab_utils.h"

#include "nntpgrab_types.h"

#ifdef WIN32

#define CLOSE(x)    closesocket(x)

#else

#define CLOSE(x)    close(x)

#endif

ngboolean

nntpgrab_utils_strip_subject(const char *subject, char **subject_without_partnum, int *file_num, int *total_files, char **filename, char **extension, NNTPFileType *file_type, int *par2_startnum, int *num_par2_blocks, int *part_num, int *total_parts)

{

    const char **values;

    static NGRegex *re_filename_and_extension = NULL;

    static NGRegex *re_subject_without_partnum = NULL;

    NNTPFileType type;

    if (!re_filename_and_extension) {

        re_filename_and_extension = nntpgrab_utils_regex_compile("((?:.*[\"']|[^ ]+ |^)(.+(?:\"|'|)\\.([fF][lL][aA][cC]|[pP][aA][rR]2|[xX][lL][sS][xX]|[a-zA-Z0-9]{3}|[tT][sS]))[\"'\\] ].*)\\(([0-9]+)/([0-9]+)\\).*$");

    }

    if (!re_subject_without_partnum) {

        re_subject_without_partnum = nntpgrab_utils_regex_compile("(.*)\\(([0-9]+)/([0-9]+)\\).*$");

    }

    // If the user only wants to know the subject without part numbers, use a more simple regex

    if (!(file_num || total_files || filename || extension || file_type || par2_startnum || num_par2_blocks)) {

        values = nntpgrab_utils_regex_match(re_subject_without_partnum, subject);

        if (values == NULL) {

            return FALSE;

        }

        if (subject_without_partnum) {

            *subject_without_partnum = g_strdup(values[1]);

        }

        if (part_num) {

            *part_num = atoi(values[2]);

        }

        if (total_parts) {

            *total_parts = atoi(values[3]);

        }

        nntpgrab_utils_regex_matches_free(values);

        return TRUE;

    }

    values = nntpgrab_utils_regex_match(re_filename_and_extension, subject);

    if (values == NULL) {

        return FALSE;

    }

    if (subject_without_partnum) {

        *subject_without_partnum = g_strdup(values[1]);

    }

    if (filename) {

        *filename = g_strdup(values[2]);

    }

    if (extension) {

        *extension = g_strdup(values[3]);

    }

    if (file_type || par2_startnum || num_par2_blocks) {

        if (!g_strcasecmp(values[3], "rar")) {

            type = NNTP_FILE_TYPE_RAR;

        } else if (!g_strcasecmp(values[3], "par2")) {

            type = NNTP_FILE_TYPE_PAR2;

        } else if (!g_strcasecmp(values[3], "par")) {

            type = NNTP_FILE_TYPE_PAR;

        } else if (!g_strcasecmp(values[3], "sfv")) {

            type = NNTP_FILE_TYPE_SFV;

        } else if (!g_strcasecmp(values[3], "nfo")) {

            type = NNTP_FILE_TYPE_NFO;

        } else if (!g_strcasecmp(values[3], "nzb")) {

            type = NNTP_FILE_TYPE_NZB;

        } else {

            type = NNTP_FILE_TYPE_OTHER;

        }

        if (file_type) {

            *file_type = type;

        }

        if (par2_startnum || num_par2_blocks) {

            if (par2_startnum) {

                *par2_startnum = -1;

            }

            if (num_par2_blocks) {

                *num_par2_blocks = -1;

            }

            if (type == NNTP_FILE_TYPE_PAR2) {

                // Find out the block numbers of this PAR2 file.

                // FIXME: This should be integrated in the main regexp

                static NGRegex *re_par2_blocknumbers = NULL;

                const char **values_par2;

                if (!re_par2_blocknumbers) {

                    re_par2_blocknumbers = nntpgrab_utils_regex_compile(".*\\.[vV][oO][lL](\\d+)\\+(\\d+)\\.[pP][aA][rR]2$");

                }

                values_par2 = nntpgrab_utils_regex_match(re_par2_blocknumbers, values[2]);

                if (values_par2 && values_par2[0] && values_par2[1] && values_par2[2]) {

                    if (par2_startnum) {

                        *par2_startnum = atoi(values_par2[1]);

                    }

                    if (num_par2_blocks) {

                        *num_par2_blocks = atoi(values_par2[2]);

                    }

                    nntpgrab_utils_regex_matches_free(values_par2);

                }

            }

        }

    }

    if (part_num) {

        *part_num = atoi(values[4]);

    }

    if (total_parts) {

        *total_parts = atoi(values[5]);

    }

    nntpgrab_utils_regex_matches_free(values);

    return TRUE;

}

NNTPFileType

nntpgrab_utils_get_file_type_of_filename(const char *filename)

{

    char *filename_tmp = g_strdup_printf("%s.", filename);

    char *ptr = g_strrstr(filename_tmp, ".");

    NNTPFileType type = NNTP_FILE_TYPE_UNKNOWN;

    while (ptr) {

        if (!g_strncasecmp(ptr + 1, "rar.", 4)) {

            type = NNTP_FILE_TYPE_RAR;

            break;

        } else if (!g_strncasecmp(ptr + 1, "par2.", 5)) {

            type = NNTP_FILE_TYPE_PAR2;

            break;

        } else if (!g_strncasecmp(ptr + 1, "par.", 4)) {

            type = NNTP_FILE_TYPE_PAR;

            break;

        } else if (!g_strncasecmp(ptr + 1, "sfv.", 4)) {

            type = NNTP_FILE_TYPE_SFV;

            break;

        } else if (!g_strncasecmp(ptr + 1, "nfo.", 4)) {

            type = NNTP_FILE_TYPE_NFO;

            break;

        } else if (!g_strncasecmp(ptr + 1, "nzb.", 4)) {

            type = NNTP_FILE_TYPE_NZB;

            break;

        }

        ptr = g_strrstr_len(filename_tmp, ptr - filename_tmp - 1, ".");

    }

    g_free(filename_tmp);

    return type;

}

void

nntpgrab_utils_calculate_file_size(nguint64 file_size, char *file_size_str, int file_size_str_len)

{

    double d_file_size;

    d_file_size = (double) file_size;

    if (d_file_size < 1024) {

        snprintf(file_size_str, file_size_str_len, "%.1f bytes", d_file_size);

        return;

    }

    d_file_size /= 1024;

    if (d_file_size < 1024) {

        snprintf(file_size_str, file_size_str_len, "%.1f KB", d_file_size);

        return;

    }

    d_file_size /= 1024;

    if (d_file_size < 1024) {

        snprintf(file_size_str, file_size_str_len, "%.1f MB", d_file_size);

        return;

    }

    d_file_size /= 1024;

    snprintf(file_size_str, file_size_str_len, "%.1f GB", d_file_size);

}

int

nntpgrab_utils_calculate_estimated_time_remaining(int bytes_received1, int bytes_received2, int bytes_received3, int bytes_received4, int bytes_received5, int bytes_received6, int bytes_received7, int bytes_received8, int bytes_received9, int bytes_received10, nguint64 file_size)

{

    int bytes_per_sec_avg;

    guint64 ret;

    // calculate the average speed of the last 10 seconds

    bytes_per_sec_avg  = bytes_received1;

    bytes_per_sec_avg += bytes_received2;

    bytes_per_sec_avg += bytes_received3;

    bytes_per_sec_avg += bytes_received4;

    bytes_per_sec_avg += bytes_received5;

    bytes_per_sec_avg += bytes_received6;

    bytes_per_sec_avg += bytes_received7;

    bytes_per_sec_avg += bytes_received8;

    bytes_per_sec_avg += bytes_received9;

    bytes_per_sec_avg += bytes_received10;

    bytes_per_sec_avg /= 10;

    // Is there any data received in the last 10 seconds?

    if (bytes_per_sec_avg == 0) {

        return -1;

    }

    // Don't make an estimation when there hasn't been much data seen in the last 10 seconds

    if (bytes_per_sec_avg < 2048) {

        return -1;

    }

    ret = file_size / bytes_per_sec_avg;

    return (int) ret;

}

void

nntpgrab_utils_get_readable_time_remaining(int estimated_time_remaining, char *time_remaining_str, int time_remaining_str_len)

{

    int num_days;

    int num_hours;

    int num_minutes;

    int num_seconds;

    int left;

    char days[64];

    char hours[64];

    char minutes[64];

    char seconds[64];

    if (estimated_time_remaining <= 0) {

        time_remaining_str[0] = '\0';

        return;

    }

    memset(&days, 0, sizeof(days));

    memset(&hours, 0, sizeof(hours));

    memset(&minutes, 0, sizeof(minutes));

    memset(&seconds, 0, sizeof(seconds));

    num_days = estimated_time_remaining / 86400;

    left = estimated_time_remaining % 86400;

    num_hours = left / 3600;

    left %= 3600;

    num_minutes = left / 60;

    num_seconds = left % 60;

    if (num_days == 0) {

        /* Do nothing */

    } else if (num_days == 1) {

        snprintf(days, sizeof(days) - 1, _("%i day"), num_days);

    } else  {

        snprintf(days, sizeof(days) - 1, _("%i days"), num_days);

    }

    if (num_hours == 1) {

        snprintf(hours, sizeof(hours) - 1, _("1 hour"));

    } else {

        snprintf(hours, sizeof(hours) - 1, _("%i hours"), num_hours);

    }

    if (num_minutes == 1) {

        snprintf(minutes, sizeof(minutes) - 1, _("1 minute"));

    } else {

        snprintf(minutes, sizeof(minutes) - 1, _("%i minutes"), num_minutes);

    }

    if (num_seconds == 0 || num_days > 0) {

        /* Do nothing */

    } else if (num_seconds == 1) {

        snprintf(seconds, sizeof(seconds) - 1, _("1 second"));

    } else {

        snprintf(seconds, sizeof(seconds) - 1, _("%i seconds"), num_seconds);

    }

    if (num_days > 0) {

        snprintf(time_remaining_str, time_remaining_str_len, "%s %s %s", days, hours, minutes);

    } else {

        if (num_hours == 0) {

            if (num_seconds == 0) {

                snprintf(time_remaining_str, time_remaining_str_len, "%s", minutes);

            } else {

                snprintf(time_remaining_str, time_remaining_str_len, "%s %s", minutes, seconds);

            }

        } else {

            if (num_seconds == 0) {

                snprintf(time_remaining_str, time_remaining_str_len, "%s %s", hours, minutes);

            } else {

                snprintf(time_remaining_str, time_remaining_str_len, "%s %s %s", hours, minutes, seconds);

            }

        }

    }

}

void

nntpgrab_utils_get_readable_finished_time(int estimated_time_remaining, char *time_remaining_str, int time_remaining_str_len)

{

    struct tm *now;

    time_t stamp;

    static int nugrft_once = 0;

    if (estimated_time_remaining <= 0) {

        time_remaining_str[0] = '\0';

        return;

    }

    stamp = time(NULL) + estimated_time_remaining;

    if ((now = localtime(&stamp)) == NULL) {

        // Date could not be parsed

        time_remaining_str[0] = '\0';

        return;

    }

    if (strftime(time_remaining_str, time_remaining_str_len, "%c", now) == 0) {

        if (!nugrft_once) {

            g_error(__FILE__ ":%i buffer too small", __LINE__);

            nugrft_once = 1;

        }

    }

}

void

nntpgrab_utils_get_readable_time_stamp(time_t stamp, char *stamp_str, int stamp_str_len)

{

    struct tm *now;

    static int nugrft_once = 0;

    if (stamp <= 0) {

        stamp_str[0] = '\0';

        return;

    }

    if ((now = localtime(&stamp)) == NULL) {

        // Date could not be parsed

        stamp_str[0] = '\0';

        return;

    }

    if (strftime(stamp_str, stamp_str_len, "%c", now) == 0) {

        if (!nugrft_once) {

            g_error(__FILE__ ":%i buffer too small", __LINE__);

            nugrft_once = 1;

        }

    }

}

static gint

sort_folders_func(gconstpointer a, gconstpointer b)

{

    const NNTPGrabFolder *folderA = a;

    const NNTPGrabFolder *folderB = b;

    if (a == NULL) {

        return 1;

    }

    if (b == NULL) {

        return 1;

    }

    return g_strcasecmp(folderA->folder, folderB->folder);

}

/** 

 * Retrieve all the folders which belong to path

 *

 * @param parent        The path whose belonging folders should be looked up. If NULL, all the drive letters will be returned (on Win32) or "/" is returned (*nix/osx)

 * @param folders       Return address for a list containing g_slice_new'ed ConfigFolder structures containing the requested info

 *

 * @return              FALSE when the given parent is invalid

 */

ngboolean

nntpgrab_utils_get_folder_listing(const char *parent, NGList **folders)

{

    GDir *dir;

    const char *filename;

#ifdef WIN32

    char *tmp;

#endif

    g_assert(folders);

    *folders = NULL;

    if (!parent) {

#ifdef WIN32

        DWORD logicalDrives = GetLogicalDrives() << 1;

        int i = 1;

        char driveLetter = 'A';

        while(driveLetter <= 'Z') {

            char *path;

            if(logicalDrives & (int)pow(2,i)) {

                GDir *dir;

                NNTPGrabFolder *folder = g_slice_new0(NNTPGrabFolder);

                path = g_strdup_printf("%c:\\", driveLetter);

#ifdef WIN32

                // Prevent the message 'No disk in drive' by checking via another method if

                // the given path is reachable

                if (!PathFileExistsA(path)) {

                    i++;

                    driveLetter++;

                    g_slice_free(NNTPGrabFolder, folder);

                    g_free(path);

                    continue;

                }

#endif

                dir = g_dir_open(path, 0, NULL);

                folder->has_subfolders = FALSE;

                if (dir) {

                    const char *filename;

                    while ((filename = g_dir_read_name(dir))) {

                        char *path2 = g_build_filename(path, filename, NULL);

                        if (g_file_test(path2, G_FILE_TEST_IS_DIR)) {

                            folder->has_subfolders = TRUE;

                        }

                        g_free(path2);

                    }

                    g_dir_close(dir);

                }

                // Strip the \ character from the path

                path[strlen(path) - 1] = '\0';

                strncpy(folder->folder, path, sizeof(folder->folder) - 1);

                *folders = ng_list_append(*folders, folder);

                g_free(path);

            }

            i++;

            driveLetter++;

        }

        return TRUE;

#else

        NNTPGrabFolder *folder = g_slice_new0(NNTPGrabFolder);

        folder->has_subfolders = TRUE;      // There's no need to test this as there is always a root directory containing subdirectories

        folder->folder[0] = '/';

        folder->folder[1] = '\0';

        *folders = ng_list_append(*folders, folder);

        return TRUE;

#endif

    }

#ifdef WIN32

    if (strlen(parent) == 2) {

        tmp = g_strdup_printf("%s\\", parent);

    } else {

        tmp = g_strdup(parent);

    }

    dir = g_dir_open(tmp, 0, NULL);

    g_free(tmp);

#else

    dir = g_dir_open(parent, 0, NULL);

#endif

    if (!dir) {

        return FALSE;

    }

    while ((filename = g_dir_read_name(dir))) {

        // Is this a directory ?

        char *path = g_build_filename(parent, filename, NULL);

        if (g_file_test(path, G_FILE_TEST_IS_DIR)) {

            GDir *dir2 = g_dir_open(path, 0, NULL);

            if (dir2) {

                NNTPGrabFolder *folder = g_slice_new0(NNTPGrabFolder);

                const char *filename2;

                folder->has_subfolders = FALSE;

                while ((filename2 = g_dir_read_name(dir2))) {

                    char *path2 = g_build_filename(parent, filename, filename2, NULL);

                    if (g_file_test(path2, G_FILE_TEST_IS_DIR)) {

                        folder->has_subfolders = TRUE;

                        g_free(path2);

                        break;

                    }

                    g_free(path2);

                }

                g_dir_close(dir2);

                strncpy(folder->folder, filename, sizeof(folder->folder) - 1);

                *folders = ng_list_append(*folders, folder);

            }

        }

        g_free(path);

    }

    g_dir_close(dir);

    *folders = (NGList*) g_list_sort((GList*) *folders, sort_folders_func);

    return TRUE;

}

void

nntpgrab_utils_free_folder_listing(NGList *folders)

{

    NGList *list = folders;

    while (list) {

        g_slice_free(NNTPGrabFolder, list->data);

        list = ng_list_next(list);

    }

    ng_list_free(folders);

}

void

nntpgrab_utils_sanitize_text(char *text, int length)

{

    char *ptr = text;

    char *end = NULL;

    while (!g_utf8_validate(ptr, length, (const char**) &end)) {

        // Invalid character found, replace it with an ' '

        *end = ' ';

        length = length - (end - ptr) - 1;

        ptr = end + 1;

    }

}

void

nntpgrab_utils_sanitize_collection_name(char *collection_name)

{

    // Strip out any of the following characters from the collection_name: *!"'()/\[] and the tab character

    char *ptr = collection_name;

    while ((ptr = strstr(ptr, "*"))) {

        *ptr = ' ';

        ptr++;

    }

    ptr = collection_name;

    while ((ptr = strstr(ptr, "!"))) {

        *ptr = ' ';

        ptr++;

    }

    ptr = collection_name;

    while ((ptr = strstr(ptr, "\""))) {

        *ptr = ' ';

        ptr++;

    }

    ptr = collection_name;

    while ((ptr = strstr(ptr, "/"))) {

        *ptr = ' ';

        ptr++;

    }

    ptr = collection_name;

    while ((ptr = strstr(ptr, "\\"))) {

        *ptr = ' ';

        ptr++;

    }

    ptr = collection_name;

    while ((ptr = strstr(ptr, "'"))) {

        *ptr = ' ';

        ptr++;

    }

    ptr = collection_name;

    while ((ptr = strstr(ptr, "("))) {

        *ptr = ' ';

        ptr++;

    }

    ptr = collection_name;

    while ((ptr = strstr(ptr, ")"))) {

        *ptr = ' ';

        ptr++;

    }

    ptr = collection_name;

    while ((ptr = strstr(ptr, ":"))) {

        *ptr = ' ';

        ptr++;

    }

    ptr = collection_name;

    while ((ptr = strstr(ptr, "["))) {

        *ptr = ' ';

        ptr++;

    }

    ptr = collection_name;

    while ((ptr = strstr(ptr, "]"))) {

        *ptr = ' ';

        ptr++;

    }

    ptr = collection_name;

    while ((ptr = strstr(ptr, "<"))) {

        *ptr = ' ';

        ptr++;

    }

    ptr = collection_name;

    while ((ptr = strstr(ptr, ">"))) {

        *ptr = ' ';

        ptr++;

    }

    ptr = collection_name;

    while ((ptr = strstr(ptr, "\t"))) {

        *ptr = ' ';

        ptr++;

    }

    // Strip any whitespace at the beginning and end

    g_strstrip(collection_name);

}

void

nntpgrab_utils_strip_nzb_extension(char *filename)

{

    char *tmp;

    tmp = strstr(filename, ".nzb");

    if (tmp) {

        tmp[0] = '\0';

    }

    tmp = strstr(filename, ".NZB");

    if (tmp) {

        tmp[0] = '\0';

    }

}

ngboolean

nntpgrab_utils_extract_par2set_name_from_par2_filename(const char *par2filename, char *par2set, int par2set_length)

{

    static NGRegex *re_par2_filename = NULL;

    const char **values_par2;

    g_return_val_if_fail(par2filename != NULL, FALSE);

    g_return_val_if_fail(par2set != NULL, FALSE);

    g_return_val_if_fail(par2set_length > 0, FALSE);

    if (!re_par2_filename) {

        re_par2_filename = nntpgrab_utils_regex_compile("(.*?)(\\.[vV][oO][lL]\\d+\\+\\d+)?\\.[pP][aA][rR]2$");

    }

    values_par2 = nntpgrab_utils_regex_match(re_par2_filename, par2filename);

    if (!(values_par2 && values_par2[0] && values_par2[1])) {

        if (values_par2) {

            nntpgrab_utils_regex_matches_free(values_par2);

        }

        return FALSE;

    }

    strncpy(par2set, values_par2[1], par2set_length);

    nntpgrab_utils_regex_matches_free(values_par2);

    return TRUE;

}

ngboolean

nntpgrab_utils_test_is_server_already_running(void)

{

    int sock = -1;

    char *str_port;

    struct addrinfo hints, *res, *ressave;

    int n;

    memset(&hints, 0, sizeof(struct addrinfo));

    hints.ai_family = AF_UNSPEC;

    hints.ai_socktype = SOCK_STREAM;

    str_port = g_strdup_printf("%i", 5423);

    n = getaddrinfo("localhost", str_port, &hints, &res);

    g_free(str_port);

    /* If 'localhost' could not be resolved, something is wrong with the user's network configuration */

    if (n < 0) {

        fprintf(stderr,

                "getaddrinfo error:: [%s]\n",

#ifdef WIN32

                WSAGetLastError());

#else

                gai_strerror(n));

#endif

        g_return_val_if_fail(n == 0, FALSE);    /* This always fails */

    }

    ressave = res;

    while (res) {

        sock = socket(res->ai_family, res->ai_socktype, res->ai_protocol);

#ifdef WIN32

        if ((sock == INVALID_SOCKET)) {

#else

        if ((sock == -1)) {

#endif

            // The socket couldn't be created

            res = res->ai_next;

            continue;

        }

        if (connect(sock, res->ai_addr, (int) res->ai_addrlen) == 0) {

            // Connection succesfull

            break;

        }

        CLOSE(sock);

        sock = -1;

        res = res->ai_next;

    }

    if (sock == -1) {

        freeaddrinfo(ressave);

        return FALSE;

    }

    freeaddrinfo(ressave);

    CLOSE(sock);

    return TRUE;

}