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 "nntpgrab_utils.h"

HINSTANCE get_hinstance(void);

static HANDLE hMutex = NULL;

static NGOpenNZBCallback internal_open_nzb_callback = NULL;

static NGBringToFrontCallback internal_bring_to_front_callback = NULL;

static void *internal_user_data = NULL;

#define NNTPGRAB_WM_OPEN_NZB        WM_APP + 100

#define NNTPGRAB_WM_BRING_TO_FRONT  WM_APP + 101

ngboolean

nntpgrab_utils_test_is_frontend_already_running(ngboolean *is_running, char **errmsg)

{

    g_return_val_if_fail(is_running != NULL, FALSE);

    if (hMutex) {

        /* We managed to create a mutex for the name so we can assume there is no other NNTPGrab instance running */

        *is_running = FALSE;

        return TRUE;

    }

    if ((hMutex = CreateMutexA(NULL, FALSE, "nntpgrab_is_running"))) {

        DWORD err = GetLastError();

        if (err == ERROR_ALREADY_EXISTS) {

            *is_running = TRUE;

            return TRUE;

        } else if (err != ERROR_SUCCESS) {

            if (errmsg) {

                *errmsg = g_strdup_printf("Error (%u) accessing \"nntpgrab_is_running\" mutex.\n", (UINT) err);

            }

            return FALSE;

        }

    }

    *is_running = FALSE;

    return TRUE;

}

static LRESULT CALLBACK

wndproc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)

{

    g_return_val_if_fail(internal_open_nzb_callback != NULL, DefWindowProcA(hwnd, msg, wparam, lparam));

    if (msg == NNTPGRAB_WM_OPEN_NZB) {

        internal_open_nzb_callback((char *) lparam, internal_user_data);

        return TRUE;

    }

    return DefWindowProcA(hwnd, msg, wparam, lparam);

}

ngboolean

nntpgrab_utils_register_frontend(NGOpenNZBCallback open_nzb_callback, NGBringToFrontCallback bring_to_front_callback, void *user_data, char **errmsg)

{

    ngboolean is_running = FALSE;

    HWND win_hwnd;

    WNDCLASSEX wcx;

    LPCTSTR wname;

    g_return_val_if_fail(open_nzb_callback, FALSE);

    if (!nntpgrab_utils_test_is_frontend_already_running(&is_running, errmsg)) {

        return FALSE;

    }

    if (is_running) {

        if (errmsg) {

            *errmsg = g_strdup(_("An already running NNTPGrab frontend was detected"));

        }

        return FALSE;

    }

    wname = TEXT("NNTPGrabWinCls");

    wcx.cbSize = sizeof(wcx);

    wcx.style = 0;

    wcx.lpfnWndProc = wndproc;

    wcx.cbClsExtra = 0;

    wcx.cbWndExtra = 0;

    wcx.hInstance = /*get_hinstance()*/ NULL;           /* FIXME: get_hinstance() */

    wcx.hIcon = NULL;

    wcx.hCursor = NULL;

    wcx.hbrBackground = NULL;

    wcx.lpszMenuName = NULL;

    wcx.lpszClassName = wname;

    wcx.hIconSm = NULL;

    if (RegisterClassEx(&wcx) == 0) {

        char *last_error_msg = g_win32_error_message(GetLastError());

        *errmsg = g_strdup_printf("RegisterClassEx failed: %s (%u)", last_error_msg, (UINT) GetLastError());

        g_free(last_error_msg);

        return FALSE;

    }

    internal_open_nzb_callback = open_nzb_callback;

    internal_bring_to_front_callback = bring_to_front_callback;

    internal_user_data = user_data;

    /* Create the window */

    if(!(win_hwnd = CreateWindow(wname, TEXT("NNTPGrabWin"), 0, 0, 0, 0, 0, NULL, NULL, /*get_hinstance()*/ NULL, 0))) {        /* FIXME: get_hinstance() */

        char *last_error_msg = g_win32_error_message(GetLastError());

        *errmsg = g_strdup_printf("CreateWindow failed: %s (%u)", last_error_msg, (UINT) GetLastError());

        g_free(last_error_msg);

        return FALSE;

    }

    return TRUE;

}

void

nntpgrab_utils_unregister_frontend(void)

{

    if (hMutex) {

        ReleaseMutex(hMutex);

        hMutex = NULL;

    }

}

ngboolean

ipc_send_msg(UINT msg, const char *nzb_file, char **errmsg)

{

    char *remote_msg;

    HWND msg_win;

    DWORD pid;

    HANDLE process;

    SIZE_T len_written;

    ngboolean ret = TRUE;

    g_return_val_if_fail(nzb_file, FALSE);

    if (!(msg_win = FindWindowEx(NULL, NULL, TEXT("NNTPGrabWinCls"), NULL))) {

        if (errmsg) {

            *errmsg = g_strdup("Unable to find an instance of NNTPGrab to handle protocol message");

        }

        return FALSE;

    }

    GetWindowThreadProcessId(msg_win, &pid);

    if (!(process = OpenProcess(PROCESS_VM_OPERATION | PROCESS_VM_WRITE, FALSE, pid))) {

        if (errmsg) {

            char *last_error_msg = g_win32_error_message(GetLastError());

            *errmsg = g_strdup_printf("Unable to open NNTPGrab process: %s (%u)", last_error_msg, (UINT) GetLastError());

            g_free(last_error_msg);

        }

        return FALSE;

    }

    /* MEM_COMMIT initializes the memory to zero, 

     * so we don't need to worry that our section of tmp1 isn't nul-terminated */

    if ((remote_msg = (char*) VirtualAllocEx(process, NULL, strlen(nzb_file) + 1, MEM_COMMIT, PAGE_READWRITE))) {

        if (WriteProcessMemory(process, remote_msg, nzb_file, strlen(nzb_file), &len_written)) {

            if (!SendMessageA(msg_win, msg, len_written, (LPARAM) remote_msg)) {

                if (errmsg) {

                    char *last_error_msg = g_win32_error_message(GetLastError());

                    *errmsg = g_strdup_printf("Unable to send protocol message to NNTPGrab instance: %s (%u)", last_error_msg, (UINT) GetLastError());

                    g_free(last_error_msg);

                }

                ret = FALSE;

            }

        } else {

            if (errmsg) {

                char *last_error_msg = g_win32_error_message(GetLastError());

                *errmsg = g_strdup_printf("Unable to write to remote memory: %s (%u)", last_error_msg, (UINT) GetLastError());

                g_free(last_error_msg);

            }

            ret = FALSE;

        }

        VirtualFreeEx(process, remote_msg, 0, MEM_RELEASE);

    } else {

        if (errmsg) {

            char *last_error_msg = g_win32_error_message(GetLastError());

            *errmsg = g_strdup_printf("Unable to allocate remote memory: %s (%u)", last_error_msg, (UINT) GetLastError());

        }

        ret = FALSE;

    }

    CloseHandle(process);

    return ret;

}

ngboolean

nntpgrab_utils_send_open_nzb_file_request(const char *nzb_file, char **errmsg)

{

    return ipc_send_msg(NNTPGRAB_WM_OPEN_NZB, nzb_file, errmsg);

}

ngboolean

nntpgrab_utils_send_bring_to_front_request(char **errmsg)

{

    return ipc_send_msg(NNTPGRAB_WM_BRING_TO_FRONT, "", errmsg);

}