Carregar dinamicamente

Estou com um problema muito estranho ao usar a função dlopen.
Tenho várias chamadas dentro do programa e ela funciona normalmente mas algumas vzs ela corrompe áreas de memória que não tem relação aparente com a estrutura. ex:

c = tmp->data //unsigned char *
.... //outras funções do código sem conexão alguma com tmp->data;
void *dllmanager = dlopen("nome.so",RTLD_LAZY);
//PRONTO ! c está todo corrompido!

Alguma idéia??

o retorno é um ponteiro void

void *dllmanager = dlopen("nome.so",RTLD_LAZY);

Correto, falha minha que coloquei errado aqui no post, mas no codigo já estava void *
Arrumei agora

blz, então coloque uma porção maior do código, o problema pode ter origem lá atrás. o ideal é dar um backtrace no gdb para tirar a teima se o problema está ou não relacionado ao carregamento da lib ou na própria (tanto na entry quanto no código mesmo). essa lib aí, foi você quem criou? ou ainda, você tem acesso ao código fonte?

não entendi bem o seu problema mas pode ser que o ponteiro esteja estourando a memoria.... no prototipo dele predetermina o tamanho eg.:
void c[1..50];

Sim , a lib fui eu quem criou, tenho acesso total ao código dela :) o problema não é a lib em si mas parece que ao chamar a função de carregar a lib ela gera um estouro de memória que corrompe os dados. Eu fiz os testes e executei exatamente o mesmo código sem a linha de codigo do dlopen e fica tudo certo, ao executar o dlopen a memória é corrompida. Algo me diz que é esse ponteiro do tipo void...

//codigo

while(!exec_queue.empty()) //percorre um vetor
{
tmp = &lp->list_macro.back(); //puxa os dados
addr = lp->point_device->addr;
dll = search_device(addr); //retorna o caminho para a lib
void *dllmanager = dlopen(dll,RTLD_LAZY);
if (dllmanager == NULL)
{
fprintf(stderr,"Error: load of dynamic .so failed : %s\n",dlerror());
exit(1);
}
check_events = (unsigned char *(*)(device *,unsigned char*,int)) dlsym(dllmanager,"check_events"); //Funcao a ser executada
if ((error = dlerror()) != NULL )
{
fprintf(stderr,"Error loading dynamic function: %s\n",dlerror());
}
tmp_device = lp->point_device;
rsp = check_events(tmp_device,tmp->command,tmp->size);
dlclose(dllmanager);
//Problema !! Aqui tmp->command está corrompido!!
bytes = write(serialfd,tmp->command,tmp->size);
lp->list_macro.pop_back();

Adiantando ...
ja arranquei toda parte de codigo entre tmp->command e o dlopen ! Eu fiz um teste onde eu dou um print em tmp->command antes e depois do dlopen e é exatamente depois que o dado se torna corrompido

pode ser tambem que esse ponteiro void esteja causando algum erro de comparacao entre ponteiro e inteiro... tente usar um tipo de enumeracao na criacao desse ponteiro... onde esta o prototipo desse ponteiro? vc esta criando ele sem prototipar???

O seu código leva-me a crer que você desenvolveu sua solução em C++, apesar de seu código ser um mix de C e C++, a não ser que você esteja usando ponteiros para função dentro das suas estruturas de dados.

dlopen não corrompe memória. Operadores relacionais também não corrompem memória. O seu código sim. Ao executar um dlopen, o sistema operacional reorganiza a memória do seu processo de tal maneira que se possa comportar o código do arquivo carregado dinamicamente. Tudo é feito dentro do espaço de endereçamento do mesmo processo que solicitou o dlopen ao sistema operacional. Se você escreveu seu código em C++, verifique se dentro da sua biblioteca há alguma classe sendo construída durante a carga (singletons e objetos globais são uma boa dica).

Verifique se há algum vetor ou ponteiro sendo manipulado erroneamente. O trecho de código que você colou aqui demonstra várias funções que tem potencial para causar o problema.