@@ -102,7 +102,7 @@ clone git github.com/pborman/uuid v1.0

 # get desired notary commit, might also need to be updated in Dockerfile

 clone git github.com/docker/notary v0.3.0

-clone git google.golang.org/grpc ab0be5212fb225475f2087566eded7da5d727960 https://github.com/grpc/grpc-go.git

+clone git google.golang.org/grpc v1.0.1-GA https://github.com/grpc/grpc-go.git

 clone git github.com/miekg/pkcs11 df8ae6ca730422dba20c768ff38ef7d79077a59f

 clone git github.com/docker/go v1.5.1-1-1-gbaf439e

 clone git github.com/agl/ed25519 d2b94fd789ea21d12fac1a4443dd3a3f79cda72c

@@ -114,7 +114,7 @@ clone git github.com/seccomp/libseccomp-golang 32f571b70023028bd57d9288c20efbcb2

 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 3c84672111d91bb5ac31719e112f9f7126a0e26e

+clone git github.com/golang/protobuf 1f49d83d9aa00e6ce4fc8258c71cc7786aec968a

 # gelf logging driver deps

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

@@ -146,7 +146,7 @@ clone git github.com/docker/containerd 4c21ad662f71af56c0e6b29c0afef72df441d1ff

 # cluster

 clone git github.com/docker/swarmkit 27fbaef4ceed648bb575969ccc9083a6e104a719

 clone git github.com/golang/mock bd3c8e81be01eef76d4b503f5e687d2d1354d2d9

-clone git github.com/gogo/protobuf 43a2e0b1c32252bfbbdf81f7faa7a88fb3fa4028

+clone git github.com/gogo/protobuf v0.3

 clone git github.com/cloudflare/cfssl 7fb22c8cba7ecaf98e4082d22d65800cf45e042a

 clone git github.com/google/certificate-transparency 0f6e3d1d1ba4d03fdaab7cd716f36255c2e48341

 clone git golang.org/x/crypto 3fbbcd23f1cb824e69491a5930cfeff09b12f4d2 https://github.com/golang/crypto.git

@@ -1,7 +1,7 @@

-Extensions for Protocol Buffers to create more go like structures.

+Protocol Buffers for Go with Gadgets

-Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved.

-http://github.com/gogo/protobuf/gogoproto

+Copyright (c) 2013, The GoGo Authors. All rights reserved.

+http://github.com/gogo/protobuf

 Go support for Protocol Buffers - Google's data interchange format

@@ -1,7 +1,7 @@

-# Extensions for Protocol Buffers to create more go like structures.

+# Protocol Buffers for Go with Gadgets

 #

-# Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved.

-# http://github.com/gogo/protobuf/gogoproto

+# Copyright (c) 2013, The GoGo Authors. All rights reserved.

+# http://github.com/gogo/protobuf

 #

 # Redistribution and use in source and binary forms, with or without

 # modification, are permitted provided that the following conditions are

@@ -1,7 +1,7 @@

-// Extensions for Protocol Buffers to create more go like structures.

+// Protocol Buffers for Go with Gadgets

 //

-// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved.

-// http://github.com/gogo/protobuf/gogoproto

+// Copyright (c) 2013, The GoGo Authors. All rights reserved.

+// http://github.com/gogo/protobuf

 //

 // Redistribution and use in source and binary forms, with or without

 // modification, are permitted provided that the following conditions are

@@ -24,7 +24,9 @@ var _ = math.Inf

 // This is a compile-time assertion to ensure that this generated file

 // is compatible with the proto package it is being compiled against.

-const _ = proto.GoGoProtoPackageIsVersion1

+// A compilation error at this line likely means your copy of the

+// proto package needs to be updated.

+const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package

 var E_GoprotoEnumPrefix = &proto.ExtensionDesc{

 	ExtendedType:  (*google_protobuf.EnumOptions)(nil),

@@ -587,75 +589,77 @@ func init() {

 	proto.RegisterExtension(E_Castvalue)

 }

+func init() { proto.RegisterFile("gogo.proto", fileDescriptorGogo) }

+

 var fileDescriptorGogo = []byte{

-	// 1096 bytes of a gzipped FileDescriptorProto

-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x94, 0x97, 0xcb, 0x6f, 0xdc, 0x54,

-	0x14, 0x87, 0x85, 0x48, 0x95, 0x99, 0x93, 0x17, 0x99, 0x84, 0x50, 0x2a, 0x10, 0xed, 0x8e, 0x55,

-	0xba, 0x42, 0xa8, 0xae, 0x10, 0x6a, 0xab, 0x34, 0x2a, 0x22, 0x10, 0x05, 0x52, 0x40, 0x2c, 0x46,

-	0x9e, 0xc9, 0x8d, 0x3b, 0xe0, 0xf1, 0x35, 0xbe, 0x76, 0xd5, 0xb0, 0x43, 0xe5, 0x21, 0x84, 0x78,

-	0x23, 0x41, 0x4b, 0xcb, 0x63, 0xc1, 0xfb, 0x59, 0x1e, 0x7b, 0x36, 0xc0, 0x9a, 0xff, 0x81, 0x0d,

-	0x10, 0x5e, 0x52, 0x76, 0xd9, 0xf4, 0x1e, 0xfb, 0x1c, 0xcf, 0xb5, 0x67, 0xa4, 0x7b, 0x67, 0xe7,

-	0x64, 0xee, 0xf7, 0xcd, 0xf5, 0x39, 0xbe, 0xe7, 0x37, 0x06, 0x08, 0x64, 0x20, 0x97, 0xe3, 0x44,

-	0xa6, 0xb2, 0xd5, 0xc4, 0xeb, 0xfc, 0xf2, 0xd0, 0xe1, 0x40, 0xca, 0x20, 0x14, 0x47, 0xf3, 0xbf,

-	0x3a, 0xd9, 0xf6, 0xd1, 0x2d, 0xa1, 0xba, 0x49, 0x2f, 0x4e, 0x65, 0x52, 0x2c, 0xf6, 0x1e, 0x80,

-	0x05, 0x5a, 0xdc, 0x16, 0x51, 0xd6, 0x6f, 0xc7, 0x89, 0xd8, 0xee, 0x5d, 0x68, 0xdd, 0xb6, 0x5c,

-	0x90, 0xcb, 0x4c, 0x2e, 0xaf, 0xe8, 0x4f, 0x1f, 0x8c, 0xd3, 0x9e, 0x8c, 0xd4, 0xc1, 0x6b, 0xbf,

-	0xdf, 0x78, 0xf8, 0x86, 0x3b, 0x1b, 0x1b, 0xf3, 0x84, 0xe2, 0x67, 0xeb, 0x39, 0xe8, 0x6d, 0xc0,

-	0xcd, 0x15, 0x9f, 0x4a, 0x93, 0x5e, 0x14, 0x88, 0xc4, 0x62, 0xfc, 0x99, 0x8c, 0x0b, 0x86, 0xf1,

-	0x21, 0x42, 0xbd, 0x53, 0x30, 0x33, 0x8e, 0xeb, 0x17, 0x72, 0x4d, 0x0b, 0x53, 0xb2, 0x0a, 0x73,

-	0xb9, 0xa4, 0x9b, 0xa9, 0x54, 0xf6, 0x23, 0xbf, 0x2f, 0x2c, 0x9a, 0x5f, 0x73, 0x4d, 0x73, 0x63,

-	0x16, 0xb1, 0x53, 0x25, 0xe5, 0x9d, 0x85, 0x45, 0xfc, 0xcf, 0x79, 0x3f, 0xcc, 0x84, 0x69, 0x3b,

-	0x32, 0xd2, 0x76, 0x16, 0x97, 0xb1, 0xf2, 0xb7, 0x8b, 0x13, 0xb9, 0x72, 0xa1, 0x14, 0x18, 0x5e,

-	0xa3, 0x13, 0x81, 0x48, 0x53, 0x91, 0xa8, 0xb6, 0x1f, 0x86, 0x23, 0x36, 0x79, 0xba, 0x17, 0x96,

-	0xc6, 0x4b, 0xbb, 0xd5, 0x4e, 0xac, 0x16, 0xe4, 0x89, 0x30, 0xf4, 0x36, 0xe1, 0x96, 0x11, 0x9d,

-	0x75, 0x70, 0x5e, 0x26, 0xe7, 0xe2, 0x50, 0x77, 0x51, 0xbb, 0x0e, 0xfc, 0xff, 0xb2, 0x1f, 0x0e,

-	0xce, 0x77, 0xc9, 0xd9, 0x22, 0x96, 0xdb, 0x82, 0xc6, 0xfb, 0x60, 0xfe, 0xbc, 0x48, 0x3a, 0x52,

-	0x89, 0xb6, 0x78, 0x2a, 0xf3, 0x43, 0x07, 0xdd, 0x15, 0xd2, 0xcd, 0x11, 0xb8, 0x82, 0x1c, 0xba,

-	0x8e, 0x41, 0x63, 0xdb, 0xef, 0x0a, 0x07, 0xc5, 0x55, 0x52, 0x4c, 0xe2, 0x7a, 0x44, 0x4f, 0xc0,

-	0x74, 0x20, 0x8b, 0x5b, 0x72, 0xc0, 0xdf, 0x23, 0x7c, 0x8a, 0x19, 0x52, 0xc4, 0x32, 0xce, 0x42,

-	0x3f, 0x75, 0xd9, 0xc1, 0xfb, 0xac, 0x60, 0x86, 0x14, 0x63, 0x94, 0xf5, 0x03, 0x56, 0x28, 0xa3,

-	0x9e, 0xf7, 0xc2, 0x94, 0x8c, 0xc2, 0x1d, 0x19, 0xb9, 0x6c, 0xe2, 0x43, 0x32, 0x00, 0x21, 0x28,

-	0x38, 0x0e, 0x4d, 0xd7, 0x46, 0x7c, 0x44, 0x78, 0x43, 0x70, 0x07, 0xf4, 0x39, 0xe3, 0x21, 0xa3,

-	0x57, 0x38, 0x28, 0x3e, 0x26, 0xc5, 0xac, 0x81, 0xd1, 0x6d, 0xa4, 0x42, 0xa5, 0x81, 0x70, 0x91,

-	0x7c, 0xc2, 0xb7, 0x41, 0x08, 0x95, 0xb2, 0x23, 0xa2, 0xee, 0x39, 0x37, 0xc3, 0xa7, 0x5c, 0x4a,

-	0x66, 0x50, 0xa1, 0x27, 0x4f, 0xdf, 0x4f, 0xd4, 0x39, 0x3f, 0x74, 0x6a, 0xc7, 0x67, 0xe4, 0x98,

-	0x2e, 0x21, 0xaa, 0x48, 0x16, 0x8d, 0xa3, 0xf9, 0x9c, 0x2b, 0x62, 0x60, 0x74, 0xf4, 0x54, 0xea,

-	0x77, 0x42, 0xd1, 0x1e, 0xc7, 0xf6, 0x05, 0x1f, 0xbd, 0x82, 0x5d, 0x33, 0x8d, 0xba, 0xd3, 0xaa,

-	0xf7, 0xb4, 0x93, 0xe6, 0x4b, 0xee, 0x74, 0x0e, 0x20, 0xfc, 0x18, 0xdc, 0x3a, 0x72, 0xd4, 0x3b,

-	0xc8, 0xbe, 0x22, 0xd9, 0xd2, 0x88, 0x71, 0x4f, 0x23, 0x61, 0x5c, 0xe5, 0xd7, 0x3c, 0x12, 0x44,

-	0xcd, 0xa5, 0xab, 0x96, 0x45, 0xca, 0xdf, 0x1e, 0xaf, 0x6a, 0xdf, 0x70, 0xd5, 0x0a, 0xb6, 0x52,

-	0xb5, 0x87, 0x61, 0x89, 0x8c, 0xe3, 0xf5, 0xf5, 0x5b, 0x1e, 0xac, 0x05, 0xbd, 0x59, 0xed, 0xee,

-	0xe3, 0x70, 0xa8, 0x2c, 0xe7, 0x85, 0x54, 0x44, 0x0a, 0x19, 0xbd, 0xe7, 0xd8, 0xc1, 0x7c, 0x8d,

-	0xcc, 0x3c, 0xf1, 0x57, 0x4a, 0xc1, 0x9a, 0x1f, 0xa3, 0xfc, 0x51, 0x38, 0xc8, 0xf2, 0x2c, 0x4a,

-	0x44, 0x57, 0x06, 0x91, 0x6e, 0xe3, 0x96, 0x83, 0xfa, 0xbb, 0x5a, 0xab, 0x36, 0x0d, 0x1c, 0xcd,

-	0x67, 0xe0, 0xa6, 0xf2, 0xf7, 0x46, 0xbb, 0xd7, 0x8f, 0x65, 0x92, 0x5a, 0x8c, 0xdf, 0x73, 0xa7,

-	0x4a, 0xee, 0x4c, 0x8e, 0x79, 0x2b, 0x30, 0x9b, 0xff, 0xe9, 0xfa, 0x48, 0xfe, 0x40, 0xa2, 0x99,

-	0x01, 0x45, 0x83, 0xa3, 0x2b, 0xfb, 0xb1, 0x9f, 0xb8, 0xcc, 0xbf, 0x1f, 0x79, 0x70, 0x10, 0x52,

-	0x3c, 0x7d, 0x73, 0xb5, 0x24, 0x6e, 0xdd, 0x31, 0x24, 0x59, 0x13, 0x4a, 0xf9, 0x41, 0xe9, 0x79,

-	0x66, 0x8f, 0xce, 0x6c, 0x35, 0x88, 0xbd, 0xfb, 0xb1, 0x3c, 0xd5, 0xb8, 0xb4, 0xcb, 0x2e, 0xee,

-	0x95, 0x15, 0xaa, 0xa4, 0xa5, 0x77, 0x1a, 0x66, 0x2a, 0x51, 0x69, 0x57, 0x3d, 0x4b, 0xaa, 0x69,

-	0x33, 0x29, 0xbd, 0xbb, 0x60, 0x02, 0x63, 0xcf, 0x8e, 0x3f, 0x47, 0x78, 0xbe, 0xdc, 0xbb, 0x07,

-	0x1a, 0x1c, 0x77, 0x76, 0xf4, 0x79, 0x42, 0x4b, 0x04, 0x71, 0x8e, 0x3a, 0x3b, 0xfe, 0x02, 0xe3,

-	0x8c, 0x20, 0xee, 0x5e, 0xc2, 0x9f, 0x5e, 0x9a, 0xa0, 0x71, 0xc5, 0xb5, 0x3b, 0x0e, 0x93, 0x94,

-	0x71, 0x76, 0xfa, 0x45, 0xfa, 0x72, 0x26, 0xbc, 0xbb, 0xe1, 0x80, 0x63, 0xc1, 0x5f, 0x26, 0xb4,

-	0x58, 0xaf, 0x13, 0x64, 0xca, 0xc8, 0x35, 0x3b, 0xfe, 0x0a, 0xe1, 0x26, 0x85, 0x5b, 0xa7, 0x5c,

-	0xb3, 0x0b, 0x5e, 0xe5, 0xad, 0x13, 0x81, 0x65, 0xe3, 0x48, 0xb3, 0xd3, 0xaf, 0x71, 0xd5, 0x19,

-	0xd1, 0xa7, 0xa9, 0x59, 0x8e, 0x29, 0x3b, 0xff, 0x3a, 0xf1, 0x03, 0x06, 0x2b, 0x60, 0x8c, 0x49,

-	0xbb, 0xe2, 0x0d, 0xae, 0x80, 0x41, 0xe1, 0x31, 0xaa, 0x47, 0x9f, 0xdd, 0xf4, 0x26, 0x1f, 0xa3,

-	0x5a, 0xf2, 0x61, 0x37, 0xf3, 0x69, 0x61, 0x57, 0xbc, 0xc5, 0xdd, 0xcc, 0xd7, 0xe3, 0x36, 0xea,

-	0x59, 0x62, 0x77, 0xbc, 0xcd, 0xdb, 0xa8, 0x45, 0x89, 0x4e, 0xa6, 0xd6, 0x70, 0x8e, 0xd8, 0x7d,

-	0xef, 0x90, 0x6f, 0x7e, 0x28, 0x46, 0xbc, 0x47, 0x60, 0x69, 0x74, 0x86, 0xd8, 0xad, 0x97, 0xf6,

-	0x6a, 0xbf, 0xfa, 0xcd, 0x08, 0xd1, 0x91, 0xb7, 0x38, 0x2a, 0x3f, 0xec, 0xda, 0xcb, 0x7b, 0xd5,

-	0x17, 0x3b, 0x33, 0x3e, 0xf4, 0x2f, 0x34, 0x18, 0x8c, 0x6e, 0xbb, 0xeb, 0x0a, 0xb9, 0x0c, 0x08,

-	0x8f, 0x06, 0x4d, 0x6e, 0x3b, 0x7f, 0x95, 0x8f, 0x06, 0x11, 0x1a, 0x6e, 0x44, 0x59, 0x18, 0xe2,

-	0xc3, 0xd1, 0xba, 0x7d, 0x44, 0x4c, 0x88, 0x70, 0x8b, 0xd9, 0x3f, 0xf6, 0xe9, 0x60, 0x30, 0xa0,

-	0x67, 0xe8, 0x01, 0xd1, 0xef, 0xe8, 0x1a, 0x58, 0xc8, 0x3f, 0xf7, 0x79, 0x20, 0xe0, 0x6a, 0x7d,

-	0x9e, 0xa0, 0x78, 0x69, 0x4c, 0x77, 0x62, 0xeb, 0xb7, 0xfe, 0xb5, 0x5f, 0xbc, 0x83, 0x1a, 0xc8,

-	0x40, 0x90, 0xbf, 0x75, 0x5a, 0x04, 0xbb, 0x55, 0x41, 0xfe, 0xa2, 0x79, 0x0c, 0x26, 0x9f, 0x50,

-	0x32, 0x4a, 0xfd, 0xc0, 0x46, 0xff, 0x4d, 0x34, 0xaf, 0xc7, 0x82, 0xf5, 0x65, 0x22, 0xf4, 0xa5,

-	0xb2, 0xb1, 0xff, 0x10, 0x5b, 0x02, 0x08, 0x77, 0x7d, 0x95, 0xba, 0xdc, 0xf7, 0xbf, 0x0c, 0x33,

-	0x80, 0x9b, 0xc6, 0xeb, 0x27, 0xc5, 0x8e, 0x8d, 0xfd, 0x8f, 0x37, 0x4d, 0xeb, 0xf5, 0x00, 0x6c,

-	0xe2, 0x65, 0xfe, 0xbe, 0x6d, 0x83, 0xff, 0x27, 0x78, 0x40, 0x9c, 0x3c, 0x02, 0x0b, 0xfa, 0x79,

-	0xa9, 0x63, 0x27, 0x61, 0x55, 0xae, 0xca, 0xf5, 0xfc, 0x41, 0xbc, 0x1e, 0x00, 0x00, 0xff, 0xff,

-	0x87, 0x5c, 0xee, 0x2b, 0x7e, 0x11, 0x00, 0x00,

+	// 1098 bytes of a gzipped FileDescriptorProto

+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x94, 0x97, 0xc9, 0x6f, 0x1c, 0x45,

+	0x14, 0x87, 0x85, 0x70, 0xe4, 0x99, 0xe7, 0x0d, 0x8f, 0x8d, 0x09, 0x11, 0x88, 0xe4, 0xc6, 0xc9,

+	0x39, 0x45, 0x28, 0x65, 0x45, 0x96, 0x63, 0x39, 0xa3, 0x20, 0x0c, 0x23, 0x13, 0x07, 0x10, 0x87,

+	0x51, 0xcf, 0xb8, 0xdc, 0x19, 0xe8, 0xee, 0x6a, 0xba, 0xba, 0xa3, 0x38, 0x37, 0x14, 0x16, 0x21,

+	0xc4, 0x8e, 0x04, 0x09, 0x09, 0xcb, 0x81, 0x7d, 0x0d, 0xcb, 0x9d, 0x0b, 0x70, 0xe6, 0x7f, 0xe0,

+	0x02, 0x98, 0x4d, 0xf2, 0xcd, 0x17, 0xf4, 0xba, 0xdf, 0xeb, 0xa9, 0x1e, 0x8f, 0x54, 0x35, 0xb7,

+	0xf6, 0xb8, 0xbe, 0x6f, 0xaa, 0xdf, 0xeb, 0x7a, 0xbf, 0x69, 0x00, 0x5f, 0xf9, 0x6a, 0x31, 0x4e,

+	0x54, 0xaa, 0x1a, 0x75, 0xbc, 0xce, 0x2f, 0x8f, 0x1c, 0xf5, 0x95, 0xf2, 0x03, 0x79, 0x3c, 0xff,

+	0xab, 0x93, 0x6d, 0x1f, 0xdf, 0x92, 0xba, 0x9b, 0xf4, 0xe2, 0x54, 0x25, 0xc5, 0x62, 0xf1, 0x20,

+	0xcc, 0xd1, 0xe2, 0xb6, 0x8c, 0xb2, 0xb0, 0x1d, 0x27, 0x72, 0xbb, 0x77, 0xa9, 0x71, 0xd7, 0x62,

+	0x41, 0x2e, 0x32, 0xb9, 0xb8, 0x16, 0x65, 0xe1, 0x43, 0x71, 0xda, 0x53, 0x91, 0x3e, 0x7c, 0xf3,

+	0xb7, 0x5b, 0x8f, 0xde, 0x72, 0x6f, 0x6d, 0x63, 0x96, 0x50, 0xfc, 0x5f, 0x2b, 0x07, 0xc5, 0x06,

+	0xdc, 0x5e, 0xf1, 0xe9, 0x34, 0xe9, 0x45, 0xbe, 0x4c, 0x2c, 0xc6, 0x9f, 0xc8, 0x38, 0x67, 0x18,

+	0x1f, 0x26, 0x54, 0xac, 0xc2, 0xd4, 0x28, 0xae, 0x9f, 0xc9, 0x35, 0x29, 0x4d, 0x49, 0x13, 0x66,

+	0x72, 0x49, 0x37, 0xd3, 0xa9, 0x0a, 0x23, 0x2f, 0x94, 0x16, 0xcd, 0x2f, 0xb9, 0xa6, 0xbe, 0x31,

+	0x8d, 0xd8, 0x6a, 0x49, 0x89, 0xf3, 0x30, 0x8f, 0x9f, 0x5c, 0xf4, 0x82, 0x4c, 0x9a, 0xb6, 0x63,

+	0x43, 0x6d, 0xe7, 0x71, 0x19, 0x2b, 0x7f, 0xbd, 0x32, 0x96, 0x2b, 0xe7, 0x4a, 0x81, 0xe1, 0x35,

+	0x3a, 0xe1, 0xcb, 0x34, 0x95, 0x89, 0x6e, 0x7b, 0x41, 0x30, 0x64, 0x93, 0x67, 0x7a, 0x41, 0x69,

+	0xbc, 0xba, 0x5b, 0xed, 0x44, 0xb3, 0x20, 0x57, 0x82, 0x40, 0x6c, 0xc2, 0x1d, 0x43, 0x3a, 0xeb,

+	0xe0, 0xbc, 0x46, 0xce, 0xf9, 0x03, 0xdd, 0x45, 0x6d, 0x0b, 0xf8, 0xf3, 0xb2, 0x1f, 0x0e, 0xce,

+	0x77, 0xc8, 0xd9, 0x20, 0x96, 0xdb, 0x82, 0xc6, 0xfb, 0x61, 0xf6, 0xa2, 0x4c, 0x3a, 0x4a, 0xcb,

+	0xb6, 0x7c, 0x2a, 0xf3, 0x02, 0x07, 0xdd, 0x75, 0xd2, 0xcd, 0x10, 0xb8, 0x86, 0x1c, 0xba, 0x4e,

+	0x42, 0x6d, 0xdb, 0xeb, 0x4a, 0x07, 0xc5, 0x0d, 0x52, 0x8c, 0xe3, 0x7a, 0x44, 0x57, 0x60, 0xd2,

+	0x57, 0xc5, 0x2d, 0x39, 0xe0, 0xef, 0x12, 0x3e, 0xc1, 0x0c, 0x29, 0x62, 0x15, 0x67, 0x81, 0x97,

+	0xba, 0xec, 0xe0, 0x3d, 0x56, 0x30, 0x43, 0x8a, 0x11, 0xca, 0xfa, 0x3e, 0x2b, 0xb4, 0x51, 0xcf,

+	0x65, 0x98, 0x50, 0x51, 0xb0, 0xa3, 0x22, 0x97, 0x4d, 0x7c, 0x40, 0x06, 0x20, 0x04, 0x05, 0x4b,

+	0x50, 0x77, 0x6d, 0xc4, 0x87, 0x84, 0xd7, 0x24, 0x77, 0xa0, 0x09, 0x33, 0x3c, 0x64, 0x7a, 0x2a,

+	0x72, 0x50, 0x7c, 0x44, 0x8a, 0x69, 0x03, 0xa3, 0xdb, 0x48, 0xa5, 0x4e, 0x7d, 0xe9, 0x22, 0xf9,

+	0x98, 0x6f, 0x83, 0x10, 0x2a, 0x65, 0x47, 0x46, 0xdd, 0x0b, 0x6e, 0x86, 0x4f, 0xb8, 0x94, 0xcc,

+	0xa0, 0x62, 0x15, 0xa6, 0x42, 0x2f, 0xd1, 0x17, 0xbc, 0xc0, 0xa9, 0x1d, 0x9f, 0x92, 0x63, 0xb2,

+	0x84, 0xa8, 0x22, 0x59, 0x34, 0x8a, 0xe6, 0x33, 0xae, 0x88, 0x81, 0xd1, 0xd1, 0xd3, 0xa9, 0xd7,

+	0x09, 0x64, 0x7b, 0x14, 0xdb, 0xe7, 0x7c, 0xf4, 0x0a, 0x76, 0xdd, 0x34, 0x2e, 0x41, 0x5d, 0xf7,

+	0x2e, 0x3b, 0x69, 0xbe, 0xe0, 0x4e, 0xe7, 0x00, 0xc2, 0x8f, 0xc1, 0x9d, 0x43, 0x47, 0xbd, 0x83,

+	0xec, 0x4b, 0x92, 0x2d, 0x0c, 0x19, 0xf7, 0x34, 0x12, 0x46, 0x55, 0x7e, 0xc5, 0x23, 0x41, 0x0e,

+	0xb8, 0x5a, 0x30, 0x9f, 0x45, 0xda, 0xdb, 0x1e, 0xad, 0x6a, 0x5f, 0x73, 0xd5, 0x0a, 0xb6, 0x52,

+	0xb5, 0x73, 0xb0, 0x40, 0xc6, 0xd1, 0xfa, 0xfa, 0x0d, 0x0f, 0xd6, 0x82, 0xde, 0xac, 0x76, 0xf7,

+	0x71, 0x38, 0x52, 0x96, 0xf3, 0x52, 0x2a, 0x23, 0x8d, 0x4c, 0x3b, 0xf4, 0x62, 0x07, 0xf3, 0x4d,

+	0x32, 0xf3, 0xc4, 0x5f, 0x2b, 0x05, 0xeb, 0x5e, 0x8c, 0xf2, 0x47, 0xe1, 0x30, 0xcb, 0xb3, 0x28,

+	0x91, 0x5d, 0xe5, 0x47, 0xbd, 0xcb, 0x72, 0xcb, 0x41, 0xfd, 0xed, 0x40, 0xab, 0x36, 0x0d, 0x1c,

+	0xcd, 0x67, 0xe1, 0xb6, 0xf2, 0xf7, 0x46, 0xbb, 0x17, 0xc6, 0x2a, 0x49, 0x2d, 0xc6, 0xef, 0xb8,

+	0x53, 0x25, 0x77, 0x36, 0xc7, 0xc4, 0x1a, 0x4c, 0xe7, 0x7f, 0xba, 0x3e, 0x92, 0xdf, 0x93, 0x68,

+	0xaa, 0x4f, 0xd1, 0xe0, 0xe8, 0xaa, 0x30, 0xf6, 0x12, 0x97, 0xf9, 0xf7, 0x03, 0x0f, 0x0e, 0x42,

+	0x8a, 0xa7, 0x6f, 0x66, 0x20, 0x89, 0x1b, 0xf7, 0x1c, 0x90, 0xac, 0x4b, 0xad, 0x3d, 0xbf, 0xf4,

+	0x3c, 0xbd, 0x47, 0x67, 0xb6, 0x1a, 0xc4, 0xe2, 0x01, 0x2c, 0x4f, 0x35, 0x2e, 0xed, 0xb2, 0x2b,

+	0x7b, 0x65, 0x85, 0x2a, 0x69, 0x29, 0xce, 0xc0, 0x54, 0x25, 0x2a, 0xed, 0xaa, 0x67, 0x48, 0x35,

+	0x69, 0x26, 0xa5, 0x38, 0x01, 0x63, 0x18, 0x7b, 0x76, 0xfc, 0x59, 0xc2, 0xf3, 0xe5, 0xe2, 0x14,

+	0xd4, 0x38, 0xee, 0xec, 0xe8, 0x73, 0x84, 0x96, 0x08, 0xe2, 0x1c, 0x75, 0x76, 0xfc, 0x79, 0xc6,

+	0x19, 0x41, 0xdc, 0xbd, 0x84, 0x3f, 0xbe, 0x38, 0x46, 0xe3, 0x8a, 0x6b, 0xb7, 0x04, 0xe3, 0x94,

+	0x71, 0x76, 0xfa, 0x05, 0xfa, 0x72, 0x26, 0xc4, 0x7d, 0x70, 0xc8, 0xb1, 0xe0, 0x2f, 0x11, 0x5a,

+	0xac, 0x17, 0xab, 0x30, 0x61, 0xe4, 0x9a, 0x1d, 0x7f, 0x99, 0x70, 0x93, 0xc2, 0xad, 0x53, 0xae,

+	0xd9, 0x05, 0xaf, 0xf0, 0xd6, 0x89, 0xc0, 0xb2, 0x71, 0xa4, 0xd9, 0xe9, 0x57, 0xb9, 0xea, 0x8c,

+	0x88, 0x65, 0xa8, 0x97, 0x63, 0xca, 0xce, 0xbf, 0x46, 0x7c, 0x9f, 0xc1, 0x0a, 0x18, 0x63, 0xd2,

+	0xae, 0x78, 0x9d, 0x2b, 0x60, 0x50, 0x78, 0x8c, 0x06, 0xa3, 0xcf, 0x6e, 0x7a, 0x83, 0x8f, 0xd1,

+	0x40, 0xf2, 0x61, 0x37, 0xf3, 0x69, 0x61, 0x57, 0xbc, 0xc9, 0xdd, 0xcc, 0xd7, 0xe3, 0x36, 0x06,

+	0xb3, 0xc4, 0xee, 0x78, 0x8b, 0xb7, 0x31, 0x10, 0x25, 0xa2, 0x05, 0x8d, 0x83, 0x39, 0x62, 0xf7,

+	0xbd, 0x4d, 0xbe, 0xd9, 0x03, 0x31, 0x22, 0x1e, 0x81, 0x85, 0xe1, 0x19, 0x62, 0xb7, 0x5e, 0xdd,

+	0x1b, 0xf8, 0xd5, 0x6f, 0x46, 0x88, 0x38, 0xd7, 0xff, 0xd5, 0x6f, 0xe6, 0x87, 0x5d, 0x7b, 0x6d,

+	0xaf, 0xfa, 0x62, 0x67, 0xc6, 0x87, 0x58, 0x01, 0xe8, 0x8f, 0x6e, 0xbb, 0xeb, 0x3a, 0xb9, 0x0c,

+	0x08, 0x8f, 0x06, 0x4d, 0x6e, 0x3b, 0x7f, 0x83, 0x8f, 0x06, 0x11, 0x62, 0x09, 0x6a, 0x51, 0x16,

+	0x04, 0xf8, 0x70, 0x34, 0xee, 0x1e, 0x12, 0x13, 0x32, 0xd8, 0x62, 0xf6, 0xf7, 0x7d, 0x3a, 0x18,

+	0x0c, 0x88, 0x13, 0x70, 0x48, 0x86, 0x1d, 0xb9, 0x65, 0x23, 0xff, 0xd8, 0xe7, 0x81, 0x80, 0xab,

+	0xc5, 0x32, 0x40, 0xf1, 0xd2, 0x98, 0xee, 0xc4, 0xd6, 0x6f, 0xfd, 0x73, 0xbf, 0x78, 0x07, 0x35,

+	0x90, 0xbe, 0x20, 0x7f, 0xeb, 0xb4, 0x08, 0x76, 0xab, 0x82, 0xfc, 0x45, 0xf3, 0x24, 0x8c, 0x3f,

+	0xa1, 0x55, 0x94, 0x7a, 0xbe, 0x8d, 0xfe, 0x8b, 0x68, 0x5e, 0x8f, 0x05, 0x0b, 0x55, 0x22, 0x53,

+	0xcf, 0xd7, 0x36, 0xf6, 0x6f, 0x62, 0x4b, 0x00, 0xe1, 0xae, 0xa7, 0x53, 0x97, 0xfb, 0xfe, 0x87,

+	0x61, 0x06, 0x70, 0xd3, 0x78, 0xfd, 0xa4, 0xdc, 0xb1, 0xb1, 0xff, 0xf2, 0xa6, 0x69, 0xbd, 0x38,

+	0x05, 0x75, 0xbc, 0xcc, 0xdf, 0xb7, 0x6d, 0xf0, 0x7f, 0x04, 0xf7, 0x89, 0xd3, 0xc7, 0x60, 0xae,

+	0xab, 0xc2, 0x41, 0xec, 0x34, 0x34, 0x55, 0x53, 0xb5, 0xf2, 0x07, 0xf1, 0xff, 0x00, 0x00, 0x00,

+	0xff, 0xff, 0x87, 0x5c, 0xee, 0x2b, 0x7e, 0x11, 0x00, 0x00,

 }

@@ -1,5 +1,7 @@

-// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved.

-// http://github.com/gogo/protobuf/gogoproto

+// Protocol Buffers for Go with Gadgets

+//

+// Copyright (c) 2013, The GoGo Authors. All rights reserved.

+// http://github.com/gogo/protobuf

 //

 // Redistribution and use in source and binary forms, with or without

 // modification, are permitted provided that the following conditions are

@@ -1,4 +1,6 @@

-// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved.

+// Protocol Buffers for Go with Gadgets

+//

+// Copyright (c) 2013, The GoGo Authors. All rights reserved.

 // http://github.com/gogo/protobuf

 //

 // Redistribution and use in source and binary forms, with or without

@@ -84,14 +84,20 @@ func mergeStruct(out, in reflect.Value) {

 		mergeAny(out.Field(i), in.Field(i), false, sprop.Prop[i])

 	}

-	if emIn, ok := in.Addr().Interface().(extensionsMap); ok {

-		emOut := out.Addr().Interface().(extensionsMap)

-		mergeExtension(emOut.ExtensionMap(), emIn.ExtensionMap())

-	} else if emIn, ok := in.Addr().Interface().(extensionsBytes); ok {

+	if emIn, ok := in.Addr().Interface().(extensionsBytes); ok {

 		emOut := out.Addr().Interface().(extensionsBytes)

 		bIn := emIn.GetExtensions()

 		bOut := emOut.GetExtensions()

 		*bOut = append(*bOut, *bIn...)

+	} else if emIn, ok := extendable(in.Addr().Interface()); ok {

+		emOut, _ := extendable(out.Addr().Interface())

+		mIn, muIn := emIn.extensionsRead()

+		if mIn != nil {

+			mOut := emOut.extensionsWrite()

+			muIn.Lock()

+			mergeExtension(mOut, mIn)

+			muIn.Unlock()

+		}

 	}

 	uf := in.FieldByName("XXX_unrecognized")

@@ -378,6 +378,11 @@ func (o *Buffer) unmarshalType(st reflect.Type, prop *StructProperties, is_group

 		wire := int(u & 0x7)

 		if wire == WireEndGroup {

 			if is_group {

+				if required > 0 {

+					// Not enough information to determine the exact field.

+					// (See below.)

+					return &RequiredNotSetError{"{Unknown}"}

+				}

 				return nil // input is satisfied

 			}

 			return fmt.Errorf("proto: %s: wiretype end group for non-group", st)

@@ -390,16 +395,20 @@ func (o *Buffer) unmarshalType(st reflect.Type, prop *StructProperties, is_group

 		if !ok {

 			// Maybe it's an extension?

 			if prop.extendable {

-				if e := structPointer_Interface(base, st).(extendableProto); isExtensionField(e, int32(tag)) {

-					if err = o.skip(st, tag, wire); err == nil {

-						if ee, eok := e.(extensionsMap); eok {

-							ext := ee.ExtensionMap()[int32(tag)] // may be missing

-							ext.enc = append(ext.enc, o.buf[oi:o.index]...)

-							ee.ExtensionMap()[int32(tag)] = ext

-						} else if ee, eok := e.(extensionsBytes); eok {

-							ext := ee.GetExtensions()

+				if e, eok := structPointer_Interface(base, st).(extensionsBytes); eok {

+					if isExtensionField(e, int32(tag)) {

+						if err = o.skip(st, tag, wire); err == nil {

+							ext := e.GetExtensions()

 							*ext = append(*ext, o.buf[oi:o.index]...)

 						}

+						continue

+					}

+				} else if e, _ := extendable(structPointer_Interface(base, st)); isExtensionField(e, int32(tag)) {

+					if err = o.skip(st, tag, wire); err == nil {

+						extmap := e.extensionsWrite()

+						ext := extmap[int32(tag)] // may be missing

+						ext.enc = append(ext.enc, o.buf[oi:o.index]...)

+						extmap[int32(tag)] = ext

 					}

 					continue

 				}

@@ -773,10 +782,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)

@@ -1,5 +1,7 @@

-// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved.

-// http://github.com/gogo/protobuf/gogoproto

+// Protocol Buffers for Go with Gadgets

+//

+// Copyright (c) 2013, The GoGo Authors. All rights reserved.

+// http://github.com/gogo/protobuf

 //

 // Redistribution and use in source and binary forms, with or without

 // modification, are permitted provided that the following conditions are

@@ -64,8 +64,16 @@ 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")

+

+	// ErrTooLarge is the error returned if Marshal is called with a

+	// message that encodes to >2GB.

+	ErrTooLarge = errors.New("proto: message encodes to over 2 GB")

 )

 // The fundamental encoders that put bytes on the wire.

@@ -74,6 +82,10 @@ var (

 const maxVarintBytes = 10 // maximum length of a varint

+// maxMarshalSize is the largest allowed size of an encoded protobuf,

+// since C++ and Java use signed int32s for the size.

+const maxMarshalSize = 1<<31 - 1

+

 // EncodeVarint returns the varint encoding of x.

 // This is the format for the

 // int32, int64, uint32, uint64, bool, and enum

@@ -273,6 +285,9 @@ func (p *Buffer) Marshal(pb Message) error {

 		stats.Encode++

 	}

+	if len(p.buf) > maxMarshalSize {

+		return ErrTooLarge

+	}

 	return err

 }

@@ -1058,10 +1073,25 @@ func size_slice_struct_group(p *Properties, base structPointer) (n int) {

 // Encode an extension map.

 func (o *Buffer) enc_map(p *Properties, base structPointer) error {

-	v := *structPointer_ExtMap(base, p.field)

-	if err := encodeExtensionMap(v); err != nil {

+	exts := structPointer_ExtMap(base, p.field)

+	if err := encodeExtensionsMap(*exts); err != nil {

+		return err

+	}

+

+	return o.enc_map_body(*exts)

+}

+

+func (o *Buffer) enc_exts(p *Properties, base structPointer) error {

+	exts := structPointer_Extensions(base, p.field)

+	if err := encodeExtensions(exts); err != nil {

 		return err

 	}

+	v, _ := exts.extensionsRead()

+

+	return o.enc_map_body(v)

+}

+

+func (o *Buffer) enc_map_body(v map[int32]Extension) error {

 	// Fast-path for common cases: zero or one extensions.

 	if len(v) <= 1 {

 		for _, e := range v {

@@ -1084,8 +1114,13 @@ func (o *Buffer) enc_map(p *Properties, base structPointer) error {

 }

 func size_map(p *Properties, base structPointer) int {

-	v := *structPointer_ExtMap(base, p.field)

-	return sizeExtensionMap(v)

+	v := structPointer_ExtMap(base, p.field)

+	return extensionsMapSize(*v)

+}

+

+func size_exts(p *Properties, base structPointer) int {

+	v := structPointer_Extensions(base, p.field)

+	return extensionsSize(v)

 }

 // Encode a map field.

@@ -1114,7 +1149,7 @@ func (o *Buffer) enc_new_map(p *Properties, base structPointer) error {

 		if err := p.mkeyprop.enc(o, p.mkeyprop, keybase); err != nil {

 			return err

 		}

-		if err := p.mvalprop.enc(o, p.mvalprop, valbase); err != nil {

+		if err := p.mvalprop.enc(o, p.mvalprop, valbase); err != nil && err != ErrNil {

 			return err

 		}

 		return nil

@@ -1124,11 +1159,6 @@ func (o *Buffer) enc_new_map(p *Properties, base structPointer) error {

 	for _, key := range v.MapKeys() {

 		val := v.MapIndex(key)

-		// The only illegal map entry values are nil message pointers.

-		if val.Kind() == reflect.Ptr && val.IsNil() {

-			return errors.New("proto: map has nil element")

-		}

-

 		keycopy.Set(key)

 		valcopy.Set(val)

@@ -1216,13 +1246,18 @@ func (o *Buffer) enc_struct(prop *StructProperties, base structPointer) error {

 					return err

 				}

 			}

+			if len(o.buf) > maxMarshalSize {

+				return ErrTooLarge

+			}

 		}

 	}

 	// 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

 		}

 	}

@@ -1230,6 +1265,9 @@ func (o *Buffer) enc_struct(prop *StructProperties, base structPointer) error {

 	// Add unrecognized fields at the end.

 	if prop.unrecField.IsValid() {

 		v := *structPointer_Bytes(base, prop.unrecField)

+		if len(o.buf)+len(v) > maxMarshalSize {

+			return ErrTooLarge

+		}

 		if len(v) > 0 {

 			o.buf = append(o.buf, v...)

 		}

@@ -1,7 +1,7 @@

-// Extensions for Protocol Buffers to create more go like structures.

+// Protocol Buffers for Go with Gadgets

 //

-// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved.

-// http://github.com/gogo/protobuf/gogoproto

+// Copyright (c) 2013, The GoGo Authors. All rights reserved.

+// http://github.com/gogo/protobuf

 //

 // Go support for Protocol Buffers - Google's data interchange format

 //

@@ -121,9 +121,16 @@ func equalStruct(v1, v2 reflect.Value) bool {

 		}

 	}

+	if em1 := v1.FieldByName("XXX_InternalExtensions"); em1.IsValid() {

+		em2 := v2.FieldByName("XXX_InternalExtensions")

+		if !equalExtensions(v1.Type(), em1.Interface().(XXX_InternalExtensions), em2.Interface().(XXX_InternalExtensions)) {

+			return false

+		}

+	}

+

 	if em1 := v1.FieldByName("XXX_extensions"); em1.IsValid() {

 		em2 := v2.FieldByName("XXX_extensions")

-		if !equalExtensions(v1.Type(), em1.Interface().(map[int32]Extension), em2.Interface().(map[int32]Extension)) {

+		if !equalExtMap(v1.Type(), em1.Interface().(map[int32]Extension), em2.Interface().(map[int32]Extension)) {

 			return false

 		}

 	}

@@ -184,6 +191,13 @@ func equalAny(v1, v2 reflect.Value, prop *Properties) bool {

 		}

 		return true

 	case reflect.Ptr:

+		// Maps may have nil values in them, so check for nil.

+		if v1.IsNil() && v2.IsNil() {

+			return true

+		}

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

+			return false

+		}

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

 	case reflect.Slice:

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

@@ -223,8 +237,14 @@ func equalAny(v1, v2 reflect.Value, prop *Properties) bool {

 }

 // base is the struct type that the extensions are based on.

-// em1 and em2 are extension maps.

-func equalExtensions(base reflect.Type, em1, em2 map[int32]Extension) bool {

+// x1 and x2 are InternalExtensions.

+func equalExtensions(base reflect.Type, x1, x2 XXX_InternalExtensions) bool {

+	em1, _ := x1.extensionsRead()

+	em2, _ := x2.extensionsRead()

+	return equalExtMap(base, em1, em2)

+}

+

+func equalExtMap(base reflect.Type, em1, em2 map[int32]Extension) bool {

 	if len(em1) != len(em2) {

 		return false

 	}

@@ -52,23 +52,112 @@ type ExtensionRange struct {

 	Start, End int32 // both inclusive

 }

-// extendableProto is an interface implemented by any protocol buffer that may be extended.

+// extendableProto is an interface implemented by any protocol buffer generated by the current

+// proto compiler that may be extended.

 type extendableProto interface {

 	Message

 	ExtensionRangeArray() []ExtensionRange

+	extensionsWrite() map[int32]Extension

+	extensionsRead() (map[int32]Extension, sync.Locker)

 }

-type extensionsMap interface {

-	extendableProto

+// extendableProtoV1 is an interface implemented by a protocol buffer generated by the previous

+// version of the proto compiler that may be extended.

+type extendableProtoV1 interface {

+	Message

+	ExtensionRangeArray() []ExtensionRange

 	ExtensionMap() map[int32]Extension

 }

 type extensionsBytes interface {

-	extendableProto

+	Message

+	ExtensionRangeArray() []ExtensionRange

 	GetExtensions() *[]byte

 }

+// extensionAdapter is a wrapper around extendableProtoV1 that implements extendableProto.

+type extensionAdapter struct {

+	extendableProtoV1

+}

+

+func (e extensionAdapter) extensionsWrite() map[int32]Extension {

+	return e.ExtensionMap()

+}

+

+func (e extensionAdapter) extensionsRead() (map[int32]Extension, sync.Locker) {

+	return e.ExtensionMap(), notLocker{}

+}

+

+// notLocker is a sync.Locker whose Lock and Unlock methods are nops.

+type notLocker struct{}

+

+func (n notLocker) Lock()   {}

+func (n notLocker) Unlock() {}

+

+// extendable returns the extendableProto interface for the given generated proto message.

+// If the proto message has the old extension format, it returns a wrapper that implements

+// the extendableProto interface.

+func extendable(p interface{}) (extendableProto, bool) {

+	if ep, ok := p.(extendableProto); ok {

+		return ep, ok

+	}

+	if ep, ok := p.(extendableProtoV1); ok {

+		return extensionAdapter{ep}, ok

+	}

+	return nil, false

+}

+

+// XXX_InternalExtensions is an internal representation of proto extensions.

+//

+// Each generated message struct type embeds an anonymous XXX_InternalExtensions field,

+// thus gaining the unexported 'extensions' method, which can be called only from the proto package.

+//

+// The methods of XXX_InternalExtensions are not concurrency safe in general,

+// but calls to logically read-only methods such as has and get may be executed concurrently.

+type XXX_InternalExtensions struct {

+	// The struct must be indirect so that if a user inadvertently copies a

+	// generated message and its embedded XXX_InternalExtensions, they

+	// avoid the mayhem of a copied mutex.

+	//

+	// The mutex serializes all logically read-only operations to p.extensionMap.

+	// It is up to the client to ensure that write operations to p.extensionMap are

+	// mutually exclusive with other accesses.

+	p *struct {

+		mu           sync.Mutex

+		extensionMap map[int32]Extension

+	}

+}

+

+// extensionsWrite returns the extension map, creating it on first use.

+func (e *XXX_InternalExtensions) extensionsWrite() map[int32]Extension {

+	if e.p == nil {

+		e.p = new(struct {

+			mu           sync.Mutex

+			extensionMap map[int32]Extension

+		})

+		e.p.extensionMap = make(map[int32]Extension)

+	}

+	return e.p.extensionMap

+}

+

+// extensionsRead returns the extensions map for read-only use.  It may be nil.

+// The caller must hold the returned mutex's lock when accessing Elements within the map.

+func (e *XXX_InternalExtensions) extensionsRead() (map[int32]Extension, sync.Locker) {

+	if e.p == nil {

+		return nil, nil

+	}

+	return e.p.extensionMap, &e.p.mu

+}

+

+type extensionRange interface {

+	Message

+	ExtensionRangeArray() []ExtensionRange

+}

+

 var extendableProtoType = reflect.TypeOf((*extendableProto)(nil)).Elem()

+var extendableProtoV1Type = reflect.TypeOf((*extendableProtoV1)(nil)).Elem()

+var extendableBytesType = reflect.TypeOf((*extensionsBytes)(nil)).Elem()

+var extensionRangeType = reflect.TypeOf((*extensionRange)(nil)).Elem()

 // ExtensionDesc represents an extension specification.

 // Used in generated code from the protocol compiler.

@@ -101,20 +190,23 @@ type Extension struct {

 }

 // SetRawExtension is for testing only.

-func SetRawExtension(base extendableProto, id int32, b []byte) {

-	if ebase, ok := base.(extensionsMap); ok {

-		ebase.ExtensionMap()[id] = Extension{enc: b}

-	} else if ebase, ok := base.(extensionsBytes); ok {

+func SetRawExtension(base Message, id int32, b []byte) {

+	if ebase, ok := base.(extensionsBytes); ok {

 		clearExtension(base, id)

 		ext := ebase.GetExtensions()

 		*ext = append(*ext, b...)

-	} else {

-		panic("unreachable")

+		return

+	}

+	epb, ok := extendable(base)

+	if !ok {

+		return

 	}

+	extmap := epb.extensionsWrite()

+	extmap[id] = Extension{enc: b}

 }

 // isExtensionField returns true iff the given field number is in an extension range.

-func isExtensionField(pb extendableProto, field int32) bool {

+func isExtensionField(pb extensionRange, field int32) bool {

 	for _, er := range pb.ExtensionRangeArray() {

 		if er.Start <= field && field <= er.End {

 			return true

@@ -125,8 +217,12 @@ func isExtensionField(pb extendableProto, field int32) bool {

 // checkExtensionTypes checks that the given extension is valid for pb.

 func checkExtensionTypes(pb extendableProto, extension *ExtensionDesc) error {

+	var pbi interface{} = pb

 	// Check the extended type.

-	if a, b := reflect.TypeOf(pb), reflect.TypeOf(extension.ExtendedType); a != b {

+	if ea, ok := pbi.(extensionAdapter); ok {

+		pbi = ea.extendableProtoV1

+	}

+	if a, b := reflect.TypeOf(pbi), reflect.TypeOf(extension.ExtendedType); a != b {

 		return errors.New("proto: bad extended type; " + b.String() + " does not extend " + a.String())

 	}

 	// Check the range.

@@ -172,43 +268,57 @@ func extensionProperties(ed *ExtensionDesc) *Properties {

 	return prop

 }

-// encodeExtensionMap encodes any unmarshaled (unencoded) extensions in m.

-func encodeExtensionMap(m map[int32]Extension) error {

+// encode encodes any unmarshaled (unencoded) extensions in e.

+func encodeExtensions(e *XXX_InternalExtensions) error {

+	m, mu := e.extensionsRead()

+	if m == nil {

+		return nil // fast path

+	}

+	mu.Lock()

+	defer mu.Unlock()

+	return encodeExtensionsMap(m)

+}

+

+// encode encodes any unmarshaled (unencoded) extensions in e.

+func encodeExtensionsMap(m map[int32]Extension) error {

 	for k, e := range m {

-		err := encodeExtension(&e)

-		if err != nil {

+		if e.value == nil || e.desc == nil {

+			// Extension is only in its encoded form.

+			continue

+		}

+

+		// We don't skip extensions that have an encoded form set,

+		// because the extension value may have been mutated after

+		// the last time this function was called.

+

+		et := reflect.TypeOf(e.desc.ExtensionType)

+		props := extensionProperties(e.desc)

+

+		p := NewBuffer(nil)

+		// If e.value has type T, the encoder expects a *struct{ X T }.

+		// Pass a *T with a zero field and hope it all works out.

+		x := reflect.New(et)

+		x.Elem().Set(reflect.ValueOf(e.value))

+		if err := props.enc(p, props, toStructPointer(x)); err != nil {

 			return err

 		}

+		e.enc = p.buf

 		m[k] = e

 	}

 	return nil

 }

-func encodeExtension(e *Extension) error {

-	if e.value == nil || e.desc == nil {

-		// Extension is only in its encoded form.

-		return nil

-	}

-	// We don't skip extensions that have an encoded form set,

-	// because the extension value may have been mutated after

-	// the last time this function was called.

-

-	et := reflect.TypeOf(e.desc.ExtensionType)

-	props := extensionProperties(e.desc)

-

-	p := NewBuffer(nil)

-	// If e.value has type T, the encoder expects a *struct{ X T }.

-	// Pass a *T with a zero field and hope it all works out.

-	x := reflect.New(et)

-	x.Elem().Set(reflect.ValueOf(e.value))

-	if err := props.enc(p, props, toStructPointer(x)); err != nil {

-		return err

+func extensionsSize(e *XXX_InternalExtensions) (n int) {

+	m, mu := e.extensionsRead()

+	if m == nil {

+		return 0

 	}

-	e.enc = p.buf

-	return nil

+	mu.Lock()

+	defer mu.Unlock()

+	return extensionsMapSize(m)

 }

-func sizeExtensionMap(m map[int32]Extension) (n int) {

+func extensionsMapSize(m map[int32]Extension) (n int) {

 	for _, e := range m {

 		if e.value == nil || e.desc == nil {

 			// Extension is only in its encoded form.

@@ -233,12 +343,8 @@ func sizeExtensionMap(m map[int32]Extension) (n int) {

 }

 // HasExtension returns whether the given extension is present in pb.

-func HasExtension(pb extendableProto, extension *ExtensionDesc) bool {

-	// TODO: Check types, field numbers, etc.?

-	if epb, doki := pb.(extensionsMap); doki {

-		_, ok := epb.ExtensionMap()[extension.Field]

-		return ok

-	} else if epb, doki := pb.(extensionsBytes); doki {

+func HasExtension(pb Message, extension *ExtensionDesc) bool {

+	if epb, doki := pb.(extensionsBytes); doki {

 		ext := epb.GetExtensions()

 		buf := *ext

 		o := 0

@@ -258,7 +364,19 @@ func HasExtension(pb extendableProto, extension *ExtensionDesc) bool {

 		}

 		return false

 	}

-	panic("unreachable")

+	// TODO: Check types, field numbers, etc.?

+	epb, ok := extendable(pb)

+	if !ok {

+		return false

+	}

+	extmap, mu := epb.extensionsRead()

+	if extmap == nil {

+		return false

+	}

+	mu.Lock()

+	_, ok = extmap[extension.Field]

+	mu.Unlock()

+	return ok

 }

 func deleteExtension(pb extensionsBytes, theFieldNum int32, offset int) int {

@@ -281,64 +399,32 @@ func deleteExtension(pb extensionsBytes, theFieldNum int32, offset int) int {

 	return -1

 }

-func clearExtension(pb extendableProto, fieldNum int32) {

-	if epb, doki := pb.(extensionsMap); doki {

-		delete(epb.ExtensionMap(), fieldNum)

-	} else if epb, doki := pb.(extensionsBytes); doki {

+// ClearExtension removes the given extension from pb.

+func ClearExtension(pb Message, extension *ExtensionDesc) {

+	clearExtension(pb, extension.Field)

+}

+

+func clearExtension(pb Message, fieldNum int32) {

+	if epb, doki := pb.(extensionsBytes); doki {

 		offset := 0

 		for offset != -1 {

 			offset = deleteExtension(epb, fieldNum, offset)

 		}

-	} else {

-		panic("unreachable")

+		return

+	}

+	epb, ok := extendable(pb)

+	if !ok {

+		return

 	}

-}

-

-// ClearExtension removes the given extension from pb.

-func ClearExtension(pb extendableProto, extension *ExtensionDesc) {

 	// TODO: Check types, field numbers, etc.?

-	clearExtension(pb, extension.Field)

+	extmap := epb.extensionsWrite()

+	delete(extmap, fieldNum)

 }

 // GetExtension parses and returns the given extension of pb.