golang CGo : converting union field to Go type

Question

我在 64 位平台上使用这个 C 结构，试图访问 value 联合中的 ui32v 字段:

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 */
};

我可以为每个 union 元素编写一个 C 包装器函数，但出于教学目的，我宁愿在 Go 中工作。以下是我尝试访问 ui32v 字段的方式:

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 {
    return (*_Ctype_guint32)(unsafe.Pointer(ptr))
  }
  return nil
}

但是这会产生错误cannot convert ptr (type uint64) to type unsafe.Pointer

那么如何将 uint64 转换为指向 C guint32 的 Go 类型？我尝试了各种组合，先转换为 uintptr，然后转换为 *_Ctype_guint32，转换为 uintptr，然后使用 unsafe.Pointer，...

我的理由是:我收到了一个 8 字节的数组。将其转换为 uint64，即内存地址。将其转换为指向 guint32 的指针(即 guint32 的 C 数组)，并将其作为结果返回 - 即作为 guint32 * 的联合字段“值”。

---

上下文

稍后我想使用 value_len 字段将 guint32 的 C 数组转换为字符串，使用我知道已经有效的函数:

guint32_star := union_to_guint32_ptr(data.value)
result += OidArrayToString(guint32_star, data.value_len)

C代码来自gsnmp .

Answer 1

cgo 将联合公开为一个字节数组，其大小足以容纳联合的最大成员。在您的情况下，它是 64 位，即 8 个字节，[8]byte。正如您所演示的，此数组的内容包含联合的内容，使用它是指针转换的问题。

但是，您可以使用数组的地址 来大大简化该过程。对于名为 data 的 C._GNetSnmpVarBind，

guint32_star := *(**C.guint32)(unsafe.Pointer(&data.value[0]))

第一次看的时候不是很理解，拆开之后就更清楚了:

var data C._GNetSnmpVarBind    // The C struct
var union [8]byte = data.value // The union, as eight contiguous bytes of memory

// The first magic. The address of the first element in that contiguous memory
// is the address of that memory. In other words, the address of that union.
var addr *byte = &union[0]

// The second magic. Instead of pointing to bytes of memory, we can point
// to some useful type, T, by changing the type of the pointer to *T using
// unsafe.Pointer. In this case we want to interpret the union as member
// `guint32 *ui32v`. That is, T = (*C.guint32) and *T = (**C.guint32).
var cast **C.guint32 = (**C.guint32)(unsafe.Pointer(addr))

// The final step. We wanted the contents of the union, not the address
// of the union. Dereference it!
var guint32_star *C.guint32 = *cast

感谢 Alan Shen 的 article它以一种最终对我有意义的方式描述了联合的 cgo 表示。