सिग्नल फाइल ट्रांसफर

शुभ दोपहर, ह्रज़ितली। निश्चित रूप से हर कोई जानता है कि लिनक्स में क्या संकेत हैं और वे किस लिए हैं। लेकिन आज, मैं इसके बारे में बात करना चाहूंगा, जैसा कि मुझे लगता है, उनका अपरंपरागत अनुप्रयोग।

यह कार्य बहुत दूर की कौड़ी है और इसका उद्देश्य संकेतों और थोड़ा सा, बिटवाइज़ ऑपरेशंस के साथ काम करने में अपने कौशल को प्रशिक्षित करना है। सामान्य तौर पर, कार्य:
प्रोग्राम को एक प्रक्रिया को स्पॉन करना चाहिए, जो केवल संकेतों का उपयोग करते हुए, कमांड लाइन तर्क के रूप में निर्दिष्ट फ़ाइल में पैरेंट को पास करता है। अभिभावक परिणामी फाइल को स्टडआउट में प्रिंट करता है।


समाधान बहुत सरल है: हम मोर्स कोड जैसे संकेतों का उपयोग करेंगे, केवल SIGUSR1 और SIGUSR2 का उपयोग "प्वाइंट" और "डैश" के बजाय किया जाएगा ।

निर्णय

हम SIGUSR2 और SIGUSR1 संकेतों का उपयोग करके फ़ाइल को बिट द्वारा स्थानांतरित करेंगे
SIGUSR2 - शून्य से थोड़ा सा, SIGUSR1 - एक के बराबर सा।

डेटा भेज रहा है

चर सी में फ़ाइल से बाइट पढ़ें।
काउंटर वेरिएबल 0b10000000 या 128 के बराबर बनाएं।
यदि c और (जिसका अर्थ है "बिट वाइज और") काउंटर एक के बराबर है, तो सबसे महत्वपूर्ण बिट एक के बराबर है, हम SIGUSR1 भेजते हैं, अन्यथा हम SIGUSR2 भेजते हैं।
हम आधे में काउंटर को विभाजित करते हैं (हमें 0b01000000 या 64 मिलता है), यानी हम बाईं ओर दूसरे बिट में पास होते हैं।
काउंटर शून्य होने तक दोहराएं। फिर हम फ़ाइल से नई बाइट पढ़ते हैं।

सी में, यह इस तरह दिखता है:

while (read(fd, &c, 1) > 0) { for ( i = 128; i >= 1; i /= 2) { if ( i & c ) // 1 kill(ppid, SIGUSR1); else // 0 kill(ppid, SIGUSR2); } 

डेटा का स्वागत

हम परिवर्तनशील__चक्र में स्वीकार करेंगे, शुरू में शून्य के बराबर।
जबकि काउंटर शून्य के बराबर नहीं है, हम संकेतों को निम्नानुसार संसाधित करते हैं:
यदि SIGUSR1 आया है, तो out_char + = काउंटर , फिर काउंटर / = 2 ।
अगर SIGUSR1 आया, तो काउंटर / = 2 ।

हम संकेतों के लिए हैंडलर लिखेंगे:

 // SIGUSR1 void one(int signo) { out_char += counter; counter /= 2; } // SIGUSR2 void zero(int signo) { counter/=2; } 

काम करने का विकल्प

अब आपको माता-पिता या बच्चे की अप्रत्याशित मौत पर विचार करने की आवश्यकता है। यदि बच्चा मर जाता है, तो सब कुछ सरल है - माता-पिता को SIGCHLD प्राप्त होगा।

 // SIGCHLD void childexit(int signo) { exit(EXIT_SUCCESS); } 

यह बच्चे के साथ थोड़ा अधिक कठिन होगा, इसमें कोई गारंटी नहीं है कि बच्चे को उसके माता-पिता की मृत्यु के बारे में सूचित किया जाएगा। इसलिए, हम कर्नेल से हमें SIGALRM भेजने के लिए कहते हैं यदि किसी निश्चित समय के बाद कोई अन्य संकेत हमें नहीं भेजे जाते हैं। इसे भेजने वाले लूप में जोड़ें:

 while (read(fd, &c, 1) > 0) { // SIGALRM          alarm(1); //   for ( i = 128; i >= 1; i /= 2) { if ( i & c ) // 1 kill(ppid, SIGUSR1); else // 0 kill(ppid, SIGUSR2); } } 

माता-पिता द्वारा बच्चे से संकेत की प्राप्ति की पुष्टि करने के लिए एक तंत्र जोड़ें। यही है, जब तक कि माता-पिता बिट की प्राप्ति की पुष्टि नहीं करते, तब तक बच्चा अगले एक को प्रेषित नहीं करेगा।

यह केवल एक और शून्य कार्यों में किया जाता है, आपको एक प्रतिक्रिया भेजने की आवश्यकता होती है। हम एक संकेत SIGUSR1 के साथ प्रतिक्रिया देंगे । परिवर्तनों के बाद, कार्य इस तरह दिखाई देंगे:

 // SIGUSR1 void one(int signo) { out_char += counter; counter /= 2; kill(pid, SIGUSR1); } // SIGUSR2 void zero(int signo) { counter/=2; kill(pid, SIGUSR1); } 

और बच्चे की पुष्टि के लिए प्रतीक्षा करने के लिए, sigsuspend (और सेट) जोड़ें:

 while (read(fd, &c, 1) > 0){ // SIGALRM          alarm(1); //   for ( i = 128; i >= 1; i /= 2){ if ( i & c ) // 1 kill(ppid, SIGUSR1); else // 0 kill(ppid, SIGUSR2); //      //     sigsuspend(&set); } 

पैरेंट की ओर से कन्फर्मेशन सिग्नल आने पर किया गया फंक्शन, हालांकि खाली होना चाहिए, नहीं तो डिफॉल्ट सिग्नल, आउटपुट के लिए एक्शन परफॉर्म करना होगा।

वास्तव में कार्य और सेट :

 // Nothing void empty(int signo) { } // SET sigemptyset(&set); //    // SIGUSR1 - empty() struct sigaction act_empty; memset(&act_empty, 0, sizeof(act_empty)); act_empty.sa_handler = empty; sigfillset(&act_empty.sa_mask); sigaction(SIGUSR1, &act_empty, NULL); // SIGALRM - parentexit() struct sigaction act_alarm; memset(&act_alarm, 0, sizeof(act_alarm)); act_alarm.sa_handler = parentexit; sigfillset(&act_alarm.sa_mask); sigaction(SIGALRM, &act_alarm, NULL); 

माता-पिता में, सिग्नल मास्क निम्नानुसार होना चाहिए:

 // SIGCHLD - exit struct sigaction act_exit; memset(&act_exit, 0, sizeof(act_exit)); act_exit.sa_handler = childexit; sigfillset(&act_exit.sa_mask); sigaction(SIGCHLD, &act_exit, NULL); // SIGUSR1 - one() struct sigaction act_one; memset(&act_one, 0, sizeof(act_one)); act_one.sa_handler = one; sigfillset(&act_one.sa_mask); sigaction(SIGUSR1, &act_one, NULL); // SIGUSR2 - zero() struct sigaction act_zero; memset(&act_zero, 0, sizeof(act_zero)); act_zero.sa_handler = zero; sigfillset(&act_zero.sa_mask); sigaction(SIGUSR2, &act_zero, NULL); //   sigaddset(&set, SIGUSR1); sigaddset(&set, SIGUSR2); sigaddset(&set, SIGCHLD); sigprocmask(SIG_BLOCK, &set, NULL ); 

चूंकि कार्यक्रम के संचालन के दौरान एक नई प्रक्रिया होगी, जो तुरंत हमें सिग्नल (डेटा), सिगप्रोमैक्स (SIG_BLOCK, और सेट, NULL) भेजना शुरू कर देती है, कांटे से पहले किया जाना चाहिए, अन्यथा दौड़ प्रभाव (दौड़) के कारण त्रुटि होने का मौका है हालत)।
नतीजतन, कार्यक्रम इस तरह दिखेगा:

 int out_char = 0, counter = 128; pid_t pid; //      // SIGCHLD void childexit(int signo) { exit(EXIT_SUCCESS); } // SIGALRM void parentexit(int signo) { exit(EXIT_SUCCESS); } // Nothing void empty(int signo) { } // SIGUSR1 void one(int signo) { out_char += counter; counter /= 2; kill(pid, SIGUSR1); } // SIGUSR2 void zero(int signo) { counter/=2; kill(pid, SIGUSR1); } int main(int argc, char ** argv){ if (argc != 2) { fprintf(stderr, "Use: %s [source]\n", argv[0]); exit(EXIT_FAILURE); } pid_t ppid = getpid(); //   ,    sigset_t set; //     //  SIGCHLD -  struct sigaction act_exit; memset(&act_exit, 0, sizeof(act_exit)); act_exit.sa_handler = childexit; sigfillset(&act_exit.sa_mask); sigaction(SIGCHLD, &act_exit, NULL); // SIGUSR1 - one() struct sigaction act_one; memset(&act_one, 0, sizeof(act_one)); act_one.sa_handler = one; sigfillset(&act_one.sa_mask); sigaction(SIGUSR1, &act_one, NULL); // SIGUSR2 - zero() struct sigaction act_zero; memset(&act_zero, 0, sizeof(act_zero)); act_zero.sa_handler = zero; sigfillset(&act_zero.sa_mask); sigaction(SIGUSR2, &act_zero, NULL); //sigemptyset(&set); //   sigaddset(&set, SIGUSR1); sigaddset(&set, SIGUSR2); sigaddset(&set, SIGCHLD); sigprocmask(SIG_BLOCK, &set, NULL ); sigemptyset(&set); //  pid = fork(); //  () if (pid == 0) { unsigned int fd = 0; char c = 0; sigemptyset(&set); //    // SIGUSR1 - empty() struct sigaction act_empty; memset(&act_empty, 0, sizeof(act_empty)); act_empty.sa_handler = empty; sigfillset(&act_empty.sa_mask); sigaction(SIGUSR1, &act_empty, NULL); // SIGALRM - parentexit() struct sigaction act_alarm; memset(&act_alarm, 0, sizeof(act_alarm)); act_alarm.sa_handler = parentexit; sigfillset(&act_alarm.sa_mask); sigaction(SIGALRM, &act_alarm, NULL); if ((fd = open(argv[1], O_RDONLY)) < 0 ){ perror("Can't open file"); exit(EXIT_FAILURE); } int i; while (read(fd, &c, 1) > 0){ // SIGALRM          alarm(1); //   for ( i = 128; i >= 1; i /= 2){ if ( i & c ) // 1 kill(ppid, SIGUSR1); else // 0 kill(ppid, SIGUSR2); //     //      sigsuspend(&set); } } //   exit(EXIT_SUCCESS); } errno = 0; //      do { if(counter == 0){ // Whole byte write(STDOUT_FILENO, &out_char, 1); // fflush(stdout); counter=128; out_char = 0; } sigsuspend(&set); //     } while (1); exit(EXIT_SUCCESS); } 

कार्यक्रम का स्रोत कोड यहां डाउनलोड किया जा सकता है ।

यह है कि आप केवल संकेतों का उपयोग करके फ़ाइलों को एक कार्यक्रम से दूसरे में स्थानांतरित कर सकते हैं। सच है, यह दृष्टिकोण बहुत प्रभावी नहीं है और मुझे नहीं लगता कि वास्तविक परियोजनाओं में इसका कोई अनुप्रयोग है।

आपका ध्यान के लिए धन्यवाद!