python_wrapper_protocol.c

Go to the documentation of this file.

/*
 * Remmina - The GTK+ Remote Desktop Client
 * Copyright (C) 2014-2023 Antenore Gatta, Giovanni Panozzo, Mathias Winterhalter (ToolsDevler)
 *
 * 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., 51 Franklin Street, Fifth Floor,
 * Boston, MA  02110-1301, USA.
 *
 *  In addition, as a special exception, the copyright holders give
 *  permission to link the code of portions of this program with the
 *  OpenSSL library under certain conditions as described in each
 *  individual source file, and distribute linked combinations
 *  including the two.
 *  You must obey the GNU General Public License in all respects
 *  for all of the code used other than OpenSSL. *  If you modify
 *  file(s) with this exception, you may extend this exception to your
 *  version of the file(s), but you are not obligated to do so. *  If you
 *  do not wish to do so, delete this exception statement from your
 *  version. *  If you delete this exception statement from all source
 *  files in the program, then also delete it here.
 */

// I N C L U D E S

#include "python_wrapper_common.h"
#include "python_wrapper_protocol.h"
#include "python_wrapper_remmina.h"

// D E C L A R A T I O N S

// A P I

void python_wrapper_protocol_init(void)
{
    TRACE_CALL(__func__);
}

void remmina_protocol_init_wrapper(RemminaProtocolWidget* gp)
{
    TRACE_CALL(__func__);
    PyPlugin* py_plugin = python_wrapper_get_plugin_by_protocol_widget(gp);
    py_plugin->gp->gp = gp;
    CallPythonMethod(py_plugin->instance, "init", "O", py_plugin->gp);
}

gboolean remmina_protocol_open_connection_wrapper(RemminaProtocolWidget* gp)
{
    TRACE_CALL(__func__);
    PyPlugin* py_plugin = python_wrapper_get_plugin_by_protocol_widget(gp);
    if (py_plugin)
    {
        PyObject* result = CallPythonMethod(py_plugin->instance, "open_connection", "O", py_plugin->gp);
        return result == Py_True;
    }
    else
    {
        return gtk_false();
    }
}

gboolean remmina_protocol_close_connection_wrapper(RemminaProtocolWidget* gp)
{
    TRACE_CALL(__func__);
    PyPlugin* py_plugin = python_wrapper_get_plugin_by_protocol_widget(gp);
    PyObject* result = CallPythonMethod(py_plugin->instance, "close_connection", "O", py_plugin->gp);
    return result == Py_True;
}

gboolean remmina_protocol_query_feature_wrapper(RemminaProtocolWidget* gp,
    const RemminaProtocolFeature* feature)
{
    TRACE_CALL(__func__);
    PyPlugin* py_plugin = python_wrapper_get_plugin_by_protocol_widget(gp);
    PyRemminaProtocolFeature* pyFeature = python_wrapper_protocol_feature_new();
    pyFeature->type = (gint)feature->type;
    pyFeature->id = feature->id;
    pyFeature->opt1 = python_wrapper_generic_new();
    pyFeature->opt1->raw = feature->opt1;
    pyFeature->opt2 = python_wrapper_generic_new();
    pyFeature->opt2->raw = feature->opt2;
    pyFeature->opt3 = python_wrapper_generic_new();
    pyFeature->opt3->raw = feature->opt3;

    PyObject* result = CallPythonMethod(py_plugin->instance, "query_feature", "OO", py_plugin->gp, pyFeature);
    Py_DecRef((PyObject*)pyFeature);
    Py_DecRef((PyObject*)pyFeature->opt1);
    Py_DecRef((PyObject*)pyFeature->opt2);
    Py_DecRef((PyObject*)pyFeature->opt3);
    return result == Py_True;
}

void remmina_protocol_call_feature_wrapper(RemminaProtocolWidget* gp, const RemminaProtocolFeature* feature)
{
    TRACE_CALL(__func__);
    PyPlugin* py_plugin = python_wrapper_get_plugin_by_protocol_widget(gp);
    PyRemminaProtocolFeature* pyFeature = python_wrapper_protocol_feature_new();
    pyFeature->type = (gint)feature->type;
    pyFeature->id = feature->id;
    pyFeature->opt1 = python_wrapper_generic_new();
    pyFeature->opt1->raw = feature->opt1;
    pyFeature->opt1->type_hint = feature->opt1_type_hint;
    pyFeature->opt2 = python_wrapper_generic_new();
    pyFeature->opt2->raw = feature->opt2;
    pyFeature->opt2->type_hint = feature->opt2_type_hint;
    pyFeature->opt3 = python_wrapper_generic_new();
    pyFeature->opt3->raw = feature->opt3;
    pyFeature->opt3->type_hint = feature->opt3_type_hint;

    CallPythonMethod(py_plugin->instance, "call_feature", "OO", py_plugin->gp, pyFeature);
    Py_DecRef((PyObject*)pyFeature);
    Py_DecRef((PyObject*)pyFeature->opt1);
    Py_DecRef((PyObject*)pyFeature->opt2);
    Py_DecRef((PyObject*)pyFeature->opt3);
}

void remmina_protocol_send_keytrokes_wrapper(RemminaProtocolWidget* gp,
    const guint keystrokes[],
    const gint keylen)
{
    TRACE_CALL(__func__);
    PyPlugin* py_plugin = python_wrapper_get_plugin_by_protocol_widget(gp);
    PyObject* obj = PyList_New(keylen);
    Py_IncRef(obj);
    for (int i = 0; i < keylen; ++i)
    {
        PyList_SetItem(obj, i, PyLong_FromLong(keystrokes[i]));
    }
    CallPythonMethod(py_plugin->instance, "send_keystrokes", "OO", py_plugin->gp, obj);
    Py_DecRef(obj);
}

gboolean remmina_protocol_get_plugin_screenshot_wrapper(RemminaProtocolWidget* gp,
    RemminaPluginScreenshotData* rpsd)
{
    TRACE_CALL(__func__);

    PyPlugin* py_plugin = python_wrapper_get_plugin_by_protocol_widget(gp);
    PyRemminaPluginScreenshotData* data = python_wrapper_screenshot_data_new();
    Py_IncRef((PyObject*)data);
    PyObject* result = CallPythonMethod(py_plugin->instance, "get_plugin_screenshot", "OO", py_plugin->gp, data);
    if (result == Py_True)
    {
        if (!PyByteArray_Check((PyObject*)data->buffer))
        {
            g_printerr("Unable to parse screenshot data. 'buffer' needs to be an byte array!");
            return 0;
        }
        Py_ssize_t buffer_len = PyByteArray_Size((PyObject*)data->buffer);

        // Is being freed by Remmina!
        rpsd->buffer = (unsigned char*)python_wrapper_malloc(sizeof(unsigned char) * buffer_len);
        if (!rpsd->buffer)
        {
            return 0;
        }
        memcpy(rpsd->buffer, PyByteArray_AsString((PyObject*)data->buffer), sizeof(unsigned char) * buffer_len);
        rpsd->bytesPerPixel = data->bytesPerPixel;
        rpsd->bitsPerPixel = data->bitsPerPixel;
        rpsd->height = data->height;
        rpsd->width = data->width;
    }
    Py_DecRef((PyObject*)data->buffer);
    Py_DecRef((PyObject*)data);
    return result == Py_True;
}

gboolean remmina_protocol_map_event_wrapper(RemminaProtocolWidget* gp)
{
    PyPlugin* plugin = python_wrapper_get_plugin_by_protocol_widget(gp);
    PyObject* result = CallPythonMethod(plugin->instance, "map_event", "O", plugin->gp);
    return PyBool_Check(result) && result == Py_True;
}

gboolean remmina_protocol_unmap_event_wrapper(RemminaProtocolWidget* gp)
{
    PyPlugin* plugin = python_wrapper_get_plugin_by_protocol_widget(gp);
    PyObject* result = CallPythonMethod(plugin->instance, "unmap_event", "O", plugin->gp);
    return PyBool_Check(result) && result == Py_True;
}

RemminaPlugin* python_wrapper_create_protocol_plugin(PyPlugin* plugin)
{
    PyObject* instance = plugin->instance;

    if (!python_wrapper_check_attribute(instance, ATTR_ICON_NAME_SSH)
        || !python_wrapper_check_attribute(instance, ATTR_ICON_NAME)
        || !python_wrapper_check_attribute(instance, ATTR_FEATURES)
        || !python_wrapper_check_attribute(instance, ATTR_BASIC_SETTINGS)
        || !python_wrapper_check_attribute(instance, ATTR_ADVANCED_SETTINGS)
        || !python_wrapper_check_attribute(instance, ATTR_SSH_SETTING))
    {
        g_printerr("Unable to create protocol plugin. Aborting!\n");
        return NULL;
    }

    RemminaProtocolPlugin* remmina_plugin = (RemminaProtocolPlugin*)python_wrapper_malloc(sizeof(RemminaProtocolPlugin));

    remmina_plugin->type = REMMINA_PLUGIN_TYPE_PROTOCOL;
    remmina_plugin->domain = GETTEXT_PACKAGE;
    remmina_plugin->basic_settings = NULL;
    remmina_plugin->advanced_settings = NULL;
    remmina_plugin->features = NULL;

    remmina_plugin->name = PyUnicode_AsUTF8(PyObject_GetAttrString(instance, ATTR_NAME));
    remmina_plugin->description = PyUnicode_AsUTF8(PyObject_GetAttrString(instance, ATTR_DESCRIPTION));
    remmina_plugin->version = PyUnicode_AsUTF8(PyObject_GetAttrString(instance, ATTR_VERSION));
    remmina_plugin->icon_name = PyUnicode_AsUTF8(PyObject_GetAttrString(instance, ATTR_ICON_NAME));
    remmina_plugin->icon_name_ssh = PyUnicode_AsUTF8(PyObject_GetAttrString(instance, ATTR_ICON_NAME_SSH));

    PyObject* list = PyObject_GetAttrString(instance, "basic_settings");
    Py_ssize_t len = PyList_Size(list);
    if (len)
    {
        RemminaProtocolSetting* basic_settings = (RemminaProtocolSetting*)python_wrapper_malloc(
            sizeof(RemminaProtocolSetting) * (len + 1));
        memset(basic_settings, 0, sizeof(RemminaProtocolSetting) * (len + 1));

        for (Py_ssize_t i = 0; i < len; ++i)
        {
            RemminaProtocolSetting* dest = basic_settings + i;
            python_wrapper_to_protocol_setting(dest, PyList_GetItem(list, i));
        }
        RemminaProtocolSetting* dest = basic_settings + len;
        dest->type = REMMINA_PROTOCOL_SETTING_TYPE_END;
        remmina_plugin->basic_settings = basic_settings;
    }

    list = PyObject_GetAttrString(instance, "advanced_settings");
    len = PyList_Size(list);
    if (len)
    {
        RemminaProtocolSetting* advanced_settings = (RemminaProtocolSetting*)python_wrapper_malloc(
            sizeof(RemminaProtocolSetting) * (len + 1));
        memset(advanced_settings, 0, sizeof(RemminaProtocolSetting) * (len + 1));

        for (Py_ssize_t i = 0; i < len; ++i)
        {
            RemminaProtocolSetting* dest = advanced_settings + i;
            python_wrapper_to_protocol_setting(dest, PyList_GetItem(list, i));
        }

        RemminaProtocolSetting* dest = advanced_settings + len;
        dest->type = REMMINA_PROTOCOL_SETTING_TYPE_END;

        remmina_plugin->advanced_settings = advanced_settings;
    }

    list = PyObject_GetAttrString(instance, "features");
    len = PyList_Size(list);
    if (len)
    {
        RemminaProtocolFeature* features = (RemminaProtocolFeature*)python_wrapper_malloc(
            sizeof(RemminaProtocolFeature) * (len + 1));
        memset(features, 0, sizeof(RemminaProtocolFeature) * (len + 1));

        for (Py_ssize_t i = 0; i < len; ++i)
        {
            RemminaProtocolFeature* dest = features + i;
            python_wrapper_to_protocol_feature(dest, PyList_GetItem(list, i));
        }

        RemminaProtocolFeature* dest = features + len;
        dest->type = REMMINA_PROTOCOL_FEATURE_TYPE_END;

        remmina_plugin->features = features;
    }

    remmina_plugin->ssh_setting = (RemminaProtocolSSHSetting)python_wrapper_get_attribute_long(instance,
        ATTR_SSH_SETTING,
        REMMINA_PROTOCOL_SSH_SETTING_NONE);

    remmina_plugin->init = remmina_protocol_init_wrapper;                             // Plugin initialization
    remmina_plugin->open_connection = remmina_protocol_open_connection_wrapper;       // Plugin open connection
    remmina_plugin->close_connection = remmina_protocol_close_connection_wrapper;     // Plugin close connection
    remmina_plugin->query_feature = remmina_protocol_query_feature_wrapper;           // Query for available features
    remmina_plugin->call_feature = remmina_protocol_call_feature_wrapper;             // Call a feature
    remmina_plugin->send_keystrokes =
        remmina_protocol_send_keytrokes_wrapper;                                      // Send a keystroke
    remmina_plugin->get_plugin_screenshot =
        remmina_protocol_get_plugin_screenshot_wrapper;                               // Screenshot support unavailable

    remmina_plugin->map_event = remmina_protocol_map_event_wrapper;
    remmina_plugin->unmap_event = remmina_protocol_unmap_event_wrapper;

    plugin->protocol_plugin = remmina_plugin;
    plugin->generic_plugin = (RemminaPlugin*)remmina_plugin;

    python_wrapper_add_plugin(plugin);

    return (RemminaPlugin*)remmina_plugin;
}