कुल कमांडर के दोस्त (64 बिट्स) और प्लगइन्स (32 बिट्स)

मैं आपको एक छोटी परियोजना के बारे में बताऊंगा जो आपको कुल कमांडर के 64 बिट संस्करण (इसके अलावा टीसीपी) में 32 बिट संस्करण एक्सटेंशन का उपयोग करने की अनुमति देता है। परियोजना डेमो स्टेज पर है और कार्यों के न्यूनतम आवश्यक सेट (अभिलेखागार की सामग्री को देखने और निकालने या अभिलेखागार के रूप में प्रतिनिधित्व किया जा सकता है) के साथ WCX मॉड्यूल का उपयोग करने की अनुमति देता है। खैर, अंत में, इस तरह के एक समाधान की प्रासंगिकता और परियोजना को एक निश्चित स्तर पर लाने के लिए, एपीआई के सभी संभावित हिस्से और मॉड्यूल के सभी संभावित श्रेणियों को कवर किया गया।

समस्या और उसके समाधान का विवरण

टीसी के लिए मॉड्यूल एक्सटेंशन WCX, WFX, WLX, WDX के साथ DLL फाइलें हैं और निर्यात कार्यों के एक विशिष्ट सेट (मॉड्यूल की श्रेणी के अनुसार) युक्त हैं। सब कुछ ठीक होगा, लेकिन सभी लेखकों ने 64 बिट संस्करणों का ध्यान नहीं रखा है। और स्रोत कोड उपलब्ध नहीं है, एक नियम के रूप में ...

प्रश्न - क्या मैं मौजूदा 32 बिट संस्करणों का उपयोग कर सकता हूँ?
उत्तर - हां, लेकिन इतना सरल नहीं है।

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



संभावित IPC विकल्प MSDN - इंटरप्रोसेस संचार पर उपलब्ध हैं। अपने प्रोजेक्ट के लिए, मैंने पाइप्स को चुना। यह सबसे तेज़ तरीका नहीं हो सकता है, लेकिन यह आपको सरोगेट प्रक्रिया के स्वास्थ्य की निगरानी करने की अनुमति देता है। यदि सरोगेट प्रक्रिया क्रैश हो जाती है, तो पाइप चैनल टूट जाता है और हमारी लाइब्रेरी इसके बारे में जानती है। निम्नलिखित चल रही प्रक्रियाओं का विवरण है।

लाइब्रेरी को कनेक्ट करते समय

• पाइप के लिए अद्वितीय नाम पीढ़ी
• पाइप निर्माण
• एक सरोगेट प्रक्रिया का निर्माण
• सरोगेट प्रक्रिया के लिए पाइप का नाम गुजर रहा है
• प्रतीक्षा और पाइप के माध्यम से एक ग्राहक को जोड़ने

एक अद्वितीय नाम उत्पन्न करने के लिए, हम UuidCreate () फ़ंक्शन का उपयोग करेंगे। यह एक UUID (GUID) उत्पन्न करेगा। इसे स्ट्रिंग (UuidToString) में बदलें और पाइप के लिए पथ भरें। एक पाइप बनाएं (CreateNamedPipe) ब्लॉकिंग मोड में काम करने और संदेश भेजने के लिए। सरोगेट प्रक्रिया (CreateProcess) चलाएँ। पाइप का नाम कमांड लाइन पैरामीटर के रूप में पारित किया गया है। और हम ग्राहक (ConnectNamedPipe) की प्रतीक्षा करेंगे।

लाइब्रेरी बंद करते समय

• पाइप से क्लाइंट को डिस्कनेक्ट करें
• सरोगेट प्रक्रिया को पूरा करें
• बंद पाइप (आम तौर पर मुफ्त आवंटित संसाधन)

क्लाइंट को डिस्कनेक्ट करें (डिस्कनेक्टनामाइडपाइप), सरोगेट प्रक्रिया (टर्मिनेटप्रोसेस) को समाप्त करें, पाइप को बंद करें और संसाधनों को साफ करें (CloseHandle)

सरोगेट प्रक्रिया शुरू करते समय

• नाम पाइप मिल
• एक ग्राहक के रूप में पाइप से कनेक्ट करें
• लोड मॉड्यूल
• संदेश की उम्मीद

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

सरोगेट प्रक्रिया के अंत में

• पाइप से डिस्कनेक्ट करें
• अनलोड मॉड्यूल

पाइप (CloseHandle) से डिस्कनेक्ट करें और मॉड्यूल (FreeLibrary) को अनलोड करें।

पुस्तकालय से एक समारोह बुलाते समय

• किसी संदेश में पैरामीटर पैक करें
• पाइप के माध्यम से अनुरोध पारित करें
• जवाब मिला
• परिणाम को अनज़िप करें और फ़ंक्शन से बाहर निकलें

हम एक उदाहरण का उपयोग करके एक फ़ंक्शन कॉल करते हैं

__declspec(dllexport) HANDLE __stdcall OpenArchive(tOpenArchiveData *ArchiveData) { if (s_init && ArchiveData) { // serialize uint8_t *p = s_buff; SET_FUNC(p, OPENARCHIVE) SET_CALLTYPE(p, CALL_QUERY) SET_STR_A(p, ArchiveData->ArcName) SET_INT(p, ArchiveData->OpenMode) // send DWORD writeSize = p - s_buff; DWORD writedSize; while (WriteFile(s_pipe, s_buff, writeSize, &writedSize, NULL)) { assert(writeSize == writedSize); // recv DWORD readedSize; if (ReadFile(s_pipe, s_buff, PIPE_BUFF_SIZE, &readedSize, NULL)) { // deserialize uint8_t *p = s_buff; uint8_t func; GET_FUNC(p, func) uint8_t callType; GET_CALLTYPE(p, callType) if (callType == CALL_ANSWER) { assert(func == OPENARCHIVE); GET_INT(p, ArchiveData->OpenResult) HANDLE r; GET_HANDLE(p, r) // result return r; } else if (callType == CALL_QUERY) { CALL_PROC } assert(0); } } ArchiveData->OpenResult = E_NOT_SUPPORTED; } return NULL; } 

OpenArchive पहला फ़ंक्शन है जो मॉड्यूल लोड करने के बाद TC कॉल करता है। प्रकार tOpenArchiveData की एक पॉइंटर संरचना इसके पास जाती है।

 typedef struct { char* ArcName; int OpenMode; int OpenResult; char* CmtBuf; int CmtBufSize; int CmtSize; int CmtState; } tOpenArchiveData; 

हम संरचना के लिए एक सूचक पारित नहीं कर सकते हैं, प्रक्रियाएं अलग-थलग हैं और एक दूसरे की स्मृति को नहीं देखती हैं। हम केवल पंक्ति (सूचक) के लिए सूचक और फ़ील्ड के संरेखण के कारण, संरचना को केवल संदेश में कॉपी करके स्थानांतरित नहीं कर सकते। साथ ही, कुछ फ़ील्ड्स को किसी फ़ंक्शन (ArcName, OpenMode) में डेटा ट्रांसफर करने के लिए डिज़ाइन किया गया है, और कुछ परिणाम (OpenResult) को वापस करने के लिए एक बफर के रूप में काम करते हैं, बाद वाले का उपयोग बिल्कुल नहीं किया जाता है (Cmt *)। हमें मार्शल चाहिए, अर्थात्, डेटा को ट्रांसमिशन के लिए उपयुक्त प्रारूप में परिवर्तित करें। इसके लिए, लिखित मैक्रो SET_ * की एक श्रृंखला का उपयोग किया जाता है। SET_INT बफर को 32 बिट संख्या के रूप में एक इंट लिखता है। SET_STR_A बफर को सूचक की वैधता के संकेत को स्ट्रिंग पर लिखता है, और वैधता के मामले में, टर्मिनल शून्य के साथ स्ट्रिंग का आकार और सूचक द्वारा इंगित वर्णों की सरणी लिखता है। बफर के शीर्ष पर दो मान रखे गए हैं: यह किस प्रकार का कार्य है और यह किस प्रकार का अनुरोध है। अगला, आपको बफर को लिखे गए डेटा के आकार की गणना करने और उन्हें पाइप पर लिखने की आवश्यकता है। दूसरी ओर से उत्तर की प्रतीक्षा करें। प्रतिक्रिया प्राप्त करते समय, दो मान पढ़ें: यह किस प्रकार का कार्य है और यह प्रतिक्रिया समारोह के निष्पादन के लिए एक प्रतिक्रिया या अनुरोध है। यदि यह उत्तर है, तो हमें परिणाम मिलता है, संरचना को भाग लिखें और फ़ंक्शन से बाहर निकलें। यदि यह एक प्रतिक्रिया फ़ंक्शन को कॉल करने का अनुरोध है, तो हम इसके लिए पैरामीटर प्राप्त करते हैं, इसे निष्पादित करते हैं, परिणाम लौटाते हैं और अगली प्रतिक्रिया की प्रतीक्षा करते हैं (यह सब CALL_PROC मैक्रो में छिपा हुआ है)। अलग-अलग, यह माना फ़ंक्शन के परिणाम के प्रकार को ध्यान देने योग्य है। यह हस्तरेखा है, लेकिन वास्तव में एक सूचक है। इसे टीसी के बाकी फ़ंक्शन को कॉल करने के लिए एक पैरामीटर के रूप में आवश्यक होगा। लेकिन इसका महत्व केवल मॉड्यूल के भीतर एक भूमिका निभाता है। 32 बिट प्रक्रियाओं में, सूचक 32 बिट है, क्रमशः 64 में, 64 बिट में। और यह एक 32 बिट प्रक्रिया में बनाया गया है। इसलिए, इसे 64 और फिर 32 में परिवर्तित करने से डेटा हानि नहीं होगी।
दो फ़ंक्शन (SetChangeVolProc, SetProcessDataProc) मॉड्यूल में फीडबैक फ़ंक्शन रजिस्टर करते हैं। हमारे भाग के लिए, हम बस उन्हें याद करते हैं, और पंजीकरण के तथ्य से अवगत कराते हैं। CALL_PROC में उनकी आवश्यकता होगी।

संदेश मिलने पर

• एक संदेश मिलता है
• अनजिप विकल्प
• एक्सटेंशन से कॉल फ़ंक्शन
• परिणाम पैक करें
• परिणाम के साथ एक संदेश भेजें

संदेश प्राप्त चक्र

  while (s_loop) { DWORD readedSize; if (ReadFile(s_pipe, s_buff, PIPE_BUFF_SIZE, &readedSize, NULL)) { // deserialize, process, serialize uint8_t *p = s_buff; uint8_t func; GET_FUNC(p, func) uint8_t callType; GET_CALLTYPE(p, callType) assert(callType == CALL_QUERY); if (func == OPENARCHIVE) { tOpenArchiveData openArchiveData = {0}; GET_STR_A(p, openArchiveData.ArcName) GET_INT(p, openArchiveData.OpenMode) HANDLE r = OpenArchive(&openArchiveData); p = s_buff; SET_FUNC(p, OPENARCHIVE) SET_CALLTYPE(p, CALL_ANSWER) SET_INT(p, openArchiveData.OpenResult) SET_HANDLE(p, r) } else ... ... { assert(0); } DWORD writeSize = p - s_buff; DWORD writedSize; if (!WriteFile(s_pipe, s_buff, writeSize, &writedSize, NULL) || writeSize != writedSize) { return -6; } } else if (GetLastError() != ERROR_TIMEOUT) { break; } } 

सब कुछ उसी के बारे में है। हमें एक संदेश मिलेगा, पता करें कि वे किस फ़ंक्शन को कॉल करने के लिए कह रहे हैं, रिवर्स प्रोसेस को मार्शलिंग (GET_ *) के लिए करें, फ़ंक्शन को कॉल करें, परिणाम प्राप्त करें और इसे लाइब्रेरी में भेजें। फ़ंक्शन कॉल के दौरान, कॉलबैक फ़ंक्शन हो सकता है।

 int __stdcall ChangeVolProc(char *ArcName, int Mode) { uint8_t *p = s_buff; SET_FUNC(p, CHANGEVOLPROC) SET_CALLTYPE(p, CALL_QUERY) SET_STR_A(p, ArcName) SET_INT(p, Mode) DWORD writeSize = p - s_buff; DWORD writedSize; assert(WriteFile(s_pipe, s_buff, writeSize, &writedSize, NULL) || writeSize == writedSize); DWORD readedSize; assert(ReadFile(s_pipe, s_buff, PIPE_BUFF_SIZE, &readedSize, NULL)); p = s_buff; uint8_t func; GET_FUNC(p, func) uint8_t callType; GET_CALLTYPE(p, callType) assert(func == CHANGEVOLPROC && callType == CALL_ANSWER); int r; GET_INT(p, r) return r; } 

हमारे शेल फ़ंक्शन को कहा जाता है, जो कनेक्शन का संचालन करेगा (पुस्तकालय के साथ)।

यह सब सरोगेट प्रक्रिया की असामान्य समाप्ति, स्टब फ़ंक्शंस के प्रतिस्थापन और डिफ़ॉल्ट मानों की वापसी के रूप में त्रुटि से निपटने के साथ है।

समाधान का नकारात्मक पक्ष: यह सब मॉड्यूल की गति को धीमा कर देता है।

शायद यह सब ...

क्या बचा है?

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

पूर्ण स्रोत कोड स्रोत पर पाया जा सकता है। आप विंडोज के लिए पील्स सी का उपयोग करके निर्माण कर सकते हैं। परिणामी एप्लिकेशन और लाइब्रेरी को मॉड्यूल के अनुसार नाम दिया जाना चाहिए (उदाहरण: msi.wcx मॉड्यूल, msi.exe प्रोग्राम, msi.wcx64 लाइब्रेरी) और मॉड्यूल के बगल में रखा गया है।

और मैं आपकी राय जानना चाहूंगा