Question

I am new to Haskell programming, Foreign Function Interface and Stackoverflow. I am trying to build a Haskell FFI binding for a C based library. Please find below a hypothetical example which is very similar to my current problem:

Consider I have a C struct and a function like this:

typedef struct {
      int someInt;
      void *someInternalData;
   } opaque_t;

int bar (opaque_t *aPtr, int anArg);

The opaque C structure is the out parameter here. I should pass on the same to other APIs. The caller need not de-reference the opaque struct.

Find below myFFI.hsc file with FFI imports:

{-# LANGUAGE CPP, ForeignFunctionInterface #-}
module MyFFI where
import Foreign
import Foreign.Ptr
import Foreign.ForeignPtr
import Foreign.C.Types
import Foreign.C
import System.IO.Unsafe
import Foreign.Marshal
import qualified Foreign.ForeignPtr.Unsafe (unsafeForeignPtrToPtr)
import qualified System.IO (putStrLn)

#include "myclib.h"

newtype OpaquePtr = OpaquePtr (ForeignPtr OpaquePtr)

#let alignment t = "%lu", (unsigned long)offsetof(struct {char x__; t (y__); }, y__) 
instance Storable OpaquePtr where
    sizeOf _ = #{size opaque_t}
    alignment _ = #{alignment opaque_t}
    peek _ = error "Cant peek"

foreign import ccall unsafe "myclib.h bar"
    c_bar :: Ptr OpaquePtr
                -> CInt
                -> CInt

barWrapper :: Int -> (Int, ForeignPtr OpaquePtr)
barWrapper anArg = System.IO.Unsafe.unsafePerformIO $ do
    o <- mallocForeignPtr
    let res = c_bar (fromIntegral anArg) (Foreign.ForeignPtr.Unsafe.unsafeForeignPtrToPtr o)
    return ((fromIntegral res), o)

In my actual code, similar implementation of the above seems to work. But when I pass around the opaque struct reference, I am getting weird output and some times the ghci crases.

I am not sure about the usage of mallocForeignPtr and ForeignPtr in FFI call. For a long living reference we should use ForeignPtr + mallocForeignPtr, but we cannot pass a ForeignPtr in a ccall. How to do it then? Is my above logic correct?
Any kind of help would be really great. Thanks.

Answer 1

Well, I think I found a solution with proper usage of ForeignPtr and mallocForeignPtr:

barWrapper :: Int -> (Int, Either error (ForeignPtr OpaquePtr))
barWrapper anArg = System.IO.Unsafe.unsafePerformIO $ do
    o <- mallocForeignPtr
    withForeignPtr o $ \opaque_ptr -> do
        let res = c_bar (fromIntegral anArg) opaque_ptr
        if res /= (-1)
            then return ((fromIntegral res), Right o)
        else
            return ((fromIntegral res), Left $ error "some problem")

The issues were:

1. I overlook the lazy evaluation thingy of Haskell : only on accessing the ‘res’ the foreign call will be executed. So, I had to use a if / else block to make it call the ccall
2. I should be using withForeignPtr instead of unsafeForeignPtrtoPtr