खुले से हुक से सेगमेंटेशन गलती()

Question

मैं सिस्टम फ़ंक्शन open() पर एक हुक बनाने की कोशिश कर रहा हूं। मैंने इसे निम्नलिखित पंक्तियों के साथ किया है।

extern int mocked_open(const char* fn, int flags, va_list args); 

int open(const char* fn, int flags, ...) 
{ 
    int r = -1; 
    va_list args; 

    va_start(args, flags); 
    r = mocked_open(fn, flags, args); 
    va_end(args); 

    return r; 
} 

मैं libwrapper.so में इस संकलन है, जो मैं LD_PRELOAD का उपयोग करके लोड:

मैं निम्नलिखित के साथ एक आवरण पुस्तकालय बनाया।

int mocked_open(const char* fn, int flags, va_list args) 
{ 
    if (strncmp(fn, test_device_id, 11) == 0) 
    { 
     return mock().actualCall("open").returnValue().getIntValue(); 
    } 
    else 
    { 
     int r = -1; 
     int (*my_open)(const char*, int, ...); 
     void* fptr = dlsym(RTLD_NEXT, "open"); 
     memcpy(&my_open, &fptr, sizeof(my_open)); 

     if (flags & O_CREAT) 
     { 
      r = my_open(fn, flags, va_arg(args, mode_t)); 
     } 
     else 
     { 
      r = my_open(fn, flags); 
     } 

     return r; 
    } 
} 

test_device_id एक सरल स्ट्रिंग ("test_device"), जो मुझे आशा है कि अन्यत्र इस्तेमाल नहीं किया जाता है:

mocked_open() के कार्यान्वयन के रूप में इस प्रकार है (मैं CPPUtest ढांचे का उपयोग) है।

परीक्षण चलाने के दौरान निष्पादन योग्य एक खंडन गलती के साथ दुर्घटनाग्रस्त हो जाता है। मैंने इसे जीसीसी प्रोफाइलिंग कार्यक्षमता में खोज लिया है, जो .gcda फ़ाइलों का एक गुच्छा खोलना/बनाना चाहता है और इसके लिए open() पर कॉल करना चाहता है।

स्ट्रेस (नीचे प्रति सुझाव) के साथ कुछ डिबगिंग के बाद, मैंने पाया कि लाइन r = my_open(fn, flags, va_arg(args, mode_t)); वास्तव में अपराधी है। इसे रिकर्सिवली कहा जा रहा है, या ऐसा लगता है: फ़ंक्शन लौटने के बिना, मुझे इस लाइन में बहुत सी कॉल दिखाई देती हैं। फिर एक segfault। खोला जा रहा फ़ाइल संबंधित .gcda फ़ाइल (प्रोफाइलिंग के लिए) है। वास्तव में, segfault केवल प्रोफाइलिंग प्रोफाइलिंग के साथ होता है।

Answer 1

के लिए जब आप सक्षम gcov रूपरेखा के साथ संकलन उम्मीद है, संकलक अपने कार्यों में अतिरिक्त कोड सम्मिलित करता है, ट्रैक जिनमें से कोड निष्पादित कर दिया गया है रखने के लिए। किसी न किसी तरह स्यूडोकोड में, कि डाला कोड (अन्य बातों के अलावा) करना होगा:

if (!output_file_has_been_opened) { 
    fd = open(output_filename, ...); 
    check_ok(fd); 
    output_file_has_been_opened = TRUE; 
    track_coverage(); 
} 

... इसलिए यदि आउटपुट फ़ाइल अभी तक सफलतापूर्वक नहीं खोला गया है (अपने कार्यक्रम के शुरू में के रूप में), यह प्रयास करेंगे इसे खोलने के लिए। दुर्भाग्यवश, इस मामले में जो आपके मॉक open() फ़ंक्शन को कॉल करेगा - जिसमें एक ही डाला गया कोड होगा; चूंकि फ़ाइल अभी भी सफलतापूर्वक खोला नहीं गया है, और चूंकि gcov कोड को पता नहीं है कि कुछ असामान्य चल रहा है, यह open() फिर से कॉल करने का प्रयास करेगा - और यही कारण है कि रिकर्सन (और आखिरकार segfault, एक बार ढेर थका हुआ है)।

Answer 2

इस

typedef int (*OpenFunction)(const char* fn, int flags, ...); 

प्रयास करें तो

OpenFunction function; 
void  **pointer; 

pointer = (void **)&function; 
*pointer = dlsym(RTLD_NEXT, "open"); 

इस एक पूरा काम कर उदाहरण

#include <stdio.h> 
#include <string.h> 
#include <stdlib.h> 
#include <dlfcn.h> 
#include <unistd.h> 
#include <fcntl.h> 

#include <errno.h> 

typedef int (*OpenFunction)(const char* fn, int flags, ...); 

int main(int argc, char **argv) 
{ 
    OpenFunction function; 
    void  *dl; 
    int   fd; 
    void  **pointer; 

    if (argc < 2) 
     return -1; 
    pointer = (void **)&function; 
    *pointer = dlsym(RTLD_NEXT, "open"); 

    fd = function(argv[1], O_RDONLY); 
    if (fd != -1) 
    { 
     printf("file opened succesfully\n"); 
     close(fd); 
    } 
    else 
    { 
     printf("%s: cannot open the file\n", strerror(errno)); 
    } 
    return 0; 
} 

Answer 3

आप va_list गलत तरीके से गुजर रहे हैं। निम्नलिखित का प्रयास करें यह मदद करता है

 r = my_open(fn, flags, args); 

अधिक जानकारी http://c-faq.com/varargs/handoff.html