CODEWITHSUNDEEP
c#wrapper32bit-64bitdllimport
Gayan
Gayan

Reputation: 2860

32 bit unmanaged dll in 64 bit wrapper

I'm creating a wrapper from loading 32-bit unmanaged dll to execute in 64-bit environment. so my approach used this LegacyWrapper 

[LegacyDllImport("ste.dll")]
public interface INativeMethods : IDisposable
{
    [LegacyDllMethod(CallingConvention = CallingConvention.Winapi)]
    IIntPtr ste_init_with_environment_info(string dirLocation, string language);
}

I'm calling this method as below 

public IWrapperConfig Configuration
{
    get
    {
        return _configuration ??= WrapperConfigBuilder.Create().TargetArchitecture(TargetArchitecture.X86).Build();
    }
}


using var client = WrapperProxyFactory<INativeMethods>.GetInstance(Configuration);
_steHandle = client.ste_init_with_environment_info(steHomeDirectory, SystemProperties());

it seems works without exception but. When I call the function, as a result, I'm getting 0x0000000000000000 which should be something like 0x0186ad58 what causes the issue?

UPDATE

when I see the source code of LagacyWrapper see the serialization and deserialization as below using System.Runtime.Serialization.IFormatter

public void SendCallRequest(CallData callData)
{
    _formatter.Serialize(_pipe, callData);
}

public CallResult ReceiveCallResponse()
{
    CallResult callResult = (CallResult)_formatter.Deserialize(_pipe);

    if (callResult.Exception != null)
    {
        throw callResult.Exception;
    }

    return callResult;
}

Upvotes: 0

Views: 864

Answers (1)

JonasH
JonasH

Reputation: 36341

I'm not very familiar with LegacyWrapper, so this is based on conjecture.

From the blogpost introducing Legacy wrapper:

Since we can’t load 32bit code into our 64bit process, the idea is to create a separate executable for this task. It would somehow load a library, invoke a specific function and pass the results back to the caller.

Since your library runs in another process, returning a pointer to memory will probably not work. As far as I know there is no general way to know how much valid memory a pointer points to, so how would the wrapper know how much memory to copy? This might be possible to solve for some special cases, but I cannot find any documentation about the details of the serialization-process.

You might be able to define that the pointer should be marshalled to a structure. Otherwise you might want to post an issue at the legacyWrapper project page, to clarify the documentation if nothing else.

Upvotes: 2

Related Questions