@@ -67,7 +67,7 @@ clone git github.com/seccomp/libseccomp-golang 1b506fc7c24eec5a3693cdcbed40d9c22

 clone git github.com/coreos/go-systemd v4

 clone git github.com/godbus/dbus v4.0.0

 clone git github.com/syndtr/gocapability 2c00daeb6c3b45114c80ac44119e7b8801fdd852

-clone git github.com/golang/protobuf 68415e7123da32b07eab49c96d2c4d6158360e9b

+clone git github.com/golang/protobuf 8d92cf5fc15a4382f8964b08e1f42a75c0591aa3

 # gelf logging driver deps

 clone git github.com/Graylog2/go-gelf aab2f594e4585d43468ac57287b0dece9d806883

@@ -39,5 +39,5 @@ test: install generate-test-pbs

 generate-test-pbs:

 	make install

 	make -C testdata

-	protoc --go_out=Mtestdata/test.proto=github.com/golang/protobuf/proto/testdata:. proto3_proto/proto3.proto

+	protoc --go_out=Mtestdata/test.proto=github.com/golang/protobuf/proto/testdata,Mgoogle/protobuf/any.proto=github.com/golang/protobuf/ptypes/any:. proto3_proto/proto3.proto

 	make

@@ -768,10 +768,11 @@ func (o *Buffer) dec_new_map(p *Properties, base structPointer) error {

 		}

 	}

 	keyelem, valelem := keyptr.Elem(), valptr.Elem()

-	if !keyelem.IsValid() || !valelem.IsValid() {

-		// We did not decode the key or the value in the map entry.

-		// Either way, it's an invalid map entry.

-		return fmt.Errorf("proto: bad map data: missing key/val")

+	if !keyelem.IsValid() {

+		keyelem = reflect.Zero(p.mtype.Key())

+	}

+	if !valelem.IsValid() {

+		valelem = reflect.Zero(p.mtype.Elem())

 	}

 	v.SetMapIndex(keyelem, valelem)

@@ -64,6 +64,10 @@ var (

 	// a struct with a repeated field containing a nil element.

 	errRepeatedHasNil = errors.New("proto: repeated field has nil element")

+	// errOneofHasNil is the error returned if Marshal is called with

+	// a struct with a oneof field containing a nil element.

+	errOneofHasNil = errors.New("proto: oneof field has nil value")

+

 	// ErrNil is the error returned if Marshal is called with nil.

 	ErrNil = errors.New("proto: Marshal called with nil")

 )

@@ -1222,7 +1226,9 @@ func (o *Buffer) enc_struct(prop *StructProperties, base structPointer) error {

 	// Do oneof fields.

 	if prop.oneofMarshaler != nil {

 		m := structPointer_Interface(base, prop.stype).(Message)

-		if err := prop.oneofMarshaler(m, o); err != nil {

+		if err := prop.oneofMarshaler(m, o); err == ErrNil {

+			return errOneofHasNil

+		} else if err != nil {

 			return err

 		}

 	}

@@ -50,7 +50,9 @@ Equality is defined in this way:

     are equal, and extensions sets are equal.

   - Two set scalar fields are equal iff their values are equal.

     If the fields are of a floating-point type, remember that

-    NaN != x for all x, including NaN.

+    NaN != x for all x, including NaN. If the message is defined

+    in a proto3 .proto file, fields are not "set"; specifically,

+    zero length proto3 "bytes" fields are equal (nil == {}).

   - Two repeated fields are equal iff their lengths are the same,

     and their corresponding elements are equal (a "bytes" field,

     although represented by []byte, is not a repeated field)

@@ -88,6 +90,7 @@ func Equal(a, b Message) bool {

 // v1 and v2 are known to have the same type.

 func equalStruct(v1, v2 reflect.Value) bool {

+	sprop := GetProperties(v1.Type())

 	for i := 0; i < v1.NumField(); i++ {

 		f := v1.Type().Field(i)

 		if strings.HasPrefix(f.Name, "XXX_") {

@@ -113,7 +116,7 @@ func equalStruct(v1, v2 reflect.Value) bool {

 			}

 			f1, f2 = f1.Elem(), f2.Elem()

 		}

-		if !equalAny(f1, f2) {

+		if !equalAny(f1, f2, sprop.Prop[i]) {

 			return false

 		}

 	}

@@ -140,7 +143,8 @@ func equalStruct(v1, v2 reflect.Value) bool {

 }

 // v1 and v2 are known to have the same type.

-func equalAny(v1, v2 reflect.Value) bool {

+// prop may be nil.

+func equalAny(v1, v2 reflect.Value, prop *Properties) bool {

 	if v1.Type() == protoMessageType {

 		m1, _ := v1.Interface().(Message)

 		m2, _ := v2.Interface().(Message)

@@ -163,7 +167,7 @@ func equalAny(v1, v2 reflect.Value) bool {

 		if e1.Type() != e2.Type() {

 			return false

 		}

-		return equalAny(e1, e2)

+		return equalAny(e1, e2, nil)

 	case reflect.Map:

 		if v1.Len() != v2.Len() {

 			return false

@@ -174,16 +178,22 @@ func equalAny(v1, v2 reflect.Value) bool {

 				// This key was not found in the second map.

 				return false

 			}

-			if !equalAny(v1.MapIndex(key), val2) {

+			if !equalAny(v1.MapIndex(key), val2, nil) {

 				return false

 			}

 		}

 		return true

 	case reflect.Ptr:

-		return equalAny(v1.Elem(), v2.Elem())

+		return equalAny(v1.Elem(), v2.Elem(), prop)

 	case reflect.Slice:

 		if v1.Type().Elem().Kind() == reflect.Uint8 {

 			// short circuit: []byte

+

+			// Edge case: if this is in a proto3 message, a zero length

+			// bytes field is considered the zero value.

+			if prop != nil && prop.proto3 && v1.Len() == 0 && v2.Len() == 0 {

+				return true

+			}

 			if v1.IsNil() != v2.IsNil() {

 				return false

 			}

@@ -194,7 +204,7 @@ func equalAny(v1, v2 reflect.Value) bool {

 			return false

 		}

 		for i := 0; i < v1.Len(); i++ {

-			if !equalAny(v1.Index(i), v2.Index(i)) {

+			if !equalAny(v1.Index(i), v2.Index(i), prop) {

 				return false

 			}

 		}

@@ -229,7 +239,7 @@ func equalExtensions(base reflect.Type, em1, em2 map[int32]Extension) bool {

 		if m1 != nil && m2 != nil {

 			// Both are unencoded.

-			if !equalAny(reflect.ValueOf(m1), reflect.ValueOf(m2)) {

+			if !equalAny(reflect.ValueOf(m1), reflect.ValueOf(m2), nil) {

 				return false

 			}

 			continue

@@ -257,7 +267,7 @@ func equalExtensions(base reflect.Type, em1, em2 map[int32]Extension) bool {

 			log.Printf("proto: badly encoded extension %d of %v: %v", extNum, base, err)

 			return false

 		}

-		if !equalAny(reflect.ValueOf(m1), reflect.ValueOf(m2)) {

+		if !equalAny(reflect.ValueOf(m1), reflect.ValueOf(m2), nil) {

 			return false

 		}

 	}

@@ -70,6 +70,12 @@ for a protocol buffer variable v:

 	with distinguished wrapper types for each possible field value.

   - Marshal and Unmarshal are functions to encode and decode the wire format.

+When the .proto file specifies `syntax="proto3"`, there are some differences:

+

+  - Non-repeated fields of non-message type are values instead of pointers.

+  - Getters are only generated for message and oneof fields.

+  - Enum types do not get an Enum method.

+

 The simplest way to describe this is to see an example.

 Given file test.proto, containing

@@ -229,6 +235,7 @@ To create and play with a Test object:

 		test := &pb.Test{

 			Label: proto.String("hello"),

 			Type:  proto.Int32(17),

+			Reps:  []int64{1, 2, 3},

 			Optionalgroup: &pb.Test_OptionalGroup{

 				RequiredField: proto.String("good bye"),

 			},

@@ -881,3 +888,7 @@ func isProto3Zero(v reflect.Value) bool {

 	}

 	return false

 }

+

+// ProtoPackageIsVersion1 is referenced from generated protocol buffer files

+// to assert that that code is compatible with this version of the proto package.

+const ProtoPackageIsVersion1 = true

@@ -173,6 +173,7 @@ func (sp *StructProperties) Swap(i, j int) { sp.order[i], sp.order[j] = sp.order

 type Properties struct {

 	Name     string // name of the field, for error messages

 	OrigName string // original name before protocol compiler (always set)

+	JSONName string // name to use for JSON; determined by protoc

 	Wire     string

 	WireType int

 	Tag      int

@@ -229,8 +230,9 @@ func (p *Properties) String() string {

 	if p.Packed {

 		s += ",packed"

 	}

-	if p.OrigName != p.Name {

-		s += ",name=" + p.OrigName

+	s += ",name=" + p.OrigName

+	if p.JSONName != p.OrigName {

+		s += ",json=" + p.JSONName

 	}

 	if p.proto3 {

 		s += ",proto3"

@@ -310,6 +312,8 @@ func (p *Properties) Parse(s string) {

 			p.Packed = true

 		case strings.HasPrefix(f, "name="):

 			p.OrigName = f[5:]

+		case strings.HasPrefix(f, "json="):

+			p.JSONName = f[5:]

 		case strings.HasPrefix(f, "enum="):

 			p.Enum = f[5:]

 		case f == "proto3":

@@ -175,7 +175,93 @@ type raw interface {

 	Bytes() []byte

 }

-func writeStruct(w *textWriter, sv reflect.Value) error {

+func requiresQuotes(u string) bool {

+	// When type URL contains any characters except [0-9A-Za-z./\-]*, it must be quoted.

+	for _, ch := range u {

+		switch {

+		case ch == '.' || ch == '/' || ch == '_':

+			continue

+		case '0' <= ch && ch <= '9':

+			continue

+		case 'A' <= ch && ch <= 'Z':

+			continue

+		case 'a' <= ch && ch <= 'z':

+			continue

+		default:

+			return true

+		}

+	}

+	return false

+}

+

+// isAny reports whether sv is a google.protobuf.Any message

+func isAny(sv reflect.Value) bool {

+	type wkt interface {

+		XXX_WellKnownType() string

+	}

+	t, ok := sv.Addr().Interface().(wkt)

+	return ok && t.XXX_WellKnownType() == "Any"

+}

+

+// writeProto3Any writes an expanded google.protobuf.Any message.

+//

+// It returns (false, nil) if sv value can't be unmarshaled (e.g. because

+// required messages are not linked in).

+//

+// It returns (true, error) when sv was written in expanded format or an error

+// was encountered.

+func (tm *TextMarshaler) writeProto3Any(w *textWriter, sv reflect.Value) (bool, error) {

+	turl := sv.FieldByName("TypeUrl")

+	val := sv.FieldByName("Value")

+	if !turl.IsValid() || !val.IsValid() {

+		return true, errors.New("proto: invalid google.protobuf.Any message")

+	}

+

+	b, ok := val.Interface().([]byte)

+	if !ok {

+		return true, errors.New("proto: invalid google.protobuf.Any message")

+	}

+

+	parts := strings.Split(turl.String(), "/")

+	mt := MessageType(parts[len(parts)-1])

+	if mt == nil {

+		return false, nil

+	}

+	m := reflect.New(mt.Elem())

+	if err := Unmarshal(b, m.Interface().(Message)); err != nil {

+		return false, nil

+	}

+	w.Write([]byte("["))

+	u := turl.String()

+	if requiresQuotes(u) {

+		writeString(w, u)

+	} else {

+		w.Write([]byte(u))

+	}

+	if w.compact {

+		w.Write([]byte("]:<"))

+	} else {

+		w.Write([]byte("]: <\n"))

+		w.ind++

+	}

+	if err := tm.writeStruct(w, m.Elem()); err != nil {

+		return true, err

+	}

+	if w.compact {

+		w.Write([]byte("> "))

+	} else {

+		w.ind--

+		w.Write([]byte(">\n"))

+	}

+	return true, nil

+}

+

+func (tm *TextMarshaler) writeStruct(w *textWriter, sv reflect.Value) error {

+	if tm.ExpandAny && isAny(sv) {

+		if canExpand, err := tm.writeProto3Any(w, sv); canExpand {

+			return err

+		}

+	}

 	st := sv.Type()

 	sprops := GetProperties(st)

 	for i := 0; i < sv.NumField(); i++ {

@@ -227,7 +313,7 @@ func writeStruct(w *textWriter, sv reflect.Value) error {

 					}

 					continue

 				}

-				if err := writeAny(w, v, props); err != nil {

+				if err := tm.writeAny(w, v, props); err != nil {

 					return err

 				}

 				if err := w.WriteByte('\n'); err != nil {

@@ -269,7 +355,7 @@ func writeStruct(w *textWriter, sv reflect.Value) error {

 						return err

 					}

 				}

-				if err := writeAny(w, key, props.mkeyprop); err != nil {

+				if err := tm.writeAny(w, key, props.mkeyprop); err != nil {

 					return err

 				}

 				if err := w.WriteByte('\n'); err != nil {

@@ -286,7 +372,7 @@ func writeStruct(w *textWriter, sv reflect.Value) error {

 							return err

 						}

 					}

-					if err := writeAny(w, val, props.mvalprop); err != nil {

+					if err := tm.writeAny(w, val, props.mvalprop); err != nil {

 						return err

 					}

 					if err := w.WriteByte('\n'); err != nil {

@@ -358,7 +444,7 @@ func writeStruct(w *textWriter, sv reflect.Value) error {

 		}

 		// Enums have a String method, so writeAny will work fine.

-		if err := writeAny(w, fv, props); err != nil {

+		if err := tm.writeAny(w, fv, props); err != nil {

 			return err

 		}

@@ -370,7 +456,7 @@ func writeStruct(w *textWriter, sv reflect.Value) error {

 	// Extensions (the XXX_extensions field).

 	pv := sv.Addr()

 	if pv.Type().Implements(extendableProtoType) {

-		if err := writeExtensions(w, pv); err != nil {

+		if err := tm.writeExtensions(w, pv); err != nil {

 			return err

 		}

 	}

@@ -400,7 +486,7 @@ func writeRaw(w *textWriter, b []byte) error {

 }

 // writeAny writes an arbitrary field.

-func writeAny(w *textWriter, v reflect.Value, props *Properties) error {

+func (tm *TextMarshaler) writeAny(w *textWriter, v reflect.Value, props *Properties) error {

 	v = reflect.Indirect(v)

 	// Floats have special cases.

@@ -449,15 +535,15 @@ func writeAny(w *textWriter, v reflect.Value, props *Properties) error {

 			}

 		}

 		w.indent()

-		if tm, ok := v.Interface().(encoding.TextMarshaler); ok {

-			text, err := tm.MarshalText()

+		if etm, ok := v.Interface().(encoding.TextMarshaler); ok {

+			text, err := etm.MarshalText()

 			if err != nil {

 				return err

 			}

 			if _, err = w.Write(text); err != nil {

 				return err

 			}

-		} else if err := writeStruct(w, v); err != nil {

+		} else if err := tm.writeStruct(w, v); err != nil {

 			return err

 		}

 		w.unindent()

@@ -601,7 +687,7 @@ func (s int32Slice) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }

 // writeExtensions writes all the extensions in pv.

 // pv is assumed to be a pointer to a protocol message struct that is extendable.

-func writeExtensions(w *textWriter, pv reflect.Value) error {

+func (tm *TextMarshaler) writeExtensions(w *textWriter, pv reflect.Value) error {

 	emap := extensionMaps[pv.Type().Elem()]

 	ep := pv.Interface().(extendableProto)

@@ -636,13 +722,13 @@ func writeExtensions(w *textWriter, pv reflect.Value) error {

 		// Repeated extensions will appear as a slice.

 		if !desc.repeated() {

-			if err := writeExtension(w, desc.Name, pb); err != nil {

+			if err := tm.writeExtension(w, desc.Name, pb); err != nil {

 				return err

 			}

 		} else {

 			v := reflect.ValueOf(pb)

 			for i := 0; i < v.Len(); i++ {

-				if err := writeExtension(w, desc.Name, v.Index(i).Interface()); err != nil {

+				if err := tm.writeExtension(w, desc.Name, v.Index(i).Interface()); err != nil {

 					return err

 				}

 			}

@@ -651,7 +737,7 @@ func writeExtensions(w *textWriter, pv reflect.Value) error {

 	return nil

 }

-func writeExtension(w *textWriter, name string, pb interface{}) error {

+func (tm *TextMarshaler) writeExtension(w *textWriter, name string, pb interface{}) error {

 	if _, err := fmt.Fprintf(w, "[%s]:", name); err != nil {

 		return err

 	}

@@ -660,7 +746,7 @@ func writeExtension(w *textWriter, name string, pb interface{}) error {

 			return err

 		}

 	}

-	if err := writeAny(w, reflect.ValueOf(pb), nil); err != nil {

+	if err := tm.writeAny(w, reflect.ValueOf(pb), nil); err != nil {

 		return err

 	}

 	if err := w.WriteByte('\n'); err != nil {

@@ -685,7 +771,15 @@ func (w *textWriter) writeIndent() {

 	w.complete = false

 }

-func marshalText(w io.Writer, pb Message, compact bool) error {

+// TextMarshaler is a configurable text format marshaler.

+type TextMarshaler struct {

+	Compact   bool // use compact text format (one line).

+	ExpandAny bool // expand google.protobuf.Any messages of known types

+}

+

+// Marshal writes a given protocol buffer in text format.

+// The only errors returned are from w.

+func (tm *TextMarshaler) Marshal(w io.Writer, pb Message) error {

 	val := reflect.ValueOf(pb)

 	if pb == nil || val.IsNil() {

 		w.Write([]byte("<nil>"))

@@ -700,11 +794,11 @@ func marshalText(w io.Writer, pb Message, compact bool) error {

 	aw := &textWriter{

 		w:        ww,

 		complete: true,

-		compact:  compact,

+		compact:  tm.Compact,

 	}

-	if tm, ok := pb.(encoding.TextMarshaler); ok {

-		text, err := tm.MarshalText()

+	if etm, ok := pb.(encoding.TextMarshaler); ok {

+		text, err := etm.MarshalText()

 		if err != nil {

 			return err

 		}

@@ -718,7 +812,7 @@ func marshalText(w io.Writer, pb Message, compact bool) error {

 	}

 	// Dereference the received pointer so we don't have outer < and >.

 	v := reflect.Indirect(val)

-	if err := writeStruct(aw, v); err != nil {

+	if err := tm.writeStruct(aw, v); err != nil {

 		return err

 	}

 	if bw != nil {

@@ -727,25 +821,29 @@ func marshalText(w io.Writer, pb Message, compact bool) error {

 	return nil

 }

+// Text is the same as Marshal, but returns the string directly.

+func (tm *TextMarshaler) Text(pb Message) string {

+	var buf bytes.Buffer

+	tm.Marshal(&buf, pb)

+	return buf.String()

+}

+

+var (

+	defaultTextMarshaler = TextMarshaler{}

+	compactTextMarshaler = TextMarshaler{Compact: true}

+)

+

+// TODO: consider removing some of the Marshal functions below.

+

 // MarshalText writes a given protocol buffer in text format.

 // The only errors returned are from w.

-func MarshalText(w io.Writer, pb Message) error {

-	return marshalText(w, pb, false)

-}

+func MarshalText(w io.Writer, pb Message) error { return defaultTextMarshaler.Marshal(w, pb) }

 // MarshalTextString is the same as MarshalText, but returns the string directly.

-func MarshalTextString(pb Message) string {

-	var buf bytes.Buffer

-	marshalText(&buf, pb, false)

-	return buf.String()

-}

+func MarshalTextString(pb Message) string { return defaultTextMarshaler.Text(pb) }

 // CompactText writes a given protocol buffer in compact text format (one line).

-func CompactText(w io.Writer, pb Message) error { return marshalText(w, pb, true) }

+func CompactText(w io.Writer, pb Message) error { return compactTextMarshaler.Marshal(w, pb) }

 // CompactTextString is the same as CompactText, but returns the string directly.

-func CompactTextString(pb Message) string {

-	var buf bytes.Buffer

-	marshalText(&buf, pb, true)

-	return buf.String()

-}

+func CompactTextString(pb Message) string { return compactTextMarshaler.Text(pb) }

@@ -119,6 +119,14 @@ func isWhitespace(c byte) bool {

 	return false

 }

+func isQuote(c byte) bool {

+	switch c {

+	case '"', '\'':

+		return true

+	}

+	return false

+}

+

 func (p *textParser) skipWhitespace() {

 	i := 0

 	for i < len(p.s) && (isWhitespace(p.s[i]) || p.s[i] == '#') {

@@ -155,7 +163,7 @@ func (p *textParser) advance() {

 	p.cur.offset, p.cur.line = p.offset, p.line

 	p.cur.unquoted = ""

 	switch p.s[0] {

-	case '<', '>', '{', '}', ':', '[', ']', ';', ',':

+	case '<', '>', '{', '}', ':', '[', ']', ';', ',', '/':

 		// Single symbol

 		p.cur.value, p.s = p.s[0:1], p.s[1:len(p.s)]

 	case '"', '\'':

@@ -333,13 +341,13 @@ func (p *textParser) next() *token {

 	p.advance()

 	if p.done {

 		p.cur.value = ""

-	} else if len(p.cur.value) > 0 && p.cur.value[0] == '"' {

+	} else if len(p.cur.value) > 0 && isQuote(p.cur.value[0]) {

 		// Look for multiple quoted strings separated by whitespace,

 		// and concatenate them.

 		cat := p.cur

 		for {

 			p.skipWhitespace()

-			if p.done || p.s[0] != '"' {

+			if p.done || !isQuote(p.s[0]) {

 				break

 			}

 			p.advance()

@@ -443,7 +451,10 @@ func (p *textParser) readStruct(sv reflect.Value, terminator string) error {

 	fieldSet := make(map[string]bool)

 	// A struct is a sequence of "name: value", terminated by one of

 	// '>' or '}', or the end of the input.  A name may also be

-	// "[extension]".

+	// "[extension]" or "[type/url]".

+	//

+	// The whole struct can also be an expanded Any message, like:

+	// [type/url] < ... struct contents ... >

 	for {

 		tok := p.next()

 		if tok.err != nil {

@@ -453,33 +464,66 @@ func (p *textParser) readStruct(sv reflect.Value, terminator string) error {

 			break

 		}

 		if tok.value == "[" {

-			// Looks like an extension.

+			// Looks like an extension or an Any.

 			//

 			// TODO: Check whether we need to handle

 			// namespace rooted names (e.g. ".something.Foo").

-			tok = p.next()

-			if tok.err != nil {

-				return tok.err

+			extName, err := p.consumeExtName()

+			if err != nil {

+				return err

+			}

+

+			if s := strings.LastIndex(extName, "/"); s >= 0 {

+				// If it contains a slash, it's an Any type URL.

+				messageName := extName[s+1:]

+				mt := MessageType(messageName)

+				if mt == nil {

+					return p.errorf("unrecognized message %q in google.protobuf.Any", messageName)

+				}

+				tok = p.next()

+				if tok.err != nil {

+					return tok.err

+				}

+				// consume an optional colon

+				if tok.value == ":" {

+					tok = p.next()

+					if tok.err != nil {

+						return tok.err

+					}

+				}

+				var terminator string

+				switch tok.value {

+				case "<":

+					terminator = ">"

+				case "{":

+					terminator = "}"

+				default:

+					return p.errorf("expected '{' or '<', found %q", tok.value)

+				}

+				v := reflect.New(mt.Elem())

+				if pe := p.readStruct(v.Elem(), terminator); pe != nil {

+					return pe

+				}

+				b, err := Marshal(v.Interface().(Message))

+				if err != nil {

+					return p.errorf("failed to marshal message of type %q: %v", messageName, err)

+				}

+				sv.FieldByName("TypeUrl").SetString(extName)

+				sv.FieldByName("Value").SetBytes(b)

+				continue

 			}

+

 			var desc *ExtensionDesc

 			// This could be faster, but it's functional.

 			// TODO: Do something smarter than a linear scan.

 			for _, d := range RegisteredExtensions(reflect.New(st).Interface().(Message)) {

-				if d.Name == tok.value {

+				if d.Name == extName {

 					desc = d

 					break

 				}

 			}

 			if desc == nil {

-				return p.errorf("unrecognized extension %q", tok.value)

-			}

-			// Check the extension terminator.

-			tok = p.next()

-			if tok.err != nil {

-				return tok.err

-			}

-			if tok.value != "]" {

-				return p.errorf("unrecognized extension terminator %q", tok.value)

+				return p.errorf("unrecognized extension %q", extName)

 			}

 			props := &Properties{}

@@ -635,6 +679,35 @@ func (p *textParser) readStruct(sv reflect.Value, terminator string) error {

 	return reqFieldErr

 }

+// consumeExtName consumes extension name or expanded Any type URL and the

+// following ']'. It returns the name or URL consumed.

+func (p *textParser) consumeExtName() (string, error) {

+	tok := p.next()

+	if tok.err != nil {

+		return "", tok.err

+	}

+

+	// If extension name or type url is quoted, it's a single token.

+	if len(tok.value) > 2 && isQuote(tok.value[0]) && tok.value[len(tok.value)-1] == tok.value[0] {

+		name, err := unquoteC(tok.value[1:len(tok.value)-1], rune(tok.value[0]))

+		if err != nil {

+			return "", err

+		}

+		return name, p.consumeToken("]")

+	}

+

+	// Consume everything up to "]"

+	var parts []string

+	for tok.value != "]" {

+		parts = append(parts, tok.value)

+		tok = p.next()

+		if tok.err != nil {

+			return "", p.errorf("unrecognized type_url or extension name: %s", tok.err)

+		}

+	}

+	return strings.Join(parts, ""), nil

+}

+

 // consumeOptionalSeparator consumes an optional semicolon or comma.

 // It is used in readStruct to provide backward compatibility.

 func (p *textParser) consumeOptionalSeparator() error {