जीएनयू/लिनक्स में सी

Question

में कैप्चरिंग कीस्ट्रोक यदि मैं किसी एप्लिकेशन में काम कर रहा हूं और मैं कुंजीपटल से कुंजी दबाता हूं, तो मैं उस कुंजी (या स्ट्रिंग) को स्रोत एप्लिकेशन के नाम सहित, सी में, जीएनयू/लिनक्स के तहत कैप्चर कैसे कर सकता हूं, उपयोगकर्तालैंड में, X11 के बिना :)

धन्यवाद।

Answer 1

एक संभावना: 'sudosh', 'सूडो शैल' (या इसके प्रतिस्थापन में से एक के बाद स्रोत को देखने के लिए स्रोत को देखें और इसे थोड़ी देर में संशोधित नहीं किया गया है; Google आपका मित्र है)।

यह छद्म-ttys के साथ गड़बड़ करता है और फ़ाइल को जानकारी रिकॉर्ड करके सभी इनपुट और आउटपुट ट्रैक करता है।

चाहे वह आपके लिए पर्याप्त सटीक है, शायद अधिक बहस योग्य है; यह सभी अनुप्रयोगों के लिए सभी कीस्ट्रोक लॉग करेगा। मैं यह भी निश्चित नहीं हूं कि यह एक्स 11 के साथ कैसे काम करता है - अगर यह एक्स 11 के साथ काम करता है।

Answer 2

आप/dev/input में फ़ाइलों में से किसी एक से डेटा पढ़ सकते हैं। कौन सा आपके सिस्टम पर निर्भर करता है। यह/dev/input/event0 या/dev/input/by-path/platform-i8042-serio-0-event-kbd या कुछ और हो सकता है। प्रारूप कर्नेल हेडर input.h में निर्दिष्ट है। यह

struct input_event { 
     struct timeval time; 
     __u16 type; 
     __u16 code; 
     __s32 value; 
}; 

आप

od -tx2 FILENAME 

चलाने के लिए और देखने के लिए कुछ क्या होता टाइप कर सकते हैं।

यह पता लगाने के लिए कि कौन सा एप्लिकेशन महत्वपूर्ण कार्यक्रम प्राप्त करता है, मुझे यकीन नहीं है। आप यह जांचने का प्रयास कर सकते हैं कि कौन सा मुख्य tty से पढ़ रहा है।

Answer 3

ठीक है, X11 के बिना यह समस्या अधिक कठिन है।
कीस्ट्रोक हिस्सा आपको एक कोड इस एक के लिए इसी तरह उपयोग कर सकते हैं, लेकिन आप एक तर्क के रूप युक्ति है कि आप पढ़ रहे हैं (कुंजीपटल, आमतौर पर/dev/इनपुट/event0)

#include <linux/input.h> 
#include <sys/types.h> 
#include <sys/stat.h> 
#include <fcntl.h> 
#include <stdio.h> 
#include <unistd.h> 

int main(int argc, char **argv) 
{ 
    int fd; 
    if(argc < 2) { 
     printf("usage: %s <device>\n", argv[0]); 
     return 1; 
    } 
    fd = open(argv[1], O_RDONLY); 
    struct input_event ev; 

    while (1) 
    { 
    read(fd, &ev, sizeof(struct input_event)); 

    if(ev.type == 1) 
     printf("key %i state %i\n", ev.code, ev.value); 

    } 
} 

क्रेडिट कर पारित करने के लिए है मेरे पास नहीं, यह कोड वेंट्रिलोक्टल हैक से कीस्ट्रोक प्राप्त करने के लिए लिया जाता है। http://public.callutheran.edu/~abarker/ventriloctrl-0.4.tar.gz

आशा है कि मैं कुछ मदद कर रहा हूं।

Answer 4

एक बहुत अच्छे उदाहरण के लिए, showkey कोड पर एक नज़र डालें।

विशेष रूप से, यहां मुख्य लूप है। यह सब टर्मिनल प्राप्त करता है, इसे कॉपी करता है, कॉपी किए गए को कच्चे मोड में बदल देता है, और जब तक 'छोड़ें' या 'इंटरप्ट' कुंजी अनुक्रम नहीं दिया जाता है, तो यह केवल प्रिंट करता है कि टर्मिनल को कौन सी कुंजी दी गई थी।

/* 
* showkey.c -- display cooked key sequences 
* 
* Invoke this (no arguments needed) to see keycap-to-keystrokes mappings. 
* 
* by Eric S. Raymond <esr@snark.thyrsus.com>, 1 Nov 88 
* - fix for little-endian machines (version 1.1), 21 Oct 1996. 
* - cleanup and modern packaging (version 1.2), 1 Aug 2002. 
* - changed to use termios (version 1.3), 26 Aug 2002. 
* See the RPM spec file changelog for more recent stuff. 
*/ 
#include <stdio.h> 
#include <termios.h> 
#include <signal.h> 
#include <string.h> 
#include <stdbool.h> 
static int signalled; 

// ... 

main() 
{ 
    struct termios cooked, raw; 
    unsigned char c; 
    unsigned int i, timeouts; 
    char intrchar[32], quitchar[32]; 

    for (i = SIGHUP; i <= SIGIO; i++) 
    (void) signal(c, catcher); 

    // Get the state of the tty 
    (void) tcgetattr(0, &cooked); 
    // Make a copy we can mess with 
    (void) memcpy(&raw, &cooked, sizeof(struct termios)); 
    // Turn off echoing, linebuffering, and special-character processing, 
    // but not the SIGINT or SIGQUIT keys. 
    raw.c_lflag &=~ (ICANON | ECHO); 
    // Ship the raw control blts 
    (void) tcsetattr(0, TCSANOW, &raw); 

    (void) printf("Type any key to see the sequence it sends.\n"); 
    visualize(raw.c_cc[VINTR], intrchar); 
    visualize(raw.c_cc[VQUIT], quitchar); 
    (void) printf("Terminate with your shell interrupt %s or quit %s character.\n", 
      intrchar, quitchar); 
    signalled = 0; 
    while (!signalled) 
    { 
    char cbuf[32]; 

    read(0, &c, 1); 
    visualize(c, cbuf); 
    (void)fputs(cbuf, stdout); 
    (void) fflush(stdout); 
    } 

    (void) printf("\nBye...\n"); 
    // Restore the cooked state 
    (void) tcsetattr(0, TCSANOW, &cooked); 
}