Исправления для CMake

freerdp/client/X11/cli/address.c

@@ -0,0 +1,29 @@
+/*
+ * address.c
+ *
+ *  Created on: 15 июл. 2022 г.
+ *      Author: alexander
+ */
+
+#include "address.h"
+
+#include <netdb.h>
+#include <arpa/inet.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <stdio.h>
+
+char *getHostIP(char *dnsName)
+{
+    char *result = NULL;
+    struct hostent *he = gethostbyname(dnsName);
+    if (he)
+    {
+        char *ip = inet_ntoa(*(struct in_addr*)he->h_addr);
+        size_t size = strlen(ip) + 1;
+        result = (char *)malloc(sizeof(char) * size);
+        strncpy(result, ip, size);
+    }
+    return result;
+}

freerdp/client/X11/cli/address.h

@@ -0,0 +1,13 @@
+/*
+ * address.h
+ *
+ *  Created on: 15 июл. 2022 г.
+ *      Author: alexander
+ */
+
+#ifndef ADDRESS_H_
+#define ADDRESS_H_
+
+char *getHostIP(char *dnsName);
+
+#endif /* ADDRESS_H_ */

freerdp/client/X11/cli/arguments.c

@@ -0,0 +1,61 @@
+/*
+ * arguments.c
+ *
+ *  Created on: 6 июл. 2022 г.
+ *      Author: alexander
+ */
+
+#include <stdlib.h>
+#include "arguments.h"
+#include "node_settings.h"
+#include "concat.h"
+
+#include "rxrandr.h"
+#include "db.h"
+#include "monitor.h"
+
+void settingsLoad(char *pathDB)
+{
+    getPathDB(pathDB);
+
+    dbLoadData();
+
+    Monitors *monitors = loadMonitors();
+    for (size_t i = 0; i < monitors->size; ++i)
+    {
+        addParameterValue(PARAMETER_MONITORS, i, monitors->monitor[i]->data[3], !i);
+    }
+
+    dbFreeMonitors(monitors);
+}
+
+void settingsFree()
+{
+    freeSettings();
+}
+
+void buildArguments(Arguments *args)
+{
+    args->argc = 0;
+    args->argv = (char **)malloc(sizeof(char *) * settings.countParameterSet);
+
+    for (NodeParameter *head = settings.parameter; head; head = head->next)
+    {
+        if (head->set)
+        {
+            if (head->value)
+                args->argv[(args->argc)++] = concat(head->key, getSetNodeValue(head)->current);
+            else
+                args->argv[(args->argc)++] = concat(head->key, NULL);
+        }
+    }
+}
+
+void freeArguments(Arguments *args)
+{
+    for (int i = 0; i < args->argc; ++i)
+    {
+        free(args->argv[i]);
+    }
+    free(args->argv);
+}

freerdp/client/X11/cli/arguments.h

@@ -0,0 +1,23 @@
+/*
+ * arguments.h
+ *
+ *  Created on: 6 июл. 2022 г.
+ *      Author: alexander
+ */
+
+#ifndef ARGUMENTS_H_
+#define ARGUMENTS_H_
+
+typedef struct
+{
+    int argc;
+    char **argv;
+} Arguments;
+
+void buildArguments(Arguments *args);
+void freeArguments(Arguments *args);
+
+void settingsLoad(char *pathDB);
+void settingsFree();
+
+#endif /* ARGUMENTS_H_ */

freerdp/client/X11/cli/concat.c

@@ -0,0 +1,37 @@
+/*
+ * concat.c
+ *
+ *  Created on: 6 июл. 2022 г.
+ *      Author: alexander
+ */
+
+#include "concat.h"
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+char* concat(char *s1, char *s2)
+{
+    size_t len1 = s1 ? strlen(s1) : 0;
+    size_t len2 = s2 ? strlen(s2) : 0;
+
+    char *result = (char *)malloc(sizeof(char) * (len1 + len2 + 1));
+
+    if (!result)
+    {
+        fprintf(stderr, "malloc() failed: insufficient memory!\n");
+        return NULL;
+    }
+
+    if (s1)
+    {
+        strncpy(result, s1, (len1 + 1));
+    }
+    if (s2)
+    {
+        strncpy(result + len1, s2, (len2 + 1));
+    }
+
+    return result;
+}

freerdp/client/X11/cli/concat.h

@@ -0,0 +1,13 @@
+/*
+ * concat.h
+ *
+ *  Created on: 6 июл. 2022 г.
+ *      Author: alexander
+ */
+
+#ifndef CONCAT_H_
+#define CONCAT_H_
+
+char* concat(char *s1, char *s2);
+
+#endif /* CONCAT_H_ */

freerdp/client/X11/cli/db.c

@@ -0,0 +1,602 @@
+/*
+ * db.c
+ *
+ *  Created on: 13 июл. 2022 г.
+ *      Author: alexander
+ */
+
+#include "sqlite3.h"
+//#include <sqlite3.h>
+#include <stdio.h>
+#include <string.h>
+#include <time.h>
+
+#include "db.h"
+#include "node_settings.h"
+
+char* getPathDB(char *path)
+{
+    static char *current = NULL;
+    if (path && !current)
+    {
+        current = path;
+    }
+
+    return current;
+}
+
+static sqlite3* dbGetBase(char *path)
+{
+    sqlite3 *db = NULL;
+
+    if (sqlite3_open(path, &db) != SQLITE_OK)
+    {
+        fprintf(stderr, "Cannot open database: %s\n", sqlite3_errmsg(db));
+        sqlite3_close(db);
+
+        return NULL;
+    }
+
+    return db;
+}
+
+/*
+ * 0 - parameter
+ * 1 - key
+ * 2 - set_key
+ * 3 - single
+ * 4 - value
+ * 5 - current (data)
+ * 6 - set_val
+ * 7 - dependence
+ * 8 - conflict
+ */
+static int dbLoad(void *NotUsed, int argc, char **argv, char **azColName)
+{
+    if (!getParameter(atoi(argv[0])))
+    {
+        addParameterKey(atoi(argv[0]), argv[1], atoi(argv[2]), atoi(argv[3]),
+                (argv[7] ? getParameter(atoi(argv[7])) : NULL),
+                (argv[8] ? getParameter(atoi(argv[8])) : NULL));
+    }
+
+    if (argv[4] && argv[5])
+    {
+        addParameterValue(atoi(argv[0]), atoi(argv[4]), argv[5], atoi(argv[6]));
+    }
+
+    return 0;
+}
+
+bool dbLoadData()
+{
+    sqlite3 *db = dbGetBase(getPathDB(NULL));
+    if (!db)
+    {
+        return false;
+    }
+
+    char *err_msg = 0;
+    char *sql =
+            "SELECT `parameters`.`id` as `parameter`, `parameters`.`data` as `key`, `parameters`.`set` as `set_key`, `parameters`.`single` as `single`, `values`.`id` as `value`, `values`.`data` as `current`, `values`.`set` as `set_val`,`dependencies`.`dependence` as `dependence`, `conflicts`.`conflict` as `conflict` \
+                FROM `parameters` as `parameters` \
+                LEFT JOIN `arguments` as `arguments` ON `parameters`.`id` = `arguments`.`parameter` \
+                LEFT JOIN `values` as `values` ON `arguments`.`value` = `values`.`id` \
+                LEFT JOIN `dependencies` as `dependencies` ON `dependencies`.`parameter` = `parameters`.`id` \
+                LEFT JOIN `conflicts` as `conflicts` ON `conflicts`.`parameter` = `parameters`.`id`";
+
+    if (sqlite3_exec(db, sql, dbLoad, 0, &err_msg) != SQLITE_OK)
+    {
+        fprintf(stderr, "Ошибка выполнения запроса: %s\n", err_msg);
+        sqlite3_free(err_msg);
+        sqlite3_close(db);
+        return false;
+    }
+
+    sqlite3_close(db);
+
+    return true;
+}
+
+static int dbCreateHostsList(void *answer, int argc, char **argv, char **azColName)
+{
+    Hosts *hosts = *(Hosts**) answer;
+    Host *host = (Host*) malloc(sizeof(Host));
+    host->data = (char**) malloc(sizeof(char*) * argc);
+    host->size = argc;
+
+    for (int i = 0; i < argc; i++)
+    {
+        size_t size = strlen(argv[i]) + 1;
+        host->data[i] = (char*) malloc(sizeof(char) * size);
+        strncpy(host->data[i], argv[i], size);
+    }
+
+    Host **tmp = hosts->host;
+    hosts->host = (Host**) malloc(sizeof(Host*) * ++hosts->size);
+    for (size_t i = 0; i < hosts->size - 1; ++i)
+    {
+        hosts->host[i] = tmp[i];
+    }
+    if (tmp)
+    {
+        free(tmp);
+    }
+    hosts->host[hosts->size - 1] = host;
+
+    return 0;
+}
+
+Hosts* dbGetHostsList()
+{
+    sqlite3 *db = dbGetBase(getPathDB(NULL));
+    if (!db)
+    {
+        return false;
+    }
+
+    char *err_msg = 0;
+    char *sql = "SELECT ROW_NUMBER () OVER (ORDER BY `hosts`.`ip`) `item`, `hosts`.`dns` as `dns`, `hosts`.`set` as `set` FROM `hosts` as `hosts`";
+    Hosts *hosts = (Hosts*) malloc(sizeof(Hosts));
+    hosts->size = 0;
+    hosts->host = NULL;
+
+    if (sqlite3_exec(db, sql, dbCreateHostsList, &hosts, &err_msg) != SQLITE_OK)
+    {
+        fprintf(stderr, "Ошибка выполнения запроса: %s\n", err_msg);
+        sqlite3_free(err_msg);
+        sqlite3_close(db);
+        exit(-1);
+    }
+    sqlite3_close(db);
+    return hosts;
+}
+
+void dbFreeHosts(Hosts *hosts)
+{
+    for (size_t i = 0; i < hosts->size; ++i)
+    {
+        for (size_t j = 0; j < hosts->host[i]->size; ++j)
+        {
+            free(hosts->host[i]->data[j]);
+        }
+        free(hosts->host[i]->data);
+        free(hosts->host[i]);
+    }
+    free(hosts);
+}
+
+bool dbWriteParameter(Parameter name, bool set)
+{
+    sqlite3 *db = dbGetBase(getPathDB(NULL));
+    if (!db)
+    {
+        return false;
+    }
+
+    sqlite3_stmt *res;
+    char *sql = "UPDATE `parameters` set `set` = ? where id = ?";
+
+    if (sqlite3_prepare_v2(db, sql, -1, &res, 0) == SQLITE_OK)
+    {
+        sqlite3_bind_int(res, 1, set);
+        sqlite3_bind_int(res, 2, name);
+    }
+
+    if (sqlite3_step(res) == SQLITE_BUSY)
+    {
+        fprintf(stderr, "[ЗАНЯТО] %s - \"%s\"\n", set ? "включено" : "выключено", getParameter(name)->key);
+    }
+    if (sqlite3_step(res) == SQLITE_ERROR)
+    {
+        fprintf(stderr, "[ОШИБКА] %s - \"%s\"\n", set ? "включено" : "выключено", getParameter(name)->key);
+    }
+    if (sqlite3_step(res) == SQLITE_DONE)
+    {
+        fprintf(stdout, "[УСПЕШНО] %s - \"%s\"\n", set ? "включено" : "выключено", getParameter(name)->key);
+    }
+
+    sqlite3_finalize(res);
+    sqlite3_close(db);
+
+    return true;
+}
+
+bool dbWriteValue(Value name, bool set)
+{
+    sqlite3 *db = dbGetBase(getPathDB(NULL));
+    if (!db)
+    {
+        return false;
+    }
+
+    sqlite3_stmt *res;
+    char *sql = "UPDATE `values` set `set` = ? where id = ?";
+
+    if (sqlite3_prepare_v2(db, sql, -1, &res, 0) == SQLITE_OK)
+    {
+        sqlite3_bind_int(res, 1, set);
+        sqlite3_bind_int(res, 2, name);
+    }
+
+    if (sqlite3_step(res) == SQLITE_BUSY)
+    {
+        fprintf(stderr, "[ЗАНЯТО] %s - \"%s\"\n", set ? "включено" : "выключено", getValue(name)->current);
+    }
+    if (sqlite3_step(res) == SQLITE_ERROR)
+    {
+        fprintf(stderr, "[ОШИБКА] %s - \"%s\"\n", set ? "включено" : "выключено", getValue(name)->current);
+    }
+    if (sqlite3_step(res) == SQLITE_DONE)
+    {
+        fprintf(stdout, "[УСПЕШНО] %s - \"%s\"\n", set ? "включено" : "выключено", getValue(name)->current);
+    }
+
+    sqlite3_finalize(res);
+    sqlite3_close(db);
+
+    return true;
+}
+
+int dbAddServer(char *ip, char *dns)
+{
+    int result = 0;
+
+    if (!(ip && strlen(ip) && dns && strlen(dns)))
+        return -1;
+
+    sqlite3 *db = dbGetBase(getPathDB(NULL));
+    if (!db)
+    {
+        return -2;
+    }
+
+    sqlite3_stmt *res;
+    char *sql = "SELECT * FROM `hosts` WHERE `ip` = ? OR `dns` = ?";
+    if (sqlite3_prepare_v2(db, sql, -1, &res, 0) == SQLITE_OK)
+    {
+        sqlite3_bind_text(res, 1, ip, -1, 0);
+        sqlite3_bind_text(res, 2, dns, -1, 0);
+    }
+    else
+    {
+        sqlite3_finalize(res);
+        sqlite3_close(db);
+        return -3;
+    }
+
+    if (sqlite3_step(res) == SQLITE_ROW)
+    {
+        int id = atoi((const char*) sqlite3_column_text(res, 0));
+        sqlite3_finalize(res);
+
+        sql = "UPDATE `hosts` set `set` = 0";
+        if (sqlite3_exec(db, sql, NULL, NULL, NULL) == SQLITE_OK)
+        {
+            sql = "UPDATE `hosts` set `dns` = ?, `ip` = ?, `set` = 1 where id = ?";
+
+            if (sqlite3_prepare_v2(db, sql, -1, &res, 0) == SQLITE_OK)
+            {
+                sqlite3_bind_text(res, 1, dns, -1, 0);
+                sqlite3_bind_text(res, 2, ip, -1, 0);
+                sqlite3_bind_int(res, 3, id);
+            }
+
+            if (sqlite3_step(res) == SQLITE_BUSY)
+            {
+                fprintf(stderr, "[ЗАНЯТО] %s - \"%s\"\n", dns ? "установлено" : "очищено", ip);
+                result = 5;
+            }
+            if (sqlite3_step(res) == SQLITE_ERROR)
+            {
+                fprintf(stderr, "[ОШИБКА] %s - \"%s\"\n", dns ? "установлено" : "очищено", ip);
+                result = 4;
+            }
+            if (sqlite3_step(res) == SQLITE_DONE)
+            {
+                fprintf(stdout, "[УСПЕШНО] %s - \"%s\"\n", dns ? "установлено" : "очищено", ip);
+                result = 3;
+            }
+        }
+        else
+        {
+            result = -5;
+        }
+    }
+    else if (sqlite3_step(res) == SQLITE_DONE)
+    {
+        sqlite3_finalize(res);
+
+        sql = "UPDATE `hosts` set `set` = 0";
+        if (sqlite3_exec(db, sql, NULL, NULL, NULL) == SQLITE_OK)
+        {
+            sql = "INSERT INTO `hosts` (`ip`, `dns`, `set`) VALUES (?, ?, 1)";
+            if (sqlite3_prepare_v2(db, sql, -1, &res, 0) == SQLITE_OK)
+            {
+                sqlite3_bind_text(res, 1, ip, -1, 0);
+                sqlite3_bind_text(res, 2, dns, -1, 0);
+            }
+
+            if (sqlite3_step(res) == SQLITE_BUSY)
+            {
+                fprintf(stderr, "[ЗАНЯТО] %s - \"%s\"\n", dns ? "установлено" : "очищено", ip);
+                result = 2;
+            }
+            if (sqlite3_step(res) == SQLITE_ERROR)
+            {
+                fprintf(stderr, "[ОШИБКА] %s - \"%s\"\n", dns ? "установлено" : "очищено", ip);
+                result = 1;
+            }
+            if (sqlite3_step(res) == SQLITE_DONE)
+            {
+                fprintf(stdout, "[УСПЕШНО] %s - \"%s\"\n", dns ? "установлено" : "очищено", ip);
+                result = 0;
+            }
+        }
+        else
+        {
+            result = -6;
+        }
+    }
+    else
+    {
+        result = -4;
+    }
+
+    sqlite3_finalize(res);
+    sqlite3_close(db);
+
+    return result;
+}
+
+bool dbSetUserNameCurrent(char *current)
+{
+    sqlite3 *db = dbGetBase(getPathDB(NULL));
+    if (!db)
+    {
+        return false;
+    }
+
+    char *text = strlen(current) ? current : NULL;
+    sqlite3_stmt *res;
+    char *sql = "UPDATE `values` set `data` = ?, `set` = ? where id = ?";
+
+    if (sqlite3_prepare_v2(db, sql, -1, &res, 0) == SQLITE_OK)
+    {
+        sqlite3_bind_text(res, 1, text, -1, 0);
+        sqlite3_bind_int(res, 2, text ? true : false);
+        sqlite3_bind_int(res, 3, VALUE_USERNAME);
+    }
+
+    if (sqlite3_step(res) == SQLITE_BUSY)
+    {
+        fprintf(stderr, "[ЗАНЯТО] %s - \"%s\"\n", text ? "установлено" : "очищено", text ? getValue(VALUE_USERNAME)->current : "");
+    }
+    if (sqlite3_step(res) == SQLITE_ERROR)
+    {
+        fprintf(stderr, "[ОШИБКА] %s - \"%s\"\n", text ? "установлено" : "очищено", text ? getValue(VALUE_USERNAME)->current : "");
+    }
+    if (sqlite3_step(res) == SQLITE_DONE)
+    {
+        fprintf(stdout, "[УСПЕШНО] %s - \"%s\"\n", text ? "установлено" : "очищено", text ? getValue(VALUE_USERNAME)->current : "");
+    }
+
+    sqlite3_finalize(res);
+    sqlite3_close(db);
+
+    return true;
+}
+
+static int dbCreateMonitorsList(void *answer, int argc, char **argv, char **azColName)
+{
+    Monitors *monitors = *(Monitors**) answer;
+    Monitor *monitor = (Monitor*) malloc(sizeof(Monitor));
+    monitor->data = (char**) malloc(sizeof(char*) * argc);
+    monitor->size = argc;
+
+    for (int i = 0; i < argc; i++)
+    {
+        size_t size = strlen(argv[i]) + 1;
+        monitor->data[i] = (char*) malloc(sizeof(char) * size);
+        strncpy(monitor->data[i], argv[i], size);
+    }
+
+    Monitor **tmp = monitors->monitor;
+    monitors->monitor = (Monitor**) malloc(sizeof(Monitor*) * ++monitors->size);
+    for (size_t i = 0; i < monitors->size - 1; ++i)
+    {
+        monitors->monitor[i] = tmp[i];
+    }
+    if (tmp)
+    {
+        free(tmp);
+    }
+    monitors->monitor[monitors->size - 1] = monitor;
+
+    return 0;
+}
+
+Monitors* dbGetMonitorsList()
+{
+    sqlite3 *db = dbGetBase(getPathDB(NULL));
+    if (!db)
+    {
+        exit(-1);
+    }
+
+    char *err_msg = 0;
+    char *sql =
+            "SELECT ROW_NUMBER () OVER (ORDER BY `monitors`.`set` DESC) `item`, `monitors`.`name` as `name`, `monitors`.`set` as `set`, (ROW_NUMBER () OVER (ORDER BY `monitors`.`id`)) - 1 `item` FROM `monitors` as `monitors`";
+
+    Monitors *monitors = (Monitors*) malloc(sizeof(Monitors));
+    monitors->size = 0;
+    monitors->monitor = NULL;
+
+    if (sqlite3_exec(db, sql, dbCreateMonitorsList, &monitors, &err_msg) != SQLITE_OK)
+    {
+        fprintf(stderr, "Получение списка мониторов. Ошибка выполнения запроса: %s\n", err_msg);
+        sqlite3_free(err_msg);
+        sqlite3_close(db);
+        exit(-2);
+    }
+
+    sqlite3_close(db);
+
+    return monitors;
+}
+
+void dbFreeMonitors(Monitors *monitors)
+{
+    for (size_t i = 0; i < monitors->size; ++i)
+    {
+        for (size_t j = 0; j < monitors->monitor[i]->size; ++j)
+        {
+            free(monitors->monitor[i]->data[j]);
+        }
+        free(monitors->monitor[i]->data);
+        free(monitors->monitor[i]);
+    }
+    free(monitors);
+}
+
+bool deleteAllMonitors()
+{
+    sqlite3 *db = dbGetBase(getPathDB(NULL));
+    if (!db)
+    {
+        return false;
+    }
+
+    bool result = false;
+    char *sql = "DELETE FROM `monitors`";
+
+    if (sqlite3_exec(db, sql, NULL, NULL, NULL) == SQLITE_OK)
+    {
+        result = true;
+    }
+
+    sqlite3_close(db);
+
+    return result;
+}
+
+int dbAddMonitor(char *monitor, bool set)
+{
+    if (!(monitor && strlen(monitor)))
+        return -1;
+
+    sqlite3 *db = dbGetBase(getPathDB(NULL));
+    if (!db)
+    {
+        return -2;
+    }
+
+    sqlite3_stmt *res;
+    char *sql = "INSERT INTO `monitors` (`name`, `set`) VALUES (?, ?)";
+    if (sqlite3_prepare_v2(db, sql, -1, &res, 0) == SQLITE_OK)
+    {
+        sqlite3_bind_text(res, 1, monitor, -1, 0);
+        sqlite3_bind_int(res, 2, set);
+    }
+
+//    if (sqlite3_step(res) == SQLITE_BUSY)
+//    {
+//        fprintf(stderr, "[ЗАНЯТО] %s - \"%s\"\n", text ? "установлено" : "очищено", text ? getValue(VALUE_USERNAME)->current : "");
+//    }
+//    if (sqlite3_step(res) == SQLITE_ERROR)
+//    {
+//        fprintf(stderr, "[ОШИБКА] %s - \"%s\"\n", text ? "установлено" : "очищено", text ? getValue(VALUE_USERNAME)->current : "");
+//    }
+    if (sqlite3_step(res) == SQLITE_DONE)
+    {
+        fprintf(stdout, "[УСПЕШНО] %s - \"%s\"\n", monitor ? "установлено" : "очищено", monitor ? monitor : "");
+        return 0;
+    }
+
+    sqlite3_finalize(res);
+    sqlite3_close(db);
+
+    return -3;
+}
+
+int dbSaveMonitors(char *name)
+{
+    int result = 0;
+
+    if (!(name && strlen(name)))
+        return -1;
+
+    sqlite3 *db = dbGetBase(getPathDB(NULL));
+    if (!db)
+    {
+        return -2;
+    }
+
+    char *sql = "UPDATE `monitors` set `set` = 0";
+    if (sqlite3_exec(db, sql, NULL, NULL, NULL) == SQLITE_OK)
+    {
+        sqlite3_stmt *res;
+        sql = "UPDATE `monitors` SET `set` = 1 WHERE `name` = ?";
+        if (sqlite3_prepare_v2(db, sql, -1, &res, 0) == SQLITE_OK)
+        {
+            sqlite3_bind_text(res, 1, name, -1, 0);
+        }
+
+        if (sqlite3_step(res) == SQLITE_BUSY)
+        {
+            fprintf(stderr, "[ЗАНЯТО] %s - \"%s\"\n", name ? "установлено" : "очищено", name);
+            result = 2;
+        }
+        if (sqlite3_step(res) == SQLITE_ERROR)
+        {
+            fprintf(stderr, "[ОШИБКА] %s - \"%s\"\n", name ? "установлено" : "очищено", name);
+            result = 1;
+        }
+        if (sqlite3_step(res) == SQLITE_DONE)
+        {
+            fprintf(stdout, "[УСПЕШНО] %s - \"%s\"\n", name ? "установлено" : "очищено", name);
+            result = 0;
+        }
+        sqlite3_finalize(res);
+    }
+
+    sqlite3_close(db);
+
+    return result;
+}
+
+int dbInsertHistory(char *login, char *host)
+{
+    int result = 0;
+
+    if (!(login && strlen(login)) || !(host && strlen(host)))
+        return -1;
+
+    sqlite3 *db = dbGetBase(getPathDB(NULL));
+
+    if (!db)
+    {
+        return -2;
+    }
+
+    sqlite3_stmt *res;
+    char *sql = "INSERT INTO `history` (`login`, `host`, `time`) VALUES (?, ?, ?)";
+    if (sqlite3_prepare_v2(db, sql, -1, &res, 0) == SQLITE_OK)
+    {
+        sqlite3_bind_text(res, 1, login, -1, 0);
+        sqlite3_bind_text(res, 2, host, -1, 0);
+        sqlite3_bind_int(res, 3, (unsigned)time(NULL));
+    }
+
+    if (sqlite3_step(res) == SQLITE_DONE)
+    {
+        sqlite3_finalize(res);
+        sqlite3_close(db);
+        return 0;
+    }
+
+    sqlite3_finalize(res);
+    sqlite3_close(db);
+
+    return result;
+}

freerdp/client/X11/cli/db.h

@@ -0,0 +1,57 @@
+/*
+ * db.h
+ *
+ *  Created on: 13 июл. 2022 г.
+ *      Author: alexander
+ */
+
+#ifndef DB_H_
+#define DB_H_
+
+#include <stdlib.h>
+#include <stdbool.h>
+
+#include "parameter.h"
+#include "value.h"
+
+typedef struct Host
+{
+    char **data;
+    size_t size;
+} Host;
+
+typedef struct Hosts
+{
+    Host **host;
+    size_t size;
+} Hosts;
+
+typedef struct Monitor
+{
+    char **data;
+    size_t size;
+} Monitor;
+
+typedef struct Monitors
+{
+    Monitor **monitor;
+    size_t size;
+} Monitors;
+
+char *getPathDB(char *path);
+
+bool dbLoadData();
+Hosts *dbGetHostsList();
+void dbFreeHosts(Hosts *hosts);
+Monitors *dbGetMonitorsList();
+void dbFreeMonitors(Monitors *monitors);
+bool deleteAllMonitors();
+int dbAddMonitor(char *monitor, bool set);
+int dbSaveMonitors(char *name);
+bool dbWriteParameter(Parameter name, bool set);
+bool dbWriteValue(Value name, bool set);
+bool dbSetUserNameCurrent(char *current);
+int dbAddServer(char *ip, char *dns);
+int dbInsertHistory(char *login, char *host);
+
+#endif /* DB_H_ */

freerdp/client/X11/cli/gui.c

@@ -0,0 +1,234 @@
+/*
+ * gui.c
+ *
+ *  Created on: 6 июл. 2022 г.
+ *      Author: alexander
+ */
+
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "gui.h"
+#include "settings.h"
+#include "node_settings.h"
+#include "images.h"
+#include "arguments.h"
+#include "address.h"
+
+#include "db.h"
+#include "xrdp.h"
+#include "../xfreerdp.h"
+
+static int guiExit(Ihandle *self)
+{
+    return IUP_CLOSE;
+}
+
+int isEmptyFieldServerUser(Ihandle *self)
+{
+    char *name = IupGetAttribute(self, "NAME");
+    if (!strcmp(name, "SERVER"))
+        return !strcmp(IupGetAttribute(IupGetDialogChild(self, "USER"), "LINEVALUE"), "\0");
+    else
+        return !strcmp(IupGetAttribute(IupGetDialogChild(self, "SERVER"), "VALUE"), "\0");
+}
+
+static int activeBtnConnect(Ihandle *self, int c, char *value)
+{
+    if (!strcmp(value, "\0") || isEmptyFieldServerUser(self))
+    {
+        IupSetInt(IupGetDialogChild(self, "CONNECT"), "ACTIVE", 0);
+#ifdef WITH_COLOR_BUTTONS
+        IupSetAttribute(IupGetDialogChild(self, "CONNECT"), "BGCOLOR", "49 54 61");
+        IupSetAttribute(IupGetDialogChild(self, "CONNECT"), "FGCOLOR", "238 238 238");
+#endif
+    }
+    else
+    {
+        IupSetInt(IupGetDialogChild(self, "CONNECT"), "ACTIVE", 1);
+#ifdef WITH_COLOR_BUTTONS
+        IupSetAttribute(IupGetDialogChild(self, "CONNECT"), "BGCOLOR", "0 179 0");
+        IupSetAttribute(IupGetDialogChild(self, "CONNECT"), "FGCOLOR", "255 255 255");
+#endif
+    }
+    return IUP_DEFAULT;
+}
+
+static int guiConnect(Ihandle *self)
+{
+    char *host = IupGetAttribute(IupGetDialogChild(self, "SERVER"), "VALUE");
+    char *result = getHostIP(host);
+
+    if (!result)
+        return IUP_IGNORE;
+
+    char *login = IupGetAttribute(IupGetDialogChild(self, "USER"), "LINEVALUE");
+
+    if (!strcmp(login, "\0"))
+        return IUP_IGNORE;
+
+    setParameterValue(PARAMETER_SERVER, VALUE_SERVER, result);
+    setParameterValue(PARAMETER_USERNAME, VALUE_USERNAME, login);
+    setParameterValue(PARAMETER_PASSWORD, VALUE_PASSWORD, IupGetAttribute(IupGetDialogChild(self, "PASSWORD"), "LINEVALUE"));
+
+    Arguments args;
+    buildArguments(&args);
+    for (int i = 0; i < args.argc; ++i)
+    {
+        printf("%s\n", args.argv[i]);
+    }
+
+    enum XF_EXIT_CODE xCode = free_rdp_connect(args.argc, args.argv);
+
+    if (!(xCode == XF_EXIT_DNS_NAME_NOT_FOUND || xCode == XF_EXIT_CONNECT_FAILED || xCode == XF_EXIT_TLS_CONNECT_FAILED))
+    {
+        IupSetAttribute(IupGetDialogChild(self, "PASSWORD"), "VALUE", "");
+
+        if (!dbAddServer(result, host))
+        {
+            dbInsertHistory(login, host);
+            IupSetAttribute(IupGetDialogChild(self, "SERVER"), "APPENDITEM", host);
+        }
+        dbSetUserNameCurrent(login);
+    }
+
+    freeArguments(&args);
+
+    return IUP_DEFAULT;
+}
+
+static void createHostsList(Ihandle *iupList)
+{
+    Hosts *hosts = dbGetHostsList();
+    char *indexItem = NULL;
+    char *serverName = NULL;
+
+    for (size_t i = 0; i < hosts->size; ++i)
+    {
+        Host *host = hosts->host[i];
+        size_t size = strlen(host->data[0]) + 1;
+        indexItem = (char *)malloc(sizeof(char) * size);
+        strncpy(indexItem, host->data[0], size);
+        size = strlen(host->data[1]) + 1;
+        serverName = (char *)malloc(sizeof(char) * size);
+        strncpy(serverName, host->data[1], size);
+
+        IupSetAttribute(iupList, indexItem, serverName);
+        if (atoi(host->data[2]))
+            IupSetAttribute(iupList, "VALUE", serverName);
+    }
+    dbFreeHosts(hosts);
+}
+
+Ihandle* guiStart()
+{
+    Ihandle *dlg;
+    Ihandle *icon, *bgHead;
+    Ihandle *vBoxMain, *hBoxServer, *hBoxUser, *hBoxPassword, *hBoxButtons;  // Boxes
+    Ihandle *labelImage;
+    Ihandle *labelServer, *inputServer;
+    Ihandle *labelUser, *inputUser;
+    Ihandle *labelPassword, *inputPassword;
+    Ihandle *btnConnect, *btnClose, *btnSettings;
+
+    icon = IupImageRGBA(64, 64, idata_icon);
+    IupSetHandle("icon", icon);
+
+    labelImage = IupLabel(NULL);
+
+    bgHead = IupImageRGBA(405, 72, idata_head);
+    IupSetAttributeHandle(labelImage, "IMAGE", bgHead);
+
+    labelServer = IupLabel("Компьютер:");
+    IupSetAttribute(labelServer, "SIZE", "80x16");
+    IupSetAttribute(labelServer, "ALIGNMENT", "ARIGHT:ACENTER");
+    IupSetAttribute(labelServer, "PADDING", "5");
+
+    inputServer = IupList(NULL);
+    IupSetAttribute(inputServer, "NAME", "SERVER");
+    IupSetAttribute(inputServer, "TIP", "IP-адрес или имя удаленного сервера\n(обязательное для заполнения поле)");
+    createHostsList(inputServer);
+    IupSetAttribute(inputServer, "SIZE", "100");
+    IupSetAttribute(inputServer, "EDITBOX", "YES");
+    IupSetAttribute(inputServer, "DROPDOWN", "YES");
+    IupSetAttribute(inputServer, "MASK", "[A-Za-z0-9/./-]*");
+    IupSetCallback(inputServer, "EDIT_CB", (Icallback) activeBtnConnect);
+    hBoxServer = IupHbox(labelServer, inputServer, NULL);
+    IupSetAttribute(hBoxServer, "MARGIN", "10x10");
+
+    labelUser = IupLabel("Пользователь:");
+    IupSetAttribute(labelUser, "SIZE", "80x16");
+    IupSetAttribute(labelUser, "ALIGNMENT", "ARIGHT:ACENTER");
+    IupSetAttribute(labelUser, "PADDING", "5");
+    inputUser = IupText(NULL);
+    IupSetAttribute(inputUser, "NAME", "USER");
+    IupSetAttribute(inputUser, "TIP", "<домен>\\<имя пользователя>\n<имя пользователя>@<домен>\n(обязательное для заполнения поле)");
+    IupSetAttribute(inputUser, "VALUE", getSetValueCurrent(PARAMETER_USERNAME));
+    IupSetAttribute(inputUser, "SIZE", "100");
+    IupSetAttribute(inputUser, "MASK", "(/w|[/./\\/@/-])*");
+    IupSetCallback(inputUser, "ACTION", (Icallback) activeBtnConnect);
+    hBoxUser = IupHbox(labelUser, inputUser, NULL);
+    IupSetAttribute(hBoxUser, "MARGIN", "10x0");
+
+    labelPassword = IupLabel("Пароль:");
+    IupSetAttribute(labelPassword, "SIZE", "80x16");
+    IupSetAttribute(labelPassword, "ALIGNMENT", "ARIGHT:ACENTER");
+    IupSetAttribute(labelPassword, "PADDING", "5");
+    inputPassword = IupText(NULL);
+    IupSetAttribute(inputPassword, "SIZE", "100");
+    IupSetAttribute(inputPassword, "NAME", "PASSWORD");
+    IupSetAttribute(inputPassword, "TIP", "Пароль пользователя (необязательно)");
+    IupSetAttribute(inputPassword, "VALUE", getSetValueCurrent(PARAMETER_PASSWORD));
+    IupSetAttribute(inputPassword, "PASSWORD", "YES");
+    hBoxPassword = IupHbox(labelPassword, inputPassword, NULL);
+    IupSetAttribute(hBoxPassword, "MARGIN", "10x10");
+
+    btnConnect = IupButton("Подключение", NULL);
+    IupSetHandle("CONNECT", btnConnect);
+    IupSetAttribute(btnConnect, "NAME", "CONNECT");
+    IupSetAttribute(btnConnect, "TIP", "Выполнить подключение");
+#ifdef WITH_COLOR_BUTTONS
+    IupSetAttribute(btnConnect, "BGCOLOR", "0 179 0");
+    IupSetAttribute(btnConnect, "FGCOLOR", "255 255 255");
+#endif
+
+    btnClose = IupButton("Закрыть", NULL);
+    IupSetHandle("CLOSE", btnClose);
+    IupSetAttribute(btnClose, "NAME", "CLOSE");
+    IupSetAttribute(btnClose, "TIP", "Закрыть FreeRDP");
+#ifdef WITH_COLOR_BUTTONS
+    IupSetAttribute(btnClose, "BGCOLOR", "204 0 0");
+    IupSetAttribute(btnClose, "FGCOLOR", "255 255 255");
+#endif
+
+    btnSettings = IupButton("Настройки", NULL);
+    IupSetAttribute(btnSettings, "NAME", "SETTINGS");
+    IupSetAttribute(btnSettings, "TIP", "Перейти в настройки");
+#ifdef WITH_COLOR_BUTTONS
+    IupSetAttribute(btnSettings, "BGCOLOR", "0 136 204");
+    IupSetAttribute(btnSettings, "FGCOLOR", "255 255 255");
+#endif
+
+    hBoxButtons = IupHbox(IupFill(), btnSettings, btnConnect, btnClose, IupFill(), NULL);
+    IupSetAttribute(hBoxButtons, "ALIGNMENT", "ACENTER:ACENTER");
+    IupSetAttribute(hBoxButtons, "GAP", "10");
+    IupSetAttribute(hBoxButtons, "MARGIN", "10x10");
+
+    vBoxMain = IupVbox(labelImage, hBoxServer, hBoxUser, hBoxPassword, hBoxButtons, NULL);
+
+    IupSetCallback(btnConnect, "ACTION", (Icallback) guiConnect);
+    IupSetCallback(btnClose, "ACTION", (Icallback) guiExit);
+    IupSetCallback(btnSettings, "ACTION", (Icallback) settingsMainWindow);
+
+    dlg = IupDialog(vBoxMain);
+    IupSetAttribute(dlg, "IMAGE", "BG_HEAD");
+    IupSetAttribute(dlg, "ICON", "icon");
+    IupSetAttribute(dlg, "TITLE", "GUI FreeRDP");
+    IupSetAttribute(dlg, "RESIZE", "NO");
+    IupSetAttribute(dlg, "PARENTDIALOG", "MAIN_WINDOW");
+    IupSetAttribute(dlg, "DEFAULTENTER", "CONNECT");
+    IupSetAttribute(dlg, "DEFAULTESC", "CLOSE");
+
+    return dlg;
+}

freerdp/client/X11/cli/gui.h

@@ -0,0 +1,15 @@
+/*
+ * gui.h
+ *
+ *  Created on: 6 июл. 2022 г.
+ *      Author: alexander
+ */
+
+#ifndef GUI_H_
+#define GUI_H_
+
+#include <iup.h>
+
+Ihandle* guiStart();
+
+#endif /* GUI_H_ */

freerdp/client/X11/cli/images.h

@@ -0,0 +1,14 @@
+/*
+ * image.h
+ *
+ *  Created on: 5 июл. 2022 г.
+ *      Author: alexander
+ */
+
+#ifndef IMAGE_H_
+#define IMAGE_H_
+
+extern const unsigned char idata_head[];
+extern const unsigned char idata_icon[];
+
+#endif /* IMAGE_H_ */

freerdp/client/X11/cli/monitor.c

@@ -0,0 +1,84 @@
+/*
+ * monitor.c
+ *
+ *  Created on: 18 июл. 2022 г.
+ *      Author: alexander
+ */
+
+#include <string.h>
+#include <stdio.h>
+
+#include "monitor.h"
+#include "rxrandr.h"
+
+static bool checkMonitor(Monitors *dbMonitors, x_info *pcMonitors)
+{
+    if (!dbMonitors->size || !pcMonitors->count ||
+            !(dbMonitors->size == pcMonitors->count))
+    {
+        return false;
+    }
+
+    bool compare = false;
+
+    for (size_t i = 0; i < dbMonitors->size; ++i)
+    {
+        for (size_t j = 0; j < pcMonitors->count; ++j)
+        {
+            if (!strcmp(pcMonitors->monitor[j].name, dbMonitors->monitor[i]->data[1]))
+            {
+                compare = true;
+            }
+        }
+
+        if (!compare)
+        {
+            return false;
+        }
+
+        compare = false;
+    }
+
+    return true;
+}
+
+Monitors *loadMonitors()
+{
+    Monitors *dbMonitors = dbGetMonitorsList();
+    x_info *pcMonitors = getXInfo();
+    if (!checkMonitor(dbMonitors, pcMonitors))                                              // Если строки не равны, произвести перезапись в БД
+    {
+        if (dbMonitors)
+            dbFreeMonitors(dbMonitors);
+
+        if (!deleteAllMonitors())
+        {
+            fprintf(stderr, "Не удалось удалить записи мониторов из БД\n");
+            exit(1);
+        }
+
+        for (size_t i = 0; i < pcMonitors->count; ++i)
+        {
+            dbAddMonitor(pcMonitors->monitor[i].name, pcMonitors->monitor[i].primary);
+        }
+        freeXInfo(pcMonitors);
+
+        return dbGetMonitorsList();
+    }
+
+    freeXInfo(pcMonitors);
+
+    return dbMonitors;
+}
+
+void freeMonitors(Monitors *monitors)
+{
+    for (size_t i = 0; i < monitors->size; ++i)
+    {
+        free(monitors->monitor[i]->data[2]);
+        free(monitors->monitor[i]->data[3]);
+        free(monitors->monitor[i]->data);
+        free(monitors->monitor[i]);
+    }
+    free(monitors);
+}

freerdp/client/X11/cli/monitor.h

@@ -0,0 +1,16 @@
+/*
+ * monitor.h
+ *
+ *  Created on: 18 июл. 2022 г.
+ *      Author: alexander
+ */
+
+#ifndef MONITOR_H_
+#define MONITOR_H_
+
+#include "db.h"
+
+Monitors *loadMonitors();
+void freeMonitors(Monitors *monitors);
+
+#endif /* MONITOR_H_ */

freerdp/client/X11/cli/node_settings.c

@@ -0,0 +1,522 @@
+/*
+ * node_settings.c
+ *
+ *  Created on: 6 июл. 2022 г.
+ *      Author: alexander
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+#include "node_settings.h"
+#include "concat.h"
+#include "db.h"
+
+NodeHead settings =
+{ NULL, 0 };
+
+static NodeValue* newNodeValue(Value name, char *current, bool set)
+{
+    NodeValue *node = (NodeValue*) malloc(sizeof(NodeValue));
+    node->name = name;
+    node->set = set;
+    node->change = false;
+    node->next = NULL;
+
+    size_t size = strlen(current) + 1;
+    node->current = (char*) malloc(sizeof(char) * size);
+    strncpy(node->current, current, size);
+
+    return node;
+}
+
+static void freeNodeValue(NodeValue *node)
+{
+    if (node)
+    {
+        free(node->current);
+        free(node);
+    }
+}
+
+static void freeAllNodeValue(NodeValue *node)
+{
+    NodeValue *next = NULL;
+    for (NodeValue *head = node; head; head = next)
+    {
+        next = head->next;
+        freeNodeValue(head);
+    }
+}
+
+static NodeParameter* newNodeParameter(Parameter name, char *key, bool set, bool singleValue, NodeParameter *dependence, NodeParameter *conflict)
+{
+    NodeParameter *node = (NodeParameter*) malloc(sizeof(NodeParameter));
+    node->name = name;
+    node->set = set;
+    node->change = false;
+    node->value = NULL;
+    node->countValue = 0;
+    node->countValueSet = 0;
+    node->singleValue = singleValue;
+    node->dependence = dependence;
+    node->conflict = conflict;
+    node->next = NULL;
+
+    size_t size = strlen(key) + 1;
+    node->key = (char*) malloc(sizeof(char) * size);
+    strncpy(node->key, key, size);
+
+    return node;
+}
+
+static void freeNodeParameter(NodeParameter *node)
+{
+    if (node)
+    {
+        freeAllNodeValue(node->value);
+        free(node->key);
+        free(node);
+    }
+}
+
+static void freeAllNodeParameter(NodeParameter *node)
+{
+    NodeParameter *next = NULL;
+    for (NodeParameter *head = node; head; head = next)
+    {
+        next = head->next;
+        freeNodeParameter(head);
+    }
+}
+
+///////////////////////////////
+
+static NodeParameter* getLastNodeParameter()
+{
+    NodeParameter *head = settings.parameter;
+
+    if (head)
+    {
+        while (head->next)
+        {
+            head = head->next;
+        }
+        return head;
+    }
+
+    return NULL;
+}
+
+static NodeParameter* getNodeParameter(Parameter name)
+{
+    for (NodeParameter *head = settings.parameter; head; head = head->next)
+    {
+        if (head->name == name)
+        {
+            return head;
+        }
+    }
+
+    return NULL;
+}
+
+NodeValue* getValue(Value name)
+{
+    for (NodeParameter *pNode = settings.parameter; pNode; pNode = pNode->next)
+    {
+        for (NodeValue *vNode = pNode->value; vNode; vNode = vNode->next)
+        {
+            if (vNode->name == name)
+            {
+                return vNode;
+            }
+        }
+    }
+
+    return NULL;
+}
+
+NodeParameter* getParameter(Parameter name)
+{
+    for (NodeParameter *head = settings.parameter; head; head = head->next)
+    {
+        if (head->name == name)
+        {
+            return head;
+        }
+    }
+
+    return NULL;
+}
+
+
+void addParameterKey(Parameter name, char *key, bool set, bool singleValue, NodeParameter *dependence, NodeParameter *conflict)
+{
+    if (!settings.parameter)
+    {
+        settings.parameter = newNodeParameter(name, key, set, singleValue, dependence, conflict);
+        ++settings.countParameter;
+        if (set)
+        {
+            ++settings.countParameterSet;
+        }
+        return;
+    }
+
+    NodeParameter *node = getNodeParameter(name);
+
+    if (node)
+    {
+        fprintf(stderr, "%s \"%s\" %s", "Параметр", key, "уже существует!\n");
+    }
+    else
+    {
+        node = getLastNodeParameter();
+        node->next = newNodeParameter(name, key, set, singleValue, dependence, conflict);
+        ++settings.countParameter;
+        if (set)
+        {
+            ++settings.countParameterSet;
+        }
+    }
+}
+
+static NodeValue* getLastNodeValue(NodeParameter *node)
+{
+    NodeValue *head = node->value;
+
+    if (head)
+    {
+        while (head->next)
+        {
+            head = head->next;
+        }
+        return head;
+    }
+
+    return NULL;
+}
+
+static NodeValue* getNodeValue(NodeParameter *node, Value name)
+{
+    for (NodeValue *head = node->value; head; head = head->next)
+    {
+        if (head->name == name)
+        {
+            return head;
+        }
+    }
+
+    return NULL;
+}
+
+void addParameterValue(Parameter pName, Value vName, char *current, bool set)
+{
+    NodeParameter *nodeParameter = getNodeParameter(pName);
+
+    if (!nodeParameter)
+    {
+        fprintf(stderr, "%s \"%s\" %s", "Параметр для значения", current, "не существует!\n");
+        return;
+    }
+
+    if (!nodeParameter->value)
+    {
+        nodeParameter->value = newNodeValue(vName, current, set);
+        ++nodeParameter->countValue;
+        if (set)
+        {
+            ++nodeParameter->countValueSet;
+        }
+        return;
+    }
+
+    NodeValue *nodeValue = getNodeValue(nodeParameter, vName);
+
+    if (nodeValue)
+    {
+        fprintf(stderr, "%s \"%s\" %s", "Значение", current, "уже существует!\n");
+    }
+    else
+    {
+        nodeValue = getLastNodeValue(nodeParameter);
+        nodeValue->next = newNodeValue(vName, current, set);
+        ++nodeParameter->countValue;
+        if (set)
+        {
+            ++nodeParameter->countValueSet;
+        }
+    }
+}
+
+void freeSettings()
+{
+    if (settings.parameter)
+    {
+        freeAllNodeParameter(settings.parameter);
+    }
+}
+
+/////////////////////////////////////////////////////////////
+
+NodeValue* getSetNodeValue(NodeParameter *node)
+{
+    for (NodeValue *head = node->value; head; head = head->next)
+    {
+        if (head->set)
+        {
+            return head;
+        }
+    }
+
+    return NULL;
+}
+
+char *getSetValueCurrent(Parameter name)
+{
+    NodeParameter *nodeParameter = getNodeParameter(name);
+
+    if (!nodeParameter)
+    {
+        return NULL;
+    }
+
+    for (NodeValue *head = nodeParameter->value; head; head = head->next)
+    {
+        if (head->set)
+        {
+            return head->current;
+        }
+    }
+
+    return NULL;
+}
+
+////////////////////////////////////////////////////////////////
+
+void setParameterValue(Parameter pName, Value vName, char *current)
+{
+    NodeParameter *nodeParameter = getNodeParameter(pName);
+
+    if (!nodeParameter)
+    {
+        fprintf(stderr, "%s \"%s\" %s", "Параметр для значения", current, "не существует!\n");
+        return;
+    }
+
+    size_t length = strlen(current) + 1;
+
+    if (!length)
+    {
+        if (nodeParameter->set)
+        {
+            nodeParameter->set = false;
+            --settings.countParameterSet;
+        }
+        return;
+    }
+    else
+    {
+        if (!nodeParameter->set)
+        {
+            nodeParameter->set = true;
+            ++settings.countParameterSet;
+        }
+    }
+
+    if (!nodeParameter->value)
+    {
+        nodeParameter->value = newNodeValue(vName, current, true);
+        ++nodeParameter->countValue;
+        ++nodeParameter->countValueSet;
+        return;
+    }
+
+    NodeValue *nodeValue = getNodeValue(nodeParameter, vName);
+
+    if (nodeValue)
+    {
+        free(nodeValue->current);
+        nodeValue->current = (char*) malloc(sizeof(char) * length);
+        strncpy(nodeValue->current, current, length);
+    }
+    else
+    {
+        nodeValue = getLastNodeValue(nodeParameter);
+        nodeValue->next = newNodeValue(vName, current, true);
+        ++nodeParameter->countValue;
+        ++nodeParameter->countValueSet;
+    }
+
+    changeValue(pName, vName);
+}
+
+////////////////////////////////////////////////////////////////
+
+void changeParameter(Parameter name)
+{
+    NodeParameter *node = getNodeParameter(name);
+    node->change = !node->change;
+
+}
+
+void setParameter(Parameter name, bool set)
+{
+    NodeParameter *node = getNodeParameter(name);
+    node->set = set;
+}
+
+void changeValue(Parameter pName, Value vName)
+{
+    NodeParameter *pNode = getNodeParameter(pName);
+    for (NodeValue *head = pNode->value; head; head = head->next)
+    {
+        if (pNode->singleValue)
+        {
+            head->change = head->name == vName && !head->set;
+        }
+        else
+        {
+            // ДОРАБОТАТЬ НА ИСПОЛЬЗОВАНИЕ МНОГИХ ПАРАМЕТРОВ
+            head->change = head->name == vName;
+        }
+    }
+}
+
+static void saveChangeSingleValueSettings(NodeParameter *node)
+{
+    NodeValue *nChange = NULL;
+    NodeValue *nSet = NULL;
+
+    for (NodeValue *head = node->value; head; head = head->next)
+    {
+        if (head->change)
+        {
+            nChange = head;
+        }
+        if (head->set)
+        {
+            nSet = head;
+        }
+    }
+
+    if (nChange)
+    {
+        nChange->change = false;
+        nChange->set = true;
+
+        dbWriteValue(nChange->name, nChange->set);
+
+        if (nSet)
+        {
+            nSet->set = false;
+            dbWriteValue(nSet->name, nSet->set);
+        }
+        ++node->countValueSet;
+    }
+}
+
+static void saveChangeValueSettings(NodeParameter *node)
+{
+    for (NodeValue *head = node->value; head; head = head->next)
+    {
+        if (head->change)
+        {
+            head->change = false;
+            head->set = !head->set;
+        }
+        if (head->set)
+        {
+            ++node->countValueSet;
+        }
+    }
+}
+
+void saveChangeSettings()
+{
+    settings.countParameterSet = 0;
+
+    for (NodeParameter *pHead = settings.parameter; pHead; pHead = pHead->next)
+    {
+        if (pHead->change)
+        {
+            pHead->change = false;
+            pHead->set = !pHead->set;
+        }
+        if (pHead->dependence && !pHead->dependence->set)
+        {
+            pHead->set = false;
+        }
+        if (pHead->conflict && pHead->conflict->set)
+        {
+            pHead->set = false;
+        }
+        if (pHead->set)
+        {
+            ++settings.countParameterSet;
+        }
+
+        dbWriteParameter(pHead->name, pHead->set);
+
+        pHead->countValueSet = 0;
+
+        if (pHead->singleValue)
+            saveChangeSingleValueSettings(pHead);
+        else
+            saveChangeValueSettings(pHead);
+    }
+}
+
+void resetChangeSettings()
+{
+    for (NodeParameter *pHead = settings.parameter; pHead; pHead = pHead->next)
+    {
+        pHead->change = false;
+
+        for (NodeValue *vHead = pHead->value; vHead; vHead = vHead->next)
+        {
+            vHead->change = false;
+        }
+    }
+}
+
+bool getSetParameter(Parameter name)
+{
+    NodeParameter *node = getNodeParameter(name);
+    if (!node)
+    {
+        return false;
+    }
+    return node->set;
+}
+
+bool getSetValue(Parameter pName, Value vName)
+{
+    NodeParameter *pNode = getNodeParameter(pName);
+    if (!pNode)
+    {
+        return false;
+    }
+
+    for (NodeValue *vNode = pNode->value; vNode; vNode = vNode->next)
+    {
+        if (vNode->name == vName)
+        {
+            return vNode->set;
+        }
+    }
+
+    return false;
+}
+
+int getCountValue(Parameter name)
+{
+    NodeParameter *node = getNodeParameter(name);
+    if (!node)
+    {
+        return -1;
+    }
+    return node->countValue;
+}

freerdp/client/X11/cli/node_settings.h

@@ -0,0 +1,67 @@
+/*
+ * node_settings.h
+ *
+ *  Created on: 6 июл. 2022 г.
+ *      Author: alexander
+ */
+
+#ifndef NODE_SETTINGS_H_
+#define NODE_SETTINGS_H_
+
+#include <stdbool.h>
+
+#include "parameter.h"
+#include "value.h"
+
+typedef struct NodeValue
+{
+    Value name;
+    bool set;
+    bool change;
+    char *current;
+    struct NodeValue *next;
+} NodeValue;
+
+typedef struct NodeParameter
+{
+    Parameter name;
+    bool set;
+    bool change;
+    char *key;
+    NodeValue *value;
+    bool singleValue;
+    size_t countValue;
+    size_t countValueSet;
+    struct NodeParameter *dependence;
+    struct NodeParameter *conflict;
+    struct NodeParameter *next;
+} NodeParameter;
+
+typedef struct NodeHead
+{
+    NodeParameter *parameter;
+    size_t countParameter;
+    size_t countParameterSet;
+} NodeHead;
+
+extern NodeHead settings;
+
+NodeParameter* getParameter(Parameter name);
+NodeValue* getValue(Value name);
+void addParameterKey(Parameter name, char *key, bool set, bool singleValue, NodeParameter *dependence, NodeParameter *conflict);
+void addParameterValue(Parameter pName, Value vName, char *current, bool set);
+void freeSettings();
+
+NodeValue *getSetNodeValue(NodeParameter *node);
+char *getSetValueCurrent(Parameter name);
+bool getSetParameter(Parameter name);
+bool getSetValue(Parameter pName, Value vName);
+int getCountValue(Parameter name);
+void changeParameter(Parameter name);
+void changeValue(Parameter pName, Value vName);
+void saveChangeSettings();
+void resetChangeSettings();
+void setParameter(Parameter name, bool set);
+void setParameterValue(Parameter pName, Value vName, char *current);
+
+#endif /* SETTINGS_H_ */

freerdp/client/X11/cli/parameter.h

@@ -0,0 +1,33 @@
+/*
+ * parameters.h
+ *
+ *  Created on: 7 июл. 2022 г.
+ *      Author: alexander
+ */
+
+#ifndef PARAMETERS_H_
+#define PARAMETERS_H_
+
+typedef enum
+{
+    PARAMETER_XFREERDP,
+    PARAMETER_SERVER,
+    PARAMETER_USERNAME,
+    PARAMETER_PASSWORD,
+    PARAMETER_CERTIGNORE,
+    PARAMETER_THEMES,
+    PARAMETER_WALLPAPER,
+    PARAMETER_ENCRYPTION,
+    PARAMETER_FONTS,
+    PARAMETER_SOUND,
+    PARAMETER_COMPRESSION,
+    PARAMETER_FULLSCREEN,
+    PARAMETER_MULTIMONITOR,
+    PARAMETER_MONITORS,
+    PARAMETER_AUTHENTICATION,
+    PARAMETER_SECURITY,
+    PARAMETER_BITSPERPIXEL,
+    PARAMETER_USB
+} Parameter;
+
+#endif /* PARAMETERS_H_ */

freerdp/client/X11/cli/rxrandr.h

@@ -0,0 +1,32 @@
+/*
+ * xrandr.h
+ *
+ *  Created on: 11 июл. 2022 г.
+ *      Author: alexander
+ */
+
+#ifndef XRANDR_H_
+#define XRANDR_H_
+
+typedef struct
+{
+    char name[10];
+    char *ptrName;
+    char *ptrIndexItem;
+    char *ptrIndexMonitor;
+    int width;
+    int height;
+    int primary;
+} x_monitor;
+
+typedef struct
+{
+    int count;
+    x_monitor monitor[5];
+} x_info;
+
+int XInfo(x_info *info);
+x_info *getXInfo();
+void freeXInfo(x_info *info);
+
+#endif /* XRANDR_H_ */

freerdp/client/X11/cli/rxrandr_broker.c

@@ -0,0 +1,48 @@
+/*
+ * xrandr_broker.c
+ *
+ *  Created on: 11 июл. 2022 г.
+ *      Author: alexander
+ */
+
+#include "rxrandr.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+x_info *getXInfo()
+{
+    x_info *monitors = (x_info *) malloc(sizeof(x_info));
+    monitors->count = 0;
+    XInfo(monitors);
+
+    for (int i = 0; i < monitors->count; ++i)
+    {
+        size_t size = strlen(monitors->monitor[i].name) + 1;
+
+        monitors->monitor[i].ptrName = (char *)malloc(sizeof(char) * size);
+        monitors->monitor[i].ptrIndexItem = (char *)malloc(sizeof(char) * 3);
+        monitors->monitor[i].ptrIndexMonitor = (char *)malloc(sizeof(char) * 3);
+
+        strncpy(monitors->monitor[i].ptrName, monitors->monitor[i].name, size);
+        sprintf(monitors->monitor[i].ptrIndexItem, "%d", i + 1);
+        sprintf(monitors->monitor[i].ptrIndexMonitor, "%d", i);
+    }
+
+    return monitors;
+}
+
+void freeXInfo(x_info *info)
+{
+    for (int i = 0; i < info->count; ++i)
+    {
+        if (info->monitor[i].ptrName)
+            free(info->monitor[i].ptrName);
+        if (info->monitor[i].ptrIndexItem)
+            free(info->monitor[i].ptrIndexItem);
+        if (info->monitor[i].ptrIndexMonitor)
+            free(info->monitor[i].ptrIndexMonitor);
+    }
+    free(info);
+}

freerdp/client/X11/cli/settings.c

@@ -0,0 +1,409 @@
+/*
+ * settings.c
+ *
+ *  Created on: 6 июл. 2022 г.
+ *      Author: alexander
+ */
+
+#include <iup.h>
+
+#include <stdlib.h>
+#include <stdbool.h>
+
+#include "monitor.h"
+#include <stdio.h>
+
+#include "settings.h"
+#include "arguments.h"
+#include "node_settings.h"
+
+void toggleActive(Ihandle *self, char *name)
+{
+    IupSetInt(IupGetDialogChild(self, name), "ACTIVE", !IupGetInt(IupGetDialogChild(self, name), "ACTIVE"));
+}
+
+static int settingsClose(Ihandle *self)
+{
+    resetChangeSettings();
+    IupSetAttribute(IupGetDialog(self), "SIMULATEMODAL", "OFF");
+    IupHide(IupGetDialog(self));
+    return IUP_DEFAULT;
+}
+
+static int settingsSave(Ihandle *self)
+{
+    saveChangeSettings();
+    dbSaveMonitors(IupGetAttribute(IupGetDialogChild(self, "MONITORS"), "VALUESTRING"));
+    IupSetAttribute(IupGetDialog(self), "SIMULATEMODAL", "OFF");
+    IupHide(IupGetDialog(self));
+    return IUP_DEFAULT;
+}
+
+static int settingsTglAuthentication(Ihandle *self)
+{
+    changeParameter(PARAMETER_AUTHENTICATION);
+    return IUP_DEFAULT;
+}
+
+static int settingsTglCertIgnore(Ihandle *self)
+{
+    changeParameter(PARAMETER_CERTIGNORE);
+    return IUP_DEFAULT;
+}
+
+static int settingsTglThemes(Ihandle *self)
+{
+    changeParameter(PARAMETER_THEMES);
+    return IUP_DEFAULT;
+}
+
+static int settingsTglWallpaper(Ihandle *self)
+{
+    changeParameter(PARAMETER_WALLPAPER);
+    return IUP_DEFAULT;
+}
+
+static int settingsTglSound(Ihandle *self)
+{
+    changeParameter(PARAMETER_SOUND);
+    return IUP_DEFAULT;
+}
+
+static int settingsTglFonts(Ihandle *self)
+{
+    changeParameter(PARAMETER_FONTS);
+    return IUP_DEFAULT;
+}
+
+static int settingsTglEncryption(Ihandle *self)
+{
+    changeParameter(PARAMETER_ENCRYPTION);
+    return IUP_DEFAULT;
+}
+
+static int settingsTglCompression(Ihandle *self)
+{
+    changeParameter(PARAMETER_COMPRESSION);
+    return IUP_DEFAULT;
+}
+
+static int settingsUseSecurity(Ihandle *self)
+{
+    changeParameter(PARAMETER_SECURITY);
+    toggleActive(self, "SECURITY_TLS");
+    toggleActive(self, "SECURITY_RDP");
+    toggleActive(self, "SECURITY_NLA");
+    toggleActive(self, "SECURITY_EXT");
+
+    return IUP_DEFAULT;
+}
+
+static void settingsChooseSecurity(Ihandle *self, int state)
+{
+    if (state == 1)
+    {
+        int tool_index = IupGetInt(self, "TOOLINDEX");
+        switch (tool_index)
+        {
+        case 0:
+        {
+            changeValue(PARAMETER_SECURITY, VALUE_SECURITY_TLS);
+            break;
+        }
+        case 1:
+        {
+            changeValue(PARAMETER_SECURITY, VALUE_SECURITY_RDP);
+            break;
+        }
+        case 2:
+        {
+            changeValue(PARAMETER_SECURITY, VALUE_SECURITY_NLA);
+            break;
+        }
+        case 3:
+        {
+            changeValue(PARAMETER_SECURITY, VALUE_SECURITY_EXT);
+            break;
+        }
+        }
+    }
+}
+
+static int settingsUseBitsPerPixel(Ihandle *self)
+{
+    changeParameter(PARAMETER_BITSPERPIXEL);
+    toggleActive(self, "BITSPERPIXEL_8");
+    toggleActive(self, "BITSPERPIXEL_16");
+    toggleActive(self, "BITSPERPIXEL_24");
+    toggleActive(self, "BITSPERPIXEL_32");
+
+    return IUP_DEFAULT;
+}
+
+static void settingsChooseBitsPerPixel(Ihandle *self, int state)
+{
+    if (state == 1)
+    {
+        int tool_index = IupGetInt(self, "TOOLINDEX");
+        switch (tool_index)
+        {
+        case 0:
+        {
+            changeValue(PARAMETER_BITSPERPIXEL, VALUES_BITSPERPIXEL_8);
+            break;
+        }
+        case 1:
+        {
+            changeValue(PARAMETER_BITSPERPIXEL, VALUES_BITSPERPIXEL_16);
+            break;
+        }
+        case 2:
+        {
+            changeValue(PARAMETER_BITSPERPIXEL, VALUES_BITSPERPIXEL_24);
+            break;
+        }
+        case 3:
+        {
+            changeValue(PARAMETER_BITSPERPIXEL, VALUES_BITSPERPIXEL_32);
+            break;
+        }
+        }
+    }
+}
+
+static int settingsChooseMonitor(Ihandle *ih, char *text, int item, int state)
+{
+    if (state == 1)
+    {
+        changeValue(PARAMETER_MONITORS, item - 1);
+    }
+
+    return IUP_DEFAULT;
+}
+
+static int settingsTglMultimonitor(Ihandle *self)
+{
+    changeParameter(PARAMETER_MULTIMONITOR);
+
+    IupSetInt(IupGetDialogChild(self, "MONITORS"), "ACTIVE", !IupGetInt(IupGetDialogChild(self, "SETTINGS_TGL_MULTIMONITOR"), "VALUE"));
+    setParameter(PARAMETER_MONITORS, !IupGetInt(IupGetDialogChild(self, "SETTINGS_TGL_MULTIMONITOR"), "VALUE"));
+    return IUP_DEFAULT;
+}
+
+static int settingsTglFullscreen(Ihandle *self)
+{
+    changeParameter(PARAMETER_FULLSCREEN);
+    toggleActive(self, "SETTINGS_TGL_MULTIMONITOR");
+    IupSetInt(IupGetDialogChild(self, "MONITORS"), "ACTIVE", !IupGetInt(IupGetDialogChild(self, "SETTINGS_TGL_MULTIMONITOR"), "VALUE") && IupGetInt(IupGetDialogChild(self, "SETTINGS_TGL_FULLSCREEN"), "VALUE"));
+    setParameter(PARAMETER_MONITORS, !IupGetInt(IupGetDialogChild(self, "SETTINGS_TGL_MULTIMONITOR"), "VALUE"));
+    return IUP_DEFAULT;
+}
+
+/*
+ * Блок настроек
+ */
+static Ihandle* settingsBoxCheckbox()
+{
+    Ihandle *tglAuthentication, *tglCertIgnore, *tglThemes, *tglWallpaper, *tglSound, *tglFonts, *tglEncryption, *tglCompression;
+
+    tglAuthentication = IupToggle("Аутентификация", NULL);
+    tglCertIgnore = IupToggle("Игнорировать сертификат", NULL);
+    tglThemes = IupToggle("Отключить темы", NULL);
+    tglWallpaper = IupToggle("Отключить обои", NULL);
+
+    tglSound = IupToggle("Поддержка звука", NULL);
+    tglFonts = IupToggle("Отключить прорисовку шрифтов", NULL);
+    tglEncryption = IupToggle("Отключить шифрование", NULL);
+    tglCompression = IupToggle("Сжатие данных", NULL);
+
+    IupSetInt(tglAuthentication, "VALUE", getSetParameter(PARAMETER_AUTHENTICATION));
+    IupSetInt(tglCertIgnore, "VALUE", getSetParameter(PARAMETER_CERTIGNORE));
+    IupSetInt(tglThemes, "VALUE", getSetParameter(PARAMETER_THEMES));
+    IupSetInt(tglWallpaper, "VALUE", getSetParameter(PARAMETER_WALLPAPER));
+    IupSetInt(tglSound, "VALUE", getSetParameter(PARAMETER_SOUND));
+    IupSetInt(tglFonts, "VALUE", getSetParameter(PARAMETER_FONTS));
+    IupSetInt(tglEncryption, "VALUE", getSetParameter(PARAMETER_ENCRYPTION));
+    IupSetInt(tglCompression, "VALUE", getSetParameter(PARAMETER_COMPRESSION));
+
+    return IupSetAttributes(
+            IupFrame(
+                    IupVbox(
+                            IupSetCallbacks(IupSetAttributes(tglAuthentication, "NAME=SETTINGS_TGL_AUTHENTICATION, TIP=\"Получить окно входа авторизации\""), "ACTION",
+                                    (Icallback) settingsTglAuthentication, NULL),
+                            IupSetCallbacks(IupSetAttributes(tglCertIgnore, "NAME=SETTINGS_TGL_AUTHENTICATION, TIP=\"Игнорировать подтверждение принятия сертификата\""), "ACTION",
+                                    (Icallback) settingsTglCertIgnore, NULL),
+                            IupSetCallbacks(IupSetAttributes(tglThemes, "NAME=SETTINGS_TGL_THEMES, TIP=\"Отключить поддержку тем оформления (улучшает скорость соединения)\""), "ACTION", (Icallback) settingsTglThemes,
+                            NULL),
+                            IupSetCallbacks(IupSetAttributes(tglWallpaper, "NAME=SETTINGS_TGL_WALLPAPER, TIP=\"Отключить поддержку обои рабочего стола (улучшает скорость соединения)\""), "ACTION", (Icallback) settingsTglWallpaper,
+                            NULL), IupSetCallbacks(IupSetAttributes(tglSound, "NAME=SETTINGS_TGL_SOUND, TIP=\"Включить поддержку звука с удаленного сервера\""), "ACTION", (Icallback) settingsTglSound,
+                            NULL), IupSetCallbacks(IupSetAttributes(tglFonts, "NAME=SETTINGS_TGL_FONTS, TIP=\"Отключить прорисовку шрифтов (улучшает скорость соединения)\""), "ACTION", (Icallback) settingsTglFonts,
+                            NULL),
+                            IupSetCallbacks(IupSetAttributes(tglEncryption, "NAME=SETTINGS_TGL_ENCRYPTION, TIP=\"Отключить шифрование данных\""), "ACTION",
+                                    (Icallback) settingsTglEncryption,
+                                    NULL),
+                            IupSetCallbacks(IupSetAttributes(tglCompression, "NAME=SETTINGS_TGL_COMPRESSION, TIP=\"Включить сжатие данных (улучшает скорость соединения)\""), "ACTION",
+                                    (Icallback) settingsTglCompression,
+                                    NULL),
+                            NULL)), "TITLE=\"Общие\", MARGIN=10x10");
+}
+
+static Ihandle* settingsBoxSecurity()
+{
+    Ihandle *tglSecurity;
+    Ihandle *tglTLS, *tglRDP, *tglNLA, *tglEXT;
+    Ihandle *grdSecurity;
+
+    tglSecurity = IupToggle("Использовать", NULL);
+    IupSetInt(tglSecurity, "VALUE", getSetParameter(PARAMETER_SECURITY));
+    IupSetAttribute(tglSecurity, "TIP", "Выбрать конкретный протокол передачи данных");
+    IupSetCallback(tglSecurity, "ACTION", (Icallback) settingsUseSecurity);
+
+    tglTLS = IupToggle("TLS", NULL);
+    IupSetInt(tglTLS, "VALUE", getSetValue(PARAMETER_SECURITY, VALUE_SECURITY_TLS));
+    IupSetInt(tglTLS, "ACTIVE", getSetParameter(PARAMETER_SECURITY));
+    tglRDP = IupToggle("RDP", NULL);
+    IupSetInt(tglRDP, "VALUE", getSetValue(PARAMETER_SECURITY, VALUE_SECURITY_RDP));
+    IupSetInt(tglRDP, "ACTIVE", getSetParameter(PARAMETER_SECURITY));
+    tglNLA = IupToggle("NLA", NULL);
+    IupSetInt(tglNLA, "VALUE", getSetValue(PARAMETER_SECURITY, VALUE_SECURITY_NLA));
+    IupSetInt(tglNLA, "ACTIVE", getSetParameter(PARAMETER_SECURITY));
+    tglEXT = IupToggle("EXT", NULL);
+    IupSetInt(tglEXT, "VALUE", getSetValue(PARAMETER_SECURITY, VALUE_SECURITY_EXT));
+    IupSetInt(tglEXT, "ACTIVE", getSetParameter(PARAMETER_SECURITY));
+
+    grdSecurity = IupRadio(
+            IupGridBox(
+                    IupSetCallbacks(IupSetAttributes(tglTLS, "NAME=SECURITY_TLS, TOOLINDEX=0"), "ACTION", (Icallback) settingsChooseSecurity, NULL),
+                    IupSetCallbacks(IupSetAttributes(tglRDP, "NAME=SECURITY_RDP, TOOLINDEX=1"), "ACTION", (Icallback) settingsChooseSecurity, NULL),
+                    IupSetCallbacks(IupSetAttributes(tglNLA, "NAME=SECURITY_NLA, TOOLINDEX=2"), "ACTION", (Icallback) settingsChooseSecurity, NULL),
+                    IupSetCallbacks(IupSetAttributes(tglEXT, "NAME=SECURITY_EXT, TOOLINDEX=3"), "ACTION", (Icallback) settingsChooseSecurity, NULL),
+                    NULL));
+
+    return IupHbox(IupSetAttributes(IupFrame(IupVbox(tglSecurity, grdSecurity, NULL)), "TITLE=\"Протокол безопасности\", MARGIN=15x10"), NULL);
+}
+
+static Ihandle* settingsBoxBitsPerPixel()
+{
+    Ihandle *tglBitsPerPixel;
+    Ihandle *tgl8, *tgl16, *tgl24, *tgl32;
+    Ihandle *grdBitsPerPixel;
+
+    tglBitsPerPixel = IupToggle("Использовать", NULL);
+    IupSetInt(tglBitsPerPixel, "VALUE", getSetParameter(PARAMETER_BITSPERPIXEL));
+    IupSetAttribute(tglBitsPerPixel, "TIP", "Выбрать конкретную глубину цвета (меньше глубина - выше скорость и хуже качество)");
+    IupSetCallback(tglBitsPerPixel, "ACTION", (Icallback) settingsUseBitsPerPixel);
+
+    tgl8 = IupToggle("8 бит", NULL);
+    IupSetInt(tgl8, "VALUE", getSetValue(PARAMETER_BITSPERPIXEL, VALUES_BITSPERPIXEL_8));
+    IupSetInt(tgl8, "ACTIVE", getSetParameter(PARAMETER_BITSPERPIXEL));
+    tgl16 = IupToggle("16 бит", NULL);
+    IupSetInt(tgl16, "VALUE", getSetValue(PARAMETER_BITSPERPIXEL, VALUES_BITSPERPIXEL_16));
+    IupSetInt(tgl16, "ACTIVE", getSetParameter(PARAMETER_BITSPERPIXEL));
+    tgl24 = IupToggle("24 бит", NULL);
+    IupSetInt(tgl24, "VALUE", getSetValue(PARAMETER_BITSPERPIXEL, VALUES_BITSPERPIXEL_24));
+    IupSetInt(tgl24, "ACTIVE", getSetParameter(PARAMETER_BITSPERPIXEL));
+    tgl32 = IupToggle("32 бит", NULL);
+    IupSetInt(tgl32, "VALUE", getSetValue(PARAMETER_BITSPERPIXEL, VALUES_BITSPERPIXEL_32));
+    IupSetInt(tgl32, "ACTIVE", getSetParameter(PARAMETER_BITSPERPIXEL));
+
+    grdBitsPerPixel = IupRadio(
+            IupGridBox(IupSetCallbacks(IupSetAttributes(tgl8, "NAME=BITSPERPIXEL_8, TOOLINDEX=0"), "ACTION", (Icallback) settingsChooseBitsPerPixel,
+            NULL), IupSetCallbacks(IupSetAttributes(tgl16, "NAME=BITSPERPIXEL_16, TOOLINDEX=1"), "ACTION", (Icallback) settingsChooseBitsPerPixel,
+            NULL), IupSetCallbacks(IupSetAttributes(tgl24, "NAME=BITSPERPIXEL_24, TOOLINDEX=2"), "ACTION", (Icallback) settingsChooseBitsPerPixel,
+            NULL), IupSetCallbacks(IupSetAttributes(tgl32, "NAME=BITSPERPIXEL_32, TOOLINDEX=3"), "ACTION", (Icallback) settingsChooseBitsPerPixel,
+            NULL),
+            NULL));
+
+    return IupHbox(IupSetAttributes(IupFrame(IupVbox(tglBitsPerPixel, grdBitsPerPixel, NULL)), "TITLE=\"Глубина цвета\", MARGIN=15x10"), NULL);
+}
+
+static Ihandle* settingsBoxMonitor()
+{
+    Ihandle *tglFullscreen, *tglMultimonitor, *ddMonitor;
+
+    tglMultimonitor = IupToggle("Все мониторы", NULL);
+    tglFullscreen = IupToggle("На весь экран", NULL);
+    ddMonitor = IupList(NULL);
+
+    Monitors *monitors = loadMonitors();
+    for (size_t i = 0; i < monitors->size; ++i)
+    {
+        IupSetAttribute(ddMonitor, monitors->monitor[i]->data[0], monitors->monitor[i]->data[1]);
+        if (monitors->monitor[i]->data[2][0] == '1')
+            IupSetAttribute(ddMonitor, "VALUE", monitors->monitor[i]->data[0]);
+    }
+    freeMonitors(monitors);
+
+    IupSetInt(tglMultimonitor, "VALUE", getSetParameter(PARAMETER_MULTIMONITOR));
+    IupSetInt(tglFullscreen, "VALUE", getSetParameter(PARAMETER_FULLSCREEN));
+
+    IupSetInt(tglMultimonitor, "ACTIVE", getSetParameter(PARAMETER_FULLSCREEN));
+    IupSetInt(ddMonitor, "ACTIVE", getSetParameter(PARAMETER_FULLSCREEN) && !getSetParameter(PARAMETER_MULTIMONITOR));
+
+    return IupSetAttributes(
+            IupFrame(
+                    IupVbox(
+                            IupSetCallbacks(IupSetAttributes(tglFullscreen, "NAME=SETTINGS_TGL_FULLSCREEN, EXPAND=YES, TIP=\"Выполнить подключение на весь экран\""), "ACTION",
+                                    (Icallback) settingsTglFullscreen, NULL),
+                            IupSetCallbacks(IupSetAttributes(tglMultimonitor, "NAME=SETTINGS_TGL_MULTIMONITOR, TIP=\"Задействовать все подключенные мониторы\""), "ACTION",
+                                    (Icallback) settingsTglMultimonitor, NULL),
+                            IupSetCallbacks(IupSetAttributes(ddMonitor, "NAME=MONITORS, DROPDOWN=YES, EXPAND=YES, TIP=\"Выбрать конкретный монитор для подключения\""), "ACTION",
+                                    (Icallback) settingsChooseMonitor, NULL),
+                            NULL)), "TITLE=\"Монитор\", MARGIN=10x10, CGAP=5");
+}
+
+static Ihandle* settingsHorizontalBox()
+{
+    return IupSetAttributes(
+            IupHbox(IupVbox(settingsBoxCheckbox(), settingsBoxMonitor(), NULL), settingsBoxSecurity(), settingsBoxBitsPerPixel(), NULL), "MARGIN=5x5");
+}
+
+/*
+ * Блок кнопок
+ */
+static Ihandle* settingsHorizontalBoxButtons()
+{
+    Ihandle *btnSave, *btnClose;
+
+    btnSave = IupButton("Сохранить", NULL);
+    IupSetAttribute(btnSave, "NAME", "SETTIGS_BTN_SAVE");
+    IupSetAttribute(btnSave, "TIP", "Сохранить настройки");
+#ifdef WITH_COLOR_BUTTONS
+    IupSetAttribute(btnSave, "BGCOLOR", "0 179 0");
+    IupSetAttribute(btnSave, "FGCOLOR", "255 255 255");
+#endif
+
+    btnClose = IupButton("Закрыть", NULL);
+    IupSetAttribute(btnClose, "NAME", "SETTIGS_BTN_CLOSE");
+    IupSetAttribute(btnClose, "TIP", "Отменить изменения");
+#ifdef WITH_COLOR_BUTTONS
+    IupSetAttribute(btnClose, "BGCOLOR", "204 0 0");
+    IupSetAttribute(btnClose, "FGCOLOR", "255 255 255");
+#endif
+
+    IupSetHandle("btnClosePointer", btnClose);
+
+    return IupSetAttributes(
+            IupHbox(IupFill(), IupSetCallbacks(btnSave, "ACTION", (Icallback) settingsSave, NULL),
+                    IupSetCallbacks(btnClose, "ACTION", (Icallback) settingsClose, NULL), IupFill(),
+                    NULL), "ALIGNMENT=ACENTER:ACENTER, GAP=10, MARGIN=10x10");
+}
+
+int settingsMainWindow(Ihandle *self)
+{
+    Ihandle *dlg;
+    Ihandle *vBoxMain;
+
+    vBoxMain = IupSetAttributes(IupVbox(settingsHorizontalBox(), settingsHorizontalBoxButtons(), NULL), "NMARGIN=2x2, ALIGNMENT=ACENTER");
+
+    dlg = IupDialog(vBoxMain);
+    IupSetAttribute(dlg, "TITLE", "Настройки");
+    IupSetCallback(
+            IupSetAttributes(dlg,
+                    "ICON=icon, DIALOGFRAME=ON, SIMULATEMODAL=ON, DEFAULTESC=btnClosePointer, TOPMOST=YES, BRINGFRONT=YES, NAME=SETTINGS_MAIN_WINDOW"),
+            "CLOSE_CB", (Icallback) settingsClose);
+
+    IupShowXY(dlg, IUP_CURRENT, IUP_CURRENT);
+
+    return IUP_DEFAULT;
+}

freerdp/client/X11/cli/settings.h

@@ -0,0 +1,13 @@
+/*
+ * settings.h
+ *
+ *  Created on: 6 июл. 2022 г.
+ *      Author: alexander
+ */
+
+#ifndef SETTINGS_H_
+#define SETTINGS_H_
+
+int settingsMainWindow(Ihandle *self);
+
+#endif /* SETTINGS_H_ */

freerdp/client/X11/cli/value.h

@@ -0,0 +1,27 @@
+/*
+ * value.h
+ *
+ *  Created on: 8 июл. 2022 г.
+ *      Author: alexander
+ */
+
+#ifndef VALUE_H_
+#define VALUE_H_
+
+typedef enum
+{
+    VALUE_SERVER,
+    VALUE_USERNAME,
+    VALUE_PASSWORD,
+    VALUE_SECURITY_TLS,
+    VALUE_SECURITY_RDP,
+    VALUE_SECURITY_NLA,
+    VALUE_SECURITY_EXT,
+    VALUES_BITSPERPIXEL_8,
+    VALUES_BITSPERPIXEL_16,
+    VALUES_BITSPERPIXEL_24,
+    VALUES_BITSPERPIXEL_32,
+    VALUES_USB_DRIVE
+} Value;
+
+#endif /* VALUE_H_ */

freerdp/client/X11/cli/xrdp.c

@@ -0,0 +1,71 @@
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <winpr/crt.h>
+#include <winpr/synch.h>
+#include <winpr/thread.h>
+
+#include <freerdp/freerdp.h>
+#include <freerdp/client/cmdline.h>
+
+#include "../xf_client.h"
+#include "../xfreerdp.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <iup.h>
+
+#include "xrdp.h"
+
+int free_rdp_connect(int argc, char **argv)
+{
+   int rc = 1;
+   int status;
+   HANDLE thread;
+   xfContext *xfc;
+   DWORD dwExitCode;
+   rdpContext *context;
+   rdpSettings *settings;
+   RDP_CLIENT_ENTRY_POINTS clientEntryPoints;
+
+   ZeroMemory(&clientEntryPoints, sizeof(RDP_CLIENT_ENTRY_POINTS));
+   clientEntryPoints.Size = sizeof(RDP_CLIENT_ENTRY_POINTS);
+   clientEntryPoints.Version = RDP_CLIENT_INTERFACE_VERSION;
+
+   RdpClientEntry(&clientEntryPoints);
+
+   context = freerdp_client_context_new(&clientEntryPoints);
+   if (!context)
+       return 1;
+
+   settings = context->settings;
+   xfc = (xfContext*) context;
+
+   status = freerdp_client_settings_parse_command_line(context->settings, argc, argv, FALSE);
+   if (status)
+   {
+       rc = freerdp_client_settings_command_line_status_print(settings, status, argc, argv);
+
+       if (settings->ListMonitors)
+           xf_list_monitors(xfc);
+
+       goto out;
+   }
+
+   if (freerdp_client_start(context) != 0)
+       goto out;
+
+   thread = freerdp_client_get_thread(context);
+
+   WaitForSingleObject(thread, INFINITE);
+   GetExitCodeThread(thread, &dwExitCode);
+   rc = xf_exit_code_from_disconnect_reason(dwExitCode);
+
+   freerdp_client_stop(context);
+
+   out: freerdp_client_context_free(context);
+
+   return rc;
+}

freerdp/client/X11/cli/xrdp.h

@@ -0,0 +1,13 @@
+/*
+ * xrdp.h
+ *
+ *  Created on: 15 июл. 2022 г.
+ *      Author: alexander
+ */
+
+#ifndef XRDP_H_
+#define XRDP_H_
+
+int free_rdp_connect(int argc, char **argv);
+
+#endif /* XRDP_H_ */

freerdp/cmake/FindIUP.cmake

@@ -0,0 +1,19 @@
+find_path(IUP_INCLUDE_DIR NAMES iup.h
+          PATHS /home/alexander/repositories/iup/include
+          DOC "The IUP include directory"
+)
+
+find_library(IUP_LIBRARY NAMES iup
+          PATHS /home/alexander/repositories/iup
+          DOC "The IUP library"
+)
+
+include(FindPackageHandleStandardArgs)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(IUP DEFAULT_MSG IUP_LIBRARY IUP_INCLUDE_DIR)
+
+if(IUP_FOUND)
+  set( IUP_LIBRARIES ${IUP_LIBRARY} )
+  set( IUP_INCLUDE_DIRS ${IUP_INCLUDE_DIR} )
+endif()
+
+mark_as_advanced(IUP_INCLUDE_DIR IUP_LIBRARY)

freerdp/cmake/FindSQLite.cmake

@@ -0,0 +1,19 @@
+find_path(SQLITE_INCLUDE_DIR NAMES sqlite3.h
+          PATHS /usr/include
+          DOC "The SQLITE include directory"
+)
+
+find_library(SQLITE_LIBRARY NAMES sqlite3
+          PATHS /usr/lib64
+          DOC "The SQLITE library"
+)
+
+include(FindPackageHandleStandardArgs)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(SQLite DEFAULT_MSG SQLITE_LIBRARY SQLITE_INCLUDE_DIR)
+
+if(SQLITE_FOUND)
+  set( SQLITE_LIBRARIES ${SQLITE_LIBRARY} )
+  set( SQLITE_INCLUDE_DIRS ${SQLITE_INCLUDE_DIR} )
+endif()
+
+mark_as_advanced(SQLITE_INCLUDE_DIR SQLITE_LIBRARY)