धार फ़ाइल। इसके अंदर क्या है?

परिचय

शुभ दोपहर
मैं कई, एक बड़े धार ट्रैकर - rutracker.org की तरह उपयोग करता हूं, लेकिन एक विशेषता है जो मुझे परेशान करती है।
यह पता लगाने वालों की सूची में जोड़ रहा है ix *। Rutracker.net , जो मेरे लिए अयोग्य उद्देश्यों के लिए कार्य करता है। हालांकि, जो अक्सर (मेरे लिए - लगभग हमेशा) त्रुटियां ( 502 खराब गेटवे और 0 नो रिस्पॉन्स ) फेंकता है। टोरेंट क्लाइंट (मेरे पास ट्रांसमिशन है) टोरेंट को तोड़ देता है। बेशक जो मुझे बहुत परेशान करता है। विशेष रूप से जब आप ट्रांसमिशन सुविधा पर विचार करते हैं - यह ट्रैकर की अंतिम प्रतिक्रिया के अनुसार धार की स्थिति निर्धारित करता है। यही है, हम ix * को पोल करते हैं, यह एक त्रुटि देता है, धार को ब्रोकन के रूप में चिह्नित किया जाता है, n मिनट / सेकंड के बाद सूची से अगला ट्रैकर प्रदूषित होता है - bt * .rutracker.org या retracker.local , जो एक सफल कोड लौटाता है और धार फिर से सामान्य हो जाती है। यह गंदगी मुझसे बहुत खुश नहीं है।

समाधान भोज है - इस बुरे पते को सूची से हटा दें। हालाँकि, मेरे पास बहुत सारी फाइलें हैं, मैं हर एक को मैन्युअल रूप से काटना नहीं चाहता, और एक नई धार जोड़ते समय एक अतिरिक्त कार्रवाई करने की इच्छा नहीं थी। इसलिए, मैंने प्रारूप को समझने और सूची से ट्रैकर को हटाने का निर्णय लिया।

Bencode

यह वह डेटा एन्कोडिंग प्रारूप है जिसे .torrent फ़ाइलों में कहा जाता है। यह लगभग कहीं भी कभी भी उपयोग नहीं किया जाता है, मैं इसे ट्रांसमिशन में फिर से शुरू करने-जानकारी संग्रहीत करने के प्रारूप में भी आया था।
इस प्रारूप के साथ काम करने के लिए पुस्तकालय अधिकांश वर्तमान भाषाओं के लिए लिखे गए हैं, लेकिन सी ++ के लिए नहीं, हां, हां, निश्चित रूप से, ऐसी कोई चीज है , लेकिन यह शुद्ध सी है, और इसके अलावा, प्रस्तुति फॉर्म मुझे सफल नहीं लगा, इसलिए मैंने अपनी सरल बाइक लिखी, क्योंकि प्रारूप बेहद सरल है।

4 डेटा प्रकार वर्णित हैं - बाइट सरणी, संख्या, सूची, साहचर्य सरणी।

आइए जाने क्रम में:

• संख्याएँ I के रूप में दी गई हैं <<अंकों का अनुक्रम> ई , <अनुक्रम का क्रम> - ये ascii प्रतिनिधित्व में संख्याएं हैं, अर्थात 1 को '1' या 0x31 के रूप में निर्दिष्ट किया गया है। यह ध्यान देने योग्य है कि इस तरह से हम बड़ी संख्याओं को निर्दिष्ट कर सकते हैं जो या तो लंबे या लंबे समय तक फिट नहीं होते हैं, लेकिन अधिकांश एक सीमा की कमी की उपेक्षा करते हैं और 64-बिट संख्याओं का उपयोग करते हैं।
• बाइट्स की सरणी - <सरणी लंबाई>: <सरणी ही> । सरणी की लंबाई भी अंकों के असीमित अनुक्रम द्वारा बनाई गई है।
• सूची - l <सूची आइटम> ई । एक तत्व डेटा प्रकारों में से कोई भी हो सकता है। एक नेस्टेड सूची सहित। प्रारूप से देखा गया अंत, शाब्दिक 'ई' के साथ चिह्नित है।
• सहयोगी सरणी - d <सरणी तत्व> ई । सरणी का प्रत्येक तत्व इस तरह दिखता है - <बाइट सरणी> <तत्व> । बाइट्स की एक सरणी क्लॉज से फॉर्म में एक प्रविष्टि का नाम है। एक तत्व फिर से कुछ भी हो सकता है - एक सूची, एक सरणी, एक सहयोगी सरणी, एक संख्या।

वह सब है। फ़ाइल ही ऐसी प्रविष्टियों का एक क्रम है। इसलिए, डीकोडिंग अत्यंत सरल है:

void CTorrentFile::ReadBencElement(ifstream & fin, tree <BencElement>::pre_order_iterator & parent, string name) { BencElement el; char c = fin.get(); el.name = name; if (c == 'i') { el.type = BencInteger; fin >> el.integer; m_tree.append_child(parent, el); } else if (c == 'l') { int l = fin.peek(); el.type = BencList; tree <BencElement>::pre_order_iterator it = m_tree.append_child(parent, el); while (l != 'e') { ReadBencElement(fin, it, string("")); l = fin.peek(); } fin.seekg(1, ios_base::cur); } else if (c == 'd') { int l = fin.peek(); el.type = BencDict; tree <BencElement>::pre_order_iterator it = m_tree.append_child(parent, el); while (l != 'e') { string name; int len; fin >> len; fin.seekg(1, ios_base::cur); while (len--) { char s = fin.get(); name += s; } ReadBencElement(fin, it, name); l = fin.peek(); } fin.seekg(1, ios_base::cur); } else if (c >= '0' && c <= '9') { fin.seekg(-1, ios_base::cur); int len; el.type = BencString; fin >> len; el.bstr.len = len; // skip ':' fin.seekg(1, ios_base::cur); el.bstr.byteStr = new char[len + 1]; for (int i = 0; i < len; i++) { char s = fin.get(); el.bstr.byteStr[i] = s; } el.bstr.byteStr[el.bstr.len] = 0; m_tree.append_child(parent, el); } } 

कोडिंग भी आसान है:

 void CTorrentFile::WriteBencElement(std::ofstream & fout, tree <BencElement>::sibling_iterator & el) { tree <BencElement>::sibling_iterator it; switch (el->type) { case BencInteger: fout << 'i' << el->integer << 'e'; break; case BencString: fout << el->bstr.len << ':'; fout.write(el->bstr.byteStr, el->bstr.len); break; case BencList: fout << 'l'; it = m_tree.child(el, 0); for (size_t i = 0; i < m_tree.number_of_children(el); i++, ++it) WriteBencElement(fout, it); fout << 'e'; break; case BencDict: fout << 'd'; tree <BencElement>::sibling_iterator it = m_tree.child(el, 0); for (size_t i = 0; i < m_tree.number_of_children(el); i++, ++it) { fout << it->name.length() << ':' << it->name.c_str(); WriteBencElement(fout, it); } fout << 'e'; break; } } 

.Torrent फ़ाइल की संरचना।

जैसा कि मैंने ऊपर लिखा है, बेनकोड कोडिंग के लिए उपयोग किया जाता है।
यह जोड़ने योग्य है कि यदि बाइट सरणी को स्ट्रिंग के रूप में व्याख्या किया जा सकता है (एक साहचर्य सरणी में तत्व नाम, बस स्ट्रिंग फ़ील्ड), तो utf-8 एन्कोडिंग का उपयोग किया जाता है।

निम्नलिखित क्षेत्रों के साथ सामग्री एक बड़ा साहचर्य सरणी है:

• जानकारी एक नेस्टेड एसोसिएटिव ऐरे है जो वास्तव में उन फाइलों का वर्णन करती है जो टोरेंट ट्रांसफर करती हैं।
• घोषणा - ट्रैकर के लिए URL। जानकारी के साथ एक आवश्यक क्षेत्र है, बाकी सब वैकल्पिक है।
• घोषणा-सूची - ट्रैकर्स की एक सूची, यदि कई हैं। बेनकोड दृश्य में, सूचियों की एक सूची।
• निर्माण तिथि - निर्माण तिथि। UNIX टाइमस्टैम्प।
• टिप्पणी - धार का पाठ विवरण। rutracker.org यहां एक फोरम विषय के लिए एक लिंक संग्रहीत करता है।
• द्वारा निर्मित - हमें बताता है कि इस धार को किसने बनाया।

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

जानकारी के सहयोगी सरणी में निम्न शामिल हैं:

• टुकड़ा की लंबाई - एक टुकड़े का आकार 512 किलोबाइट, 1 मीटर, और इसी तरह है। बहुत सारे टुकड़े .torrent फ़ाइल को "फुलाएँगे"।
• टुकड़े एक स्ट्रिंग है जिसमें प्रत्येक टुकड़े का वर्णन करने वाले SHA1 हैश का संयोजन होता है। इस स्ट्रिंग की लंबाई टुकड़ों की संख्या 20 * है।
• नाम - अनुशंसित फ़ाइल नाम (यदि केवल एक फ़ाइल है) या निर्देशिका। काश, कई टोरेंट क्लाइंट इसे एक स्वयंसिद्ध मानते हैं।
• लंबाई - यदि फ़ाइल एक है, तो यह फ़ील्ड सेट हो जाएगी, जिसमें फ़ाइल की लंबाई है।
• फाइलें - अगर कई फाइलें हैं, तो साहचर्य सरणियों की एक सूची दिखाई देगी।

फ़ाइलों की सूची के तत्वों का प्रारूप:

• लंबाई - फ़ाइल की लंबाई।
• पथ - पंक्तियों की एक सूची जो पथ निर्दिष्ट करती है। प्रत्येक रेखा धार की जड़ निर्देशिका के सापेक्ष पथ का एक तत्व है। पथ a / b / c / d.jpg इस सूची में 4 लाइनें होंगी - ['a', 'b', 'c', 'd.jpg'] ।

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

 int CTorrentFile::RemoveTracker(const char * mask) { int deletedCount = 0; tree <BencElement>::pre_order_iterator root = m_tree.child(m_tree.begin(), 0); tree <BencElement>::sibling_iterator it = m_tree.child(root, 0); for (size_t i = 0; i < m_tree.number_of_children(root); i++, ++it) { if (it->type == BencString && !it->name.compare("announce") && it->bstr.len > 0 && it->bstr.byteStr) { if (wildcardMatch(it->bstr.byteStr, mask)) { it->bstr.len = 0; it->bstr.byteStr[0] = 0; deletedCount++; } } else if (it->type == BencList && !it->name.compare("announce-list")) { tree <BencElement>::sibling_iterator trackerList = m_tree.child(it, 0); for (size_t j = 0; j < it.number_of_children(); j++) { if (trackerList->type != BencList) { ++trackerList; continue; } tree <BencElement>::sibling_iterator tracker = m_tree.child(trackerList, 0); for (size_t k = 0; k < trackerList.number_of_children(); k++) { if (tracker->type != BencString || tracker->bstr.len <= 0 || !tracker->bstr.byteStr) { ++tracker; continue; } if (wildcardMatch(tracker->bstr.byteStr, mask)) { tracker = m_tree.erase(tracker); deletedCount++; } else ++tracker; } if (trackerList.number_of_children() == 0) trackerList = m_tree.erase(trackerList); else ++trackerList; } } } return deletedCount; } 

हम सब कुछ एक स्रोत में लिखते हैं:
डाउनलोड - क्रॉस-प्लेटफ़ॉर्म (जीत + * निक्स), आपको बढ़ावा देने की आवश्यकता है :: फाइल सिस्टम ।

प्रयोग करने में आसान:
torrentEditor <file_name> <पैटर्न> , जहां पैटर्न वाइल्डकार्ड स्ट्रिंग है ('*' और '?'), मेरे मामले के लिए - http: //ix*rutracker.net/*
यदि आप निर्देशिका का नाम फ़ाइल नाम के रूप में प्रतिस्थापित करते हैं, तो इस निर्देशिका का पुनरावर्ती ट्रैवर्सल और * .torrent फ़ाइलों का संशोधन किया जाएगा।
<Name> .torrent के लिए बैकअप <name> .old में सहेजा गया है।

Daemons और घड़ी-निर्देशिका।

इस तरह हम मौजूदा .टोरेंट फ़ाइलों पर जा सकते हैं और ट्रैकर को काट सकते हैं, हालाँकि नई फ़ाइलों का क्या करना है?
मैं एक सुविधाजनक चीज का उपयोग करता हूं - वॉच डायरेक्टरी। हम .torrent को वहां फेंकते हैं और क्लाइंट इसे इस फ़ोल्डर में पाता है, यह स्वतः ही इसे अपने आप से जोड़ देगा।
हालांकि, मैं ट्रैकर को पहले से काटना नहीं चाहता, लेकिन मैं इस व्यवसाय को स्वचालित करना चाहता हूं।
इसलिए, मैंने एक साधारण दानव लिखा जो अपनी स्वयं की घड़ी निर्देशिका पर नज़र रखता है, ट्रैकर को हटाता है और फ़ाइल को टोरेंट क्लाइंट की घड़ी निर्देशिका में फेंकता है।
एक उपयोगकर्ता के रूप में, बिल्कुल कुछ भी नहीं बदला है, मैं फ़ाइलों को उसी फ़ोल्डर में फेंक देता हूं, मुझे आउटपुट पर क्लाइंट में धार मिलती है।

हम सी में एक अद्भुत चीज़ का उपयोग करते हुए दानव लिखते हैं - inotify ,

  notifyDesc = inotify_init(); if (notifyDesc < 0) exit(EXIT_FAILURE); watchDesc = inotify_add_watch(notifyDesc, argv[1], IN_CREATE); if (watchDesc < 0) exit(EXIT_FAILURE); // endless loop while (1) { processEvents(notifyDesc, argv[2], argv[3], argv[1]); } 

हम inotify_init () का उपयोग करके मॉड्यूल को इनिशियलाइज़ करते हैं, फिर inotify_add_watch () को ट्रैक करने के लिए डायरेक्टरी जोड़ें, हम केवल फ़ाइल बनाने में रुचि रखते हैं, इसलिए, IN_CREATE ध्वज निर्दिष्ट करें। और फिर हम अंतहीन निर्देशिका ट्रैकिंग चक्र को स्पिन करते हैं।

 static void processEvents(int wd, char * moveDir, char * pattern, char * watchDir) { #define BUF_SIZE ((sizeof(struct inotify_event) + FILENAME_MAX) * 10) int len, i = 0; char buf[BUF_SIZE]; // blocked read, we wake up when directory changed len = read(wd, buf, BUF_SIZE); while (i < len) { struct inotify_event * ev; ev = (struct inotify_event *)&buf[i]; processNewFile(ev->name, moveDir, pattern, watchDir); i += sizeof(struct inotify_event) + ev->len; } } 

पढ़ने के लिए अवरोधक कॉल () हम उन निर्देशिकाओं में से एक के रूप में जल्द ही नियंत्रण वापस कर देंगे, जो हमारे द्वारा अनुसरण की जा रही हैं। इस प्रकार, हम प्रतीक्षा करते समय प्रोसेसर को पूरी तरह से लोड नहीं करते हैं।
फ़ाइल प्रोसेसिंग अपने आप में दिलचस्प नहीं है - नाम बदलने के लिए कॉल की एक जोड़ी () और सिस्टम के लिए एक कॉल () ।

डिमोनेटाइजेशन भी मानक है:

  // create child-process pid = fork(); // error? if (pid < 0) exit(EXIT_FAILURE); // parent? if (pid > 0) exit(EXIT_SUCCESS); // new session for child sid = setsid(); if (sid < 0) exit(EXIT_FAILURE); // change current directory if (chdir("/") < 0) exit(EXIT_FAILURE); // close opened descriptors close(STDIN_FILENO); close(STDOUT_FILENO); close(STDERR_FILENO); 

स्रोत कोड