Golang CGo：安全高效地访问C语言联合体字段

// C语言结构体定义
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 是 C.guint32 的 Go 类型别名
// func union_to_guint32_ptr(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 "C" // 确保导入 C 包
import "unsafe"

// 假设 data 已经是一个 C._GNetSnmpVarBind 类型的变量
var data C._GNetSnmpVarBind

// ... (此处省略 data 的初始化代码) ...

// 访问 ui32v 字段
guint32_star := *(**C.guint32)(unsafe.Pointer(&data.value[0]))

package main

/*
#include <stdint.h> // for guint32, gsize (simulated)
#include <stdlib.h> // for malloc, free

// 模拟 gsnmp 库的类型
typedef uint32_t guint32;
typedef size_t gsize;

// 模拟 GNetSnmpVarBindType
typedef enum {
    GNET_SNMP_VARBIND_TYPE_INTEGER32 = 2,
    GNET_SNMP_VARBIND_TYPE_OCTET_STRING = 4,
    GNET_SNMP_VARBIND_TYPE_OID = 6,
    GNET_SNMP_VARBIND_TYPE_UNSIGNED32 = 65,
    // ... 其他类型
} GNetSnmpVarBindType;

// 模拟 _GNetSnmpVarBind 结构体
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;
};

// 辅助函数：创建并填充一个包含 guint32 数组的 _GNetSnmpVarBind
struct _GNetSnmpVarBind* create_varbind_with_guint32_array() {
    struct _GNetSnmpVarBind* vb = (struct _GNetSnmpVarBind*)malloc(sizeof(struct _GNetSnmpVarBind));
    if (!vb) return NULL;

    // 假设 ui32v 指向一个包含 3 个元素的数组 {10, 20, 30}
    guint32* arr = (guint32*)malloc(3 * sizeof(guint32));
    if (!arr) { free(vb); return NULL; }
    arr[0] = 10;
    arr[1] = 20;
    arr[2] = 30;

    vb->type = GNET_SNMP_VARBIND_TYPE_OID; // 或其他需要 ui32v 的类型
    vb->value.ui32v = arr;
    vb->value_len = 3 * sizeof(guint32); // 数组的字节长度

    // 填充其他字段（此处简化）
    vb->oid = NULL;
    vb->oid_len = 0;

    return vb;
}

// 辅助函数：释放 varbind
void free_varbind(struct _GNetSnmpVarBind* vb) {
    if (vb) {
        if (vb->value.ui32v) { // 假设 ui32v 是唯一动态分配的成员
            free(vb->value.ui32v);
        }
        free(vb);
    }
}

// 辅助函数：将 guint32 数组转换为字符串（模拟 OidArrayToString）
const char* OidArrayToString(guint32* arr, gsize len_bytes) {
    // 实际实现会更复杂，这里仅为演示
    // 假设 len_bytes 是数组的字节长度
    gsize num_elements = len_bytes / sizeof(guint32);
    static char buffer[256]; // 简单的静态缓冲区
    int offset = 0;
    for (gsize i = 0; i < num_elements; i++) {
        offset += snprintf(buffer + offset, sizeof(buffer) - offset, "%u.", arr[i]);
    }
    if (offset > 0 && buffer[offset-1] == '.') { // 移除末尾的点
        buffer[offset-1] = '\0';
    } else if (offset == 0) {
        snprintf(buffer, sizeof(buffer), "");
    }
    return buffer;
}
*/
import "C"
import (
    "fmt"
    "unsafe"
)

func main() {
    // 创建一个包含 guint32 数组的 C._GNetSnmpVarBind 实例
    cVarbind := C.create_varbind_with_guint32_array()
    if cVarbind == nil {
        fmt.Println("Error creating C varbind")
        return
    }
    defer C.free_varbind(cVarbind) // 确保释放C内存

    // 从 C._GNetSnmpVarBind 中获取联合体字段
    // guint32_star := *(**C.guint32)(unsafe.Pointer(&cVarbind.value[0]))
    // 注意：CGo生成的结构体字段名是小写的，所以是 cVarbind.Value
    guint32_star := *(**C.guint32)(unsafe.Pointer(&cVarbind.value[0]))

    // 验证获取到的指针和内容
    fmt.Printf("Go: Pointer to guint32 array: %p\n", guint32_star)
    fmt.Printf("Go: Value length (bytes): %d\n", cVarbind.value_len)

    // 使用 C 函数将 guint32 数组转换为字符串
    // 假设 OidArrayToString 期望 guint32* 和字节长度
    resultStr := C.GoString(C.OidArrayToString(guint32_star, cVarbind.value_len))
    fmt.Printf("Go: Converted array to string: %s\n", resultStr)

    // 也可以直接在 Go 中访问数组元素（需要小心处理 C 数组边界）
    numElements := cVarbind.value_len / C.sizeof_guint32 // C.sizeof_guint32 假设 CGo 已定义
    if numElements > 0 {
        fmt.Printf("Go: First element of array: %d\n", *guint32_star) // 解引用第一个元素
        // 访问后续元素需要指针算术，或者将 C 数组转换为 Go 切片
        // 例如，使用 reflect.SliceHeader 转换：
        // var goSlice []C.guint32
        // sliceHeader := (*reflect.SliceHeader)(unsafe.Pointer(&goSlice))
        // sliceHeader.Data = uintptr(unsafe.Pointer(guint32_star))
        // sliceHeader.Len = int(numElements)
        // sliceHeader.Cap = int(numElements)
        // fmt.Printf("Go: Array elements via slice: %v\n", goSlice)
    }
}