लाइब्रेरी और रनटाइम बनाने वाले फंक्शन कॉल्स की नेटवर्क एक्सेस

मैं एक पेशेवर गतिविधि से एक कहानी साझा करना चाहता हूं जिसे एक ब्लॉग पर पागलदेव नाम से पोस्ट किया जा सकता है :) यह असामान्य समाधानों के बारे में एक कहानी है (जिन्हें मैंने शीर्षक में संक्षेप में वर्णन करने की कोशिश की थी), जिसे मुझे और भी असामान्य प्रतिबंधों और आवश्यकताओं के लिए मजबूर किया गया था।


और किसी तरह, चतुराई से *** y के माध्यम से, यह काम करता है ©

समस्या कथन

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

समाधान खोजे

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

अनुवादक

सामान्य शब्दों में, यह इस तरह दिखता है:

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

हर जगह चंचलता

एक पुस्तकालय को जोड़ने और उससे एक फ़ंक्शन को कॉल करने का एक सरल उदाहरण।

typedef double (*myfunc_type)(long, long); ... void *mylib; myfunc_type myfunc; double res; ... mylib = dlopen("mylib.dll", RTLD_LAZY); myfunc = dlsym(mylib, "my_func_name"); res = (*myfunc)(2, 4); 

जैसा कि हम देख सकते हैं, किसी फ़ंक्शन को एक्सेस करने के लिए, हमें पहले उसके प्रकार का वर्णन करना चाहिए:
typedef double (*myfunc_type)(long, long);

और क्या करना है जब विकास के चरण में हम किस प्रकार के कार्यों को अज्ञात करेंगे?

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

 //    , //    TDLL_Function //  ,    (  ) function TDLL_Function.Execute(): TByteAr; var i: Integer; //   len : Integer; //      B1 : Byte; //    B2 : Word; //    B4 : Cardinal; //  4-  B8 : Double; //   8-  StackPos : Integer; //     begin //ParamBytes   ,      , //      len:=Length(ParamBytes); asm //    (  esp) mov StackPos, esp end; //ParamType   ,     : //TParamType = (ptOne=1, ptTwo=2, ptFour=4, ptEight=8, ptVoid=0, ptPointer=-1); //  ,       //   , ..         for i := Length(ParamType)-1 downto 0 do begin case ParamType[i] of //      ptOne:begin dec(len,1); //  ParamBytes    ( ),    Move(ParamBytes[len],B1,1); asm //  ,     MOVSX EAX,B1 PUSH EAX end; end; ptTwo:begin //     dec(len,2); Move(ParamBytes[len],B2,2); asm MOVSX EAX,B2 PUSH EAX end; end; ptFour:begin //     dec(len,4); Move(ParamBytes[len],B4,4); asm MOV EAX,B4 PUSH EAX end; end; //        ,    //64-  (8   )    ptPointer:begin dec(len,4); Move(ParamBytes[len],B4,4); asm MOV EAX,B4 PUSH EAX end; end; ptEight:begin dec(len,8); Move(ParamBytes[len],B8,8); asm //        PUSH DWORD PTR [B8]+$04 PUSH DWORD PTR B8 end; end; ptVoid: begin end; end; end; // B4       case fCallingConv of //       ccStdcall: begin TStdCall(Proc)(); //Proc -     asm //    MOV B4,EAX end; end; ccCdecl:begin TCdeclCall(Proc)(); //   Cdecl          asm MOV B4,EAX mov esp, StackPos; end; end; end; //   ,     case ResultType of //     ptOne:begin //   Result      B4 SetLength(Result,1); Move(Byte(B4),Result[0],1); end; ptTwo:begin SetLength(Result,2); Move(Word(B4),Result[0],2); end; ptFour:begin SetLength(Result,4); Move(B4,Result[0],4); end; ptPointer:begin SetLength(Result,4); Move(B4,Result[0],4); end; ptEight:begin //    ,  B8    asm FSTP B8 end; SetLength(Result,8); Move(B8,Result[0],8); end; ptVoid:begin SetLength(Result,0); end; end; end; 

मैं आपसे कोड को लात नहीं मारने के लिए कहता हूं, इसमें निश्चित रूप से अनुकूलन की आवश्यकता होती है।
कार्यान्वयन सुविधाओं के बारे में:
1) केवल stdcall और cdecl समझौते उपलब्ध हैं।
2) इस बात की कोई गारंटी नहीं है कि असेंबलर आवेषण उन आर्किटेक्चर पर भी काम करेगा, जिनके अलावा यह किया गया था।
1) 64-बिट कोड के लिए कोई समर्थन नहीं है, हालांकि सामान्य तौर पर, मैंने यह सुनिश्चित करने के लिए कुछ तरीके रखे हैं
2) यदि कोई फ़ंक्शन फ़ंक्शन के लिए पारित किया जाता है, उदाहरण के लिए, एक सरणी के लिए, तो क्लाइंट को पूरे सरणी को अग्रेषित करना चाहिए ताकि अनुवादक इसका विस्तार कर सके और फ़ंक्शन में इसे एक संकेतक भेज सके। यदि इस सरणी को वापस लौटाया जाना था, तो इसकी वापसी एक समान तरीके से आयोजित की गई थी।

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

कॉल के लिए क्रियाओं का सामान्य क्रम इस तरह देखा गया:
1) क्लाइंट अनुवादक से जुड़ता है
2) क्लाइंट उस लाइब्रेरी का नाम भेजता है जिससे वह कनेक्ट करना चाहता है
3) क्लाइंट लाइब्रेरी फ़ंक्शन का विवरण भेजता है जिसे वह कॉल करना चाहता है
4) क्लाइंट पैक और लाइब्रेरी फ़ंक्शन को कॉल करने के लिए पैरामीटर भेजता है
5) अनुवादक प्राप्त फ़ंक्शन विवरण के अनुसार मापदंडों का विस्तार करता है
6) अनुवादक पूर्वोक्त एक्सिक्यूट () कहता है
7) अनुवादक कार्य के आवश्यक परिणामों (फ़ंक्शन के विवरण के अनुसार) को पैक करता है और उन्हें क्लाइंट को भेजता है।

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

युपीडी। एक टैग "बैसाखी" जोड़ा गया ताकि वर्णित समाधानों की आत्म-पहचान के साथ कोई गलतफहमी न हो।