模块系统与生命周期 ​

// 来自 probe_openssl.go 的示例
func init() {
    RegisteFunc(NewOpenSSLProbe)
}

func NewOpenSSLProbe() IModule {
    mod := &MOpenSSLProbe{}
    mod.name = ModuleNameOpenssl
    mod.mType = ProbeTypeUprobe
    return mod
}

// 上下文和核心依赖
m.isClosed.Store(false)
m.ctx = ctx
m.logger = logger
m.eventCollector = eventCollector
m.errChan = make(chan error, 16)

// BTF 模式确定（CO-RE vs 非 CO-RE）
if conf.GetBTF() == config.BTFModeAutoDetect {
    m.autoDetectBTF()  // 检查内核中的 BTF 支持
} else {
    m.isCoreUsed = (conf.GetBTF() == config.BTFModeCore)
}

// 内核版本检测用于字节码选择
kv, err := kernel.HostVersion()
if kv < kernel.VersionCode(5, 2, 0) {
    m.isKernelLess5_2 = true  // 使用 *_less52.o 字节码变体
}

// 输出格式检测
if _, ok := m.eventCollector.(event.CollectorWriter); !ok {
    m.eventOutputType = codecTypeProtobuf
} else {
    m.eventOutputType = codecTypeText
}

// EventProcessor 初始化，支持截断
tsize := conf.GetTruncateSize()
m.processor = event_processor.NewEventProcessor(eventCollector, conf.GetHex(), tsize)

// 调用父初始化
err = m.Module.Init(ctx, logger, conf, ecw)
if err != nil {
    return err
}

// 将自身注册为子对象以进行委托模式
m.Module.SetChild(m)

// 初始化模块特定的数据结构
m.eventMaps = make([]*ebpf.Map, 0, 2)
m.eventFuncMaps = make(map[*ebpf.Map]event.IEventStruct)
m.pidConns = make(map[uint32]map[uint32]ConnInfo)  // pid -> fd -> 连接
m.sock2pidFd = make(map[uint64][2]uint32)          // sock -> [pid, fd]
m.pidLocker = new(sync.Mutex)
m.masterKeys = make(map[string]bool)                // 去重映射
m.sslVersionBpfMap = make(map[string]string)        // 版本 -> 字节码文件

// 捕获模式确定
model := m.conf.(*config.OpensslConfig).Model
switch model {
case config.TlsCaptureModelKeylog, config.TlsCaptureModelKey:
    m.keylogger, err = os.OpenFile(keylogFilename, os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0o600)
    m.eBPFProgramType = TlsCaptureModelTypeKeylog
case config.TlsCaptureModelPcap, config.TlsCaptureModelPcapng:
    m.eBPFProgramType = TlsCaptureModelTypePcap
    m.tcPacketsChan = make(chan *TcPacket, 2048)
case config.TlsCaptureModelText:
    m.eBPFProgramType = TlsCaptureModelTypeText
}

// 时钟同步用于时间戳转换
unix.ClockGettime(unix.CLOCK_MONOTONIC, &ts)
m.startTime = uint64(ts.Nano())
m.bootTime = uint64(time.Now().UnixNano() - ts.Nano())

// 初始化 OpenSSL 偏移配置
m.initOpensslOffset()

// 1. 根据捕获模式设置 eBPF 管理器
switch m.eBPFProgramType {
case TlsCaptureModelTypeKeylog:
    err = m.setupManagersKeylog()
case TlsCaptureModelTypePcap:
    err = m.setupManagersPcap()
case TlsCaptureModelTypeText:
    err = m.setupManagersText()
}

// 2. 如果在 pcap 模式下应用 pcap 过滤器
if m.eBPFProgramType == TlsCaptureModelTypePcap && pcapFilter != "" {
    m.bpfManager.InstructionPatchers = prepareInsnPatchers(...)
}

// 3. 选择适当的字节码文件
bpfFileName := m.geteBPFName(filepath.Join("user/bytecode", m.sslBpfFile))
// 结果：例如 "user/bytecode/openssl_3_0_0_kern_core.o"

// 4. 从资产加载嵌入的字节码
byteBuf, err := assets.Asset(bpfFileName)

// 5. 使用字节码初始化 eBPF 管理器
err = m.bpfManager.InitWithOptions(bytes.NewReader(byteBuf), m.bpfManagerOptions)

// 6. 启动管理器（附加所有探针）
err = m.bpfManager.Start()

// 7. 为映射注册事件解码器
switch m.eBPFProgramType {
case TlsCaptureModelTypeKeylog:
    err = m.initDecodeFunKeylog()
case TlsCaptureModelTypePcap:
    err = m.initDecodeFunPcap()
case TlsCaptureModelTypeText:
    err = m.initDecodeFunText()
}

for {
    select {
    case <-m.ctx.Done():
        return  // 优雅关闭
    default:
    }
    
    record, err := rd.Read()  // 阻塞等待事件
    if err != nil {
        if errors.Is(err, perf.ErrClosed) {
            return
        }
        errChan <- err
        return
    }
    
    // 将原始字节解码为类型化事件
    evt, err := m.child.Decode(em, record.RawSample)
    
    // 路由到适当的处理器
    m.Dispatcher(evt)
}

// 分离 eBPF 程序并卸载映射
err := m.bpfManager.Stop(manager.CleanAll)

// 关闭文件句柄
if m.keylogger != nil {
    m.keylogger.Close()
}

// 调用父清理
return m.Module.Close()

func (m *Module) Decode(em *ebpf.Map, b []byte) (event.IEventStruct, error) {
    // 委托给子对象以获取此映射的适当解码器
    es, found := m.child.DecodeFun(em)
    if !found {
        return nil, fmt.Errorf("找不到映射 %s 的解码器", em.String())
    }
    
    // 克隆事件结构模板并解码
    te := es.Clone()
    err = te.Decode(b)
    return te, err
}

func (m *MOpenSSLProbe) Init(ctx context.Context, logger *zerolog.Logger, 
                             conf config.IConfig, ecw io.Writer) error {
    // 调用父 Init
    err := m.Module.Init(ctx, logger, conf, ecw)
    if err != nil {
        return err
    }
    
    // 将自身注册为子对象以进行委托
    m.Module.SetChild(m)
    
    // 模块特定初始化继续...
}

reload:
    // 初始化并启动模块
    mod := modFunc()
    err = mod.Init(ctx, &logger, modConfig, ecw)
    err = mod.Run()
    
    // 等待信号
    select {
    case <-stopper:          // SIGINT 或 SIGTERM
        isReload = false
    case rc := <-reRloadConfig:  // HTTP POST /config
        isReload = true
        modConfig = rc
    }
    
    // 清理当前实例
    err = mod.Close()
    
    // 如果配置已更改则重新加载
    if isReload {
        goto reload  // 使用新配置重新启动
    }

func (m *MOpenSSLProbe) Dispatcher(eventStruct event.IEventStruct) {
    switch ev := eventStruct.(type) {
    case *event.ConnDataEvent:
        // 连接生命周期跟踪
        if ev.IsDestroy == 0 {
            m.AddConn(ev.Pid, ev.Fd, ev.Tuple, ev.Sock)
        } else {
            m.DelConn(ev.Sock)
        }
    
    case *event.MasterSecretEvent:
        // TLS 主密钥（OpenSSL）
        m.saveMasterSecret(ev)  // 写入 keylog 文件或 PCAP DSB
    
    case *event.MasterSecretBSSLEvent:
        // TLS 主密钥（BoringSSL 变体）
        m.saveMasterSecretBSSL(ev)
    
    case *event.TcSkbEvent:
        // 来自 TC 钩子的网络数据包
        err := m.dumpTcSkb(ev)  // 写入 PCAP 文件
    
    case *event.SSLDataEvent:
        // 明文 SSL 数据
        m.dumpSslData(ev)  // 发送到 EventProcessor
    }
}