निषिद्ध सूचना धारा बनाना। 257 धागे

निषिद्ध सूचना प्रवाह (आईपी) बनाने पर लेखों की श्रृंखला में यह पहला लेख है। इन IP को व्यवस्थित करने के विचारों का आविष्कार यहाँ नहीं किया गया था और न ही मेरे द्वारा। मुझे बस इतना करना था कि इन कमजोरियों को प्रदर्शित करने वाले प्रशिक्षण उद्देश्यों के लिए लागू करना था।

इस लेख में मैं सूचना प्रवाह के संगठन के बारे में बात करूँगा, जो कि इसके राज्य के अनुप्रयोगों में से एक के परिवर्तन के आधार पर दूसरे राज्य द्वारा पहले के राज्य के मतदान के लिए किया जाएगा। इस इंटरैक्शन मॉडल के साथ, एक एकल ट्रांसमीटर में कई श्रोता हो सकते हैं। बाद के लेखों में, प्रोग्राम इंटरेक्शन वातावरण और सूचना विनिमय एल्गोरिदम दोनों अलग-अलग होंगे।

तो, कोड के लिए! सबसे पहले, हमें अतिरिक्त 256 थ्रेड्स के पहचानकर्ताओं के साथ एक सरणी की आवश्यकता है। जबकि थ्रेड्स नहीं बनाए जाते हैं, पहचानकर्ताओं को शून्य के बराबर बनाया जाता है।

#define MAX_THREADS 256 pthread_t threads[MAX_THREADS]; 

हम कुछ चरों को घोषित करेंगे, जिसमें हम थ्रेड्स की वर्तमान संख्या और थ्रेड्स की आवश्यक संख्या के बारे में जानकारी अगले चरण में संग्रहीत करेंगे:

 int todayThreads = 0; int tomorrowThreads = 0; 

अब उस फ़ंक्शन को देखें, जिसमें सभी नए बनाए गए थ्रेड्स को निर्देशित किया जाएगा:

 void * funcParallel(void * p) { long threadIndex = (long)p; while (true) { usleep(200); if (threadIndex + 1 > tomorrowThreads) { pthread_exit(NULL); return NULL; } } } 

अब एक फ़ंक्शन बनाते हैं जो दिए गए एक के बराबर चलने वाले थ्रेड्स की संख्या बनाता है:

 void changeNumThreads(int num) { tomorrowThreads = num; if (tomorrowThreads > todayThreads) { // Creating new threads for (int i = todayThreads; i < tomorrowThreads; i++) pthread_create(threads+i, NULL, funcParallel, (void*)i); } else if (tomorrowThreads < todayThreads) { void * status; // Waiting for killing threads pthread_join(threads[tomorrowThreads], &status); } todayThreads = tomorrowThreads; } 

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

 int main(int argc, char * argv[]) { int pid = getpid(); if (argc == 1) { runSender(pid); } else if (argc == 2) { sscanf(argv[1], "%d", &pid); runReceiver(pid); } else { printf("Usage: unichat [PID]\n"); printf("Examples: unichat\n"); printf(" unichat 2790\n"); } } 

अब चलो रनसेंडर () हस्तांतरण फ़ंक्शन के लिए कोड देखें। यह पीआईडी ​​को प्रिंट करता है, जिसके बाद यह मानक इनपुट स्ट्रीम से एक बार में एक चरित्र को पढ़ता है, थ्रेड्स की संख्या को रीड कैरेक्टर के कोड के बराबर संख्या में बदलता है, 1000 माइक्रोसेकंड की प्रतीक्षा करता है, थ्रेड्स की संख्या को शून्य के बराबर बनाता है और फिर से इंतजार करता है।

 void runSender(int pid) { printf("Sender PID = %d\n", pid); while (true) { char ch = getchar(); changeNumThreads(ch); usleep(1000); changeNumThreads(0); usleep(1000); } } 

यह होस्ट कोड देखने के लिए बना हुआ है। वह थोड़ा और जटिल है। यह किसी विशेष एप्लिकेशन में थ्रेड्स की संख्या पर नज़र रखता है और अधिकतम प्राप्त संख्या को याद रखता है। जैसे ही थ्रेड्स की संख्या 0 हो जाती है (मुख्य थ्रेड को छोड़कर) - यह एक ऐसे चरित्र को प्रिंट करता है जिसका कोड देखे गए थ्रेड्स के अधिकतम मूल्य के बराबर है। मुद्रण के बाद, थ्रेड्स की संग्रहीत अधिकतम संख्या रीसेट हो जाती है।

 void runReceiver(int pid) { printf("Receive from PID = %d\n", pid); char line[1024]; char filename[1024]; snprintf(filename, sizeof(filename), "/proc/%d/status", pid); int maxThreads = 0; int threads = 0; while (true) { usleep(200); FILE * f = fopen(filename, "rt"); if (f == NULL) { printf("Can't open file %s, error: %d!\n", filename, errno); return; } while (!feof(f)) { fscanf(f, "%s", line); if (feof(f)) break; if (memcmp(line, "Threads:", 8) == 0) { fscanf(f, "%d", &threads); threads--; if ((threads == 0) && (maxThreads != 0)) { printf("%c", maxThreads); fflush(stdout); maxThreads = 0; } else { if (threads > maxThreads) maxThreads = threads; } break; } } fclose(f); } } 

तो यहाँ होता है:
1. मापदंडों के बिना कार्यक्रम चलाएं
2. हम स्क्रीन पर एक नंबर देखते हैं, उदाहरण के लिए 1234
3. पैरामीटर 1234 के साथ कार्यक्रम चलाएं
4. पहले प्रोग्राम में, 'a' बटन दबाएं
5. प्रक्रिया 1234 में थ्रेड्स की संख्या 'a' + 1 = 98 हो जाती है
6. मेजबान कार्यक्रम थ्रेड्स की संख्या में वृद्धि का निरीक्षण करता है (यह फ़ाइल / proc / 1234 / स्थिति में लिखा गया है)
7. मेजबान 98 का ​​अधिकतम मूल्य प्राप्त करता है
8. संचारण कार्यक्रम मुख्य को छोड़कर सभी थ्रेड्स को मारता है)
9. होस्ट प्रोग्राम थ्रेड्स की संख्या को ठीक करता है = 1 (मुख्य)
10. प्राप्त कार्यक्रम स्क्रीन पर कोड 98-1 = 97 = 'ए' के ​​साथ एक प्रतीक प्रिंट करता है।

निष्कर्ष:
इस प्रकार, डेटा को उच्च स्तर की गोपनीयता के साथ एक प्रक्रिया से निचले स्तर की गोपनीयता के साथ एक प्रक्रिया में स्थानांतरित किया जाता है। विनिमय करने की क्षमता गोपनीयता के स्तर पर किसी भी प्रतिबंध के बिना किसी अन्य प्रक्रिया की स्थिति की निगरानी करने के लिए एक प्रक्रिया की क्षमता पर आधारित है।