free() invalid pointer ao usar mail_inicializar com c++

[gabr]

Compilei a biblioteca acbrlibmail consolemt para linux x86_64-mt nogui, mas ao tentar rodar esse arquivo simples de teste, obtenho o erro:
 

$ g++ test_mail.cpp -o test_mail -ldl
$ ./test_mail
MAIL_Inicializar = 0
free(): invalid pointer
Abortado (imagem do núcleo gravada)

arquivo test_mail.cpp:

#include <iostream>
#include <dlfcn.h>
#include <cstring>

typedef int (*MAIL_Inicializar_t)(char*, char*);
typedef int (*MAIL_Finalizar_t)();

int main() {
    void* handle = dlopen("/usr/lib/libacbrmail64.so", RTLD_NOW);
    if (!handle) { std::cerr << dlerror() << std::endl; return 1; }

    auto MAIL_Inicializar = (MAIL_Inicializar_t)dlsym(handle, "MAIL_Inicializar");
    auto MAIL_Finalizar   = (MAIL_Finalizar_t)dlsym(handle, "MAIL_Finalizar");

    char ini[256] = "";
    char key[256] = "";

    int ret = MAIL_Inicializar(ini, key);
    std::cout << "MAIL_Inicializar = " << ret << std::endl;

    ret = MAIL_Finalizar();
    std::cout << "MAIL_Finalizar = " << ret << std::endl;

    dlclose(handle);
    return 0;
}

Não tem como o mail_finalizar estar errado pois não tem parâmetros....

[gabr]

Não entendi muito bem o por quê mas resolvi usando os seguintes arquivos gerados pelo chatgpt:

main.cpp, ACBrMail.h e ACBrMail.cpp respectivamente

#include <iostream>
#include "ACBrMail.h"

#define B(x) long x##_len = 8192; char x[8192] = {0};

int main() {
    try {
        ACBrMail mail("config.ini", "");

        // verifica versão
        B(versao)
        mail.MAIL_Versao(versao, &versao_len);
        std::cout << "ACBrMail Versão: " << versao << "\n";

        // limpar estado do e-mail
        mail.MAIL_Clear();

        // configurar campos básicos
        mail.MAIL_SetSubject("Teste ACBrMail");
        mail.MAIL_AddAddress("[email protected]", "[email protected]");
        mail.MAIL_AddBody("Olá!\nEste é um teste de envio via ACBrLibMail.");

        // enviar
        int ret = mail.MAIL_Send();
        std::cout << "MAIL_Send retornou: " << ret << "\n";

        // pegar retorno do ACBr
        B(resp)
        mail.MAIL_UltimoRetorno(resp, &resp_len);
        std::cout << "Resposta:\n" << resp << "\n";
    }
    catch (const std::exception& ex) {
        std::cerr << "Erro: " << ex.what() << "\n";
    }
}

#pragma once
#include <string>

#if _WIN32 || _WIN64
#define ISWINDOWS
#include <windows.h>
#else
#define ISUNIX
#include <dlfcn.h>
#endif

class ACBrMail {
public:
    ACBrMail(const std::string& arqConfig="", const std::string& chaveCrypt="");
    ~ACBrMail();

    // --- métodos ACBr originais ---
    int MAIL_Inicializar(const char* eArqConfig, const char* eChaveCrypt);
    int MAIL_Finalizar();
    int MAIL_Inicializada();
    int MAIL_Nome(char* buffer, long* bufferSize);
    int MAIL_Versao(char* buffer, long* bufferSize);
    int MAIL_ConfigGravarValor(const char* sessao, const char* chave, const char* valor);
    int MAIL_ConfigGravar(const char* eArqConfig);
    int MAIL_ConfigLer(const char* eArqConfig);
    int MAIL_ConfigLerValor(const char* sessao, const char* chave, char* buffer, long* bufferSize);

    int MAIL_SetSubject(const char* subject);
    int MAIL_AddAddress(const char* email, const char* nome);
    int MAIL_AddBody(const char* body);
    int MAIL_AddAttachment(const char* filename);
    int MAIL_Clear();
    int MAIL_Send();
    int MAIL_UltimoRetorno(char* buffer, long* bufferSize);

private:
#if defined(ISWINDOWS)
    HMODULE handle;
#else
    void* handle;
#endif
    void* mailHandler;

    template<typename T>
    T load(const char* name) {
#if defined(ISWINDOWS)
        return reinterpret_cast<T>(GetProcAddress(handle, name));
#else
        return reinterpret_cast<T>(dlsym(handle, name));
#endif
    }
};

#include "ACBrMail.h"
#include <stdexcept>

#define BUFFER_LEN 8192

// typedefs nativos ACBrLibMail
typedef int (*fnMAIL_Inicializar)(void**, const char*, const char*);
typedef int (*fnMAIL_Finalizar)(void*);
typedef int (*fnMAIL_Inicializada)(void*);
typedef int (*fnMAIL_Nome)(void*, char*, long*);
typedef int (*fnMAIL_Versao)(void*, char*, long*);
typedef int (*fnMAIL_ConfigGravarValor)(void*, const char*, const char*, const char*);
typedef int (*fnMAIL_ConfigGravar)(void*, const char*);
typedef int (*fnMAIL_ConfigLer)(void*, const char*);
typedef int (*fnMAIL_ConfigLerValor)(void*, const char*, const char*, char*, long*);
typedef int (*fnMAIL_SetSubject)(void*, const char*);
typedef int (*fnMAIL_AddAddress)(void*, const char*, const char*);
typedef int (*fnMAIL_AddBody)(void*, const char*);
typedef int (*fnMAIL_AddAttachment)(void*, const char*);
typedef int (*fnMAIL_Clear)(void*);
typedef int (*fnMAIL_Send)(void*);
typedef int (*fnMAIL_UltimoRetorno)(void*, char*, long*);

// -----------------------------------------------------

ACBrMail::ACBrMail(const std::string& arqConfig, const std::string& chaveCrypt)
{
#if defined(ISWINDOWS)
    handle = LoadLibraryW(L"ACBrMail64.dll");
#else
    handle = dlopen("/usr/lib/libacbrmail64.so", RTLD_LAZY);
#endif

    if (!handle)
        throw std::runtime_error("Falha ao carregar ACBrLibMail");

    mailHandler = nullptr;

    fnMAIL_Inicializar f = load<fnMAIL_Inicializar>("MAIL_Inicializar");
    if (!f) throw std::runtime_error("MAIL_Inicializar não encontrado");

    int ret = f(&mailHandler, arqConfig.c_str(), chaveCrypt.c_str());
    if (ret != 0)
        throw std::runtime_error("Erro em MAIL_Inicializar: " + std::to_string(ret));
}

ACBrMail::~ACBrMail()
{
    if (!handle) return;

    fnMAIL_Finalizar f = load<fnMAIL_Finalizar>("MAIL_Finalizar");
    if (f && mailHandler)
        f(mailHandler);

#if defined(ISWINDOWS)
    FreeLibrary(handle);
#else
    dlclose(handle);
#endif
}

// -------- funções originais ---------

int ACBrMail::MAIL_Inicializar(const char* a, const char* b) {
    return load<fnMAIL_Inicializar>("MAIL_Inicializar")(&mailHandler, a, b);
}
int ACBrMail::MAIL_Finalizar() {
    return load<fnMAIL_Finalizar>("MAIL_Finalizar")(mailHandler);
}
int ACBrMail::MAIL_Inicializada() {
    return load<fnMAIL_Inicializada>("MAIL_Inicializada")(mailHandler);
}
int ACBrMail::MAIL_Nome(char* buf, long* len) {
    return load<fnMAIL_Nome>("MAIL_Nome")(mailHandler, buf, len);
}
int ACBrMail::MAIL_Versao(char* buf, long* len) {
    return load<fnMAIL_Versao>("MAIL_Versao")(mailHandler, buf, len);
}
int ACBrMail::MAIL_ConfigGravarValor(const char* s, const char* k, const char* v) {
    return load<fnMAIL_ConfigGravarValor>("MAIL_ConfigGravarValor")(mailHandler, s, k, v);
}
int ACBrMail::MAIL_ConfigGravar(const char* a) {
    return load<fnMAIL_ConfigGravar>("MAIL_ConfigGravar")(mailHandler, a);
}
int ACBrMail::MAIL_ConfigLer(const char* a) {
    return load<fnMAIL_ConfigLer>("MAIL_ConfigLer")(mailHandler, a);
}
int ACBrMail::MAIL_ConfigLerValor(const char* s, const char* k, char* b, long* l) {
    return load<fnMAIL_ConfigLerValor>("MAIL_ConfigLerValor")(mailHandler, s, k, b, l);
}

int ACBrMail::MAIL_SetSubject(const char* x) {
    return load<fnMAIL_SetSubject>("MAIL_SetSubject")(mailHandler, x);
}
int ACBrMail::MAIL_AddAddress(const char* e, const char* n) {
    return load<fnMAIL_AddAddress>("MAIL_AddAddress")(mailHandler, e, n);
}
int ACBrMail::MAIL_AddBody(const char* b) {
    return load<fnMAIL_AddBody>("MAIL_AddBody")(mailHandler, b);
}
int ACBrMail::MAIL_AddAttachment(const char* f) {
    return load<fnMAIL_AddAttachment>("MAIL_AddAttachment")(mailHandler, f);
}
int ACBrMail::MAIL_Clear() {
    return load<fnMAIL_Clear>("MAIL_Clear")(mailHandler);
}
int ACBrMail::MAIL_Send() {
    return load<fnMAIL_Send>("MAIL_Send")(mailHandler);
}
int ACBrMail::MAIL_UltimoRetorno(char* b, long* l) {
    return load<fnMAIL_UltimoRetorno>("MAIL_UltimoRetorno")(mailHandler, b, l);
}

 

 

[Juliomar Marchetti]

ficaria bom anexar como arquivo do que colar no corpo