लिनक्स में LD_PRELOAD या फ़ंक्शन प्रतिस्थापन का व्यावहारिक उपयोग

सभी को नमस्कार!
2010 में, shoumikhin ने एक बढ़िया लेख, साझा पुनर्भरण लाइब्रेरी में फ़ीचर पुनर्निर्देशन लिखा। यह लेख बहुत अच्छी तरह से लिखा गया है, पूर्ण है, लेकिन यह फ़ंक्शन को प्रतिस्थापित करने के अधिक कट्टर तरीके का वर्णन करता है। इस लेख में, हम डायनामिक लिंकर के मानक फीचर का उपयोग करेंगे - पर्यावरण चर LD_PRELOAD, जो बाकी लोड करने से पहले आपकी लाइब्रेरी को लोड कर सकता है।

यह कैसे काम करता है?

हां, यह बहुत सरल है - लिंकर आपके पुस्तकालय को आपके "मानक" कार्यों के साथ पहले लोड करता है, और जो पहला है - वह और चप्पल। और आप अपनी लाइब्रेरी से वास्तविक एक, और "प्रॉक्सी" कॉल डाउनलोड कर सकते हैं, साथ ही साथ जो चाहें कर सकते हैं।

रियल उपयोग-केस # 1: ओपेरा में mimeinfo.cache को अवरुद्ध करना

मुझे वास्तव में ओपेरा ब्राउज़र पसंद है। मैं केडीई का भी उपयोग करता हूं। ओपेरा वास्तव में केडीई अनुप्रयोगों की प्राथमिकताओं का सम्मान नहीं करता है, और अक्सर एमकॉम में डाउनलोड किए गए ज़िप संग्रह को खोलने की कोशिश करता है, पीडीएफ में इमगुर-अपलोडर, सामान्य तौर पर, आप जिस्ट को पकड़ते हैं। हालाँकि, अगर उसे mimeinfo.cache फ़ाइल को पढ़ने से मना किया जाता है, तो वह "kioclient exec" के माध्यम से सब कुछ खोल देगी, और वह बेहतर जानता है कि मैं इस या उस फ़ाइल को क्या खोलना चाहता हूँ।

कोई एप्लिकेशन फ़ाइल कैसे खोल सकता है? दो कार्य दिमाग में आते हैं: खुला और खुला । मेरे मामले में, ओपेरा ने 64-बिट फोपेन एनालॉग - fopen64 का उपयोग किया । आप इसे ltrace उपयोगिता का उपयोग करके या बस objdump उपयोगिता आयात तालिका को देखकर निर्धारित कर सकते हैं।

हमें लाइब्रेरी लिखने के लिए क्या चाहिए? सबसे पहले, आपको मूल फ़ंक्शन का एक प्रोटोटाइप बनाने की आवश्यकता है।
मेन फोपेन द्वारा देखते हुए, इस फ़ंक्शन का प्रोटोटाइप निम्नानुसार है:

FILE *fopen(const char *path, const char *mode) 

और यह फ़ाइल को नहीं खोला जा सकता है, तो यह FILE या NULL को एक पॉइंटर देता है। ठीक है, कोड लिखें:

 #define _GNU_SOURCE #include <stdio.h> #include <string.h> #include <dlfcn.h> static FILE* (*fopen64_orig)(const char * path, const char * mode) = NULL; FILE* fopen64(const char * path, const char * mode) { if (fopen64_orig == NULL) fopen64_orig = dlsym(RTLD_NEXT, "fopen64"); if (strstr(path, "mimeinfo.cache") != NULL) { printf("Blocking mimeinfo.cache read\n"); return NULL; } return fopen64_orig(path, mode); } 

जैसा कि आप देख सकते हैं, सब कुछ सरल है: हम fopen64 फ़ंक्शन की घोषणा करते हैं, हमारे संबंध में "अगला" (मूल) फ़ंक्शन लोड करते हैं, और जांचें कि क्या हम "mimeinfo.cache" फ़ाइल खोल रहे हैं। इसे निम्न कमांड के साथ संकलित करें:

 gcc -shared -fPIC -ldl -O2 -o opera-block-mime.so opera-block-mime.c 

और ओपेरा चलाएं:

 LD_PRELOAD=./opera-block-mime.so opera 

और हम देखते हैं:

 Blocking mimeinfo.cache read Blocking mimeinfo.cache read Blocking mimeinfo.cache read Blocking mimeinfo.cache read 

सफलता!

वास्तविक उपयोग-केस # 2: किसी फ़ाइल को सॉकेट में बदलना

मेरे पास एक स्वामित्व अनुप्रयोग है जो प्रिंटर (डिवाइस फ़ाइल / देव / यूएसबी / एलपी 0) तक सीधी पहुंच का उपयोग करता है। मैं डिबगिंग के उद्देश्यों के लिए उसके लिए अपना सर्वर लिखना चाहता था। क्या खुला () लौटता है? फ़ाइल विवरणक। सॉकेट () क्या लौटाता है? एक ही फाइल डिस्क्रिप्टर जो पढ़ता है () और लिखता है () ठीक उसी तरह काम करता है। आरंभ करना:

 #define _GNU_SOURCE #include <stdio.h> #include <stdlib.h> #include <dlfcn.h> #include <strings.h> #include <sys/socket.h> #include <netinet/in.h> static int (*orig_open)(char * filename, int flags) = NULL; int open(char * filename, int flags) { if (orig_open == NULL) orig_open = dlsym(RTLD_NEXT, "open"); if (strcmp(filename, "/dev/usb/lp0") == 0) { //opening tcp socket struct sockaddr_in servaddr, cliaddr; int socketfd = socket(AF_INET, SOCK_STREAM, 0); bzero(&servaddr,sizeof(servaddr)); servaddr.sin_family = AF_INET; servaddr.sin_addr.s_addr=inet_addr("127.0.0.1"); // addr servaddr.sin_port=htons(32000); // port if (connect(socketfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) == 0) printf("[Open] TCP Connected\n"); else printf("[Open] TCP Connection failed!\n"); return socketfd; } return orig_open(filename, flags); } 

बहुत वास्तविक उपयोग-केस # 3 नहीं: C ++ विधियों को इंटरसेप्ट करना

C ++ के साथ, चीजें थोड़ी अलग हैं। मान लीजिए कि हमारे पास एक वर्ग है:

 class Testclass { int var = 0; public: int setvar(int val); int getvar(); }; 

 #include <stdio.h> #include "class.h" void Testclass() { int var = 0; } int Testclass::setvar(int val) { printf("setvar!\n"); this->var = val; return 0; } int Testclass::getvar() { printf("getvar! %d\n", this->var); return this->var; } 

लेकिन कार्यों को परिणामी फाइल में "टेस्टक्लास :: गेटवर" और "टेस्टक्लास :: सेटवर" नहीं कहा जाएगा। कार्यों के नाम जानने के लिए, बस निर्यात तालिका देखें:

 nm -D libclass.so … 0000000000000770 T _Z9Testclassv 00000000000007b0 T _ZN9Testclass6getvarEv 0000000000000780 T _ZN9Testclass6setvarEi 

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

 #define _GNU_SOURCE #include <stdio.h> #include <dlfcn.h> typedef int (*orig_getvar_type)(void* instance); int _ZN9Testclass6getvarEv(void* instance) { printf("Wrapped getvar! %d\n", instance); orig_getvar_type orig_getvar; orig_getvar = (orig_getvar_type)dlsym(RTLD_NEXT, "_ZN9Testclass6getvarEv"); printf("orig getvar %d\n", orig_getvar(instance)); return 0; } 

वह, वास्तव में, मैं जो भी बात करना चाहता था। मुझे उम्मीद है कि यह किसी के लिए उपयोगी होगा।