cmd/protoc-gen-go: unexport implementation-specific XXX fields
We modify protoc-gen-go to stop generating exported XXX fields.
The unsafe implementation is unaffected by this change since unsafe
can access fields regardless of visibility. However, for the purego
implementation, we need to respect Go visibility rules as enforced
by the reflect package.
We work around this by generating a exporter function that given
a reference to the message and the field to export, returns a reference
to the unexported field value. This exporter function is protected by
a constant such that it is not linked into the final binary in non-purego
build environment.
Updates golang/protobuf#276
Change-Id: Idf5c1f158973fa1c61187ff41440acb21c5dac94
Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/185141
Reviewed-by: Damien Neil <dneil@google.com>
diff --git a/internal/impl/codec_message.go b/internal/impl/codec_message.go
index 2d5b376..e4e3706 100644
--- a/internal/impl/codec_message.go
+++ b/internal/impl/codec_message.go
@@ -19,8 +19,8 @@
type coderMessageInfo struct {
orderedCoderFields []*coderFieldInfo
sizecacheOffset offset
- extensionOffset offset
unknownOffset offset
+ extensionOffset offset
needsInitCheck bool
}
@@ -55,7 +55,7 @@
}
mi.orderedCoderFields = append(mi.orderedCoderFields, &coderFieldInfo{
num: fd.Number(),
- offset: offsetOf(fs),
+ offset: offsetOf(fs, mi.Exporter),
wiretag: wiretag,
tagsize: wire.SizeVarint(wiretag),
funcs: fieldCoder(fd, ft),
@@ -71,7 +71,7 @@
fs := si.oneofsByName[od.Name()]
mi.orderedCoderFields = append(mi.orderedCoderFields, &coderFieldInfo{
num: od.Fields().Get(0).Number(),
- offset: offsetOf(fs),
+ offset: offsetOf(fs, mi.Exporter),
funcs: makeOneofFieldCoder(fs, od, si.fieldsByNumber, si.oneofWrappersByNumber),
isPointer: true,
})
diff --git a/internal/impl/message.go b/internal/impl/message.go
index 82107df..ec9be4e 100644
--- a/internal/impl/message.go
+++ b/internal/impl/message.go
@@ -29,6 +29,10 @@
// Once set, this field must never be mutated.
PBType pref.MessageType
+ // Exporter must be provided in a purego environment in order to provide
+ // access to unexported fields.
+ Exporter exporter
+
// OneofWrappers is list of pointers to oneof wrapper struct types.
OneofWrappers []interface{}
@@ -51,6 +55,11 @@
extensionFieldInfos map[pref.ExtensionType]*extensionFieldInfo
}
+// exporter is a function that returns a reference to the ith field of v,
+// where v is a pointer to a struct. It returns nil if it does not support
+// exporting the requested field (e.g., already exported).
+type exporter func(v interface{}, i int) interface{}
+
var prefMessageType = reflect.TypeOf((*pref.Message)(nil)).Elem()
// getMessageInfo returns the MessageInfo (if any) for a type.
@@ -120,8 +129,8 @@
type structInfo struct {
sizecacheOffset offset
- extensionOffset offset
unknownOffset offset
+ extensionOffset offset
fieldsByNumber map[pref.FieldNumber]reflect.StructField
oneofsByName map[pref.Name]reflect.StructField
@@ -132,8 +141,8 @@
func (mi *MessageInfo) makeStructInfo(t reflect.Type) structInfo {
si := structInfo{
sizecacheOffset: invalidOffset,
- extensionOffset: invalidOffset,
unknownOffset: invalidOffset,
+ extensionOffset: invalidOffset,
fieldsByNumber: map[pref.FieldNumber]reflect.StructField{},
oneofsByName: map[pref.Name]reflect.StructField{},
@@ -141,17 +150,26 @@
oneofWrappersByNumber: map[pref.FieldNumber]reflect.Type{},
}
+ if f, _ := t.FieldByName("sizeCache"); f.Type == sizecacheType {
+ si.sizecacheOffset = offsetOf(f, mi.Exporter)
+ }
if f, _ := t.FieldByName("XXX_sizecache"); f.Type == sizecacheType {
- si.sizecacheOffset = offsetOf(f)
+ si.sizecacheOffset = offsetOf(f, mi.Exporter)
}
- if f, _ := t.FieldByName("XXX_InternalExtensions"); f.Type == extensionFieldsType {
- si.extensionOffset = offsetOf(f)
- }
- if f, _ := t.FieldByName("XXX_extensions"); f.Type == extensionFieldsType {
- si.extensionOffset = offsetOf(f)
+ if f, _ := t.FieldByName("unknownFields"); f.Type == unknownFieldsType {
+ si.unknownOffset = offsetOf(f, mi.Exporter)
}
if f, _ := t.FieldByName("XXX_unrecognized"); f.Type == unknownFieldsType {
- si.unknownOffset = offsetOf(f)
+ si.unknownOffset = offsetOf(f, mi.Exporter)
+ }
+ if f, _ := t.FieldByName("extensionFields"); f.Type == extensionFieldsType {
+ si.extensionOffset = offsetOf(f, mi.Exporter)
+ }
+ if f, _ := t.FieldByName("XXX_InternalExtensions"); f.Type == extensionFieldsType {
+ si.extensionOffset = offsetOf(f, mi.Exporter)
+ }
+ if f, _ := t.FieldByName("XXX_extensions"); f.Type == extensionFieldsType {
+ si.extensionOffset = offsetOf(f, mi.Exporter)
}
// Generate a mapping of field numbers and names to Go struct field or type.
@@ -209,15 +227,15 @@
var fi fieldInfo
switch {
case fd.ContainingOneof() != nil:
- fi = fieldInfoForOneof(fd, si.oneofsByName[fd.ContainingOneof().Name()], si.oneofWrappersByNumber[fd.Number()])
+ fi = fieldInfoForOneof(fd, si.oneofsByName[fd.ContainingOneof().Name()], mi.Exporter, si.oneofWrappersByNumber[fd.Number()])
case fd.IsMap():
- fi = fieldInfoForMap(fd, fs)
+ fi = fieldInfoForMap(fd, fs, mi.Exporter)
case fd.IsList():
- fi = fieldInfoForList(fd, fs)
+ fi = fieldInfoForList(fd, fs, mi.Exporter)
case fd.Kind() == pref.MessageKind || fd.Kind() == pref.GroupKind:
- fi = fieldInfoForMessage(fd, fs)
+ fi = fieldInfoForMessage(fd, fs, mi.Exporter)
default:
- fi = fieldInfoForScalar(fd, fs)
+ fi = fieldInfoForScalar(fd, fs, mi.Exporter)
}
mi.fields[fd.Number()] = &fi
}
@@ -225,7 +243,7 @@
mi.oneofs = map[pref.Name]*oneofInfo{}
for i := 0; i < mi.PBType.Descriptor().Oneofs().Len(); i++ {
od := mi.PBType.Descriptor().Oneofs().Get(i)
- mi.oneofs[od.Name()] = makeOneofInfo(od, si.oneofsByName[od.Name()], si.oneofWrappersByType)
+ mi.oneofs[od.Name()] = makeOneofInfo(od, si.oneofsByName[od.Name()], mi.Exporter, si.oneofWrappersByType)
}
}
diff --git a/internal/impl/message_field.go b/internal/impl/message_field.go
index dede8a3..f3b4f8a 100644
--- a/internal/impl/message_field.go
+++ b/internal/impl/message_field.go
@@ -26,7 +26,7 @@
newMessage func() pref.Message
}
-func fieldInfoForOneof(fd pref.FieldDescriptor, fs reflect.StructField, ot reflect.Type) fieldInfo {
+func fieldInfoForOneof(fd pref.FieldDescriptor, fs reflect.StructField, x exporter, ot reflect.Type) fieldInfo {
ft := fs.Type
if ft.Kind() != reflect.Interface {
panic(fmt.Sprintf("invalid type: got %v, want interface kind", ft))
@@ -44,7 +44,7 @@
}
// TODO: Implement unsafe fast path?
- fieldOffset := offsetOf(fs)
+ fieldOffset := offsetOf(fs, x)
return fieldInfo{
// NOTE: The logic below intentionally assumes that oneof fields are
// well-formatted. That is, the oneof interface never contains a
@@ -111,7 +111,7 @@
}
}
-func fieldInfoForMap(fd pref.FieldDescriptor, fs reflect.StructField) fieldInfo {
+func fieldInfoForMap(fd pref.FieldDescriptor, fs reflect.StructField, x exporter) fieldInfo {
ft := fs.Type
if ft.Kind() != reflect.Map {
panic(fmt.Sprintf("invalid type: got %v, want map kind", ft))
@@ -123,7 +123,7 @@
})
// TODO: Implement unsafe fast path?
- fieldOffset := offsetOf(fs)
+ fieldOffset := offsetOf(fs, x)
return fieldInfo{
fieldDesc: fd,
has: func(p pointer) bool {
@@ -158,7 +158,7 @@
}
}
-func fieldInfoForList(fd pref.FieldDescriptor, fs reflect.StructField) fieldInfo {
+func fieldInfoForList(fd pref.FieldDescriptor, fs reflect.StructField, x exporter) fieldInfo {
ft := fs.Type
if ft.Kind() != reflect.Slice {
panic(fmt.Sprintf("invalid type: got %v, want slice kind", ft))
@@ -169,7 +169,7 @@
})
// TODO: Implement unsafe fast path?
- fieldOffset := offsetOf(fs)
+ fieldOffset := offsetOf(fs, x)
return fieldInfo{
fieldDesc: fd,
has: func(p pointer) bool {
@@ -206,7 +206,7 @@
var emptyBytes = reflect.ValueOf([]byte{})
-func fieldInfoForScalar(fd pref.FieldDescriptor, fs reflect.StructField) fieldInfo {
+func fieldInfoForScalar(fd pref.FieldDescriptor, fs reflect.StructField, x exporter) fieldInfo {
ft := fs.Type
nullable := fd.Syntax() == pref.Proto2
if nullable {
@@ -220,7 +220,7 @@
conv, _ := newConverter(ft, fd.Kind())
// TODO: Implement unsafe fast path?
- fieldOffset := offsetOf(fs)
+ fieldOffset := offsetOf(fs, x)
return fieldInfo{
fieldDesc: fd,
has: func(p pointer) bool {
@@ -281,13 +281,13 @@
}
}
-func fieldInfoForMessage(fd pref.FieldDescriptor, fs reflect.StructField) fieldInfo {
+func fieldInfoForMessage(fd pref.FieldDescriptor, fs reflect.StructField, x exporter) fieldInfo {
ft := fs.Type
conv, _ := newConverter(ft, fd.Kind())
frozenEmpty := pref.ValueOf(frozenMessage{conv.NewMessage()})
// TODO: Implement unsafe fast path?
- fieldOffset := offsetOf(fs)
+ fieldOffset := offsetOf(fs, x)
return fieldInfo{
fieldDesc: fd,
has: func(p pointer) bool {
@@ -334,8 +334,8 @@
which func(pointer) pref.FieldNumber
}
-func makeOneofInfo(od pref.OneofDescriptor, fs reflect.StructField, wrappersByType map[reflect.Type]pref.FieldNumber) *oneofInfo {
- fieldOffset := offsetOf(fs)
+func makeOneofInfo(od pref.OneofDescriptor, fs reflect.StructField, x exporter, wrappersByType map[reflect.Type]pref.FieldNumber) *oneofInfo {
+ fieldOffset := offsetOf(fs, x)
return &oneofInfo{
oneofDesc: od,
which: func(p pointer) pref.FieldNumber {
diff --git a/internal/impl/pointer_reflect.go b/internal/impl/pointer_reflect.go
index 207c20b..6060154 100644
--- a/internal/impl/pointer_reflect.go
+++ b/internal/impl/pointer_reflect.go
@@ -11,26 +11,37 @@
"reflect"
)
+const UnsafeEnabled = false
+
// offset represents the offset to a struct field, accessible from a pointer.
// The offset is the field index into a struct.
-type offset []int
+type offset struct {
+ index int
+ export exporter
+}
// offsetOf returns a field offset for the struct field.
-func offsetOf(f reflect.StructField) offset {
+func offsetOf(f reflect.StructField, x exporter) offset {
if len(f.Index) != 1 {
panic("embedded structs are not supported")
}
- return f.Index
+ if f.PkgPath == "" {
+ return offset{index: f.Index[0]} // field is already exported
+ }
+ if x == nil {
+ panic("exporter must be provided for unexported field")
+ }
+ return offset{index: f.Index[0], export: x}
}
// IsValid reports whether the offset is valid.
-func (f offset) IsValid() bool { return f != nil }
+func (f offset) IsValid() bool { return f.index >= 0 }
// invalidOffset is an invalid field offset.
-var invalidOffset = offset(nil)
+var invalidOffset = offset{index: -1}
// zeroOffset is a noop when calling pointer.Apply.
-var zeroOffset = offset([]int{0})
+var zeroOffset = offset{index: 0}
// pointer is an abstract representation of a pointer to a struct or field.
type pointer struct{ v reflect.Value }
@@ -53,8 +64,12 @@
// Apply adds an offset to the pointer to derive a new pointer
// to a specified field. The current pointer must be pointing at a struct.
func (p pointer) Apply(f offset) pointer {
- // TODO: Handle unexported fields in an API that hides XXX fields?
- return pointer{v: p.v.Elem().FieldByIndex(f).Addr()}
+ if f.export != nil {
+ if v := reflect.ValueOf(f.export(p.v.Interface(), f.index)); v.IsValid() {
+ return pointer{v: v}
+ }
+ }
+ return pointer{v: p.v.Elem().Field(f.index).Addr()}
}
// AsValueOf treats p as a pointer to an object of type t and returns the value.
diff --git a/internal/impl/pointer_unsafe.go b/internal/impl/pointer_unsafe.go
index 39f1995..bd5ab4b 100644
--- a/internal/impl/pointer_unsafe.go
+++ b/internal/impl/pointer_unsafe.go
@@ -11,12 +11,14 @@
"unsafe"
)
+const UnsafeEnabled = true
+
// offset represents the offset to a struct field, accessible from a pointer.
// The offset is the byte offset to the field from the start of the struct.
type offset uintptr
// offsetOf returns a field offset for the struct field.
-func offsetOf(f reflect.StructField) offset {
+func offsetOf(f reflect.StructField, x exporter) offset {
return offset(f.Offset)
}