Detecting and clearing wrong object imported from dll in C++ - c++

Question

I have a dll ("so.dll") definition as follow, in which I have a function TestWrongClass, which returns a pointer
to a class object (TestWrongClass).
/////// "IOReader.h" //////////////
class IOReader
{
public :
IOReader() {};
virtual ~IOReader() {};
virtual bool open(const std::string &format,
const std::string &fileName, const int mask) = 0;
std::string errorMessage;
};
// "IOReader.h" Ends Here
// ---- so.dll ---- /
//////////////// sio.h ////////////
#ifdef SEIO_EXPORTS
#define SEIO_API __declspec(dllexport)
#else
#define SEIO_API __declspec(dllimport)
#endif
#include <string>
#include "IOReader.h"
class SReaderIO : public IOReader
{
public:
SReaderIO() {};
bool open(const std::string &format,
const std::string &fileName, const int mask)
{
return true;
}
};
class TestWrongClass
{
public:
TestWrongClass() { };
bool open(const std::string &format,
const std::string &fileName, const int mask)
{
return true;
}
};
SEIO_API TestWrongClass* CreateIOReader()
{
TestWrongClass * module = new TestWrongClass();
return module;
}
//// sio.h ends here ///////
//in the main executable I am loading the dll on run time
// and after creating a object of type TestWrongClass,
//I explicitly try to cast it with the wrong object, as follows
/// Main Source //
#include <iostream>
#include <windows.h>
#include "IOReader.h"
int main ()
{
HMODULE hDLL=LoadLibrary(L"sIO.dll");
CreateSealafineReaderFn _funcSelafinCreator = NULL;
_funcSelafinCreator = (CreateSealafineReaderFn) GetProcAddress (hDLL,
"CreateIOReader");
// Method 1
void *Iref = (_funcSelafinCreator)();
IOReader * locReader = NULL;
locReader = reinterpret_cast <IOReader *>(Iref); // but how to check
// that object locReader is not of base type IOReader
// so that I may call delete Iref
// If I try to do as follow, then I get illegal error from compiler
// locReader = dynamic_cast <IOReader *>(Iref); // illegal
// Method 2
try
{
locReader = dynamic_cast <IOReader *>((_funcSelafinCreator)());
// works but how can I check wrong casting and catch exception
} catch (std::bast_cast)
{
// how to clear the object created by CreateIOReader
}
}
//
The reason why I doing this process is to check if any dlls, which the main program will be scanning from the dll directory
may be having a method of the same name, however return pointer type of the created object by the method may be different, which is not desired.
(In the above mentioned case the method is CreateIOReader)
if I use dynamic_cast, I can check for the bad_cast exception, however the object will be already created in the dll, and won't be freed, since I
don't have access to the internal code of the dll.
the above method which I have given using reintepret_cast works, however I cannot check whether the correct object type is returned or not.
if get to know by some method that if the casting is not of correct type, then I can call delete on the Iref pointer "delete Iref" to clear the object from the heap.
Is there any method to check creation of wrong object by the method CreateIOReader, and thus delete it from the executable source code

Answer 1

For this problem dynamic_cast cannot help you. The issue is that you do not know the real return type of your function, and are just pretending it is IOReader*, when it could in fact be something else (i.e. TestWrongClass*). Under aliasing rules this is not allowed.
Contrast this with the situation:
class IBase { ... };
class IOReader : public IBase { ... };
class TestWrongClass : public IBase { ... };
where you also know that your function returns an IBase*. Here indeed a dynamic cast could help you, as IOReader and TestWrongClass have common ancestry, and it would be valid to refer to either through a IBase*.
I have to say it is a strange problem to have: a call to a library function where you have no idea what might be returned. I would suggest changing the design somewhat. You could (amongst other things):
Create the unified hierarchy as per above
Have the call return something like std::pair<int, void*>, where the int (or enum) would be a reliable way to determine what is being returned, after which you could reinterpret_cast the void*
If you choose approach 1, then to address your deletion problem, you could add a function like destroy() to the IBase interface, which would cause the library to delete the object (note: it is bad idea to delete yourself objects that are given to you by an external library).
If you choose approach 2, then perhaps you could have a library function like void destroy(int, void*), to which you could pass the members of your std::pair in case you received something other than what you wanted. The library could then use these to cast the void* back into the right thing to delete it internally.