Blog

#pragma once
#include <string>

constexpr int PLUGIN_API_VERSION = 2;

struct IPlugin {                                  // 호스트와 플러그인이 공유하는 유일한 계약
    virtual ~IPlugin() = default;
    virtual const char* name() const = 0;
    virtual std::string process(const std::string& in) = 0;
};

// 이름 맹글링 없이 dlsym으로 찾을 수 있게 C 링키지로 내보낸다
extern "C" {
    using create_fn = IPlugin* (*)();
    using destroy_fn = void (*)(IPlugin*);
    using version_fn = int (*)();
}

#define EXPORT_PLUGIN(T)                                                  \
    extern "C" IPlugin* create_plugin() { return new T; }                \
    extern "C" void destroy_plugin(IPlugin* p) { delete p; }             \
    extern "C" int plugin_api_version() { return PLUGIN_API_VERSION; }

#include <cctype>
#include "plugin_api.h"

struct Upper : IPlugin {
    const char* name() const override { return "upper"; }
    std::string process(const std::string& in) override
    {
        std::string s = in;
        for (auto& c : s) c = std::toupper((unsigned char)c);
        return s;
    }
};
EXPORT_PLUGIN(Upper)

#include <string>
#include "plugin_api.h"

struct Reverse : IPlugin {
    const char* name() const override { return "reverse"; }
    std::string process(const std::string& in) override { return {in.rbegin(), in.rend()}; }
};
EXPORT_PLUGIN(Reverse)

#include <dlfcn.h>
#include <cstdio>
#include <filesystem>
#include <memory>
#include <vector>
#include "plugin_api.h"

class Plugin {                                    // 라이브러리 핸들과 객체 수명을 함께 관리
    void* lib_ = nullptr;
    IPlugin* obj_ = nullptr;
    destroy_fn destroy_ = nullptr;
public:
    explicit Plugin(const std::string& path)
    {
        lib_ = dlopen(path.c_str(), RTLD_NOW | RTLD_LOCAL);
        if (!lib_) throw std::runtime_error(dlerror());
        auto ver = reinterpret_cast<version_fn>(dlsym(lib_, "plugin_api_version"));
        auto create = reinterpret_cast<create_fn>(dlsym(lib_, "create_plugin"));
        destroy_ = reinterpret_cast<destroy_fn>(dlsym(lib_, "destroy_plugin"));
        if (!ver || !create || !destroy_) { dlclose(lib_); throw std::runtime_error("missing symbol in " + path); }
        if (ver() != PLUGIN_API_VERSION) {
            int v = ver();
            dlclose(lib_);
            throw std::runtime_error(path + ": api v" + std::to_string(v) + " != v" + std::to_string(PLUGIN_API_VERSION));
        }
        obj_ = create();
    }
    ~Plugin()
    {
        if (obj_) destroy_(obj_);                 // 객체를 먼저 파괴하고
        if (lib_) dlclose(lib_);                  // 코드는 그 다음에 내린다
    }
    Plugin(const Plugin&) = delete;
    Plugin& operator=(const Plugin&) = delete;
    IPlugin* operator->() const { return obj_; }
};

int main(int argc, char** argv)
{
    std::vector<std::unique_ptr<Plugin>> plugins;
    for (auto& e : std::filesystem::directory_iterator(argc > 1 ? argv[1] : "plugins")) {
        try { plugins.push_back(std::make_unique<Plugin>(e.path().string())); }
        catch (const std::exception& ex) { std::printf("  skip: %s\n", ex.what()); }
    }
    std::string text = "hello plugin";
    for (auto& p : plugins) {
        text = (*p)->process(text);
        std::printf("  %-8s -> %s\n", (*p)->name(), text.c_str());
    }
}

g++ -std=c++20 -Wall -fPIC -shared -o plugins/upper.so upper.cpp
g++ -std=c++20 -Wall -fPIC -shared -o plugins/reverse.so reverse.cpp
g++ -std=c++20 -Wall -o host host.cpp            # 호스트는 플러그인을 링크하지 않는다

#include "plugin_api.h"

struct Old : IPlugin {
    const char* name() const override { return "old"; }
    std::string process(const std::string& in) override { return in; }
};
extern "C" IPlugin* create_plugin() { return new Old; }
extern "C" void destroy_plugin(IPlugin* p) { delete p; }
extern "C" int plugin_api_version() { return 1; }  // 예전 API로 빌드된 플러그인

#include "plugin_api.h"
struct Echo : IPlugin {
    const char* name() const override { return "echo"; }
    std::string process(const std::string& in) override { return in; }
};
IPlugin* create_plugin() { return new Echo; }     // extern "C"를 빠뜨림
extern "C" void destroy_plugin(IPlugin* p) { delete p; }
extern "C" int plugin_api_version() { return PLUGIN_API_VERSION; }

#include <dlfcn.h>
#include <cstdio>
#include "plugin_api.h"

int main()
{
    void* lib = dlopen("./plugins/upper.so", RTLD_NOW);
    auto create = reinterpret_cast<create_fn>(dlsym(lib, "create_plugin"));
    IPlugin* p = create();
    std::printf("  %s\n", p->process("abc").c_str());
    dlclose(lib);                                 // 객체보다 라이브러리를 먼저 내림
    std::printf("  calling after dlclose...\n");
    std::fflush(stdout);
    delete p;                                     // vtable과 소멸자 코드가 이미 언매핑됨
    std::printf("  never reached\n");
}

#include <cstdio>
#include "plugin_api.h"

struct Banner {
    Banner()  { std::printf("  [autoreg.so] static ctor\n"); }
    ~Banner() { std::printf("  [autoreg.so] static dtor\n"); }
} banner;                                         // 로드·언로드 시점에 실행된다

struct Noop : IPlugin {
    const char* name() const override { return "noop"; }
    std::string process(const std::string& in) override { return in; }
};
EXPORT_PLUGIN(Noop)

#include <dlfcn.h>
#include <cstdio>

int main(int, char** argv)
{
    std::printf("  before dlopen\n");
    void* lib = dlopen(argv[1], RTLD_NOW);
    std::printf("  after dlopen\n");
    dlclose(lib);
    std::printf("  after dlclose\n");
}