is it possible to share an "unmanaged" shared memory pointer using boost interprocess?

My case is very rare.
I have a library called libtest.so. It has a function called void test1(int **p);

void test1(int **p)
{
   *p = (int *) malloc(4 * sizeof(int));
}

I can get the integer array by this way

int p = NULL;
test0(&p);

For some reason, I don't want to dlopen() it in process A.
Instead, I dlopen("libtest.so") in process B and create a managed_shared_memory.
The process A connects to the managed_shared_memory.

The process B calls the test0(&p) to obtain an integer array.
It is possible to share this pointer p(unmanaged shared memory) from process B to process A ?

I tried to pass the addr of p by pointer of pointer of the managed_shared_memory from process B to process A. But It didn't work.

// process B
struct shm_object
{
    offset_ptr<int *> pp;
	shm_object() :{};
};
...
shm = managed_shared_memory(open_or_create, INTERPROCESS_MEMORY_NAME,MANAGED_MEMORY_INITIAL_SIZE);
s_mem_object = shm.find_or_construct<shm_object>(SHARED_MEMORY_OBJECT_1_NAME)

int p;
test0(&p);

s_mem_object->pp = static_cast<int **>(shm.allocate(sizeof(int *)));
int **pp = static_cast<int **>(s_mem_object->p.get());

pp[0] = p;   // save address of the p to pp
...

// process A
...
 int **pp = static_cast<int**>(s_mem_object->pp.get());
 for(int i=0; i<4; i++)
 {
    printf("from process-A %d\n", (*pp)[i]);
 }
...

Sure, the standard way to make this scenario works is

1. to get the integer array
2. allocate a piece of memory
3. copy the integer array to the managed_shared_memory

But, it real case scenario, the memory structs are complicated. A lot of efforts have to be spent on the implementation of deep-copy.

Is there any workaround ?

If test1 cannot be (made) allocator-aware you cannot reliably/usefully share a pointer with another process.

Note that you can hand it off to another process and receive it back usefully. I'd suggest to send it as ptrdiff_t instead of the raw pointer to avoid accidental use as a pointer.