Golang CGo：使用 unsafe.Pointer 访问 C 联合体字段

// C 结构体定义 (例如，来自 gsnmp 库)
struct _GNetSnmpVarBind {
  guint32       *oid;       /* name of the variable */
  gsize     oid_len;    /* length of the name */
  GNetSnmpVarBindType   type;       /* variable type / exception */
  union {
    gint32   i32;           /* 32 bit signed   */
    guint32  ui32;          /* 32 bit unsigned */
    gint64   i64;           /* 64 bit signed   */
    guint64  ui64;          /* 64 bit unsigned */
    guint8  *ui8v;          /*  8 bit unsigned vector */
    guint32 *ui32v;         /* 32 bit unsigned vector */
  }         value;      /* value of the variable */
  gsize     value_len;  /* length of a vector in bytes */
};

import (
    "bytes"
    "encoding/binary"
    "unsafe"
)

// 假设 _Ctype_guint32 是 CGo 生成的 C.guint32 的 Go 类型别名
// type _Ctype_guint32 C.guint32

func unionToGuint32Ptr(cbytes [8]byte) (result *_Ctype_guint32) {
    buf := bytes.NewBuffer(cbytes[:])
    var ptr uint64
    if err := binary.Read(buf, binary.LittleEndian, &ptr); err == nil {
        // 这里会报错：cannot convert ptr (type uint64) to type unsafe.Pointer
        return (*_Ctype_guint32)(unsafe.Pointer(ptr))
    }
    return nil
}

import "unsafe"

// 假设 C.guint32 和 C._GNetSnmpVarBind 已经通过 CGo 导入
// var data C._GNetSnmpVarBind // 这是一个示例 C 结构体实例

// 假设我们有一个 C._GNetSnmpVarBind 实例
// 在实际应用中，data 可能来自 C 函数调用或其他 CGo 交互
var data C._GNetSnmpVarBind
// 为了示例完整性，这里可以模拟给 data.value 赋值，
// 比如将一个 C.guint32 数组的地址存入 data.value
// 但通常我们是从 C 侧接收到已经填充好的数据。

// 核心转换逻辑
// 1. 获取联合体字段 `data.value` (它是一个 [8]byte 数组) 的第一个元素的地址。
//    `&data.value[0]` 得到 `*byte` 类型，即联合体内存块的起始地址。
var addr *byte = &data.value[0]

// 2. 将 `*byte` 类型的地址转换为 `unsafe.Pointer`。
//    `unsafe.Pointer` 是一个通用指针类型，可以进行任意指针类型转换的中间桥梁。
var genericPtr unsafe.Pointer = unsafe.Pointer(addr)

// 3. 将 `unsafe.Pointer` 转换为目标 C 指针的指针类型。
//    我们想访问 `guint32 *ui32v`，这意味着 `ui32v` 本身是一个 `*C.guint32`。
//    所以，联合体内存中存储的是一个 `*C.guint32` 的值。
//    要从联合体的地址获取这个 `*C.guint32`，我们需要将其地址视为 `**C.guint32`。
var castedPtr **C.guint32 = (**C.guint32)(genericPtr)

// 4. 解引用 `**C.guint32` 得到 `*C.guint32`。
//    这就是联合体中 `ui32v` 字段的实际值（一个指向 C guint32 数组的指针）。
var guint32_star *C.guint32 = *castedPtr

// 将以上步骤合并为一行：
// guint32_star := *(**C.guint32)(unsafe.Pointer(&data.value[0]))

// 现在 guint32_star 就是一个 *C.guint32 类型的指针，
// 可以像在 C 中一样使用它来访问 guint32 数组。
// 例如，如果有一个 C 函数 `OidArrayToString` 接收 `*C.guint32` 和长度：
// result += C.OidArrayToString(guint32_star, C.gsize(data.value_len))

package main

/*
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h> // For malloc

// 示例 C 结构体和联合体
typedef uint32_t guint32;
typedef size_t gsize;
typedef int GNetSnmpVarBindType; // 简化类型定义

struct _GNetSnmpVarBind {
  guint32       *oid;
  gsize     oid_len;
  GNetSnmpVarBindType   type;
  union {
    gint32   i32;
    guint32  ui32;
    gint64   i64;
    guint64  ui64;
    guint8  *ui8v;
    guint32 *ui32v;
  }         value;
  gsize     value_len;
};

// 示例 C 函数，用于处理 guint32 数组
char* OidArrayToString(guint32 *arr, gsize len) {
    if (!arr) return strdup("");
    // 实际实现会更复杂，这里仅为示例
    char *buf = (char*)malloc(len * 12 + 1); // 假设每个 uint32 最多10位数字 + '.' + '\0'
    if (!buf) return NULL;
    buf[0] = '\0';
    char temp[16];
    for (gsize i = 0; i < len; ++i) {
        sprintf(temp, "%u.", arr[i]);
        strcat(buf, temp);
    }
    // 移除最后一个 '.'
    if (len > 0) {
        buf[strlen(buf) - 1] = '\0';
    }
    return buf;
}

// 示例 C 函数，用于创建并填充 _GNetSnmpVarBind
struct _GNetSnmpVarBind* create_varbind_with_uint32_array() {
    struct _GNetSnmpVarBind* vb = (struct _GNetSnmpVarBind*)malloc(sizeof(struct _GNetSnmpVarBind));
    if (!vb) return NULL;

    guint32* arr = (guint32*)malloc(sizeof(guint32) * 3);
    if (!arr) { free(vb); return NULL; }
    arr[0] = 1;
    arr[1] = 3;
    arr[2] = 6;

    vb->value.ui32v = arr;
    vb->value_len = 3; // 元素数量
    vb->type = 1; // 示例类型

    return vb;
}

void free_varbind(struct _GNetSnmpVarBind* vb) {
    if (vb) {
        if (vb->value.ui32v) { // 确保只释放我们分配的指针
            free(vb->value.ui32v);
        }
        free(vb);
    }
}
*/
import "C"
import (
    "fmt"
    "unsafe"
)

func main() {
    // 创建一个 C 结构体实例并填充数据
    cVarBind := C.create_varbind_with_uint32_array()
    if cVarBind == nil {
        fmt.Println("Failed to create C varbind.")
        return
    }
    defer C.free_varbind(cVarBind) // 确保释放 C 内存

    // 访问 Go 中的 C 结构体
    goVarBind := *cVarBind // 将 C 指针解引用到 Go 结构体

    // 使用 unsafe.Pointer 访问联合体中的 ui32v 字段
    // goVarBind.value 是一个 [8]byte 数组
    guint32_star := *(**C.guint32)(unsafe.Pointer(&goVarBind.value[0]))

    // 获取数组长度
    arrayLen := goVarBind.value_len

    // 使用 C 函数将 guint32 数组转换为字符串
    if guint32_star != nil {
        cString := C.OidArrayToString(guint32_star, arrayLen)
        if cString != nil {
            fmt.Printf("Converted OID array to string: %s\n", C.GoString(cString))
            C.free(unsafe.Pointer(cString)) // 释放 C 函数返回的字符串内存
        }
    } else {
        fmt.Println("ui32v pointer is nil.")
    }

    fmt.Printf("Original value_len: %d\n", arrayLen)
}

Converted OID array to string: 1.3.6
Original value_len: 3