Access Violation bei MMF-Funktionen



  • habe mir 2 funktionen zum Lesen und Schreiben aus MMFs geschrieben nur verursachen mir diese wenn ich sie in eine dll packe und bei einer hook-funktion ausführen lasse avs
    hier sind die Funktionen:

    #ifndef MyMMFH
    #define MyMMFH
    //---------------------------------------------------------------------------
    #include <string>
    const int max=100;
    
    template<class T>
    inline bool __fastcall WriteToMMF(char* name, T data)
    {
            HANDLE mmf = CreateFileMapping(INVALID_HANDLE_VALUE,NULL,
                                           PAGE_READWRITE,0, sizeof(data),name);
            if(!mmf) return false;
            LPVOID mem = MapViewOfFile(mmf, FILE_MAP_WRITE,0,0,sizeof(data));
            if(!mem) return false;
            CopyMemory(mem, &data, sizeof(T));
    
            return true;
    
    }
    template<class T>
    inline bool __fastcall ReadFromMMF(char* name, T& data)
    {
            HANDLE mmf = OpenFileMapping(FILE_MAP_READ,false,name);
            if(!mmf) return false;
            LPVOID mem = MapViewOfFile(mmf, FILE_MAP_READ,0,0,sizeof(data));
            if(!mem) return false;
            CopyMemory(&data,mem , sizeof(T));
    
            return true;
    }
    #endif
    

    seht ihr da irgendwelche sachen die auf eine av führen könnten?



  • Benutze Debugging, um den Fehler genau zu lokalisieren.
    Und was ist mit CloseHandle?
    Und wie hast du die Template Funktionen in eine DLL gepackt? Irgendwie musst du die doch für bestimmte Typen instanziert haben?



  • thx, CloseHandle hab ich vergessen.
    Und in die DLL hab ich die Datei includet.
    Ich benutze die Templates für nen Struct aus 3 bools.
    ich geh dann mal mit dem debugger durch aber die av kommt immer sehr unverhofft daher is das sehr aufwendig mit dem testen



  • Wie willst du inline Funktionen in eine DLL packen? Desweiteren ist es bei DLLs meistens das beste eine reine C Schnittstelle zu benutzen, hierfür wurden sie schließlich gebaut. Dein Beispiel würde ich folgendermaßen lösen.

    dll.cpp

    extern "C" int __stdcall WriteToMMF(char* name, const void*data, size_t size)
    {
      HANDLE mmf = CreateFileMapping(INVALID_HANDLE_VALUE,NULL,
        PAGE_READWRITE,0, size,name);
      if(!mmf) 
        return 0;
      LPVOID mem = MapViewOfFile(mmf, FILE_MAP_WRITE,0,0,size);
      if(!mem) 
        return 0;
      CopyMemory(mem, data, size);
      CloseHandle(mmf); // Hast du vergessen glaub ich
      return 1;
    }
    
    extern "C" int __stdcall ReadFromMMF(char* name, void*data, size_t size)
    {
      HANDLE mmf = OpenFileMapping(FILE_MAP_READ,FALSE,name);
      if(!mmf)
        return 0;
      LPVOID mem = MapViewOfFile(mmf, FILE_MAP_READ,0,0,size);
      if(!mem) 
        return 0;
      CopyMemory(data,mem , size);
      CloseHandle(mmf); // Hast du vergessen glaub ich
      return 1;
    }
    

    dll.h

    namespace dllimport{
      extern "C" int __stdcall WriteToMMF(char* name, const void*data, size_t size);
      extern "C" int __stdcall ReadFromMMF(char* name, void*data, size_t size);
    }
    template<class T>
    bool WriteToMMF(const std::string&str, const T&t)
    {
      return dllimport::WriteToMMF(str.c_str(), &t, sizeof(T));
    }
    template<class T>
    bool ReadFromMMF(const std::string&str, T&t)
    {
      retrun dllimport::ReadFromMMF(str.c_str(), &t, sizeof(T));
    }
    

    Ich hoffe dir ist bewusst, dass T ein POD sein muss?


Log in to reply