From e027175446e2bba3431bcd3095294531d68f35f8 Mon Sep 17 00:00:00 2001 From: Audrius Butkevicius Date: Fri, 2 Oct 2020 07:07:05 +0100 Subject: [PATCH] all: Move remaining protos to use the vanity plugin (#7009) --- lib/config/authmode.pb.go | 14 +- lib/config/blockpullorder.pb.go | 31 +- lib/config/config.pb.go | 601 +++++- lib/config/config_test.go | 16 +- lib/config/deviceconfiguration.pb.go | 857 +++++++- lib/config/folderconfiguration.pb.go | 1740 ++++++++++++++-- lib/config/foldertype.pb.go | 29 +- lib/config/guiconfiguration.pb.go | 731 ++++++- lib/config/ldapconfiguration.pb.go | 463 ++++- lib/config/ldaptransport.pb.go | 13 +- lib/config/observed.pb.go | 615 +++++- lib/config/optionsconfiguration.pb.go | 2290 ++++++++++++++++++++-- lib/config/pullorder.pb.go | 46 +- lib/config/size.pb.go | 258 ++- lib/config/tuning.pb.go | 13 +- lib/config/versioningconfiguration.pb.go | 447 ++++- lib/db/db_test.go | 2 +- lib/db/schemaupdater.go | 2 +- lib/db/set_test.go | 8 +- lib/db/structs.go | 9 +- lib/db/structs.pb.go | 253 +-- lib/fs/copyrangemethod.pb.go | 51 +- lib/fs/types.pb.go | 27 +- lib/model/devicedownloadstate.go | 10 +- lib/model/devicedownloadstate_test.go | 18 +- lib/model/fakeconns_test.go | 2 +- lib/model/folder_recvonly_test.go | 2 +- lib/model/folder_sendrecv.go | 4 +- lib/model/folder_sendrecv_test.go | 2 +- lib/model/model.go | 10 +- lib/model/model_test.go | 2 +- lib/model/progressemitter_test.go | 76 +- lib/model/sentdownloadstate.go | 18 +- lib/model/sharedpullerstate.go | 10 +- lib/protocol/benchmark_test.go | 4 +- lib/protocol/bep.pb.go | 579 +++--- lib/protocol/bep_extensions.go | 4 +- lib/protocol/compression.go | 16 +- lib/protocol/compression_test.go | 18 +- lib/protocol/protocol.go | 48 +- lib/protocol/protocol_test.go | 39 +- lib/scanner/blocks.go | 2 +- lib/scanner/walk.go | 4 +- lib/ur/contract/contract.go | 6 +- lib/ur/usage_report.go | 6 +- proto/ext.proto | 1 + proto/ext/ext.pb.go | 52 +- proto/generate.go | 5 +- proto/lib/config/blockpullorder.proto | 4 + proto/lib/config/foldertype.proto | 4 + {lib => proto/lib}/db/structs.proto | 33 +- proto/lib/fs/copyrangemethod.proto | 4 + proto/lib/fs/types.proto | 4 + proto/lib/protocol/bep.proto | 94 +- proto/scripts/protoc_plugin.go | 188 +- 55 files changed, 8371 insertions(+), 1414 deletions(-) rename {lib => proto/lib}/db/structs.proto (61%) diff --git a/lib/config/authmode.pb.go b/lib/config/authmode.pb.go index e4db555b7..5c85f185f 100644 --- a/lib/config/authmode.pb.go +++ b/lib/config/authmode.pb.go @@ -50,7 +50,7 @@ func init() { func init() { proto.RegisterFile("lib/config/authmode.proto", fileDescriptor_8e30b562e1bcea1e) } var fileDescriptor_8e30b562e1bcea1e = []byte{ - // 230 bytes of a gzipped FileDescriptorProto + // 234 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0xcc, 0xc9, 0x4c, 0xd2, 0x4f, 0xce, 0xcf, 0x4b, 0xcb, 0x4c, 0xd7, 0x4f, 0x2c, 0x2d, 0xc9, 0xc8, 0xcd, 0x4f, 0x49, 0xd5, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x83, 0x08, 0x4b, 0x29, 0x17, 0xa5, 0x16, 0xe4, 0x17, @@ -60,10 +60,10 @@ var fileDescriptor_8e30b562e1bcea1e = []byte{ 0x8d, 0x0f, 0x0e, 0x71, 0x0c, 0xf1, 0x74, 0x16, 0x60, 0x90, 0x12, 0xea, 0x9a, 0xab, 0xc0, 0x07, 0x53, 0x13, 0x5c, 0x92, 0x58, 0x92, 0x99, 0x2c, 0x64, 0xc2, 0xc5, 0x87, 0x50, 0xe9, 0xe3, 0xe2, 0x18, 0x20, 0xc0, 0x28, 0xa5, 0xd0, 0x35, 0x57, 0x81, 0x07, 0xa6, 0x0e, 0x24, 0x76, 0xa9, 0x4f, - 0x15, 0x85, 0x2f, 0xc5, 0xb2, 0x62, 0x89, 0x1c, 0x83, 0x93, 0xfb, 0x89, 0x87, 0x72, 0x0c, 0x17, - 0x1e, 0xca, 0x31, 0xbc, 0x78, 0x24, 0xc7, 0x30, 0xe1, 0xb1, 0x1c, 0xc3, 0x82, 0xc7, 0x72, 0x8c, - 0x17, 0x1e, 0xcb, 0x31, 0xdc, 0x78, 0x2c, 0xc7, 0x10, 0xa5, 0x99, 0x9e, 0x59, 0x92, 0x51, 0x9a, - 0xa4, 0x97, 0x9c, 0x9f, 0xab, 0x5f, 0x5c, 0x99, 0x97, 0x5c, 0x92, 0x91, 0x99, 0x97, 0x8e, 0xc4, - 0x42, 0x84, 0x40, 0x12, 0x1b, 0xd8, 0x07, 0xc6, 0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0x04, 0x8c, - 0xb9, 0xb3, 0x16, 0x01, 0x00, 0x00, + 0x15, 0x85, 0x2f, 0xc5, 0xb2, 0x62, 0x89, 0x1c, 0x83, 0x93, 0xf7, 0x89, 0x87, 0x72, 0x0c, 0x17, + 0x1e, 0xca, 0x31, 0x9c, 0x78, 0x24, 0xc7, 0x78, 0xe1, 0x91, 0x1c, 0xe3, 0x84, 0xc7, 0x72, 0x0c, + 0x0b, 0x1e, 0xcb, 0x31, 0x5e, 0x78, 0x2c, 0xc7, 0x70, 0xe3, 0xb1, 0x1c, 0x43, 0x94, 0x66, 0x7a, + 0x66, 0x49, 0x46, 0x69, 0x92, 0x5e, 0x72, 0x7e, 0xae, 0x7e, 0x71, 0x65, 0x5e, 0x72, 0x49, 0x46, + 0x66, 0x5e, 0x3a, 0x12, 0x0b, 0x11, 0x0a, 0x49, 0x6c, 0x60, 0x5f, 0x18, 0x03, 0x02, 0x00, 0x00, + 0xff, 0xff, 0x48, 0x80, 0x1f, 0x0c, 0x1a, 0x01, 0x00, 0x00, } diff --git a/lib/config/blockpullorder.pb.go b/lib/config/blockpullorder.pb.go index 8001610fc..42422adf0 100644 --- a/lib/config/blockpullorder.pb.go +++ b/lib/config/blockpullorder.pb.go @@ -5,6 +5,7 @@ package config import ( fmt "fmt" + _ "github.com/gogo/protobuf/gogoproto" proto "github.com/gogo/protobuf/proto" math "math" ) @@ -51,20 +52,22 @@ func init() { func init() { proto.RegisterFile("lib/config/blockpullorder.proto", fileDescriptor_3c46a5289006da6c) } var fileDescriptor_3c46a5289006da6c = []byte{ - // 237 bytes of a gzipped FileDescriptorProto + // 271 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0xcf, 0xc9, 0x4c, 0xd2, 0x4f, 0xce, 0xcf, 0x4b, 0xcb, 0x4c, 0xd7, 0x4f, 0xca, 0xc9, 0x4f, 0xce, 0x2e, 0x28, 0xcd, 0xc9, - 0xc9, 0x2f, 0x4a, 0x49, 0x2d, 0xd2, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x83, 0x48, 0x6a, - 0xed, 0x61, 0xe4, 0xe2, 0x73, 0x02, 0x29, 0x08, 0x28, 0xcd, 0xc9, 0xf1, 0x07, 0x29, 0x10, 0xb2, - 0xe4, 0x92, 0x74, 0xf2, 0xf1, 0x77, 0xf6, 0x8e, 0x0f, 0x08, 0xf5, 0xf1, 0x89, 0xf7, 0x0f, 0x72, - 0x71, 0x0d, 0x8a, 0x0f, 0x0e, 0x71, 0xf4, 0x73, 0x71, 0x0c, 0x72, 0x11, 0x60, 0x90, 0x92, 0xea, - 0x9a, 0xab, 0x20, 0x86, 0xaa, 0x25, 0xb8, 0x24, 0x31, 0x2f, 0x25, 0xb1, 0x28, 0x45, 0xc8, 0x94, - 0x4b, 0x1c, 0x43, 0x6b, 0x90, 0xa3, 0x9f, 0x8b, 0xbf, 0xaf, 0x00, 0xa3, 0x94, 0x44, 0xd7, 0x5c, - 0x05, 0x11, 0x54, 0x8d, 0x41, 0x89, 0x79, 0x29, 0xf9, 0xb9, 0x42, 0x16, 0x58, 0x6c, 0xf4, 0xf4, - 0x83, 0x30, 0x04, 0x98, 0xa4, 0x24, 0xbb, 0xe6, 0x2a, 0x88, 0xa2, 0x6a, 0xf4, 0xcc, 0x03, 0x53, - 0x4e, 0xee, 0x27, 0x1e, 0xca, 0x31, 0x5c, 0x78, 0x28, 0xc7, 0xf0, 0xe2, 0x91, 0x1c, 0xc3, 0x84, - 0xc7, 0x72, 0x0c, 0x0b, 0x1e, 0xcb, 0x31, 0x5e, 0x78, 0x2c, 0xc7, 0x70, 0xe3, 0xb1, 0x1c, 0x43, - 0x94, 0x66, 0x7a, 0x66, 0x49, 0x46, 0x69, 0x92, 0x5e, 0x72, 0x7e, 0xae, 0x7e, 0x71, 0x65, 0x5e, - 0x72, 0x49, 0x46, 0x66, 0x5e, 0x3a, 0x12, 0x0b, 0x11, 0x48, 0x49, 0x6c, 0xe0, 0x60, 0x31, 0x06, - 0x04, 0x00, 0x00, 0xff, 0xff, 0x46, 0xfd, 0xeb, 0xcf, 0x39, 0x01, 0x00, 0x00, + 0xc9, 0x2f, 0x4a, 0x49, 0x2d, 0xd2, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x83, 0x48, 0x4a, + 0x29, 0x17, 0xa5, 0x16, 0xe4, 0x17, 0xeb, 0x83, 0x05, 0x93, 0x4a, 0xd3, 0xf4, 0xd3, 0xf3, 0xd3, + 0xf3, 0xc1, 0x1c, 0x30, 0x0b, 0xa2, 0x58, 0xeb, 0x10, 0x23, 0x17, 0x9f, 0x13, 0xc8, 0x94, 0x80, + 0xd2, 0x9c, 0x1c, 0x7f, 0x90, 0x29, 0x42, 0x96, 0x5c, 0x92, 0x4e, 0x3e, 0xfe, 0xce, 0xde, 0xf1, + 0x01, 0xa1, 0x3e, 0x3e, 0xf1, 0xfe, 0x41, 0x2e, 0xae, 0x41, 0xf1, 0xc1, 0x21, 0x8e, 0x7e, 0x2e, + 0x8e, 0x41, 0x2e, 0x02, 0x0c, 0x52, 0x52, 0x5d, 0x73, 0x15, 0xc4, 0x50, 0xb5, 0x04, 0x97, 0x24, + 0xe6, 0xa5, 0x24, 0x16, 0xa5, 0x08, 0x99, 0x72, 0x89, 0x63, 0x68, 0x0d, 0x72, 0xf4, 0x73, 0xf1, + 0xf7, 0x15, 0x60, 0x94, 0x92, 0xe8, 0x9a, 0xab, 0x20, 0x82, 0xaa, 0x31, 0x28, 0x31, 0x2f, 0x25, + 0x3f, 0x57, 0xc8, 0x02, 0x8b, 0x8d, 0x9e, 0x7e, 0x10, 0x86, 0x00, 0x93, 0x94, 0x64, 0xd7, 0x5c, + 0x05, 0x51, 0x54, 0x8d, 0x9e, 0x79, 0x60, 0x4a, 0x8a, 0x65, 0xc5, 0x12, 0x39, 0x06, 0x27, 0xef, + 0x13, 0x0f, 0xe5, 0x18, 0x2e, 0x3c, 0x94, 0x63, 0x38, 0xf1, 0x48, 0x8e, 0xf1, 0xc2, 0x23, 0x39, + 0xc6, 0x09, 0x8f, 0xe5, 0x18, 0x16, 0x3c, 0x96, 0x63, 0xbc, 0xf0, 0x58, 0x8e, 0xe1, 0xc6, 0x63, + 0x39, 0x86, 0x28, 0xcd, 0xf4, 0xcc, 0x92, 0x8c, 0xd2, 0x24, 0xbd, 0xe4, 0xfc, 0x5c, 0xfd, 0xe2, + 0xca, 0xbc, 0xe4, 0x92, 0x8c, 0xcc, 0xbc, 0x74, 0x24, 0x16, 0x22, 0x4c, 0x93, 0xd8, 0xc0, 0x01, + 0x63, 0x0c, 0x08, 0x00, 0x00, 0xff, 0xff, 0x8c, 0x0c, 0xb7, 0x46, 0x68, 0x01, 0x00, 0x00, } diff --git a/lib/config/config.pb.go b/lib/config/config.pb.go index f8398ad74..4328afdcf 100644 --- a/lib/config/config.pb.go +++ b/lib/config/config.pb.go @@ -7,6 +7,7 @@ import ( fmt "fmt" proto "github.com/gogo/protobuf/proto" _ "github.com/syncthing/syncthing/proto/ext" + io "io" math "math" math_bits "math/bits" ) @@ -40,16 +41,25 @@ func (*Configuration) Descriptor() ([]byte, []int) { return fileDescriptor_baadf209193dc627, []int{0} } func (m *Configuration) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_Configuration.Unmarshal(m, b) + return m.Unmarshal(b) } func (m *Configuration) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_Configuration.Marshal(b, m, deterministic) + if deterministic { + return xxx_messageInfo_Configuration.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } } func (m *Configuration) XXX_Merge(src proto.Message) { xxx_messageInfo_Configuration.Merge(m, src) } func (m *Configuration) XXX_Size() int { - return xxx_messageInfo_Configuration.Size(m) + return m.ProtoSize() } func (m *Configuration) XXX_DiscardUnknown() { xxx_messageInfo_Configuration.DiscardUnknown(m) @@ -64,43 +74,169 @@ func init() { func init() { proto.RegisterFile("lib/config/config.proto", fileDescriptor_baadf209193dc627) } var fileDescriptor_baadf209193dc627 = []byte{ - // 544 bytes of a gzipped FileDescriptorProto + // 547 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x93, 0x4f, 0x8b, 0xd3, 0x40, - 0x18, 0xc6, 0x53, 0xdb, 0x6d, 0xdd, 0xec, 0x3f, 0xc8, 0x8a, 0xa6, 0x2a, 0x99, 0x3a, 0x54, 0xa9, - 0xa2, 0x5d, 0x58, 0x2f, 0xe2, 0xcd, 0x5a, 0x2c, 0x05, 0x41, 0x19, 0x58, 0x51, 0x2f, 0xd2, 0x36, - 0xb3, 0xe9, 0x40, 0x3b, 0x53, 0x92, 0xb4, 0xac, 0xdf, 0x42, 0xfc, 0x04, 0x5e, 0xfd, 0x06, 0x7e, - 0x84, 0xbd, 0xb5, 0x47, 0x4f, 0x03, 0xbb, 0xbd, 0x48, 0x8e, 0x39, 0x7a, 0x92, 0xf9, 0xd7, 0x4d, - 0x24, 0x7a, 0x6a, 0xde, 0xf7, 0x79, 0x9e, 0xdf, 0xfb, 0xf2, 0x36, 0xb1, 0x6f, 0x4d, 0xc8, 0xf0, - 0x68, 0xc4, 0xe8, 0x29, 0x09, 0xf4, 0x4f, 0x7b, 0x16, 0xb2, 0x98, 0x39, 0x55, 0x55, 0xdd, 0x6e, - 0x66, 0x0c, 0xa7, 0x6c, 0xe2, 0xe3, 0x50, 0x15, 0xf3, 0x70, 0x10, 0x13, 0x46, 0x95, 0x3b, 0xe7, - 0xf2, 0xf1, 0x82, 0x8c, 0x70, 0x91, 0xeb, 0x5e, 0xc6, 0x15, 0xcc, 0x49, 0x91, 0x05, 0x66, 0x2c, - 0x13, 0x7f, 0x30, 0x2b, 0xf2, 0xdc, 0xcf, 0x78, 0xd8, 0x4c, 0x08, 0x51, 0x91, 0xad, 0x9e, 0xb5, - 0x0d, 0x23, 0x1c, 0x2e, 0xb0, 0xaf, 0xa5, 0x6d, 0x7c, 0x16, 0xab, 0x47, 0xf8, 0xa3, 0x6a, 0xef, - 0xbd, 0xcc, 0xa6, 0x1d, 0x64, 0xd7, 0x16, 0x38, 0x8c, 0x08, 0xa3, 0x6e, 0xa9, 0x51, 0x6a, 0x6d, - 0x75, 0x9e, 0x25, 0x1c, 0x98, 0x56, 0xca, 0x81, 0x73, 0x36, 0x9d, 0x3c, 0x87, 0xba, 0x7e, 0x3c, - 0x88, 0xe3, 0x10, 0xfe, 0xe6, 0xa0, 0x4c, 0x68, 0x9c, 0x2c, 0x9b, 0xbb, 0xd9, 0x3e, 0x32, 0x29, - 0xe7, 0x9d, 0x5d, 0x53, 0xc7, 0x8b, 0xdc, 0x6b, 0x8d, 0x72, 0x6b, 0xe7, 0xf8, 0x4e, 0x5b, 0x5f, - 0xfb, 0x95, 0x6c, 0xe7, 0x36, 0xe8, 0x80, 0x73, 0x0e, 0x2c, 0x31, 0x54, 0x67, 0x52, 0x0e, 0x76, - 0xe5, 0x50, 0x55, 0x43, 0x64, 0x04, 0xc1, 0x55, 0xe7, 0x8e, 0xdc, 0x72, 0x9e, 0xdb, 0x95, 0xed, - 0x7f, 0x70, 0x75, 0x66, 0xc3, 0x55, 0x35, 0x44, 0x46, 0x70, 0x90, 0x5d, 0x0e, 0xe6, 0xc4, 0xad, - 0x34, 0x4a, 0xad, 0x9d, 0x63, 0xd7, 0x30, 0x7b, 0x27, 0xfd, 0x3c, 0xf0, 0x81, 0x00, 0x5e, 0x72, - 0x50, 0xee, 0x9d, 0xf4, 0x13, 0x0e, 0x44, 0x26, 0xe5, 0x60, 0x5b, 0x32, 0x83, 0x39, 0x81, 0x5f, - 0x57, 0x4d, 0x21, 0x21, 0x21, 0x38, 0x1f, 0xec, 0x8a, 0xf8, 0x47, 0xdd, 0x2d, 0x09, 0xad, 0x1b, - 0xe8, 0xeb, 0xee, 0x8b, 0xb7, 0x79, 0xea, 0x23, 0x4d, 0xad, 0x08, 0x29, 0xe1, 0x40, 0xc6, 0x52, - 0x0e, 0x6c, 0xc9, 0x15, 0x85, 0x00, 0x4b, 0x15, 0x49, 0xcd, 0x79, 0x6f, 0xd7, 0xf4, 0x8b, 0xe0, - 0x56, 0x25, 0xfd, 0xae, 0xa1, 0xbf, 0x51, 0xed, 0xfc, 0x80, 0x86, 0xb9, 0x83, 0x0e, 0xa5, 0x1c, - 0xec, 0x49, 0xb6, 0xae, 0x21, 0x32, 0x8a, 0xf3, 0xbd, 0x64, 0x1f, 0x90, 0x80, 0xb2, 0x10, 0xfb, - 0x9f, 0xcc, 0xa5, 0x6b, 0xf2, 0xd2, 0x37, 0x37, 0x23, 0xf4, 0xbb, 0xa5, 0x2e, 0xde, 0x19, 0x6b, - 0xf8, 0x8d, 0x10, 0x4f, 0x59, 0x8c, 0xfb, 0x2a, 0xdc, 0xdd, 0x5c, 0xbc, 0x2e, 0x27, 0x15, 0x88, - 0x30, 0x59, 0x36, 0x0f, 0x0b, 0xfa, 0xe9, 0xb2, 0x59, 0xc8, 0x42, 0xfb, 0x24, 0x57, 0x3b, 0xd4, - 0x3e, 0x98, 0x61, 0xea, 0x13, 0x1a, 0x6c, 0x56, 0xbd, 0xfe, 0xdf, 0x55, 0x9f, 0xe8, 0x55, 0xf7, - 0x75, 0xec, 0x6a, 0xc9, 0x43, 0xb9, 0x64, 0xae, 0x0d, 0xd1, 0x5f, 0xb6, 0x4e, 0xef, 0xfc, 0xc2, - 0xb3, 0x56, 0x17, 0x9e, 0xf5, 0xeb, 0xd2, 0xb3, 0xbe, 0xac, 0x3d, 0xeb, 0xdb, 0xda, 0x2b, 0xad, - 0xd6, 0x9e, 0xf5, 0x73, 0xed, 0x59, 0x1f, 0x1f, 0x06, 0x24, 0x1e, 0xcf, 0x87, 0xed, 0x11, 0x9b, - 0x1e, 0x45, 0x9f, 0xe9, 0x28, 0x1e, 0x13, 0x1a, 0x64, 0x9e, 0xae, 0xbe, 0xce, 0x61, 0x55, 0x7e, - 0x8a, 0x4f, 0xff, 0x04, 0x00, 0x00, 0xff, 0xff, 0xce, 0xc5, 0x80, 0x7a, 0x8d, 0x04, 0x00, 0x00, + 0x18, 0xc6, 0x13, 0xbb, 0xdb, 0xba, 0xd9, 0x7f, 0x90, 0x15, 0x4d, 0x55, 0x32, 0x75, 0xa8, 0x52, + 0x45, 0xbb, 0xb0, 0x5e, 0xc4, 0x9b, 0xb5, 0xb8, 0x14, 0x05, 0x65, 0x60, 0x45, 0xbd, 0x48, 0xdb, + 0xcc, 0xa6, 0x03, 0xed, 0x4c, 0x49, 0xd2, 0xb2, 0x7e, 0x0b, 0xf1, 0x13, 0x78, 0xf5, 0x1b, 0xf8, + 0x11, 0x7a, 0x6b, 0x8f, 0x9e, 0x06, 0xb6, 0xbd, 0xf5, 0x98, 0xa3, 0x27, 0x99, 0x7f, 0xdd, 0x44, + 0xa2, 0xa7, 0xe6, 0x7d, 0x9f, 0xe7, 0xf9, 0xbd, 0x2f, 0x6f, 0x13, 0xe7, 0xd6, 0x90, 0xf4, 0x8e, + 0xfb, 0x8c, 0x9e, 0x93, 0x50, 0xff, 0x34, 0xc7, 0x11, 0x4b, 0x98, 0x5b, 0x56, 0xd5, 0xed, 0x7a, + 0xc6, 0x70, 0xce, 0x86, 0x01, 0x8e, 0x54, 0x31, 0x89, 0xba, 0x09, 0x61, 0x54, 0xb9, 0x73, 0xae, + 0x00, 0x4f, 0x49, 0x1f, 0x17, 0xb9, 0xee, 0x65, 0x5c, 0xe1, 0x84, 0x14, 0x59, 0x60, 0xc6, 0x32, + 0x0c, 0xba, 0xe3, 0x22, 0xcf, 0xfd, 0x8c, 0x87, 0x8d, 0x85, 0x10, 0x17, 0xd9, 0xaa, 0x59, 0x5b, + 0x2f, 0xc6, 0xd1, 0x14, 0x07, 0x5a, 0xda, 0xc1, 0x17, 0x89, 0x7a, 0x84, 0x3f, 0xcb, 0xce, 0xfe, + 0xcb, 0x6c, 0xda, 0x45, 0x4e, 0x65, 0x8a, 0xa3, 0x98, 0x30, 0xea, 0xd9, 0x35, 0xbb, 0xb1, 0xdd, + 0x7a, 0xb6, 0xe6, 0xc0, 0xb4, 0x52, 0x0e, 0xdc, 0x8b, 0xd1, 0xf0, 0x39, 0xd4, 0xf5, 0xe3, 0x6e, + 0x92, 0x44, 0xf0, 0x37, 0x07, 0x25, 0x42, 0x93, 0xf5, 0xbc, 0xbe, 0x97, 0xed, 0x23, 0x93, 0x72, + 0xdf, 0x3b, 0x15, 0x75, 0xbc, 0xd8, 0xbb, 0x56, 0x2b, 0x35, 0x76, 0x4f, 0xee, 0x34, 0xf5, 0xb5, + 0x5f, 0xc9, 0x76, 0x6e, 0x83, 0x16, 0x98, 0x71, 0x60, 0x89, 0xa1, 0x3a, 0x93, 0x72, 0xb0, 0x27, + 0x87, 0xaa, 0x1a, 0x22, 0x23, 0x08, 0xae, 0x3a, 0x77, 0xec, 0x95, 0xf2, 0xdc, 0xb6, 0x6c, 0xff, + 0x83, 0xab, 0x33, 0x1b, 0xae, 0xaa, 0x21, 0x32, 0x82, 0x8b, 0x9c, 0x52, 0x38, 0x21, 0xde, 0x56, + 0xcd, 0x6e, 0xec, 0x9e, 0x78, 0x86, 0x79, 0x7a, 0xd6, 0xc9, 0x03, 0x1f, 0x08, 0xe0, 0x92, 0x83, + 0xd2, 0xe9, 0x59, 0x67, 0xcd, 0x81, 0xc8, 0xa4, 0x1c, 0xec, 0x48, 0x66, 0x38, 0x21, 0xf0, 0xdb, + 0xa2, 0x2e, 0x24, 0x24, 0x04, 0xf7, 0xa3, 0xb3, 0x25, 0xfe, 0x51, 0x6f, 0x5b, 0x42, 0xab, 0x06, + 0xfa, 0xa6, 0xfd, 0xe2, 0x5d, 0x9e, 0xfa, 0x48, 0x53, 0xb7, 0x84, 0xb4, 0xe6, 0x40, 0xc6, 0x52, + 0x0e, 0x1c, 0xc9, 0x15, 0x85, 0x00, 0x4b, 0x15, 0x49, 0xcd, 0xfd, 0xe0, 0x54, 0xf4, 0x8b, 0xe0, + 0x95, 0x25, 0xfd, 0xae, 0xa1, 0xbf, 0x55, 0xed, 0xfc, 0x80, 0x9a, 0xb9, 0x83, 0x0e, 0xa5, 0x1c, + 0xec, 0x4b, 0xb6, 0xae, 0x21, 0x32, 0x8a, 0xfb, 0xc3, 0x76, 0x0e, 0x49, 0x48, 0x59, 0x84, 0x83, + 0xcf, 0xe6, 0xd2, 0x15, 0x79, 0xe9, 0x9b, 0x9b, 0x11, 0xfa, 0xdd, 0x52, 0x17, 0x6f, 0x0d, 0x34, + 0xfc, 0x46, 0x84, 0x47, 0x2c, 0xc1, 0x1d, 0x15, 0x6e, 0x6f, 0x2e, 0x5e, 0x95, 0x93, 0x0a, 0x44, + 0xb8, 0x9e, 0xd7, 0x8f, 0x0a, 0xfa, 0xe9, 0xbc, 0x5e, 0xc8, 0x42, 0x07, 0x24, 0x57, 0xbb, 0xd4, + 0x39, 0x1c, 0x63, 0x1a, 0x10, 0x1a, 0x6e, 0x56, 0xbd, 0xfe, 0xdf, 0x55, 0x9f, 0xe8, 0x55, 0x0f, + 0x74, 0xec, 0x6a, 0xc9, 0x23, 0xb9, 0x64, 0xae, 0x0d, 0xd1, 0x5f, 0xb6, 0xd6, 0xeb, 0xd9, 0xa5, + 0x6f, 0x2d, 0x2e, 0x7d, 0x6b, 0xb6, 0xf4, 0xed, 0xc5, 0xd2, 0xb7, 0xbf, 0xae, 0x7c, 0xeb, 0xfb, + 0xca, 0xb7, 0x17, 0x2b, 0xdf, 0xfa, 0xb5, 0xf2, 0xad, 0x4f, 0x0f, 0x43, 0x92, 0x0c, 0x26, 0xbd, + 0x66, 0x9f, 0x8d, 0x8e, 0xe3, 0x2f, 0xb4, 0x9f, 0x0c, 0x08, 0x0d, 0x33, 0x4f, 0x57, 0x5f, 0x68, + 0xaf, 0x2c, 0x3f, 0xc7, 0xa7, 0x7f, 0x02, 0x00, 0x00, 0xff, 0xff, 0xcb, 0xcf, 0x98, 0x86, 0x91, + 0x04, 0x00, 0x00, } +func (m *Configuration) Marshal() (dAtA []byte, err error) { + size := m.ProtoSize() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Configuration) MarshalTo(dAtA []byte) (int, error) { + size := m.ProtoSize() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Configuration) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.PendingDevices) > 0 { + for iNdEx := len(m.PendingDevices) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.PendingDevices[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintConfig(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x42 + } + } + if len(m.IgnoredDevices) > 0 { + for iNdEx := len(m.IgnoredDevices) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.IgnoredDevices[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintConfig(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x3a + } + } + { + size, err := m.Options.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintConfig(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x32 + { + size, err := m.LDAP.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintConfig(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + { + size, err := m.GUI.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintConfig(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + if len(m.Devices) > 0 { + for iNdEx := len(m.Devices) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Devices[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintConfig(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + } + if len(m.Folders) > 0 { + for iNdEx := len(m.Folders) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Folders[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintConfig(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } + if m.Version != 0 { + i = encodeVarintConfig(dAtA, i, uint64(m.Version)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func encodeVarintConfig(dAtA []byte, offset int, v uint64) int { + offset -= sovConfig(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} func (m *Configuration) ProtoSize() (n int) { if m == nil { return 0 @@ -149,3 +285,394 @@ func sovConfig(x uint64) (n int) { func sozConfig(x uint64) (n int) { return sovConfig(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } +func (m *Configuration) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfig + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Configuration: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Configuration: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) + } + m.Version = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfig + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Version |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Folders", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfig + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthConfig + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthConfig + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Folders = append(m.Folders, FolderConfiguration{}) + if err := m.Folders[len(m.Folders)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Devices", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfig + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthConfig + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthConfig + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Devices = append(m.Devices, DeviceConfiguration{}) + if err := m.Devices[len(m.Devices)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GUI", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfig + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthConfig + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthConfig + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.GUI.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LDAP", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfig + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthConfig + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthConfig + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.LDAP.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Options", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfig + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthConfig + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthConfig + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Options.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field IgnoredDevices", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfig + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthConfig + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthConfig + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.IgnoredDevices = append(m.IgnoredDevices, ObservedDevice{}) + if err := m.IgnoredDevices[len(m.IgnoredDevices)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PendingDevices", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfig + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthConfig + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthConfig + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PendingDevices = append(m.PendingDevices, ObservedDevice{}) + if err := m.PendingDevices[len(m.PendingDevices)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipConfig(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthConfig + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthConfig + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipConfig(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowConfig + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowConfig + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowConfig + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthConfig + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupConfig + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthConfig + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthConfig = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowConfig = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupConfig = fmt.Errorf("proto: unexpected end of group") +) diff --git a/lib/config/config_test.go b/lib/config/config_test.go index a0ec753e8..0008d5c83 100644 --- a/lib/config/config_test.go +++ b/lib/config/config_test.go @@ -137,7 +137,7 @@ func TestDeviceConfig(t *testing.T) { DeviceID: device1, Name: "node one", Addresses: []string{"tcp://a"}, - Compression: protocol.CompressMetadata, + Compression: protocol.CompressionMetadata, AllowedNetworks: []string{}, IgnoredFolders: []ObservedFolder{}, PendingFolders: []ObservedFolder{}, @@ -146,7 +146,7 @@ func TestDeviceConfig(t *testing.T) { DeviceID: device4, Name: "node two", Addresses: []string{"tcp://b"}, - Compression: protocol.CompressMetadata, + Compression: protocol.CompressionMetadata, AllowedNetworks: []string{}, IgnoredFolders: []ObservedFolder{}, PendingFolders: []ObservedFolder{}, @@ -265,7 +265,7 @@ func TestDeviceAddressesDynamic(t *testing.T) { DeviceID: device4, Name: name, // Set when auto created Addresses: []string{"dynamic"}, - Compression: protocol.CompressMetadata, + Compression: protocol.CompressionMetadata, AllowedNetworks: []string{}, IgnoredFolders: []ObservedFolder{}, PendingFolders: []ObservedFolder{}, @@ -289,7 +289,7 @@ func TestDeviceCompression(t *testing.T) { device1: { DeviceID: device1, Addresses: []string{"dynamic"}, - Compression: protocol.CompressMetadata, + Compression: protocol.CompressionMetadata, AllowedNetworks: []string{}, IgnoredFolders: []ObservedFolder{}, PendingFolders: []ObservedFolder{}, @@ -297,7 +297,7 @@ func TestDeviceCompression(t *testing.T) { device2: { DeviceID: device2, Addresses: []string{"dynamic"}, - Compression: protocol.CompressMetadata, + Compression: protocol.CompressionMetadata, AllowedNetworks: []string{}, IgnoredFolders: []ObservedFolder{}, PendingFolders: []ObservedFolder{}, @@ -305,7 +305,7 @@ func TestDeviceCompression(t *testing.T) { device3: { DeviceID: device3, Addresses: []string{"dynamic"}, - Compression: protocol.CompressNever, + Compression: protocol.CompressionNever, AllowedNetworks: []string{}, IgnoredFolders: []ObservedFolder{}, PendingFolders: []ObservedFolder{}, @@ -314,7 +314,7 @@ func TestDeviceCompression(t *testing.T) { DeviceID: device4, Name: name, // Set when auto created Addresses: []string{"dynamic"}, - Compression: protocol.CompressMetadata, + Compression: protocol.CompressionMetadata, AllowedNetworks: []string{}, IgnoredFolders: []ObservedFolder{}, PendingFolders: []ObservedFolder{}, @@ -360,7 +360,7 @@ func TestDeviceAddressesStatic(t *testing.T) { DeviceID: device4, Name: name, // Set when auto created Addresses: []string{"dynamic"}, - Compression: protocol.CompressMetadata, + Compression: protocol.CompressionMetadata, AllowedNetworks: []string{}, IgnoredFolders: []ObservedFolder{}, PendingFolders: []ObservedFolder{}, diff --git a/lib/config/deviceconfiguration.pb.go b/lib/config/deviceconfiguration.pb.go index d5ca76bc0..6203e9447 100644 --- a/lib/config/deviceconfiguration.pb.go +++ b/lib/config/deviceconfiguration.pb.go @@ -9,6 +9,7 @@ import ( github_com_syncthing_syncthing_lib_protocol "github.com/syncthing/syncthing/lib/protocol" protocol "github.com/syncthing/syncthing/lib/protocol" _ "github.com/syncthing/syncthing/proto/ext" + io "io" math "math" math_bits "math/bits" ) @@ -50,16 +51,25 @@ func (*DeviceConfiguration) Descriptor() ([]byte, []int) { return fileDescriptor_744b782bd13071dd, []int{0} } func (m *DeviceConfiguration) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_DeviceConfiguration.Unmarshal(m, b) + return m.Unmarshal(b) } func (m *DeviceConfiguration) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_DeviceConfiguration.Marshal(b, m, deterministic) + if deterministic { + return xxx_messageInfo_DeviceConfiguration.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } } func (m *DeviceConfiguration) XXX_Merge(src proto.Message) { xxx_messageInfo_DeviceConfiguration.Merge(m, src) } func (m *DeviceConfiguration) XXX_Size() int { - return xxx_messageInfo_DeviceConfiguration.Size(m) + return m.ProtoSize() } func (m *DeviceConfiguration) XXX_DiscardUnknown() { xxx_messageInfo_DeviceConfiguration.DiscardUnknown(m) @@ -76,66 +86,242 @@ func init() { } var fileDescriptor_744b782bd13071dd = []byte{ - // 900 bytes of a gzipped FileDescriptorProto + // 902 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x55, 0x31, 0x6f, 0xdb, 0x46, 0x18, 0x15, 0xeb, 0xc4, 0xb6, 0xce, 0x96, 0x65, 0xd3, 0x88, 0xc3, 0x18, 0x88, 0x4e, 0x60, 0x35, - 0x28, 0x68, 0x2a, 0x17, 0x6e, 0x27, 0xa3, 0x1d, 0xca, 0x04, 0x6d, 0x83, 0xa0, 0x49, 0x7b, 0xdd, + 0x28, 0x68, 0x2a, 0x17, 0x6e, 0x27, 0xa3, 0x1d, 0xca, 0x04, 0x45, 0x03, 0xa3, 0x49, 0x7b, 0xdd, 0xbc, 0xb0, 0x24, 0xef, 0xac, 0x1c, 0x2c, 0xf2, 0x58, 0xf2, 0xa4, 0x48, 0x40, 0x87, 0x8e, 0x1d, - 0x3a, 0x14, 0x59, 0xbb, 0x14, 0x1d, 0x3a, 0xf4, 0x97, 0x04, 0xe8, 0x60, 0x8d, 0x45, 0x87, 0x03, - 0x62, 0x2f, 0x05, 0x47, 0x8e, 0x99, 0x0a, 0xde, 0x51, 0x14, 0x49, 0x47, 0x45, 0x80, 0x6e, 0x77, - 0xef, 0xbd, 0x7b, 0xef, 0xf8, 0x74, 0x1f, 0x04, 0x7a, 0x23, 0xea, 0x1e, 0x79, 0x2c, 0x38, 0xa3, - 0xc3, 0x23, 0x4c, 0x26, 0xd4, 0x23, 0x6a, 0x33, 0x8e, 0x1c, 0x4e, 0x59, 0x30, 0x08, 0x23, 0xc6, - 0x99, 0xbe, 0xae, 0xc0, 0xc3, 0x83, 0x4c, 0x2d, 0x21, 0x8f, 0x8d, 0x8e, 0x5c, 0x12, 0x2a, 0xfe, - 0xf0, 0x4e, 0xc9, 0x85, 0xb9, 0x31, 0x89, 0x26, 0x04, 0xe7, 0x54, 0x93, 0x4c, 0xb9, 0x5a, 0x9a, - 0x7f, 0xee, 0x80, 0xfd, 0x87, 0x32, 0xe3, 0x41, 0x39, 0x43, 0xff, 0x43, 0x03, 0x4d, 0x95, 0x6d, - 0x53, 0x6c, 0x68, 0x5d, 0xad, 0xbf, 0x6d, 0xfd, 0xa4, 0xbd, 0x14, 0xb0, 0xf1, 0xb7, 0x80, 0x1f, - 0x0d, 0x29, 0x7f, 0x36, 0x76, 0x07, 0x1e, 0xf3, 0x8f, 0xe2, 0x59, 0xe0, 0xf1, 0x67, 0x34, 0x18, - 0x96, 0x56, 0xe5, 0x1b, 0x0d, 0x94, 0xfb, 0xa3, 0x87, 0x97, 0x02, 0x6e, 0x2e, 0xd6, 0x89, 0x80, - 0x9b, 0x38, 0x5f, 0xa7, 0x02, 0xb6, 0xa6, 0xfe, 0xe8, 0xc4, 0xa4, 0xf8, 0xbe, 0xc3, 0x79, 0x64, - 0x26, 0x17, 0xbd, 0x8d, 0x7c, 0x9d, 0x5e, 0xf4, 0x0a, 0xdd, 0x8f, 0xf3, 0x9e, 0xf6, 0x62, 0xde, - 0x2b, 0x3c, 0xd0, 0x82, 0xc1, 0xfa, 0x57, 0xe0, 0x46, 0xe0, 0xf8, 0xc4, 0x78, 0xa7, 0xab, 0xf5, - 0x9b, 0xd6, 0xc7, 0x89, 0x80, 0x72, 0x9f, 0x0a, 0x78, 0x47, 0x3a, 0x67, 0x1b, 0xe9, 0x77, 0x9f, - 0xf9, 0x94, 0x13, 0x3f, 0xe4, 0xb3, 0x2c, 0x65, 0xff, 0x0d, 0x38, 0x92, 0x27, 0xf5, 0x29, 0x68, - 0x3a, 0x18, 0x47, 0x24, 0x8e, 0x49, 0x6c, 0xac, 0x75, 0xd7, 0xfa, 0x4d, 0xeb, 0x34, 0x11, 0x70, - 0x09, 0xa6, 0x02, 0xde, 0x93, 0xde, 0x39, 0x52, 0x72, 0xee, 0x62, 0x72, 0xe6, 0x8c, 0x47, 0xfc, - 0xc4, 0xc4, 0xb3, 0xc0, 0xf1, 0xa9, 0x97, 0x65, 0xed, 0x5d, 0xd3, 0xbd, 0xbe, 0xe8, 0x6d, 0xe4, - 0x02, 0xb4, 0xf4, 0xd5, 0x27, 0x60, 0xcb, 0x63, 0x7e, 0x98, 0xed, 0x28, 0x0b, 0x8c, 0x1b, 0x5d, - 0xad, 0xbf, 0x73, 0x7c, 0x6b, 0x50, 0xd4, 0xf9, 0x60, 0x49, 0x5a, 0x9f, 0x24, 0x02, 0x96, 0xd5, - 0xa9, 0x80, 0x07, 0xf2, 0x52, 0x25, 0xac, 0xe8, 0x74, 0xb7, 0x0e, 0xa2, 0xf2, 0x51, 0x9d, 0x80, - 0xa6, 0x47, 0x22, 0x6e, 0xcb, 0x22, 0x6f, 0xca, 0x22, 0xbf, 0xc8, 0x7e, 0xa6, 0x0c, 0x7c, 0xa2, - 0xca, 0xbc, 0xab, 0xbc, 0x73, 0xe0, 0x0d, 0x85, 0xde, 0x5e, 0xc1, 0xa1, 0xc2, 0x45, 0x3f, 0x05, - 0x80, 0x06, 0x3c, 0x62, 0x78, 0xec, 0x91, 0xc8, 0x58, 0xef, 0x6a, 0xfd, 0x4d, 0xeb, 0x24, 0x11, - 0xb0, 0x84, 0xa6, 0x02, 0xde, 0x52, 0x0f, 0xa2, 0x80, 0x8a, 0x8f, 0x68, 0xd7, 0x30, 0x54, 0x3a, - 0xa7, 0xff, 0xa6, 0x81, 0xc3, 0xf8, 0x9c, 0x86, 0xf6, 0x02, 0xcb, 0x5e, 0xb2, 0x1d, 0x11, 0x9f, - 0x4d, 0x9c, 0x51, 0x6c, 0x6c, 0xc8, 0x30, 0x9c, 0x08, 0x68, 0x64, 0xaa, 0x47, 0x25, 0x11, 0xca, - 0x35, 0xa9, 0x80, 0xef, 0xca, 0xe8, 0x55, 0x82, 0xe2, 0x22, 0x77, 0xff, 0x53, 0x81, 0x56, 0x26, - 0xe8, 0xbf, 0x6b, 0xa0, 0x55, 0xdc, 0x19, 0xdb, 0xee, 0xcc, 0xd8, 0x94, 0xc3, 0xf5, 0xc3, 0xff, - 0x1a, 0xae, 0x44, 0xc0, 0xed, 0xa5, 0xab, 0x35, 0x4b, 0x05, 0xbc, 0x5d, 0xed, 0x10, 0x5b, 0xb3, - 0xe2, 0xf2, 0x7b, 0xd7, 0xd0, 0x6c, 0xb8, 0x50, 0xc5, 0x41, 0x3f, 0x06, 0xeb, 0xa1, 0x33, 0x8e, - 0x09, 0x36, 0x9a, 0xb2, 0xb8, 0xc3, 0x44, 0xc0, 0x1c, 0x49, 0x05, 0xdc, 0x96, 0xee, 0x6a, 0x6b, - 0xa2, 0x1c, 0xd7, 0xbf, 0x07, 0xbb, 0xce, 0x68, 0xc4, 0x9e, 0x13, 0x6c, 0x07, 0x84, 0x3f, 0x67, - 0xd1, 0x79, 0x6c, 0x00, 0x39, 0x3d, 0x5f, 0x27, 0x02, 0xb6, 0x73, 0xee, 0x49, 0x4e, 0xa5, 0x02, - 0x76, 0xd4, 0x0c, 0x55, 0xf0, 0xea, 0x9b, 0x32, 0x56, 0x91, 0xa8, 0x6e, 0xa7, 0x7f, 0x0b, 0xf6, - 0x9d, 0x31, 0x67, 0xb6, 0xe3, 0x79, 0x24, 0xe4, 0xf6, 0x19, 0x1b, 0x61, 0x12, 0xc5, 0xc6, 0x96, - 0xbc, 0xfe, 0x07, 0x89, 0x80, 0x7b, 0x19, 0xfd, 0xa9, 0x64, 0x3f, 0x53, 0x64, 0xd1, 0xd3, 0x35, - 0xc6, 0x44, 0xd7, 0xd5, 0xfa, 0x53, 0xd0, 0xf2, 0x9d, 0xa9, 0x1d, 0x93, 0x00, 0xdb, 0xe7, 0x6e, - 0x18, 0x1b, 0xdb, 0x5d, 0xad, 0x7f, 0xd3, 0x7a, 0x2f, 0x9b, 0x43, 0xdf, 0x99, 0x7e, 0x43, 0x02, - 0xfc, 0xd8, 0x0d, 0x33, 0xd7, 0x3d, 0xe9, 0x5a, 0xc2, 0xcc, 0xd7, 0x02, 0xae, 0xd1, 0x80, 0xa3, - 0xb2, 0x70, 0x61, 0x18, 0x11, 0x6f, 0xa2, 0x0c, 0x5b, 0x15, 0x43, 0x44, 0xbc, 0x49, 0xdd, 0x70, - 0x81, 0x55, 0x0c, 0x17, 0xa0, 0x1e, 0x80, 0x36, 0x1d, 0x06, 0x2c, 0x22, 0xb8, 0xf8, 0xfe, 0x9d, - 0xee, 0x5a, 0x7f, 0xeb, 0xf8, 0x60, 0xa0, 0xfe, 0x0b, 0x06, 0x4f, 0xf3, 0xff, 0x02, 0xf5, 0x4d, - 0xd6, 0xfb, 0xd9, 0xb3, 0x4b, 0x04, 0xdc, 0xc9, 0x8f, 0x2d, 0x8b, 0xd9, 0x57, 0x0f, 0xa8, 0x0c, - 0x9b, 0xa8, 0x26, 0xcb, 0xf2, 0x42, 0x12, 0x60, 0x1a, 0x0c, 0x8b, 0xbc, 0xf6, 0xdb, 0xe5, 0xe5, - 0xc7, 0xea, 0x79, 0x15, 0xd8, 0x44, 0x35, 0x99, 0xfe, 0x8b, 0x06, 0xda, 0xaa, 0xb1, 0xef, 0xc6, - 0x24, 0xe6, 0xf6, 0x39, 0x75, 0x8d, 0x5d, 0xd9, 0x59, 0x7c, 0x29, 0x60, 0xeb, 0xcb, 0xac, 0x0a, - 0xc9, 0x3c, 0xa6, 0x56, 0x22, 0x60, 0xcb, 0x2f, 0x03, 0x45, 0x48, 0x05, 0x5d, 0x14, 0x99, 0x5c, - 0xf4, 0x6a, 0xf2, 0x3a, 0xf0, 0x62, 0xde, 0xab, 0x26, 0xa0, 0x0a, 0xef, 0x5a, 0x9f, 0xbf, 0x7c, - 0xd5, 0x69, 0xcc, 0x5f, 0x75, 0x1a, 0xff, 0x5c, 0x76, 0x1a, 0x3f, 0x5f, 0x75, 0x1a, 0xbf, 0x5e, - 0x75, 0xb4, 0xf9, 0x55, 0xa7, 0xf1, 0xd7, 0x55, 0xa7, 0x71, 0x7a, 0xef, 0x2d, 0x26, 0x5b, 0x95, - 0xe6, 0xae, 0xcb, 0x09, 0xff, 0xf0, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x3c, 0x69, 0xcb, 0x9f, - 0x0b, 0x08, 0x00, 0x00, + 0x3a, 0x14, 0x59, 0xbb, 0x14, 0x1d, 0x3a, 0xf4, 0x97, 0x18, 0xe8, 0x60, 0x8d, 0x45, 0x87, 0x03, + 0x62, 0x6f, 0x1c, 0x39, 0x66, 0x2a, 0x78, 0x47, 0x51, 0x24, 0x1d, 0x17, 0x06, 0xba, 0xdd, 0xbd, + 0xf7, 0xee, 0xbd, 0xe3, 0xd3, 0x7d, 0x10, 0xe8, 0x8d, 0xa8, 0x7b, 0xe0, 0xb1, 0xe0, 0x94, 0x0e, + 0x0f, 0x30, 0x99, 0x50, 0x8f, 0xa8, 0xcd, 0x38, 0x72, 0x38, 0x65, 0xc1, 0x20, 0x8c, 0x18, 0x67, + 0xfa, 0xaa, 0x02, 0xf7, 0xf7, 0x32, 0xb5, 0x84, 0x3c, 0x36, 0x3a, 0x70, 0x49, 0xa8, 0xf8, 0xfd, + 0x07, 0x25, 0x17, 0xe6, 0xc6, 0x24, 0x9a, 0x10, 0x9c, 0x53, 0x4d, 0x32, 0xe5, 0x6a, 0x69, 0xfe, + 0xb5, 0x05, 0x76, 0x9f, 0xca, 0x8c, 0x27, 0xe5, 0x0c, 0xfd, 0x4f, 0x0d, 0x34, 0x55, 0xb6, 0x4d, + 0xb1, 0xa1, 0x75, 0xb5, 0xfe, 0xa6, 0xf5, 0xb3, 0x76, 0x2e, 0x60, 0xe3, 0x1f, 0x01, 0x3f, 0x19, + 0x52, 0xfe, 0x72, 0xec, 0x0e, 0x3c, 0xe6, 0x1f, 0xc4, 0xb3, 0xc0, 0xe3, 0x2f, 0x69, 0x30, 0x2c, + 0xad, 0xca, 0x37, 0x1a, 0x28, 0xf7, 0x67, 0x4f, 0x2f, 0x05, 0x5c, 0x5f, 0xac, 0x13, 0x01, 0xd7, + 0x71, 0xbe, 0x4e, 0x05, 0x6c, 0x4d, 0xfd, 0xd1, 0x91, 0x49, 0xf1, 0x63, 0x87, 0xf3, 0xc8, 0x4c, + 0x2e, 0x7a, 0x6b, 0xf9, 0x3a, 0xbd, 0xe8, 0x15, 0xba, 0x9f, 0xe6, 0x3d, 0xed, 0xf5, 0xbc, 0x57, + 0x78, 0xa0, 0x05, 0x83, 0xf5, 0xaf, 0xc1, 0x9d, 0xc0, 0xf1, 0x89, 0xf1, 0x5e, 0x57, 0xeb, 0x37, + 0xad, 0x4f, 0x13, 0x01, 0xe5, 0x3e, 0x15, 0xf0, 0x81, 0x74, 0xce, 0x36, 0xd2, 0xef, 0x31, 0xf3, + 0x29, 0x27, 0x7e, 0xc8, 0x67, 0x59, 0xca, 0xee, 0x3b, 0x70, 0x24, 0x4f, 0xea, 0x53, 0xd0, 0x74, + 0x30, 0x8e, 0x48, 0x1c, 0x93, 0xd8, 0x58, 0xe9, 0xae, 0xf4, 0x9b, 0xd6, 0x49, 0x22, 0xe0, 0x12, + 0x4c, 0x05, 0x7c, 0x24, 0xbd, 0x73, 0xa4, 0xe4, 0xdc, 0xc5, 0xe4, 0xd4, 0x19, 0x8f, 0xf8, 0x91, + 0x89, 0x67, 0x81, 0xe3, 0x53, 0x2f, 0xcb, 0xda, 0xb9, 0xa6, 0x7b, 0x7b, 0xd1, 0x5b, 0xcb, 0x05, + 0x68, 0xe9, 0xab, 0x4f, 0xc0, 0x86, 0xc7, 0xfc, 0x30, 0xdb, 0x51, 0x16, 0x18, 0x77, 0xba, 0x5a, + 0x7f, 0xeb, 0xf0, 0xde, 0xa0, 0xa8, 0xf3, 0xc9, 0x92, 0xb4, 0x3e, 0x4b, 0x04, 0x2c, 0xab, 0x53, + 0x01, 0xf7, 0xe4, 0xa5, 0x4a, 0x58, 0xd1, 0xe9, 0x76, 0x1d, 0x44, 0xe5, 0xa3, 0x3a, 0x01, 0x4d, + 0x8f, 0x44, 0xdc, 0x96, 0x45, 0xde, 0x95, 0x45, 0x7e, 0x99, 0xfd, 0x4c, 0x19, 0xf8, 0x5c, 0x95, + 0xf9, 0x50, 0x79, 0xe7, 0xc0, 0x3b, 0x0a, 0xbd, 0x7f, 0x03, 0x87, 0x0a, 0x17, 0xfd, 0x04, 0x00, + 0x1a, 0xf0, 0x88, 0xe1, 0xb1, 0x47, 0x22, 0x63, 0xb5, 0xab, 0xf5, 0xd7, 0xad, 0xa3, 0x44, 0xc0, + 0x12, 0x9a, 0x0a, 0x78, 0x4f, 0x3d, 0x88, 0x02, 0x2a, 0x3e, 0xa2, 0x5d, 0xc3, 0x50, 0xe9, 0x9c, + 0xfe, 0xbb, 0x06, 0xf6, 0xe3, 0x33, 0x1a, 0xda, 0x0b, 0x2c, 0x7b, 0xc9, 0x76, 0x44, 0x7c, 0x36, + 0x71, 0x46, 0xb1, 0xb1, 0x26, 0xc3, 0x70, 0x22, 0xa0, 0x91, 0xa9, 0x9e, 0x95, 0x44, 0x28, 0xd7, + 0xa4, 0x02, 0xbe, 0x2f, 0xa3, 0x6f, 0x12, 0x14, 0x17, 0x79, 0xf8, 0x9f, 0x0a, 0x74, 0x63, 0x82, + 0xfe, 0x87, 0x06, 0x5a, 0xc5, 0x9d, 0xb1, 0xed, 0xce, 0x8c, 0x75, 0x39, 0x5c, 0x3f, 0xfe, 0xaf, + 0xe1, 0x4a, 0x04, 0xdc, 0x5c, 0xba, 0x5a, 0xb3, 0x54, 0xc0, 0xfb, 0xd5, 0x0e, 0xb1, 0x35, 0x2b, + 0x2e, 0xbf, 0x73, 0x0d, 0xcd, 0x86, 0x0b, 0x55, 0x1c, 0xf4, 0x43, 0xb0, 0x1a, 0x3a, 0xe3, 0x98, + 0x60, 0xa3, 0x29, 0x8b, 0xdb, 0x4f, 0x04, 0xcc, 0x91, 0x54, 0xc0, 0x4d, 0xe9, 0xae, 0xb6, 0x26, + 0xca, 0x71, 0xfd, 0x07, 0xb0, 0xed, 0x8c, 0x46, 0xec, 0x15, 0xc1, 0x76, 0x40, 0xf8, 0x2b, 0x16, + 0x9d, 0xc5, 0x06, 0x90, 0xd3, 0xf3, 0x4d, 0x22, 0x60, 0x3b, 0xe7, 0x9e, 0xe7, 0x54, 0x2a, 0x60, + 0x47, 0xcd, 0x50, 0x05, 0xaf, 0xbe, 0x29, 0xe3, 0x26, 0x12, 0xd5, 0xed, 0xf4, 0xef, 0xc0, 0xae, + 0x33, 0xe6, 0xcc, 0x76, 0x3c, 0x8f, 0x84, 0xdc, 0x3e, 0x65, 0x23, 0x4c, 0xa2, 0xd8, 0xd8, 0x90, + 0xd7, 0xff, 0x28, 0x11, 0x70, 0x27, 0xa3, 0x3f, 0x97, 0xec, 0x17, 0x8a, 0x2c, 0x7a, 0xba, 0xc6, + 0x98, 0xe8, 0xba, 0x5a, 0x7f, 0x01, 0x5a, 0xbe, 0x33, 0xb5, 0x63, 0x12, 0x60, 0xfb, 0xcc, 0x0d, + 0x63, 0x63, 0xb3, 0xab, 0xf5, 0xef, 0x5a, 0x1f, 0x64, 0x73, 0xe8, 0x3b, 0xd3, 0x6f, 0x49, 0x80, + 0x8f, 0xdd, 0x30, 0x73, 0xdd, 0x91, 0xae, 0x25, 0xcc, 0x7c, 0x2b, 0xe0, 0x0a, 0x0d, 0x38, 0x2a, + 0x0b, 0x17, 0x86, 0x11, 0xf1, 0x26, 0xca, 0xb0, 0x55, 0x31, 0x44, 0xc4, 0x9b, 0xd4, 0x0d, 0x17, + 0x58, 0xc5, 0x70, 0x01, 0xea, 0x01, 0x68, 0xd3, 0x61, 0xc0, 0x22, 0x82, 0x8b, 0xef, 0xdf, 0xea, + 0xae, 0xf4, 0x37, 0x0e, 0xf7, 0x06, 0xea, 0xbf, 0x60, 0xf0, 0x22, 0xff, 0x2f, 0x50, 0xdf, 0x64, + 0x7d, 0x98, 0x3d, 0xbb, 0x44, 0xc0, 0xad, 0xfc, 0xd8, 0xb2, 0x98, 0x5d, 0xf5, 0x80, 0xca, 0xb0, + 0x89, 0x6a, 0xb2, 0x2c, 0x2f, 0x24, 0x01, 0xa6, 0xc1, 0xb0, 0xc8, 0x6b, 0xdf, 0x2e, 0x2f, 0x3f, + 0x56, 0xcf, 0xab, 0xc0, 0x26, 0xaa, 0xc9, 0xf4, 0x5f, 0x35, 0xd0, 0x56, 0x8d, 0x7d, 0x3f, 0x26, + 0x31, 0xb7, 0xcf, 0xa8, 0x6b, 0x6c, 0xcb, 0xce, 0xe2, 0x4b, 0x01, 0x5b, 0x5f, 0x65, 0x55, 0x48, + 0xe6, 0x98, 0x5a, 0x89, 0x80, 0x2d, 0xbf, 0x0c, 0x14, 0x21, 0x15, 0x74, 0x51, 0x64, 0x72, 0xd1, + 0xab, 0xc9, 0xeb, 0xc0, 0xeb, 0x79, 0xaf, 0x9a, 0x80, 0x2a, 0xbc, 0x6b, 0x1d, 0x9f, 0xbf, 0xe9, + 0x34, 0xe6, 0x6f, 0x3a, 0x8d, 0xf3, 0xcb, 0x8e, 0x36, 0xbf, 0xec, 0x68, 0xbf, 0x5c, 0x75, 0x1a, + 0xbf, 0x5d, 0x75, 0xb4, 0xf9, 0x55, 0xa7, 0xf1, 0xf7, 0x55, 0xa7, 0x71, 0xf2, 0xe8, 0x16, 0xd3, + 0xad, 0x8a, 0x73, 0x57, 0xe5, 0x94, 0x7f, 0xfc, 0x6f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xda, 0x35, + 0x78, 0xb9, 0x0f, 0x08, 0x00, 0x00, } +func (m *DeviceConfiguration) Marshal() (dAtA []byte, err error) { + size := m.ProtoSize() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *DeviceConfiguration) MarshalTo(dAtA []byte) (int, error) { + size := m.ProtoSize() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DeviceConfiguration) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.MaxRequestKiB != 0 { + i = encodeVarintDeviceconfiguration(dAtA, i, uint64(m.MaxRequestKiB)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x80 + } + if len(m.PendingFolders) > 0 { + for iNdEx := len(m.PendingFolders) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.PendingFolders[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDeviceconfiguration(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x7a + } + } + if len(m.IgnoredFolders) > 0 { + for iNdEx := len(m.IgnoredFolders) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.IgnoredFolders[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDeviceconfiguration(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x72 + } + } + if m.MaxRecvKbps != 0 { + i = encodeVarintDeviceconfiguration(dAtA, i, uint64(m.MaxRecvKbps)) + i-- + dAtA[i] = 0x68 + } + if m.MaxSendKbps != 0 { + i = encodeVarintDeviceconfiguration(dAtA, i, uint64(m.MaxSendKbps)) + i-- + dAtA[i] = 0x60 + } + if m.AutoAcceptFolders { + i-- + if m.AutoAcceptFolders { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x58 + } + if len(m.AllowedNetworks) > 0 { + for iNdEx := len(m.AllowedNetworks) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.AllowedNetworks[iNdEx]) + copy(dAtA[i:], m.AllowedNetworks[iNdEx]) + i = encodeVarintDeviceconfiguration(dAtA, i, uint64(len(m.AllowedNetworks[iNdEx]))) + i-- + dAtA[i] = 0x52 + } + } + if m.Paused { + i-- + if m.Paused { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x48 + } + { + size := m.IntroducedBy.ProtoSize() + i -= size + if _, err := m.IntroducedBy.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintDeviceconfiguration(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x42 + if m.SkipIntroductionRemovals { + i-- + if m.SkipIntroductionRemovals { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x38 + } + if m.Introducer { + i-- + if m.Introducer { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x30 + } + if len(m.CertName) > 0 { + i -= len(m.CertName) + copy(dAtA[i:], m.CertName) + i = encodeVarintDeviceconfiguration(dAtA, i, uint64(len(m.CertName))) + i-- + dAtA[i] = 0x2a + } + if m.Compression != 0 { + i = encodeVarintDeviceconfiguration(dAtA, i, uint64(m.Compression)) + i-- + dAtA[i] = 0x20 + } + if len(m.Addresses) > 0 { + for iNdEx := len(m.Addresses) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Addresses[iNdEx]) + copy(dAtA[i:], m.Addresses[iNdEx]) + i = encodeVarintDeviceconfiguration(dAtA, i, uint64(len(m.Addresses[iNdEx]))) + i-- + dAtA[i] = 0x1a + } + } + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintDeviceconfiguration(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0x12 + } + { + size := m.DeviceID.ProtoSize() + i -= size + if _, err := m.DeviceID.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintDeviceconfiguration(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func encodeVarintDeviceconfiguration(dAtA []byte, offset int, v uint64) int { + offset -= sovDeviceconfiguration(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} func (m *DeviceConfiguration) ProtoSize() (n int) { if m == nil { return 0 @@ -211,3 +397,558 @@ func sovDeviceconfiguration(x uint64) (n int) { func sozDeviceconfiguration(x uint64) (n int) { return sovDeviceconfiguration(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } +func (m *DeviceConfiguration) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDeviceconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: DeviceConfiguration: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DeviceConfiguration: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DeviceID", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDeviceconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthDeviceconfiguration + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthDeviceconfiguration + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.DeviceID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDeviceconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthDeviceconfiguration + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthDeviceconfiguration + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Addresses", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDeviceconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthDeviceconfiguration + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthDeviceconfiguration + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Addresses = append(m.Addresses, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Compression", wireType) + } + m.Compression = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDeviceconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Compression |= protocol.Compression(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CertName", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDeviceconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthDeviceconfiguration + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthDeviceconfiguration + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.CertName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Introducer", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDeviceconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Introducer = bool(v != 0) + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field SkipIntroductionRemovals", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDeviceconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.SkipIntroductionRemovals = bool(v != 0) + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field IntroducedBy", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDeviceconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthDeviceconfiguration + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthDeviceconfiguration + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.IntroducedBy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Paused", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDeviceconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Paused = bool(v != 0) + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AllowedNetworks", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDeviceconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthDeviceconfiguration + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthDeviceconfiguration + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.AllowedNetworks = append(m.AllowedNetworks, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 11: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field AutoAcceptFolders", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDeviceconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.AutoAcceptFolders = bool(v != 0) + case 12: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MaxSendKbps", wireType) + } + m.MaxSendKbps = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDeviceconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.MaxSendKbps |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MaxRecvKbps", wireType) + } + m.MaxRecvKbps = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDeviceconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.MaxRecvKbps |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field IgnoredFolders", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDeviceconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDeviceconfiguration + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDeviceconfiguration + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.IgnoredFolders = append(m.IgnoredFolders, ObservedFolder{}) + if err := m.IgnoredFolders[len(m.IgnoredFolders)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PendingFolders", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDeviceconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDeviceconfiguration + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDeviceconfiguration + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PendingFolders = append(m.PendingFolders, ObservedFolder{}) + if err := m.PendingFolders[len(m.PendingFolders)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 16: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MaxRequestKiB", wireType) + } + m.MaxRequestKiB = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDeviceconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.MaxRequestKiB |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipDeviceconfiguration(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthDeviceconfiguration + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthDeviceconfiguration + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipDeviceconfiguration(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowDeviceconfiguration + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowDeviceconfiguration + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowDeviceconfiguration + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthDeviceconfiguration + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupDeviceconfiguration + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthDeviceconfiguration + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthDeviceconfiguration = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowDeviceconfiguration = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupDeviceconfiguration = fmt.Errorf("proto: unexpected end of group") +) diff --git a/lib/config/folderconfiguration.pb.go b/lib/config/folderconfiguration.pb.go index c801b2a5f..ce0716ed0 100644 --- a/lib/config/folderconfiguration.pb.go +++ b/lib/config/folderconfiguration.pb.go @@ -4,11 +4,13 @@ package config import ( + encoding_binary "encoding/binary" fmt "fmt" proto "github.com/gogo/protobuf/proto" fs "github.com/syncthing/syncthing/lib/fs" github_com_syncthing_syncthing_lib_protocol "github.com/syncthing/syncthing/lib/protocol" _ "github.com/syncthing/syncthing/proto/ext" + io "io" math "math" math_bits "math/bits" ) @@ -36,16 +38,25 @@ func (*FolderDeviceConfiguration) Descriptor() ([]byte, []int) { return fileDescriptor_44a9785876ed3afa, []int{0} } func (m *FolderDeviceConfiguration) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_FolderDeviceConfiguration.Unmarshal(m, b) + return m.Unmarshal(b) } func (m *FolderDeviceConfiguration) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_FolderDeviceConfiguration.Marshal(b, m, deterministic) + if deterministic { + return xxx_messageInfo_FolderDeviceConfiguration.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } } func (m *FolderDeviceConfiguration) XXX_Merge(src proto.Message) { xxx_messageInfo_FolderDeviceConfiguration.Merge(m, src) } func (m *FolderDeviceConfiguration) XXX_Size() int { - return xxx_messageInfo_FolderDeviceConfiguration.Size(m) + return m.ProtoSize() } func (m *FolderDeviceConfiguration) XXX_DiscardUnknown() { xxx_messageInfo_FolderDeviceConfiguration.DiscardUnknown(m) @@ -101,16 +112,25 @@ func (*FolderConfiguration) Descriptor() ([]byte, []int) { return fileDescriptor_44a9785876ed3afa, []int{1} } func (m *FolderConfiguration) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_FolderConfiguration.Unmarshal(m, b) + return m.Unmarshal(b) } func (m *FolderConfiguration) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_FolderConfiguration.Marshal(b, m, deterministic) + if deterministic { + return xxx_messageInfo_FolderConfiguration.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } } func (m *FolderConfiguration) XXX_Merge(src proto.Message) { xxx_messageInfo_FolderConfiguration.Merge(m, src) } func (m *FolderConfiguration) XXX_Size() int { - return xxx_messageInfo_FolderConfiguration.Size(m) + return m.ProtoSize() } func (m *FolderConfiguration) XXX_DiscardUnknown() { xxx_messageInfo_FolderConfiguration.DiscardUnknown(m) @@ -128,133 +148,533 @@ func init() { } var fileDescriptor_44a9785876ed3afa = []byte{ - // 1981 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x58, 0xcd, 0x8f, 0x1c, 0x47, - 0x15, 0xdf, 0x5e, 0x7f, 0xed, 0xd6, 0x7e, 0x97, 0xbd, 0x76, 0x79, 0x9d, 0x6c, 0x6d, 0x9a, 0x21, - 0x6c, 0xa2, 0x78, 0x6d, 0x6f, 0x10, 0x07, 0x2b, 0x09, 0x64, 0xbc, 0x59, 0x30, 0xc6, 0xf1, 0xa8, - 0xd7, 0x60, 0x61, 0x90, 0x9a, 0x9e, 0xee, 0x9a, 0x99, 0xca, 0xf6, 0x17, 0x55, 0x3d, 0xde, 0x1d, - 0x9f, 0xcc, 0x05, 0x81, 0xc8, 0x01, 0x2d, 0x07, 0xae, 0x48, 0x20, 0x04, 0xf9, 0x07, 0x90, 0xf8, - 0x0b, 0x72, 0x41, 0x3b, 0x47, 0xc4, 0xa1, 0xa4, 0xac, 0x2f, 0x68, 0x6e, 0xf4, 0xd1, 0x27, 0x54, - 0x55, 0xdd, 0x3d, 0xdd, 0x3d, 0x13, 0x84, 0x94, 0xdb, 0xd4, 0xef, 0xf7, 0xab, 0xf7, 0x5e, 0xbf, - 0x7e, 0xef, 0x55, 0xf5, 0x80, 0x86, 0x4f, 0xdb, 0xb7, 0xdc, 0x28, 0xec, 0xd0, 0xee, 0xad, 0x4e, - 0xe4, 0x7b, 0x84, 0xe9, 0x45, 0x9f, 0x39, 0x09, 0x8d, 0xc2, 0x9d, 0x98, 0x45, 0x49, 0x04, 0x2f, - 0x6a, 0x70, 0xe3, 0xc6, 0x84, 0x3a, 0x19, 0xc4, 0x44, 0x8b, 0x36, 0xd6, 0x4b, 0x24, 0xa7, 0xcf, - 0x73, 0x78, 0xa3, 0x04, 0xc7, 0x7d, 0xdf, 0x8f, 0x98, 0x47, 0x58, 0xc6, 0x6d, 0x97, 0xb8, 0x67, - 0x84, 0x71, 0x1a, 0x85, 0x34, 0xec, 0x4e, 0x89, 0x60, 0x03, 0x97, 0x94, 0x6d, 0x3f, 0x72, 0x0f, - 0xeb, 0xa6, 0xa0, 0x14, 0x74, 0xf8, 0x2d, 0x19, 0x10, 0xcf, 0xb0, 0xd7, 0x32, 0xcc, 0x8d, 0xe2, - 0x01, 0x73, 0xc2, 0x2e, 0x09, 0x48, 0xd2, 0x8b, 0xbc, 0x8c, 0x9d, 0x27, 0xc7, 0x89, 0xfe, 0x69, - 0xfe, 0x67, 0x16, 0x5c, 0xdf, 0x57, 0xcf, 0xb3, 0x47, 0x9e, 0x51, 0x97, 0xdc, 0x2b, 0x47, 0x00, - 0x3f, 0x33, 0xc0, 0xbc, 0xa7, 0x70, 0x9b, 0x7a, 0xc8, 0xd8, 0x32, 0xb6, 0x17, 0x9b, 0x9f, 0x1a, - 0x9f, 0x0b, 0x3c, 0xf3, 0x2f, 0x81, 0xbf, 0xd9, 0xa5, 0x49, 0xaf, 0xdf, 0xde, 0x71, 0xa3, 0xe0, - 0x16, 0x1f, 0x84, 0x6e, 0xd2, 0xa3, 0x61, 0xb7, 0xf4, 0x4b, 0x86, 0xa0, 0x9c, 0xb8, 0x91, 0xbf, - 0xa3, 0xad, 0xdf, 0xdf, 0x3b, 0x13, 0x78, 0x2e, 0xff, 0x3d, 0x12, 0x78, 0xce, 0xcb, 0x7e, 0xa7, - 0x02, 0x2f, 0x1d, 0x07, 0xfe, 0x5d, 0x93, 0x7a, 0xef, 0x38, 0x49, 0xc2, 0xcc, 0xd1, 0x69, 0xe3, - 0x52, 0xf6, 0x3b, 0x3d, 0x6d, 0x14, 0xba, 0x5f, 0x0d, 0x1b, 0xc6, 0xc9, 0xb0, 0x51, 0xd8, 0xb0, - 0x72, 0xc6, 0x83, 0x7f, 0x36, 0xc0, 0x12, 0x0d, 0x13, 0x16, 0x79, 0x7d, 0x97, 0x78, 0x76, 0x7b, - 0x80, 0x66, 0x55, 0xc0, 0x2f, 0xbe, 0x52, 0xc0, 0x23, 0x81, 0x17, 0xc7, 0x56, 0x9b, 0x83, 0x54, - 0xe0, 0x6b, 0x3a, 0xd0, 0x12, 0x58, 0x84, 0xbc, 0x36, 0x81, 0xca, 0x80, 0xad, 0x8a, 0x05, 0xf3, - 0x25, 0x06, 0x97, 0x75, 0xce, 0xab, 0xd9, 0xfe, 0x00, 0xcc, 0x66, 0x59, 0x9e, 0x6f, 0xee, 0x9c, - 0x09, 0x3c, 0xab, 0xbc, 0xcf, 0x52, 0xef, 0x7f, 0x25, 0xe7, 0x64, 0xd8, 0x98, 0xbd, 0xbf, 0x67, - 0xcd, 0x52, 0x0f, 0xfe, 0x10, 0x5c, 0xf0, 0x9d, 0x36, 0xf1, 0xd5, 0x73, 0xcf, 0x37, 0xbf, 0x3d, - 0x12, 0x58, 0x03, 0xa9, 0xc0, 0x5b, 0x6a, 0xbf, 0x5a, 0x69, 0x13, 0x5b, 0x8c, 0xf0, 0xc4, 0x61, - 0xc9, 0x5d, 0xb3, 0xe3, 0xf8, 0x9c, 0x48, 0x93, 0x60, 0x4c, 0xbf, 0x18, 0x36, 0x66, 0x2c, 0xbd, - 0x19, 0x76, 0xc1, 0x4a, 0x87, 0xfa, 0x84, 0x0f, 0x78, 0x42, 0x02, 0x5b, 0x56, 0x19, 0x3a, 0xb7, - 0x65, 0x6c, 0x2f, 0xef, 0xc2, 0x9d, 0x0e, 0xdf, 0xd9, 0x2f, 0xa8, 0xc7, 0x83, 0x98, 0x34, 0xdf, - 0x1e, 0x09, 0xbc, 0xdc, 0xa9, 0x60, 0xa9, 0xc0, 0x57, 0x94, 0xf7, 0x2a, 0x6c, 0x5a, 0x35, 0x1d, - 0x7c, 0x0f, 0x9c, 0x8f, 0x9d, 0xa4, 0x87, 0xce, 0xab, 0xf0, 0xb7, 0x47, 0x02, 0xab, 0x75, 0x2a, - 0xf0, 0x8a, 0xda, 0x2f, 0x17, 0xc5, 0xf3, 0xcf, 0x17, 0x2b, 0x4b, 0xa9, 0x60, 0x0b, 0x9c, 0x57, - 0xb1, 0x5d, 0xc8, 0x62, 0xd3, 0x2d, 0xb3, 0xa3, 0x13, 0xad, 0x62, 0x53, 0x16, 0x13, 0x1d, 0x91, - 0xb6, 0x28, 0x17, 0x63, 0x8b, 0xc5, 0xca, 0x52, 0x2a, 0xf8, 0x53, 0x70, 0x49, 0x17, 0x17, 0x47, - 0x17, 0xb7, 0xce, 0x6d, 0x2f, 0xec, 0xbe, 0x51, 0x35, 0x3a, 0xa5, 0x63, 0x9a, 0x58, 0xd6, 0xda, - 0x48, 0xe0, 0x7c, 0x67, 0x2a, 0xf0, 0xa2, 0x72, 0xa5, 0xd7, 0xa6, 0x95, 0x13, 0xf0, 0x77, 0x06, - 0x58, 0x63, 0x84, 0xbb, 0x4e, 0x68, 0xd3, 0x30, 0x21, 0xec, 0x99, 0xe3, 0xdb, 0x1c, 0x5d, 0xda, - 0x32, 0xb6, 0x2f, 0x34, 0xbb, 0x23, 0x81, 0x57, 0x34, 0x79, 0x3f, 0xe3, 0x0e, 0x52, 0x81, 0xdf, - 0x52, 0x96, 0x6a, 0x78, 0xf6, 0x3a, 0x3d, 0xd2, 0x71, 0xfa, 0x7e, 0x72, 0xd7, 0x7c, 0xf7, 0x5b, - 0xb7, 0x6f, 0x9b, 0xaf, 0x04, 0x3e, 0x47, 0xc3, 0x64, 0x74, 0xda, 0xb8, 0x32, 0x4d, 0xfe, 0xea, - 0xb4, 0x71, 0x5e, 0xea, 0xac, 0xba, 0x13, 0xf8, 0x77, 0x03, 0xc0, 0x0e, 0xb7, 0x8f, 0x9c, 0xc4, - 0xed, 0x11, 0x66, 0x93, 0xd0, 0x69, 0xfb, 0xc4, 0x43, 0x73, 0x5b, 0xc6, 0xf6, 0x5c, 0xf3, 0x37, - 0xc6, 0x99, 0xc0, 0xab, 0xfb, 0x07, 0x4f, 0x34, 0xfb, 0x91, 0x26, 0x47, 0x02, 0xaf, 0x76, 0x78, - 0x15, 0x4b, 0x05, 0x7e, 0x5b, 0xbf, 0xf3, 0x1a, 0x51, 0x8f, 0x36, 0x61, 0x7d, 0x55, 0x7b, 0xeb, - 0x53, 0x85, 0x32, 0x4e, 0xa9, 0x38, 0x19, 0x36, 0x26, 0xdc, 0x5a, 0x13, 0x4e, 0xe1, 0xdf, 0xaa, - 0xc1, 0x7b, 0xc4, 0x77, 0x06, 0x36, 0x47, 0xf3, 0x2a, 0xa7, 0xbf, 0x96, 0xc1, 0xaf, 0x14, 0x56, - 0xf6, 0x24, 0x79, 0x20, 0xf3, 0x5c, 0x98, 0xd1, 0x50, 0x2a, 0xf0, 0x37, 0xaa, 0xa1, 0x6b, 0xbc, - 0x1e, 0xf9, 0x9d, 0x4a, 0x96, 0xa7, 0x89, 0x5f, 0x9d, 0x36, 0x66, 0xef, 0xdc, 0x3e, 0x19, 0x36, - 0xea, 0x5e, 0xad, 0xba, 0x4f, 0xf8, 0x33, 0xb0, 0x48, 0xbb, 0x61, 0xc4, 0x88, 0x1d, 0x13, 0x16, - 0x70, 0x04, 0x54, 0xbe, 0xdf, 0x1f, 0x09, 0xbc, 0xa0, 0xf1, 0x96, 0x84, 0x53, 0x81, 0xaf, 0xea, - 0x39, 0x30, 0xc6, 0x8a, 0xf2, 0x5d, 0xad, 0x83, 0x56, 0x79, 0x2b, 0xfc, 0x85, 0x01, 0x96, 0x9d, - 0x7e, 0x12, 0xd9, 0x61, 0xc4, 0x02, 0xc7, 0xa7, 0xcf, 0x09, 0x5a, 0x50, 0x4e, 0x9e, 0x8e, 0x04, - 0x5e, 0x92, 0xcc, 0xc7, 0x39, 0x51, 0x64, 0xa0, 0x82, 0x7e, 0xd9, 0x9b, 0x83, 0x93, 0xaa, 0xfc, - 0xb5, 0x59, 0x55, 0xbb, 0xf0, 0x29, 0x58, 0x0a, 0x68, 0x68, 0x7b, 0x94, 0x1f, 0xda, 0x1d, 0x46, - 0x08, 0x5a, 0xdc, 0x32, 0xb6, 0x17, 0x76, 0x17, 0xf3, 0xb6, 0x3a, 0xa0, 0xcf, 0x49, 0x73, 0x3b, - 0xeb, 0xa0, 0x85, 0x80, 0x86, 0x7b, 0x94, 0x1f, 0xee, 0x33, 0x22, 0x23, 0x5a, 0x53, 0x11, 0x95, - 0x30, 0xd3, 0x2a, 0x2b, 0x60, 0x17, 0x80, 0xf1, 0x39, 0x8a, 0x96, 0x94, 0x61, 0x9c, 0x1b, 0xfe, - 0x51, 0xc1, 0x54, 0xbb, 0xf5, 0xcd, 0xcc, 0x57, 0x69, 0x6b, 0x2a, 0xf0, 0xaa, 0x72, 0x35, 0x86, - 0x4c, 0xab, 0xc4, 0xc3, 0xf7, 0xc1, 0x25, 0x37, 0x8a, 0x29, 0x61, 0x1c, 0x2d, 0xab, 0xc2, 0xfa, - 0x9a, 0x6c, 0xf7, 0x0c, 0x2a, 0x26, 0x75, 0xb6, 0xce, 0x4b, 0xc4, 0xca, 0x05, 0xf0, 0x1f, 0x06, - 0xb8, 0x2a, 0x4f, 0x70, 0xc2, 0xec, 0xc0, 0x39, 0xb6, 0x63, 0x12, 0x7a, 0x34, 0xec, 0xda, 0x87, - 0xb4, 0x8d, 0x56, 0x94, 0xb9, 0xdf, 0xcb, 0x3a, 0xbd, 0xdc, 0x52, 0x92, 0x87, 0xce, 0x71, 0x4b, - 0x0b, 0x1e, 0xd0, 0xe6, 0x48, 0xe0, 0xcb, 0xf1, 0x24, 0x9c, 0x0a, 0x7c, 0x5d, 0x8f, 0xc7, 0x49, - 0xae, 0x54, 0xa1, 0x53, 0xb7, 0x4e, 0x87, 0x4f, 0x86, 0x8d, 0x69, 0xfe, 0xad, 0x29, 0xda, 0xb6, - 0x4c, 0x47, 0xcf, 0xe1, 0x3d, 0x99, 0x8e, 0xd5, 0x71, 0x3a, 0x32, 0xa8, 0x48, 0x47, 0xb6, 0x1e, - 0xa7, 0x23, 0x03, 0xe0, 0x87, 0xe0, 0x82, 0xba, 0xcb, 0xa0, 0x35, 0x35, 0xb6, 0xd7, 0xf2, 0x37, - 0x26, 0xfd, 0x3f, 0x92, 0x44, 0x13, 0xc9, 0x63, 0x4c, 0x69, 0x52, 0x81, 0x17, 0x94, 0x35, 0xb5, - 0x32, 0x2d, 0x8d, 0xc2, 0x07, 0x60, 0x29, 0xeb, 0x1d, 0x8f, 0xf8, 0x24, 0x21, 0x08, 0xaa, 0xba, - 0x7e, 0x53, 0x9d, 0xdc, 0x8a, 0xd8, 0x53, 0x78, 0x2a, 0x30, 0x2c, 0x75, 0x8f, 0x06, 0x4d, 0xab, - 0xa2, 0x81, 0xc7, 0x00, 0xa9, 0x91, 0x1c, 0xb3, 0xa8, 0xcb, 0x08, 0xe7, 0xe5, 0xd9, 0x7c, 0x59, - 0x3d, 0x9f, 0x3c, 0x56, 0xd7, 0xa5, 0xa6, 0x95, 0x49, 0xca, 0x13, 0xfa, 0x86, 0x72, 0x30, 0x95, - 0x2d, 0x9e, 0x7d, 0xfa, 0x66, 0x78, 0x00, 0x96, 0xb3, 0xba, 0x88, 0x9d, 0x3e, 0x27, 0x36, 0x47, - 0x57, 0x94, 0xbf, 0x9b, 0xf2, 0x39, 0x34, 0xd3, 0x92, 0xc4, 0x41, 0xf1, 0x1c, 0x65, 0xb0, 0xb0, - 0x5e, 0x91, 0x42, 0x02, 0x96, 0x64, 0x95, 0xc9, 0xa4, 0xfa, 0xd4, 0x4d, 0x38, 0x5a, 0x57, 0x36, - 0xbf, 0x23, 0x6d, 0x06, 0xce, 0xf1, 0xbd, 0x1c, 0x4f, 0x05, 0xc6, 0xba, 0xc1, 0x4a, 0x60, 0xa9, - 0xd9, 0x6f, 0xde, 0xc9, 0x1d, 0xc8, 0xa1, 0x76, 0xf3, 0x8e, 0x55, 0xd9, 0x0d, 0x3d, 0x70, 0xc5, - 0xa3, 0x5c, 0x0e, 0x61, 0x9b, 0xc7, 0x0e, 0xe3, 0xc4, 0x56, 0x47, 0x3b, 0xba, 0xaa, 0xde, 0xc4, - 0xee, 0x48, 0x60, 0x98, 0xf1, 0x07, 0x8a, 0x56, 0x97, 0x86, 0x54, 0x60, 0xa4, 0x8f, 0xc6, 0x09, - 0xca, 0xb4, 0xa6, 0xe8, 0xcb, 0x5e, 0x12, 0x12, 0xc4, 0x36, 0x0d, 0x3d, 0x72, 0x4c, 0x38, 0xba, - 0x36, 0xe1, 0xe5, 0x31, 0x09, 0xe2, 0xfb, 0x9a, 0xad, 0x7b, 0x29, 0x51, 0x63, 0x2f, 0x25, 0x10, - 0xee, 0x82, 0x8b, 0xea, 0x05, 0x78, 0x08, 0x29, 0xbb, 0x1b, 0x23, 0x81, 0x33, 0xa4, 0x38, 0xcc, - 0xf5, 0xd2, 0xb4, 0x32, 0x1c, 0x26, 0xe0, 0xda, 0x11, 0x71, 0x0e, 0x6d, 0x59, 0xd5, 0x76, 0xd2, - 0x63, 0x84, 0xf7, 0x22, 0xdf, 0xb3, 0x63, 0x37, 0x41, 0xd7, 0x55, 0xc2, 0xe5, 0x24, 0xbf, 0x22, - 0x25, 0xdf, 0x73, 0x78, 0xef, 0x71, 0x2e, 0x68, 0xb9, 0x49, 0x2a, 0xf0, 0x86, 0x32, 0x39, 0x8d, - 0x2c, 0x5e, 0xea, 0xd4, 0xad, 0xf0, 0x1e, 0x58, 0x08, 0x1c, 0x76, 0x48, 0x98, 0x1d, 0x3a, 0x01, - 0x41, 0x1b, 0xea, 0xda, 0x64, 0xca, 0x71, 0xa6, 0xe1, 0x8f, 0x9d, 0x80, 0x14, 0xe3, 0x6c, 0x0c, - 0x99, 0x56, 0x89, 0x87, 0x03, 0xb0, 0x21, 0x3f, 0x12, 0xec, 0xe8, 0x28, 0x24, 0x8c, 0xf7, 0x68, - 0x6c, 0x77, 0x58, 0x14, 0xd8, 0xb1, 0xc3, 0x48, 0x98, 0xa0, 0x1b, 0x2a, 0x05, 0xef, 0x8d, 0x04, - 0xbe, 0x26, 0x55, 0x8f, 0x72, 0xd1, 0x3e, 0x8b, 0x82, 0x96, 0x92, 0xa4, 0x02, 0xbf, 0x9e, 0x4f, - 0xbc, 0x69, 0xbc, 0x69, 0x7d, 0xd9, 0x4e, 0xf8, 0x4b, 0x03, 0xac, 0x05, 0x91, 0x67, 0x27, 0x34, - 0x20, 0xf6, 0x11, 0x0d, 0xbd, 0xe8, 0xc8, 0xe6, 0xe8, 0x35, 0x95, 0xb0, 0x9f, 0x9c, 0x09, 0xbc, - 0x66, 0x39, 0x47, 0x0f, 0x23, 0xef, 0x31, 0x0d, 0xc8, 0x13, 0xc5, 0xca, 0xe3, 0x7a, 0x39, 0xa8, - 0x20, 0xc5, 0xe5, 0xb2, 0x0a, 0xe7, 0x99, 0x3b, 0x19, 0x36, 0x26, 0xad, 0x58, 0x35, 0x1b, 0xf0, - 0x85, 0x01, 0xd6, 0xb3, 0x36, 0x71, 0xfb, 0x4c, 0xc6, 0x66, 0x1f, 0x31, 0x9a, 0x10, 0x8e, 0x5e, - 0x57, 0xc1, 0xfc, 0x40, 0x8e, 0x5e, 0x5d, 0xf0, 0x19, 0xff, 0x44, 0xd1, 0xa9, 0xc0, 0x5f, 0x2f, - 0x75, 0x4d, 0x85, 0x2b, 0x35, 0xcf, 0x6e, 0xa9, 0x77, 0x8c, 0x5d, 0x6b, 0x9a, 0x25, 0x39, 0xc4, - 0xf2, 0xda, 0xee, 0xc8, 0x2f, 0x12, 0xb4, 0x39, 0x1e, 0x62, 0x19, 0xb1, 0x2f, 0xf1, 0xa2, 0xf9, - 0xcb, 0xa0, 0x69, 0x55, 0x34, 0xd0, 0x07, 0xab, 0xea, 0x4b, 0xd1, 0x96, 0xb3, 0xc0, 0xd6, 0xf3, - 0x15, 0xab, 0xf9, 0x7a, 0x35, 0x9f, 0xaf, 0x4d, 0xc9, 0x8f, 0x87, 0xac, 0xba, 0xb6, 0xb7, 0x2b, - 0x58, 0x91, 0xd9, 0x2a, 0x6c, 0x5a, 0x35, 0x1d, 0xfc, 0xd4, 0x00, 0x6b, 0xaa, 0x84, 0xd4, 0x87, - 0xa6, 0xad, 0xbf, 0x34, 0xd1, 0x96, 0xf2, 0x77, 0x59, 0x7e, 0x22, 0xdc, 0x8b, 0xe2, 0x81, 0x25, - 0xb9, 0x87, 0x8a, 0x6a, 0x3e, 0x90, 0xb7, 0x2e, 0xb7, 0x0a, 0xa6, 0x02, 0x6f, 0x17, 0x65, 0x54, - 0xc2, 0x4b, 0x69, 0xe4, 0x89, 0x13, 0x7a, 0x0e, 0xf3, 0xcc, 0x57, 0xa7, 0x8d, 0xb9, 0x7c, 0x61, - 0xd5, 0x0d, 0xc1, 0x3f, 0xc9, 0x70, 0x1c, 0x39, 0x40, 0x49, 0xc8, 0x69, 0x42, 0x9f, 0xc9, 0x8c, - 0xa2, 0x37, 0x54, 0x3a, 0x8f, 0xe5, 0x15, 0xf0, 0x9e, 0xc3, 0xc9, 0x41, 0xce, 0xed, 0xab, 0x2b, - 0xa0, 0x5b, 0x85, 0x52, 0x81, 0xd7, 0x75, 0x30, 0x55, 0x5c, 0x5e, 0x77, 0x26, 0xb4, 0x93, 0x90, - 0xbc, 0xf1, 0xd5, 0x9c, 0x58, 0x35, 0x0d, 0x87, 0x7f, 0x34, 0xc0, 0x6a, 0x27, 0xf2, 0xfd, 0xe8, - 0xc8, 0xfe, 0xa4, 0x1f, 0xba, 0xf2, 0x3a, 0xc2, 0x91, 0x39, 0x8e, 0xf2, 0xfb, 0x39, 0xf8, 0x21, - 0xdf, 0xa3, 0x8c, 0xcb, 0x28, 0x3f, 0xa9, 0x42, 0x45, 0x94, 0x35, 0x5c, 0x45, 0x59, 0xd7, 0x4e, - 0x42, 0x32, 0xca, 0x9a, 0x13, 0x6b, 0x45, 0x47, 0x54, 0xc0, 0xf0, 0x10, 0xcc, 0x33, 0xe2, 0x78, - 0x76, 0x14, 0xfa, 0x03, 0xf4, 0x97, 0x7d, 0x15, 0xde, 0xc3, 0x33, 0x81, 0xe1, 0x1e, 0x89, 0x19, - 0x71, 0x9d, 0x84, 0x78, 0x16, 0x71, 0xbc, 0x47, 0xa1, 0x3f, 0x18, 0x09, 0x6c, 0xdc, 0x2c, 0xbe, - 0x8e, 0x59, 0xa4, 0x6e, 0x82, 0xef, 0x44, 0x01, 0x95, 0xb3, 0x3a, 0x19, 0xa8, 0xaf, 0xe3, 0x09, - 0x14, 0x19, 0xd6, 0x1c, 0xcb, 0x0c, 0xc0, 0x9f, 0x83, 0xb5, 0xca, 0xf5, 0x50, 0xcd, 0xcf, 0xbf, - 0x4a, 0xa7, 0x46, 0xf3, 0xa3, 0x33, 0x81, 0xd1, 0xd8, 0xe9, 0xc3, 0xf1, 0xcd, 0xaf, 0xe5, 0x26, - 0xb9, 0xeb, 0xcd, 0xfa, 0x1d, 0xb1, 0xe5, 0x26, 0xa5, 0x08, 0x90, 0x61, 0x2d, 0x57, 0x49, 0xf8, - 0x63, 0x70, 0x49, 0x9f, 0x97, 0x1c, 0x7d, 0xb6, 0xaf, 0x7a, 0xfd, 0x03, 0x39, 0x78, 0xc6, 0x8e, - 0xf4, 0x3d, 0x88, 0x57, 0x1f, 0x2e, 0xdb, 0x52, 0x32, 0x9d, 0x35, 0x38, 0x32, 0xac, 0xdc, 0x5e, - 0xf3, 0xbb, 0x9f, 0x7f, 0xb1, 0x39, 0x33, 0xfc, 0x62, 0x73, 0xe6, 0xdf, 0x67, 0x9b, 0x33, 0xbf, - 0x7d, 0xb9, 0x39, 0xf3, 0x87, 0x97, 0x9b, 0xc6, 0xf0, 0xe5, 0xe6, 0xcc, 0x3f, 0x5f, 0x6e, 0xce, - 0x3c, 0x7d, 0xeb, 0xff, 0xf8, 0x2f, 0x42, 0xb7, 0x6a, 0xfb, 0xa2, 0xfa, 0x4f, 0xe2, 0xdd, 0xff, - 0x06, 0x00, 0x00, 0xff, 0xff, 0xe9, 0xb3, 0xf1, 0x6d, 0xb1, 0x12, 0x00, 0x00, + // 1983 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x58, 0xcd, 0x6f, 0x1c, 0x49, + 0x15, 0x77, 0x3b, 0x5f, 0x76, 0xf9, 0xbb, 0x12, 0x27, 0x15, 0x67, 0xd7, 0xe5, 0x6d, 0x86, 0xc5, + 0xbb, 0xda, 0x38, 0x89, 0x17, 0x71, 0x88, 0x76, 0x17, 0x76, 0xe2, 0xb5, 0x08, 0x21, 0x9b, 0x51, + 0x3b, 0x10, 0x11, 0x90, 0x9a, 0x9e, 0xee, 0x9a, 0x99, 0x5a, 0xf7, 0x17, 0x55, 0x3d, 0xb1, 0x27, + 0xa7, 0x70, 0x41, 0x20, 0xf6, 0x80, 0xcc, 0x81, 0x2b, 0x12, 0x08, 0xc1, 0xfe, 0x03, 0x48, 0xfc, + 0x05, 0xb9, 0x20, 0xcf, 0x11, 0x71, 0x28, 0x69, 0x9d, 0xdb, 0xdc, 0xe8, 0x63, 0x4e, 0xa8, 0xaa, + 0xba, 0x7b, 0xba, 0x7b, 0x66, 0x11, 0xd2, 0xde, 0xa6, 0x7e, 0xbf, 0x5f, 0xbd, 0xf7, 0xfa, 0xf5, + 0x7b, 0xaf, 0xaa, 0x07, 0x34, 0x7c, 0xda, 0xbe, 0xe5, 0x46, 0x61, 0x87, 0x76, 0x6f, 0x75, 0x22, + 0xdf, 0x23, 0x4c, 0x2f, 0xfa, 0xcc, 0x49, 0x68, 0x14, 0xee, 0xc4, 0x2c, 0x4a, 0x22, 0x78, 0x51, + 0x83, 0x1b, 0x37, 0x26, 0xd4, 0xc9, 0x20, 0x26, 0x5a, 0xb4, 0xb1, 0x5e, 0x22, 0x39, 0x7d, 0x9e, + 0xc3, 0x1b, 0x25, 0x38, 0xee, 0xfb, 0x7e, 0xc4, 0x3c, 0xc2, 0x32, 0x6e, 0xbb, 0xc4, 0x3d, 0x23, + 0x8c, 0xd3, 0x28, 0xa4, 0x61, 0x77, 0x4a, 0x04, 0x1b, 0xb8, 0xa4, 0x6c, 0xfb, 0x91, 0x7b, 0x58, + 0x37, 0x05, 0xa5, 0xa0, 0xc3, 0x6f, 0xc9, 0x80, 0x78, 0x86, 0xbd, 0x91, 0x61, 0x6e, 0x14, 0x0f, + 0x98, 0x13, 0x76, 0x49, 0x40, 0x92, 0x5e, 0xe4, 0x65, 0xec, 0x3c, 0x39, 0x4e, 0xf4, 0x4f, 0xf3, + 0x3f, 0xb3, 0xe0, 0xfa, 0xbe, 0x7a, 0x9e, 0x3d, 0xf2, 0x8c, 0xba, 0xe4, 0x5e, 0x39, 0x02, 0xf8, + 0x85, 0x01, 0xe6, 0x3d, 0x85, 0xdb, 0xd4, 0x43, 0xc6, 0x96, 0xb1, 0xbd, 0xd8, 0xfc, 0xdc, 0x78, + 0x29, 0xf0, 0xcc, 0xbf, 0x05, 0xfe, 0x76, 0x97, 0x26, 0xbd, 0x7e, 0x7b, 0xc7, 0x8d, 0x82, 0x5b, + 0x7c, 0x10, 0xba, 0x49, 0x8f, 0x86, 0xdd, 0xd2, 0x2f, 0x19, 0x82, 0x72, 0xe2, 0x46, 0xfe, 0x8e, + 0xb6, 0x7e, 0x7f, 0xef, 0x4c, 0xe0, 0xb9, 0xfc, 0xf7, 0x48, 0xe0, 0x39, 0x2f, 0xfb, 0x9d, 0x0a, + 0xbc, 0x74, 0x1c, 0xf8, 0x77, 0x4d, 0xea, 0xbd, 0xe7, 0x24, 0x09, 0x33, 0x47, 0xa7, 0x8d, 0x4b, + 0xd9, 0xef, 0xf4, 0xb4, 0x51, 0xe8, 0x7e, 0x3d, 0x6c, 0x18, 0x27, 0xc3, 0x46, 0x61, 0xc3, 0xca, + 0x19, 0x0f, 0xfe, 0xc5, 0x00, 0x4b, 0x34, 0x4c, 0x58, 0xe4, 0xf5, 0x5d, 0xe2, 0xd9, 0xed, 0x01, + 0x9a, 0x55, 0x01, 0xbf, 0xf8, 0x5a, 0x01, 0x8f, 0x04, 0x5e, 0x1c, 0x5b, 0x6d, 0x0e, 0x52, 0x81, + 0xaf, 0xe9, 0x40, 0x4b, 0x60, 0x11, 0xf2, 0xda, 0x04, 0x2a, 0x03, 0xb6, 0x2a, 0x16, 0xcc, 0x57, + 0x18, 0x5c, 0xd6, 0x39, 0xaf, 0x66, 0xfb, 0x23, 0x30, 0x9b, 0x65, 0x79, 0xbe, 0xb9, 0x73, 0x26, + 0xf0, 0xac, 0xf2, 0x3e, 0x4b, 0xbd, 0xff, 0x95, 0x9c, 0x93, 0x61, 0x63, 0xf6, 0xfe, 0x9e, 0x35, + 0x4b, 0x3d, 0xf8, 0x23, 0x70, 0xc1, 0x77, 0xda, 0xc4, 0x57, 0xcf, 0x3d, 0xdf, 0xfc, 0xee, 0x48, + 0x60, 0x0d, 0xa4, 0x02, 0x6f, 0xa9, 0xfd, 0x6a, 0xa5, 0x4d, 0x6c, 0x31, 0xc2, 0x13, 0x87, 0x25, + 0x77, 0xcd, 0x8e, 0xe3, 0x73, 0x22, 0x4d, 0x82, 0x31, 0xfd, 0x62, 0xd8, 0x98, 0xb1, 0xf4, 0x66, + 0xd8, 0x05, 0x2b, 0x1d, 0xea, 0x13, 0x3e, 0xe0, 0x09, 0x09, 0x6c, 0x59, 0x65, 0xe8, 0xdc, 0x96, + 0xb1, 0xbd, 0xbc, 0x0b, 0x77, 0x3a, 0x7c, 0x67, 0xbf, 0xa0, 0x1e, 0x0f, 0x62, 0xd2, 0x7c, 0x77, + 0x24, 0xf0, 0x72, 0xa7, 0x82, 0xa5, 0x02, 0x5f, 0x51, 0xde, 0xab, 0xb0, 0x69, 0xd5, 0x74, 0xf0, + 0x03, 0x70, 0x3e, 0x76, 0x92, 0x1e, 0x3a, 0xaf, 0xc2, 0xdf, 0x1e, 0x09, 0xac, 0xd6, 0xa9, 0xc0, + 0x2b, 0x6a, 0xbf, 0x5c, 0x14, 0xcf, 0x3f, 0x5f, 0xac, 0x2c, 0xa5, 0x82, 0x2d, 0x70, 0x5e, 0xc5, + 0x76, 0x21, 0x8b, 0x4d, 0xb7, 0xcc, 0x8e, 0x4e, 0xb4, 0x8a, 0x4d, 0x59, 0x4c, 0x74, 0x44, 0xda, + 0xa2, 0x5c, 0x8c, 0x2d, 0x16, 0x2b, 0x4b, 0xa9, 0xe0, 0xcf, 0xc0, 0x25, 0x5d, 0x5c, 0x1c, 0x5d, + 0xdc, 0x3a, 0xb7, 0xbd, 0xb0, 0xfb, 0x56, 0xd5, 0xe8, 0x94, 0x8e, 0x69, 0x62, 0x59, 0x6b, 0x23, + 0x81, 0xf3, 0x9d, 0xa9, 0xc0, 0x8b, 0xca, 0x95, 0x5e, 0x9b, 0x56, 0x4e, 0xc0, 0xdf, 0x1b, 0x60, + 0x8d, 0x11, 0xee, 0x3a, 0xa1, 0x4d, 0xc3, 0x84, 0xb0, 0x67, 0x8e, 0x6f, 0x73, 0x74, 0x69, 0xcb, + 0xd8, 0xbe, 0xd0, 0xec, 0x8e, 0x04, 0x5e, 0xd1, 0xe4, 0xfd, 0x8c, 0x3b, 0x48, 0x05, 0x7e, 0x47, + 0x59, 0xaa, 0xe1, 0xd9, 0xeb, 0xf4, 0x48, 0xc7, 0xe9, 0xfb, 0xc9, 0x5d, 0xf3, 0xfd, 0xef, 0xdc, + 0xbe, 0x6d, 0xbe, 0x16, 0xf8, 0x1c, 0x0d, 0x93, 0xd1, 0x69, 0xe3, 0xca, 0x34, 0xf9, 0xeb, 0xd3, + 0xc6, 0x79, 0xa9, 0xb3, 0xea, 0x4e, 0xe0, 0x3f, 0x0c, 0x00, 0x3b, 0xdc, 0x3e, 0x72, 0x12, 0xb7, + 0x47, 0x98, 0x4d, 0x42, 0xa7, 0xed, 0x13, 0x0f, 0xcd, 0x6d, 0x19, 0xdb, 0x73, 0xcd, 0xdf, 0x1a, + 0x67, 0x02, 0xaf, 0xee, 0x1f, 0x3c, 0xd1, 0xec, 0x27, 0x9a, 0x1c, 0x09, 0xbc, 0xda, 0xe1, 0x55, + 0x2c, 0x15, 0xf8, 0x5d, 0xfd, 0xce, 0x6b, 0x44, 0x3d, 0xda, 0x84, 0xf5, 0x55, 0xed, 0xad, 0x4f, + 0x15, 0xca, 0x38, 0xa5, 0xe2, 0x64, 0xd8, 0x98, 0x70, 0x6b, 0x4d, 0x38, 0x85, 0x7f, 0xaf, 0x06, + 0xef, 0x11, 0xdf, 0x19, 0xd8, 0x1c, 0xcd, 0xab, 0x9c, 0xfe, 0x46, 0x06, 0xbf, 0x52, 0x58, 0xd9, + 0x93, 0xe4, 0x81, 0xcc, 0x73, 0x61, 0x46, 0x43, 0xa9, 0xc0, 0xdf, 0xaa, 0x86, 0xae, 0xf1, 0x7a, + 0xe4, 0x77, 0x2a, 0x59, 0x9e, 0x26, 0x7e, 0x7d, 0xda, 0x98, 0xbd, 0x73, 0xfb, 0x64, 0xd8, 0xa8, + 0x7b, 0xb5, 0xea, 0x3e, 0xe1, 0xcf, 0xc1, 0x22, 0xed, 0x86, 0x11, 0x23, 0x76, 0x4c, 0x58, 0xc0, + 0x11, 0x50, 0xf9, 0xfe, 0x70, 0x24, 0xf0, 0x82, 0xc6, 0x5b, 0x12, 0x4e, 0x05, 0xbe, 0xaa, 0xe7, + 0xc0, 0x18, 0x2b, 0xca, 0x77, 0xb5, 0x0e, 0x5a, 0xe5, 0xad, 0xf0, 0x97, 0x06, 0x58, 0x76, 0xfa, + 0x49, 0x64, 0x87, 0x11, 0x0b, 0x1c, 0x9f, 0x3e, 0x27, 0x68, 0x41, 0x39, 0x79, 0x3a, 0x12, 0x78, + 0x49, 0x32, 0x9f, 0xe6, 0x44, 0x91, 0x81, 0x0a, 0xfa, 0x55, 0x6f, 0x0e, 0x4e, 0xaa, 0xf2, 0xd7, + 0x66, 0x55, 0xed, 0xc2, 0xa7, 0x60, 0x29, 0xa0, 0xa1, 0xed, 0x51, 0x7e, 0x68, 0x77, 0x18, 0x21, + 0x68, 0x71, 0xcb, 0xd8, 0x5e, 0xd8, 0x5d, 0xcc, 0xdb, 0xea, 0x80, 0x3e, 0x27, 0xcd, 0xed, 0xac, + 0x83, 0x16, 0x02, 0x1a, 0xee, 0x51, 0x7e, 0xb8, 0xcf, 0x88, 0x8c, 0x68, 0x4d, 0x45, 0x54, 0xc2, + 0x4c, 0xab, 0xac, 0x80, 0x5d, 0x00, 0xc6, 0xe7, 0x28, 0x5a, 0x52, 0x86, 0x71, 0x6e, 0xf8, 0xc7, + 0x05, 0x53, 0xed, 0xd6, 0xb7, 0x33, 0x5f, 0xa5, 0xad, 0xa9, 0xc0, 0xab, 0xca, 0xd5, 0x18, 0x32, + 0xad, 0x12, 0x0f, 0x3f, 0x04, 0x97, 0xdc, 0x28, 0xa6, 0x84, 0x71, 0xb4, 0xac, 0x0a, 0xeb, 0x1b, + 0xb2, 0xdd, 0x33, 0xa8, 0x98, 0xd4, 0xd9, 0x3a, 0x2f, 0x11, 0x2b, 0x17, 0xc0, 0x7f, 0x1a, 0xe0, + 0xaa, 0x3c, 0xc1, 0x09, 0xb3, 0x03, 0xe7, 0xd8, 0x8e, 0x49, 0xe8, 0xd1, 0xb0, 0x6b, 0x1f, 0xd2, + 0x36, 0x5a, 0x51, 0xe6, 0xfe, 0x20, 0xeb, 0xf4, 0x72, 0x4b, 0x49, 0x1e, 0x3a, 0xc7, 0x2d, 0x2d, + 0x78, 0x40, 0x9b, 0x23, 0x81, 0x2f, 0xc7, 0x93, 0x70, 0x2a, 0xf0, 0x75, 0x3d, 0x1e, 0x27, 0xb9, + 0x52, 0x85, 0x4e, 0xdd, 0x3a, 0x1d, 0x3e, 0x19, 0x36, 0xa6, 0xf9, 0xb7, 0xa6, 0x68, 0xdb, 0x32, + 0x1d, 0x3d, 0x87, 0xf7, 0x64, 0x3a, 0x56, 0xc7, 0xe9, 0xc8, 0xa0, 0x22, 0x1d, 0xd9, 0x7a, 0x9c, + 0x8e, 0x0c, 0x80, 0x1f, 0x83, 0x0b, 0xea, 0x2e, 0x83, 0xd6, 0xd4, 0xd8, 0x5e, 0xcb, 0xdf, 0x98, + 0xf4, 0xff, 0x48, 0x12, 0x4d, 0x24, 0x8f, 0x31, 0xa5, 0x49, 0x05, 0x5e, 0x50, 0xd6, 0xd4, 0xca, + 0xb4, 0x34, 0x0a, 0x1f, 0x80, 0xa5, 0xac, 0x77, 0x3c, 0xe2, 0x93, 0x84, 0x20, 0xa8, 0xea, 0xfa, + 0x6d, 0x75, 0x72, 0x2b, 0x62, 0x4f, 0xe1, 0xa9, 0xc0, 0xb0, 0xd4, 0x3d, 0x1a, 0x34, 0xad, 0x8a, + 0x06, 0x1e, 0x03, 0xa4, 0x46, 0x72, 0xcc, 0xa2, 0x2e, 0x23, 0x9c, 0x97, 0x67, 0xf3, 0x65, 0xf5, + 0x7c, 0xf2, 0x58, 0x5d, 0x97, 0x9a, 0x56, 0x26, 0x29, 0x4f, 0xe8, 0x1b, 0xca, 0xc1, 0x54, 0xb6, + 0x78, 0xf6, 0xe9, 0x9b, 0xe1, 0x01, 0x58, 0xce, 0xea, 0x22, 0x76, 0xfa, 0x9c, 0xd8, 0x1c, 0x5d, + 0x51, 0xfe, 0x6e, 0xca, 0xe7, 0xd0, 0x4c, 0x4b, 0x12, 0x07, 0xc5, 0x73, 0x94, 0xc1, 0xc2, 0x7a, + 0x45, 0x0a, 0x09, 0x58, 0x92, 0x55, 0x26, 0x93, 0xea, 0x53, 0x37, 0xe1, 0x68, 0x5d, 0xd9, 0xfc, + 0x9e, 0xb4, 0x19, 0x38, 0xc7, 0xf7, 0x72, 0x3c, 0x15, 0x18, 0xeb, 0x06, 0x2b, 0x81, 0xa5, 0x66, + 0xbf, 0x79, 0x27, 0x77, 0x20, 0x87, 0xda, 0xcd, 0x3b, 0x56, 0x65, 0x37, 0xf4, 0xc0, 0x15, 0x8f, + 0x72, 0x39, 0x84, 0x6d, 0x1e, 0x3b, 0x8c, 0x13, 0x5b, 0x1d, 0xed, 0xe8, 0xaa, 0x7a, 0x13, 0xbb, + 0x23, 0x81, 0x61, 0xc6, 0x1f, 0x28, 0x5a, 0x5d, 0x1a, 0x52, 0x81, 0x91, 0x3e, 0x1a, 0x27, 0x28, + 0xd3, 0x9a, 0xa2, 0x2f, 0x7b, 0x49, 0x48, 0x10, 0xdb, 0x34, 0xf4, 0xc8, 0x31, 0xe1, 0xe8, 0xda, + 0x84, 0x97, 0xc7, 0x24, 0x88, 0xef, 0x6b, 0xb6, 0xee, 0xa5, 0x44, 0x8d, 0xbd, 0x94, 0x40, 0xb8, + 0x0b, 0x2e, 0xaa, 0x17, 0xe0, 0x21, 0xa4, 0xec, 0x6e, 0x8c, 0x04, 0xce, 0x90, 0xe2, 0x30, 0xd7, + 0x4b, 0xd3, 0xca, 0x70, 0x98, 0x80, 0x6b, 0x47, 0xc4, 0x39, 0xb4, 0x65, 0x55, 0xdb, 0x49, 0x8f, + 0x11, 0xde, 0x8b, 0x7c, 0xcf, 0x8e, 0xdd, 0x04, 0x5d, 0x57, 0x09, 0x97, 0x93, 0xfc, 0x8a, 0x94, + 0x7c, 0xdf, 0xe1, 0xbd, 0xc7, 0xb9, 0xa0, 0xe5, 0x26, 0xa9, 0xc0, 0x1b, 0xca, 0xe4, 0x34, 0xb2, + 0x78, 0xa9, 0x53, 0xb7, 0xc2, 0x7b, 0x60, 0x21, 0x70, 0xd8, 0x21, 0x61, 0x76, 0xe8, 0x04, 0x04, + 0x6d, 0xa8, 0x6b, 0x93, 0x29, 0xc7, 0x99, 0x86, 0x3f, 0x75, 0x02, 0x52, 0x8c, 0xb3, 0x31, 0x64, + 0x5a, 0x25, 0x1e, 0x0e, 0xc0, 0x86, 0xfc, 0x48, 0xb0, 0xa3, 0xa3, 0x90, 0x30, 0xde, 0xa3, 0xb1, + 0xdd, 0x61, 0x51, 0x60, 0xc7, 0x0e, 0x23, 0x61, 0x82, 0x6e, 0xa8, 0x14, 0x7c, 0x30, 0x12, 0xf8, + 0x9a, 0x54, 0x3d, 0xca, 0x45, 0xfb, 0x2c, 0x0a, 0x5a, 0x4a, 0x92, 0x0a, 0xfc, 0x66, 0x3e, 0xf1, + 0xa6, 0xf1, 0xa6, 0xf5, 0x55, 0x3b, 0xe1, 0xaf, 0x0c, 0xb0, 0x16, 0x44, 0x9e, 0x9d, 0xd0, 0x80, + 0xd8, 0x47, 0x34, 0xf4, 0xa2, 0x23, 0x9b, 0xa3, 0x37, 0x54, 0xc2, 0x7e, 0x7a, 0x26, 0xf0, 0x9a, + 0xe5, 0x1c, 0x3d, 0x8c, 0xbc, 0xc7, 0x34, 0x20, 0x4f, 0x14, 0x2b, 0x8f, 0xeb, 0xe5, 0xa0, 0x82, + 0x14, 0x97, 0xcb, 0x2a, 0x9c, 0x67, 0xee, 0x64, 0xd8, 0x98, 0xb4, 0x62, 0xd5, 0x6c, 0xc0, 0x17, + 0x06, 0x58, 0xcf, 0xda, 0xc4, 0xed, 0x33, 0x19, 0x9b, 0x7d, 0xc4, 0x68, 0x42, 0x38, 0x7a, 0x53, + 0x05, 0xf3, 0x43, 0x39, 0x7a, 0x75, 0xc1, 0x67, 0xfc, 0x13, 0x45, 0xa7, 0x02, 0x7f, 0xb3, 0xd4, + 0x35, 0x15, 0xae, 0xd4, 0x3c, 0xbb, 0xa5, 0xde, 0x31, 0x76, 0xad, 0x69, 0x96, 0xe4, 0x10, 0xcb, + 0x6b, 0xbb, 0x23, 0xbf, 0x48, 0xd0, 0xe6, 0x78, 0x88, 0x65, 0xc4, 0xbe, 0xc4, 0x8b, 0xe6, 0x2f, + 0x83, 0xa6, 0x55, 0xd1, 0x40, 0x1f, 0xac, 0xaa, 0x2f, 0x45, 0x5b, 0xce, 0x02, 0x5b, 0xcf, 0x57, + 0xac, 0xe6, 0xeb, 0xd5, 0x7c, 0xbe, 0x36, 0x25, 0x3f, 0x1e, 0xb2, 0xea, 0xda, 0xde, 0xae, 0x60, + 0x45, 0x66, 0xab, 0xb0, 0x69, 0xd5, 0x74, 0xf0, 0x73, 0x03, 0xac, 0xa9, 0x12, 0x52, 0x1f, 0x9a, + 0xb6, 0xfe, 0xd2, 0x44, 0x5b, 0xca, 0xdf, 0x65, 0xf9, 0x89, 0x70, 0x2f, 0x8a, 0x07, 0x96, 0xe4, + 0x1e, 0x2a, 0xaa, 0xf9, 0x40, 0xde, 0xba, 0xdc, 0x2a, 0x98, 0x0a, 0xbc, 0x5d, 0x94, 0x51, 0x09, + 0x2f, 0xa5, 0x91, 0x27, 0x4e, 0xe8, 0x39, 0xcc, 0x33, 0x5f, 0x9f, 0x36, 0xe6, 0xf2, 0x85, 0x55, + 0x37, 0x04, 0xff, 0x2c, 0xc3, 0x71, 0xe4, 0x00, 0x25, 0x21, 0xa7, 0x09, 0x7d, 0x26, 0x33, 0x8a, + 0xde, 0x52, 0xe9, 0x3c, 0x96, 0x57, 0xc0, 0x7b, 0x0e, 0x27, 0x07, 0x39, 0xb7, 0xaf, 0xae, 0x80, + 0x6e, 0x15, 0x4a, 0x05, 0x5e, 0xd7, 0xc1, 0x54, 0x71, 0x79, 0xdd, 0x99, 0xd0, 0x4e, 0x42, 0xf2, + 0xc6, 0x57, 0x73, 0x62, 0xd5, 0x34, 0x1c, 0xfe, 0xc9, 0x00, 0xab, 0x9d, 0xc8, 0xf7, 0xa3, 0x23, + 0xfb, 0xb3, 0x7e, 0xe8, 0xca, 0xeb, 0x08, 0x47, 0xe6, 0x38, 0xca, 0x1f, 0xe4, 0xe0, 0xc7, 0x7c, + 0x8f, 0x32, 0x2e, 0xa3, 0xfc, 0xac, 0x0a, 0x15, 0x51, 0xd6, 0x70, 0x15, 0x65, 0x5d, 0x3b, 0x09, + 0xc9, 0x28, 0x6b, 0x4e, 0xac, 0x15, 0x1d, 0x51, 0x01, 0xc3, 0x43, 0x30, 0xcf, 0x88, 0xe3, 0xd9, + 0x51, 0xe8, 0x0f, 0xd0, 0x5f, 0xf7, 0x55, 0x78, 0x0f, 0xcf, 0x04, 0x86, 0x7b, 0x24, 0x66, 0xc4, + 0x75, 0x12, 0xe2, 0x59, 0xc4, 0xf1, 0x1e, 0x85, 0xfe, 0x60, 0x24, 0xb0, 0x71, 0xb3, 0xf8, 0x3a, + 0x66, 0x91, 0xba, 0x09, 0xbe, 0x17, 0x05, 0x54, 0xce, 0xea, 0x64, 0xa0, 0xbe, 0x8e, 0x27, 0x50, + 0x64, 0x58, 0x73, 0x2c, 0x33, 0x00, 0x7f, 0x01, 0xd6, 0x2a, 0xd7, 0x43, 0x35, 0x3f, 0xff, 0x26, + 0x9d, 0x1a, 0xcd, 0x4f, 0xce, 0x04, 0x46, 0x63, 0xa7, 0x0f, 0xc7, 0x37, 0xbf, 0x96, 0x9b, 0xe4, + 0xae, 0x37, 0xeb, 0x77, 0xc4, 0x96, 0x9b, 0x94, 0x22, 0x40, 0x86, 0xb5, 0x5c, 0x25, 0xe1, 0x4f, + 0xc0, 0x25, 0x7d, 0x5e, 0x72, 0xf4, 0xc5, 0xbe, 0xea, 0xf5, 0x8f, 0xe4, 0xe0, 0x19, 0x3b, 0xd2, + 0xf7, 0x20, 0x5e, 0x7d, 0xb8, 0x6c, 0x4b, 0xc9, 0x74, 0xd6, 0xe0, 0xc8, 0xb0, 0x72, 0x7b, 0xcd, + 0x07, 0x2f, 0xbf, 0xdc, 0x9c, 0x19, 0x7e, 0xb9, 0x39, 0xf3, 0xf2, 0x6c, 0xd3, 0x18, 0x9e, 0x6d, + 0x1a, 0xbf, 0x7b, 0xb5, 0x39, 0xf3, 0xc7, 0x57, 0x9b, 0xc6, 0xf0, 0xd5, 0xe6, 0xcc, 0xbf, 0x5e, + 0x6d, 0xce, 0x3c, 0x7d, 0xe7, 0xff, 0xf8, 0x3f, 0x42, 0xb7, 0x6b, 0xfb, 0xa2, 0xfa, 0x5f, 0xe2, + 0xfd, 0xff, 0x06, 0x00, 0x00, 0xff, 0xff, 0xde, 0x81, 0xf6, 0x5e, 0xb5, 0x12, 0x00, 0x00, } +func (m *FolderDeviceConfiguration) Marshal() (dAtA []byte, err error) { + size := m.ProtoSize() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *FolderDeviceConfiguration) MarshalTo(dAtA []byte) (int, error) { + size := m.ProtoSize() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *FolderDeviceConfiguration) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size := m.IntroducedBy.ProtoSize() + i -= size + if _, err := m.IntroducedBy.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintFolderconfiguration(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + { + size := m.DeviceID.ProtoSize() + i -= size + if _, err := m.DeviceID.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintFolderconfiguration(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *FolderConfiguration) Marshal() (dAtA []byte, err error) { + size := m.ProtoSize() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *FolderConfiguration) MarshalTo(dAtA []byte) (int, error) { + size := m.ProtoSize() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *FolderConfiguration) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.DeprecatedPullers != 0 { + i = encodeVarintFolderconfiguration(dAtA, i, uint64(m.DeprecatedPullers)) + i-- + dAtA[i] = 0x4 + i-- + dAtA[i] = 0xb2 + i-- + dAtA[i] = 0xd0 + } + if m.DeprecatedMinDiskFreePct != 0 { + i -= 8 + encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.DeprecatedMinDiskFreePct)))) + i-- + dAtA[i] = 0x4 + i-- + dAtA[i] = 0xb2 + i-- + dAtA[i] = 0xc9 + } + if m.DeprecatedReadOnly { + i-- + if m.DeprecatedReadOnly { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x4 + i-- + dAtA[i] = 0xb2 + i-- + dAtA[i] = 0xc0 + } + if m.JunctionsAsDirs { + i-- + if m.JunctionsAsDirs { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0x90 + } + if m.CaseSensitiveFS { + i-- + if m.CaseSensitiveFS { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0x88 + } + if m.CopyRangeMethod != 0 { + i = encodeVarintFolderconfiguration(dAtA, i, uint64(m.CopyRangeMethod)) + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0x80 + } + if m.BlockPullOrder != 0 { + i = encodeVarintFolderconfiguration(dAtA, i, uint64(m.BlockPullOrder)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xf8 + } + if m.DisableFsync { + i-- + if m.DisableFsync { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xf0 + } + if m.MaxConcurrentWrites != 0 { + i = encodeVarintFolderconfiguration(dAtA, i, uint64(m.MaxConcurrentWrites)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xe8 + } + if m.RawModTimeWindowS != 0 { + i = encodeVarintFolderconfiguration(dAtA, i, uint64(m.RawModTimeWindowS)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xe0 + } + if m.CopyOwnershipFromParent { + i-- + if m.CopyOwnershipFromParent { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xd8 + } + if len(m.MarkerName) > 0 { + i -= len(m.MarkerName) + copy(dAtA[i:], m.MarkerName) + i = encodeVarintFolderconfiguration(dAtA, i, uint64(len(m.MarkerName))) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xd2 + } + if m.WeakHashThresholdPct != 0 { + i = encodeVarintFolderconfiguration(dAtA, i, uint64(m.WeakHashThresholdPct)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xc8 + } + if m.Paused { + i-- + if m.Paused { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xc0 + } + if m.DisableTempIndexes { + i-- + if m.DisableTempIndexes { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xb8 + } + if m.DisableSparseFiles { + i-- + if m.DisableSparseFiles { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xb0 + } + if m.MaxConflicts != 0 { + i = encodeVarintFolderconfiguration(dAtA, i, uint64(m.MaxConflicts)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xa8 + } + if m.PullerPauseS != 0 { + i = encodeVarintFolderconfiguration(dAtA, i, uint64(m.PullerPauseS)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xa0 + } + if m.ScanProgressIntervalS != 0 { + i = encodeVarintFolderconfiguration(dAtA, i, uint64(m.ScanProgressIntervalS)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x98 + } + if m.IgnoreDelete { + i-- + if m.IgnoreDelete { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x90 + } + if m.Order != 0 { + i = encodeVarintFolderconfiguration(dAtA, i, uint64(m.Order)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x88 + } + if m.Hashers != 0 { + i = encodeVarintFolderconfiguration(dAtA, i, uint64(m.Hashers)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x80 + } + if m.PullerMaxPendingKiB != 0 { + i = encodeVarintFolderconfiguration(dAtA, i, uint64(m.PullerMaxPendingKiB)) + i-- + dAtA[i] = 0x78 + } + if m.Copiers != 0 { + i = encodeVarintFolderconfiguration(dAtA, i, uint64(m.Copiers)) + i-- + dAtA[i] = 0x70 + } + { + size, err := m.Versioning.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintFolderconfiguration(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x6a + { + size, err := m.MinDiskFree.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintFolderconfiguration(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x62 + if m.AutoNormalize { + i-- + if m.AutoNormalize { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x58 + } + if m.IgnorePerms { + i-- + if m.IgnorePerms { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x50 + } + if m.FSWatcherDelayS != 0 { + i = encodeVarintFolderconfiguration(dAtA, i, uint64(m.FSWatcherDelayS)) + i-- + dAtA[i] = 0x48 + } + if m.FSWatcherEnabled { + i-- + if m.FSWatcherEnabled { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x40 + } + if m.RescanIntervalS != 0 { + i = encodeVarintFolderconfiguration(dAtA, i, uint64(m.RescanIntervalS)) + i-- + dAtA[i] = 0x38 + } + if len(m.Devices) > 0 { + for iNdEx := len(m.Devices) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Devices[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintFolderconfiguration(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x32 + } + } + if m.Type != 0 { + i = encodeVarintFolderconfiguration(dAtA, i, uint64(m.Type)) + i-- + dAtA[i] = 0x28 + } + if len(m.Path) > 0 { + i -= len(m.Path) + copy(dAtA[i:], m.Path) + i = encodeVarintFolderconfiguration(dAtA, i, uint64(len(m.Path))) + i-- + dAtA[i] = 0x22 + } + if m.FilesystemType != 0 { + i = encodeVarintFolderconfiguration(dAtA, i, uint64(m.FilesystemType)) + i-- + dAtA[i] = 0x18 + } + if len(m.Label) > 0 { + i -= len(m.Label) + copy(dAtA[i:], m.Label) + i = encodeVarintFolderconfiguration(dAtA, i, uint64(len(m.Label))) + i-- + dAtA[i] = 0x12 + } + if len(m.ID) > 0 { + i -= len(m.ID) + copy(dAtA[i:], m.ID) + i = encodeVarintFolderconfiguration(dAtA, i, uint64(len(m.ID))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func encodeVarintFolderconfiguration(dAtA []byte, offset int, v uint64) int { + offset -= sovFolderconfiguration(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} func (m *FolderDeviceConfiguration) ProtoSize() (n int) { if m == nil { return 0 @@ -399,3 +819,1061 @@ func sovFolderconfiguration(x uint64) (n int) { func sozFolderconfiguration(x uint64) (n int) { return sovFolderconfiguration(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } +func (m *FolderDeviceConfiguration) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFolderconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: FolderDeviceConfiguration: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: FolderDeviceConfiguration: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DeviceID", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFolderconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthFolderconfiguration + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthFolderconfiguration + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.DeviceID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field IntroducedBy", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFolderconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthFolderconfiguration + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthFolderconfiguration + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.IntroducedBy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipFolderconfiguration(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthFolderconfiguration + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthFolderconfiguration + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *FolderConfiguration) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFolderconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: FolderConfiguration: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: FolderConfiguration: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFolderconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFolderconfiguration + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthFolderconfiguration + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ID = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Label", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFolderconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFolderconfiguration + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthFolderconfiguration + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Label = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FilesystemType", wireType) + } + m.FilesystemType = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFolderconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.FilesystemType |= fs.FilesystemType(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFolderconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFolderconfiguration + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthFolderconfiguration + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Path = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) + } + m.Type = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFolderconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Type |= FolderType(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Devices", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFolderconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFolderconfiguration + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthFolderconfiguration + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Devices = append(m.Devices, FolderDeviceConfiguration{}) + if err := m.Devices[len(m.Devices)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RescanIntervalS", wireType) + } + m.RescanIntervalS = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFolderconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.RescanIntervalS |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FSWatcherEnabled", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFolderconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.FSWatcherEnabled = bool(v != 0) + case 9: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FSWatcherDelayS", wireType) + } + m.FSWatcherDelayS = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFolderconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.FSWatcherDelayS |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 10: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field IgnorePerms", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFolderconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.IgnorePerms = bool(v != 0) + case 11: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field AutoNormalize", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFolderconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.AutoNormalize = bool(v != 0) + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MinDiskFree", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFolderconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFolderconfiguration + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthFolderconfiguration + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.MinDiskFree.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 13: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Versioning", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFolderconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFolderconfiguration + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthFolderconfiguration + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Versioning.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 14: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Copiers", wireType) + } + m.Copiers = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFolderconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Copiers |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 15: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field PullerMaxPendingKiB", wireType) + } + m.PullerMaxPendingKiB = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFolderconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.PullerMaxPendingKiB |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 16: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Hashers", wireType) + } + m.Hashers = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFolderconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Hashers |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 17: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Order", wireType) + } + m.Order = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFolderconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Order |= PullOrder(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 18: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field IgnoreDelete", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFolderconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.IgnoreDelete = bool(v != 0) + case 19: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ScanProgressIntervalS", wireType) + } + m.ScanProgressIntervalS = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFolderconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ScanProgressIntervalS |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 20: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field PullerPauseS", wireType) + } + m.PullerPauseS = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFolderconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.PullerPauseS |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 21: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MaxConflicts", wireType) + } + m.MaxConflicts = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFolderconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.MaxConflicts |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 22: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field DisableSparseFiles", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFolderconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.DisableSparseFiles = bool(v != 0) + case 23: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field DisableTempIndexes", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFolderconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.DisableTempIndexes = bool(v != 0) + case 24: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Paused", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFolderconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Paused = bool(v != 0) + case 25: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field WeakHashThresholdPct", wireType) + } + m.WeakHashThresholdPct = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFolderconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.WeakHashThresholdPct |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 26: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MarkerName", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFolderconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFolderconfiguration + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthFolderconfiguration + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.MarkerName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 27: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CopyOwnershipFromParent", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFolderconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.CopyOwnershipFromParent = bool(v != 0) + case 28: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RawModTimeWindowS", wireType) + } + m.RawModTimeWindowS = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFolderconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.RawModTimeWindowS |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 29: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MaxConcurrentWrites", wireType) + } + m.MaxConcurrentWrites = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFolderconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.MaxConcurrentWrites |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 30: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field DisableFsync", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFolderconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.DisableFsync = bool(v != 0) + case 31: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockPullOrder", wireType) + } + m.BlockPullOrder = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFolderconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.BlockPullOrder |= BlockPullOrder(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 32: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CopyRangeMethod", wireType) + } + m.CopyRangeMethod = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFolderconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.CopyRangeMethod |= fs.CopyRangeMethod(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 33: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CaseSensitiveFS", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFolderconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.CaseSensitiveFS = bool(v != 0) + case 34: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field JunctionsAsDirs", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFolderconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.JunctionsAsDirs = bool(v != 0) + case 9000: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field DeprecatedReadOnly", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFolderconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.DeprecatedReadOnly = bool(v != 0) + case 9001: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field DeprecatedMinDiskFreePct", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) + iNdEx += 8 + m.DeprecatedMinDiskFreePct = float64(math.Float64frombits(v)) + case 9002: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field DeprecatedPullers", wireType) + } + m.DeprecatedPullers = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFolderconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.DeprecatedPullers |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipFolderconfiguration(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthFolderconfiguration + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthFolderconfiguration + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipFolderconfiguration(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowFolderconfiguration + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowFolderconfiguration + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowFolderconfiguration + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthFolderconfiguration + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupFolderconfiguration + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthFolderconfiguration + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthFolderconfiguration = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowFolderconfiguration = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupFolderconfiguration = fmt.Errorf("proto: unexpected end of group") +) diff --git a/lib/config/foldertype.pb.go b/lib/config/foldertype.pb.go index edecf4a34..dedd2b12c 100644 --- a/lib/config/foldertype.pb.go +++ b/lib/config/foldertype.pb.go @@ -5,6 +5,7 @@ package config import ( fmt "fmt" + _ "github.com/gogo/protobuf/gogoproto" proto "github.com/gogo/protobuf/proto" math "math" ) @@ -51,19 +52,21 @@ func init() { func init() { proto.RegisterFile("lib/config/foldertype.proto", fileDescriptor_ea6ddb20c0633575) } var fileDescriptor_ea6ddb20c0633575 = []byte{ - // 220 bytes of a gzipped FileDescriptorProto + // 254 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0xce, 0xc9, 0x4c, 0xd2, 0x4f, 0xce, 0xcf, 0x4b, 0xcb, 0x4c, 0xd7, 0x4f, 0xcb, 0xcf, 0x49, 0x49, 0x2d, 0x2a, 0xa9, 0x2c, - 0x48, 0xd5, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x83, 0x48, 0x68, 0x6d, 0x64, 0xe4, 0xe2, - 0x72, 0x03, 0x4b, 0x86, 0x54, 0x16, 0xa4, 0x0a, 0x99, 0x73, 0x49, 0xb8, 0xf9, 0xfb, 0xb8, 0xb8, - 0x06, 0xc5, 0x87, 0x44, 0x06, 0xb8, 0xc6, 0x07, 0xbb, 0xfa, 0xb9, 0xc4, 0x07, 0xb9, 0x3a, 0xbb, - 0x7a, 0x86, 0xb9, 0x0a, 0x30, 0x48, 0x49, 0x76, 0xcd, 0x55, 0x10, 0x45, 0xa8, 0x0e, 0x4e, 0xcd, - 0x4b, 0x09, 0x4a, 0x4d, 0x4e, 0xcd, 0x2c, 0x4b, 0x15, 0x32, 0xe4, 0x12, 0xc5, 0xd0, 0xe8, 0xef, - 0xe7, 0x13, 0x29, 0xc0, 0x28, 0x25, 0xd6, 0x35, 0x57, 0x41, 0x08, 0x55, 0x97, 0x7f, 0x5e, 0x4e, - 0x25, 0xba, 0x5d, 0x50, 0x6b, 0x20, 0xba, 0x98, 0xd0, 0xed, 0x82, 0xda, 0x03, 0xd2, 0xe8, 0xe4, - 0x7e, 0xe2, 0xa1, 0x1c, 0xc3, 0x85, 0x87, 0x72, 0x0c, 0x2f, 0x1e, 0xc9, 0x31, 0x4c, 0x78, 0x2c, - 0xc7, 0xb0, 0xe0, 0xb1, 0x1c, 0xe3, 0x85, 0xc7, 0x72, 0x0c, 0x37, 0x1e, 0xcb, 0x31, 0x44, 0x69, - 0xa6, 0x67, 0x96, 0x64, 0x94, 0x26, 0xe9, 0x25, 0xe7, 0xe7, 0xea, 0x17, 0x57, 0xe6, 0x25, 0x97, - 0x64, 0x64, 0xe6, 0xa5, 0x23, 0xb1, 0x10, 0xa1, 0x92, 0xc4, 0x06, 0x0e, 0x0b, 0x63, 0x40, 0x00, - 0x00, 0x00, 0xff, 0xff, 0x7b, 0x44, 0x34, 0x9f, 0x2a, 0x01, 0x00, 0x00, + 0x48, 0xd5, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x83, 0x48, 0x48, 0x29, 0x17, 0xa5, 0x16, + 0xe4, 0x17, 0xeb, 0x83, 0x05, 0x93, 0x4a, 0xd3, 0xf4, 0xd3, 0xf3, 0xd3, 0xf3, 0xc1, 0x1c, 0x30, + 0x0b, 0xa2, 0x58, 0x6b, 0x3b, 0x23, 0x17, 0x97, 0x1b, 0xd8, 0x84, 0x90, 0xca, 0x82, 0x54, 0x21, + 0x73, 0x2e, 0x09, 0x37, 0x7f, 0x1f, 0x17, 0xd7, 0xa0, 0xf8, 0x90, 0xc8, 0x00, 0xd7, 0xf8, 0x60, + 0x57, 0x3f, 0x97, 0xf8, 0x20, 0x57, 0x67, 0x57, 0xcf, 0x30, 0x57, 0x01, 0x06, 0x29, 0xc9, 0xae, + 0xb9, 0x0a, 0xa2, 0x08, 0xd5, 0xc1, 0xa9, 0x79, 0x29, 0x41, 0xa9, 0xc9, 0xa9, 0x99, 0x65, 0xa9, + 0x42, 0x86, 0x5c, 0xa2, 0x18, 0x1a, 0xfd, 0xfd, 0x7c, 0x22, 0x05, 0x18, 0xa5, 0xc4, 0xba, 0xe6, + 0x2a, 0x08, 0xa1, 0xea, 0xf2, 0xcf, 0xcb, 0xa9, 0x44, 0xb7, 0x0b, 0x6a, 0x0d, 0x44, 0x17, 0x13, + 0xba, 0x5d, 0x50, 0x7b, 0x40, 0x1a, 0xa5, 0x58, 0x56, 0x2c, 0x91, 0x63, 0x70, 0xf2, 0x3e, 0xf1, + 0x50, 0x8e, 0xe1, 0xc2, 0x43, 0x39, 0x86, 0x13, 0x8f, 0xe4, 0x18, 0x2f, 0x3c, 0x92, 0x63, 0x9c, + 0xf0, 0x58, 0x8e, 0x61, 0xc1, 0x63, 0x39, 0xc6, 0x0b, 0x8f, 0xe5, 0x18, 0x6e, 0x3c, 0x96, 0x63, + 0x88, 0xd2, 0x4c, 0xcf, 0x2c, 0xc9, 0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0x2f, 0xae, 0xcc, + 0x4b, 0x2e, 0xc9, 0xc8, 0xcc, 0x4b, 0x47, 0x62, 0x21, 0x02, 0x31, 0x89, 0x0d, 0x1c, 0x1a, 0xc6, + 0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0x36, 0x1f, 0xe5, 0x1d, 0x59, 0x01, 0x00, 0x00, } diff --git a/lib/config/guiconfiguration.pb.go b/lib/config/guiconfiguration.pb.go index dd839780c..ed9214b4f 100644 --- a/lib/config/guiconfiguration.pb.go +++ b/lib/config/guiconfiguration.pb.go @@ -7,6 +7,7 @@ import ( fmt "fmt" proto "github.com/gogo/protobuf/proto" _ "github.com/syncthing/syncthing/proto/ext" + io "io" math "math" math_bits "math/bits" ) @@ -45,16 +46,25 @@ func (*GUIConfiguration) Descriptor() ([]byte, []int) { return fileDescriptor_2a9586d611855d64, []int{0} } func (m *GUIConfiguration) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GUIConfiguration.Unmarshal(m, b) + return m.Unmarshal(b) } func (m *GUIConfiguration) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GUIConfiguration.Marshal(b, m, deterministic) + if deterministic { + return xxx_messageInfo_GUIConfiguration.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } } func (m *GUIConfiguration) XXX_Merge(src proto.Message) { xxx_messageInfo_GUIConfiguration.Merge(m, src) } func (m *GUIConfiguration) XXX_Size() int { - return xxx_messageInfo_GUIConfiguration.Size(m) + return m.ProtoSize() } func (m *GUIConfiguration) XXX_DiscardUnknown() { xxx_messageInfo_GUIConfiguration.DiscardUnknown(m) @@ -69,62 +79,203 @@ func init() { func init() { proto.RegisterFile("lib/config/guiconfiguration.proto", fileDescriptor_2a9586d611855d64) } var fileDescriptor_2a9586d611855d64 = []byte{ - // 834 bytes of a gzipped FileDescriptorProto + // 837 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x55, 0xcd, 0x6e, 0xdb, 0x46, - 0x10, 0x16, 0x5b, 0x47, 0xb2, 0xb6, 0xae, 0x60, 0xb0, 0x4d, 0xcb, 0x04, 0x8d, 0x56, 0x51, 0xd8, - 0xc2, 0x01, 0x02, 0x39, 0x71, 0x5a, 0x24, 0xf0, 0xa1, 0x80, 0x1c, 0x20, 0x3f, 0xb0, 0x0b, 0x04, - 0x74, 0x7d, 0xc9, 0x85, 0x58, 0x91, 0x6b, 0x69, 0x21, 0xfe, 0x95, 0xbb, 0x84, 0xa4, 0x43, 0xfb, - 0x0c, 0x85, 0x7a, 0x2e, 0xd0, 0x67, 0xe8, 0xa5, 0xaf, 0xd0, 0x9b, 0x74, 0x2a, 0x72, 0x5a, 0x20, - 0xd2, 0xa5, 0xe0, 0x91, 0xc7, 0x9c, 0x8a, 0x5d, 0xfe, 0x48, 0x94, 0x95, 0x26, 0xb7, 0x9d, 0x6f, - 0xbe, 0x99, 0x6f, 0x66, 0x38, 0x03, 0x82, 0xdb, 0x0e, 0xe9, 0x1d, 0x5a, 0xbe, 0x77, 0x49, 0xfa, - 0x87, 0xfd, 0x88, 0xa4, 0xaf, 0x28, 0x44, 0x8c, 0xf8, 0x5e, 0x27, 0x08, 0x7d, 0xe6, 0xab, 0xd5, - 0x14, 0xbc, 0x79, 0x63, 0x8d, 0x8a, 0x22, 0x36, 0x70, 0x7d, 0x1b, 0xa7, 0x94, 0x9b, 0x75, 0x3c, - 0x66, 0xe9, 0xb3, 0xfd, 0x7a, 0x0f, 0xec, 0x3f, 0xbb, 0x78, 0xf1, 0x64, 0x3d, 0x91, 0xda, 0x03, - 0x35, 0xec, 0xa1, 0x9e, 0x83, 0x6d, 0x4d, 0x69, 0x29, 0x07, 0xbb, 0x27, 0xcf, 0x63, 0x0e, 0x73, - 0x28, 0xe1, 0xf0, 0xf6, 0xd8, 0x75, 0x8e, 0xdb, 0x99, 0x7d, 0x0f, 0x31, 0x16, 0xb6, 0x5b, 0x36, - 0xbe, 0x44, 0x91, 0xc3, 0x8e, 0xdb, 0x2c, 0x8c, 0x70, 0x3b, 0x9e, 0xe9, 0x7b, 0xeb, 0xfe, 0xb7, - 0x33, 0x7d, 0x47, 0x38, 0x8c, 0x3c, 0x8b, 0xfa, 0x33, 0xa8, 0x21, 0xdb, 0x0e, 0x31, 0xa5, 0xda, - 0x47, 0x2d, 0xe5, 0xa0, 0x7e, 0x62, 0x2d, 0x38, 0x04, 0x06, 0x1a, 0x75, 0x53, 0x54, 0x28, 0x66, - 0x84, 0x84, 0xc3, 0x6f, 0xa4, 0x62, 0x66, 0xaf, 0x89, 0x3d, 0x38, 0x7a, 0xd4, 0xb9, 0xdf, 0xb9, - 0xdf, 0x79, 0x70, 0xfc, 0xf8, 0xe1, 0xe3, 0x6f, 0xdb, 0x6f, 0x67, 0x7a, 0xa3, 0x0c, 0x4d, 0xe7, - 0xfa, 0x5a, 0x52, 0x23, 0x4f, 0xa9, 0xfe, 0xa3, 0x80, 0x2f, 0x23, 0x8f, 0x8c, 0x4d, 0xea, 0x5b, - 0x43, 0xcc, 0xcc, 0x00, 0x87, 0x2e, 0xa1, 0x94, 0xf8, 0x1e, 0xd5, 0x3e, 0x96, 0xf5, 0xfc, 0xae, - 0x2c, 0x38, 0xd4, 0x0c, 0x34, 0xba, 0xf0, 0xc8, 0xf8, 0x5c, 0xb2, 0x5e, 0xae, 0x48, 0x31, 0x87, - 0xd7, 0xa3, 0x6d, 0x8e, 0x84, 0xc3, 0xaf, 0x65, 0xb1, 0x5b, 0xbd, 0xf7, 0x7c, 0x97, 0x30, 0xec, - 0x06, 0x6c, 0x22, 0x46, 0x04, 0xdf, 0xc3, 0x99, 0xce, 0xf5, 0x77, 0x16, 0x60, 0x6c, 0x97, 0x57, - 0x9f, 0x82, 0x9d, 0x88, 0xe2, 0x50, 0xdb, 0x91, 0x4d, 0x1c, 0xc5, 0x1c, 0x4a, 0x3b, 0xe1, 0xf0, - 0xf3, 0xb4, 0x2c, 0x8a, 0xc3, 0x72, 0x15, 0x8d, 0x32, 0x64, 0x48, 0xbe, 0xfa, 0x0a, 0xec, 0x06, - 0x88, 0xd2, 0x91, 0x1f, 0xda, 0xda, 0x35, 0x99, 0xeb, 0xfb, 0x98, 0xc3, 0x02, 0x4b, 0x38, 0xd4, - 0x64, 0xbe, 0x1c, 0x28, 0xe7, 0x54, 0xaf, 0xc2, 0x46, 0x11, 0xab, 0xba, 0xa0, 0x2e, 0x36, 0xd2, - 0x14, 0x2b, 0xa9, 0x55, 0x5b, 0xca, 0x41, 0xe3, 0x68, 0xbf, 0x93, 0xae, 0x6a, 0xa7, 0x1b, 0xb1, - 0xc1, 0x0f, 0xbe, 0x8d, 0x53, 0x39, 0x94, 0x59, 0x85, 0x5c, 0x0e, 0x6c, 0xc8, 0x5d, 0x85, 0x8d, - 0x22, 0x56, 0xc5, 0xa0, 0x16, 0x51, 0x6c, 0x32, 0x87, 0x6a, 0x35, 0xb9, 0xce, 0x67, 0x0b, 0x0e, - 0xeb, 0x62, 0xb0, 0x14, 0xff, 0x78, 0x76, 0x1e, 0x73, 0x58, 0x8d, 0xe4, 0x2b, 0xe1, 0xb0, 0x21, - 0x55, 0x98, 0x43, 0xd3, 0xb5, 0x8e, 0x67, 0xfa, 0x6e, 0x6e, 0x24, 0x33, 0x3d, 0xe3, 0x4d, 0xe7, - 0xfa, 0x2a, 0xdc, 0x90, 0xa0, 0x43, 0x85, 0x0c, 0x0a, 0x88, 0x39, 0xc4, 0x13, 0x6d, 0x57, 0x0e, - 0x4c, 0xc8, 0x54, 0xbb, 0x2f, 0x5f, 0x9c, 0xe2, 0x89, 0xd0, 0x40, 0x01, 0x39, 0xc5, 0x93, 0x84, - 0xc3, 0x2f, 0xd2, 0x4e, 0x02, 0x32, 0xc4, 0x93, 0x72, 0x1f, 0xfb, 0x9b, 0xe0, 0x74, 0xae, 0x67, - 0x19, 0x8c, 0x2c, 0x5e, 0xfd, 0x4d, 0x01, 0xd7, 0x89, 0x47, 0xb1, 0x15, 0x85, 0xd8, 0x44, 0xb6, - 0x4b, 0x3c, 0x13, 0x59, 0x96, 0xb8, 0xa3, 0xba, 0x6c, 0xce, 0x8c, 0x39, 0xfc, 0x2c, 0x27, 0x74, - 0x85, 0xbf, 0x2b, 0xdd, 0x09, 0x87, 0x77, 0xa4, 0xf0, 0x16, 0x5f, 0xb9, 0x8a, 0x5b, 0xff, 0xcb, - 0x30, 0xb6, 0x25, 0x57, 0x4f, 0xc1, 0x35, 0x36, 0xc0, 0x2e, 0xd6, 0x80, 0x6c, 0xfd, 0xbb, 0x98, - 0xc3, 0x14, 0x48, 0x38, 0xbc, 0x95, 0xce, 0x54, 0x58, 0x6b, 0xa7, 0x9b, 0x3d, 0xc4, 0xcd, 0xd6, - 0xb2, 0xb7, 0x91, 0x86, 0xa8, 0x17, 0xa0, 0x6e, 0xe3, 0x5e, 0xd4, 0xef, 0x13, 0xaf, 0xaf, 0x7d, - 0x22, 0xbb, 0x7a, 0x14, 0x73, 0xb8, 0x02, 0x8b, 0x6d, 0x2e, 0x90, 0xe2, 0x73, 0x35, 0xca, 0x90, - 0xb1, 0x0a, 0x52, 0xff, 0x52, 0x80, 0x56, 0x4c, 0x8e, 0x0e, 0x49, 0x60, 0x0e, 0x7c, 0xca, 0x4c, - 0x6b, 0x80, 0xad, 0xa1, 0xb6, 0x27, 0x65, 0x7e, 0x11, 0x77, 0x9d, 0x73, 0xce, 0x87, 0x24, 0x78, - 0xee, 0x53, 0x26, 0x09, 0xc5, 0x5d, 0x6f, 0xf5, 0x6e, 0xdc, 0xf5, 0x7b, 0x38, 0xc9, 0x4c, 0xdf, - 0x2e, 0x62, 0x5c, 0x81, 0x9f, 0x08, 0x58, 0xfd, 0x53, 0x01, 0x5f, 0xad, 0xbe, 0xb9, 0xe3, 0xf8, - 0x23, 0xf3, 0x32, 0x44, 0x2e, 0x36, 0x1d, 0x1f, 0xd9, 0x62, 0x48, 0x9f, 0xca, 0xea, 0x7f, 0x8a, - 0x39, 0xbc, 0x51, 0x7c, 0x1d, 0x41, 0x7b, 0x2a, 0x58, 0x67, 0x29, 0x29, 0xe1, 0xf0, 0x6e, 0x79, - 0x01, 0x36, 0x19, 0xe5, 0x2e, 0xee, 0x7c, 0x00, 0xcf, 0x78, 0xb7, 0xdc, 0xc9, 0xb3, 0xbf, 0xdf, - 0x34, 0x2b, 0xf3, 0x37, 0xcd, 0xca, 0xbf, 0x8b, 0x66, 0xe5, 0xd7, 0x65, 0xb3, 0xf2, 0xc7, 0xb2, - 0xa9, 0xcc, 0x97, 0xcd, 0xca, 0xeb, 0x65, 0xb3, 0xf2, 0xea, 0x6e, 0x9f, 0xb0, 0x41, 0xd4, 0xeb, - 0x58, 0xbe, 0x7b, 0x48, 0x27, 0x9e, 0xc5, 0x06, 0xc4, 0xeb, 0xaf, 0xbd, 0x56, 0x7f, 0xaf, 0x5e, - 0x55, 0xfe, 0xaa, 0x1e, 0xfe, 0x17, 0x00, 0x00, 0xff, 0xff, 0xfa, 0x2b, 0x9a, 0x81, 0xfd, 0x06, - 0x00, 0x00, + 0x10, 0x16, 0x5b, 0x47, 0xb2, 0xb6, 0xae, 0x60, 0xb0, 0x4d, 0xcb, 0x04, 0x0d, 0xd7, 0x51, 0xd8, + 0xc2, 0x01, 0x02, 0x39, 0x71, 0x5a, 0x24, 0xf0, 0xa1, 0x80, 0x1c, 0x20, 0x4d, 0x60, 0x17, 0x08, + 0xe8, 0xfa, 0x92, 0x0b, 0xb1, 0x22, 0xd7, 0xd2, 0x42, 0xfc, 0x2b, 0x77, 0x09, 0x4b, 0x87, 0xf6, + 0x19, 0x0a, 0xf5, 0x5c, 0xa0, 0xcf, 0xd0, 0x4b, 0x5f, 0x21, 0x37, 0xe9, 0x54, 0xe4, 0xb4, 0x40, + 0xa4, 0x1b, 0x8f, 0x3c, 0xe6, 0x54, 0xec, 0xf2, 0x47, 0xa2, 0xac, 0xd4, 0xbd, 0xed, 0x7c, 0xf3, + 0xcd, 0x7c, 0x33, 0xc3, 0x19, 0x10, 0xdc, 0x75, 0x49, 0xef, 0xc0, 0x0e, 0xfc, 0x0b, 0xd2, 0x3f, + 0xe8, 0xc7, 0x24, 0x7b, 0xc5, 0x11, 0x62, 0x24, 0xf0, 0x3b, 0x61, 0x14, 0xb0, 0x40, 0xad, 0x67, + 0xe0, 0xed, 0x5b, 0x2b, 0x54, 0x14, 0xb3, 0x81, 0x17, 0x38, 0x38, 0xa3, 0xdc, 0x6e, 0xe2, 0x11, + 0xcb, 0x9e, 0xed, 0xb7, 0x3b, 0x60, 0xf7, 0x87, 0xf3, 0x97, 0xcf, 0x56, 0x13, 0xa9, 0x3d, 0xd0, + 0xc0, 0x3e, 0xea, 0xb9, 0xd8, 0xd1, 0x94, 0x3d, 0x65, 0x7f, 0xfb, 0xf8, 0x45, 0xc2, 0x61, 0x01, + 0xa5, 0x1c, 0xde, 0x1d, 0x79, 0xee, 0x51, 0x3b, 0xb7, 0x1f, 0x20, 0xc6, 0xa2, 0xf6, 0x9e, 0x83, + 0x2f, 0x50, 0xec, 0xb2, 0xa3, 0x36, 0x8b, 0x62, 0xdc, 0x4e, 0xa6, 0xc6, 0xce, 0xaa, 0xff, 0xfd, + 0xd4, 0xd8, 0x12, 0x0e, 0xb3, 0xc8, 0xa2, 0xfe, 0x02, 0x1a, 0xc8, 0x71, 0x22, 0x4c, 0xa9, 0xf6, + 0xd1, 0x9e, 0xb2, 0xdf, 0x3c, 0xb6, 0xe7, 0x1c, 0x02, 0x13, 0x5d, 0x76, 0x33, 0x54, 0x28, 0xe6, + 0x84, 0x94, 0xc3, 0x6f, 0xa4, 0x62, 0x6e, 0xaf, 0x88, 0x3d, 0x3a, 0x7c, 0xd2, 0x79, 0xd8, 0x79, + 0xd8, 0x79, 0x74, 0xf4, 0xf4, 0xf1, 0xd3, 0x6f, 0xdb, 0xef, 0xa7, 0x46, 0xab, 0x0a, 0x4d, 0x66, + 0xc6, 0x4a, 0x52, 0xb3, 0x48, 0xa9, 0xfe, 0xa3, 0x80, 0x2f, 0x63, 0x9f, 0x8c, 0x2c, 0x1a, 0xd8, + 0x43, 0xcc, 0xac, 0x10, 0x47, 0x1e, 0xa1, 0x94, 0x04, 0x3e, 0xd5, 0x3e, 0x96, 0xf5, 0xfc, 0xa1, + 0xcc, 0x39, 0xd4, 0x4c, 0x74, 0x79, 0xee, 0x93, 0xd1, 0x99, 0x64, 0xbd, 0x5a, 0x92, 0x12, 0x0e, + 0x6f, 0xc6, 0x9b, 0x1c, 0x29, 0x87, 0x5f, 0xcb, 0x62, 0x37, 0x7a, 0x1f, 0x04, 0x1e, 0x61, 0xd8, + 0x0b, 0xd9, 0x58, 0x8c, 0x08, 0x5e, 0xc3, 0x99, 0xcc, 0x8c, 0x0f, 0x16, 0x60, 0x6e, 0x96, 0x57, + 0x9f, 0x83, 0xad, 0x98, 0xe2, 0x48, 0xdb, 0x92, 0x4d, 0x1c, 0x26, 0x1c, 0x4a, 0x3b, 0xe5, 0xf0, + 0xf3, 0xac, 0x2c, 0x8a, 0xa3, 0x6a, 0x15, 0xad, 0x2a, 0x64, 0x4a, 0xbe, 0xfa, 0x1a, 0x6c, 0x87, + 0x88, 0xd2, 0xcb, 0x20, 0x72, 0xb4, 0x1b, 0x32, 0xd7, 0xf7, 0x09, 0x87, 0x25, 0x96, 0x72, 0xa8, + 0xc9, 0x7c, 0x05, 0x50, 0xcd, 0xa9, 0x5e, 0x85, 0xcd, 0x32, 0x56, 0xf5, 0x40, 0x53, 0x6c, 0xa4, + 0x25, 0x56, 0x52, 0xab, 0xef, 0x29, 0xfb, 0xad, 0xc3, 0xdd, 0x4e, 0xb6, 0xaa, 0x9d, 0x6e, 0xcc, + 0x06, 0x3f, 0x06, 0x0e, 0xce, 0xe4, 0x50, 0x6e, 0x95, 0x72, 0x05, 0xb0, 0x26, 0x77, 0x15, 0x36, + 0xcb, 0x58, 0x15, 0x83, 0x46, 0x4c, 0xb1, 0xc5, 0x5c, 0xaa, 0x35, 0xe4, 0x3a, 0x9f, 0xce, 0x39, + 0x6c, 0x8a, 0xc1, 0x52, 0xfc, 0xd3, 0xe9, 0x59, 0xc2, 0x61, 0x3d, 0x96, 0xaf, 0x94, 0xc3, 0x96, + 0x54, 0x61, 0x2e, 0xcd, 0xd6, 0x3a, 0x99, 0x1a, 0xdb, 0x85, 0x91, 0x4e, 0x8d, 0x9c, 0x37, 0x99, + 0x19, 0xcb, 0x70, 0x53, 0x82, 0x2e, 0x15, 0x32, 0x28, 0x24, 0xd6, 0x10, 0x8f, 0xb5, 0x6d, 0x39, + 0x30, 0x21, 0x53, 0xef, 0xbe, 0x7a, 0x79, 0x82, 0xc7, 0x42, 0x03, 0x85, 0xe4, 0x04, 0x8f, 0x53, + 0x0e, 0xbf, 0xc8, 0x3a, 0x09, 0xc9, 0x10, 0x8f, 0xab, 0x7d, 0xec, 0xae, 0x83, 0x93, 0x99, 0x91, + 0x67, 0x30, 0xf3, 0x78, 0xf5, 0x77, 0x05, 0xdc, 0x24, 0x3e, 0xc5, 0x76, 0x1c, 0x61, 0x0b, 0x39, + 0x1e, 0xf1, 0x2d, 0x64, 0xdb, 0xe2, 0x8e, 0x9a, 0xb2, 0x39, 0x2b, 0xe1, 0xf0, 0xb3, 0x82, 0xd0, + 0x15, 0xfe, 0xae, 0x74, 0xa7, 0x1c, 0xde, 0x93, 0xc2, 0x1b, 0x7c, 0xd5, 0x2a, 0xee, 0xfc, 0x27, + 0xc3, 0xdc, 0x94, 0x5c, 0x3d, 0x01, 0x37, 0xd8, 0x00, 0x7b, 0x58, 0x03, 0xb2, 0xf5, 0xef, 0x12, + 0x0e, 0x33, 0x20, 0xe5, 0xf0, 0x4e, 0x36, 0x53, 0x61, 0xad, 0x9c, 0x6e, 0xfe, 0x10, 0x37, 0xdb, + 0xc8, 0xdf, 0x66, 0x16, 0xa2, 0x9e, 0x83, 0xa6, 0x83, 0x7b, 0x71, 0xbf, 0x4f, 0xfc, 0xbe, 0xf6, + 0x89, 0xec, 0xea, 0x49, 0xc2, 0xe1, 0x12, 0x2c, 0xb7, 0xb9, 0x44, 0xca, 0xcf, 0xd5, 0xaa, 0x42, + 0xe6, 0x32, 0x48, 0xfd, 0x5b, 0x01, 0x5a, 0x39, 0x39, 0x3a, 0x24, 0xa1, 0x35, 0x08, 0x28, 0xb3, + 0xec, 0x01, 0xb6, 0x87, 0xda, 0x8e, 0x94, 0xf9, 0x55, 0xdc, 0x75, 0xc1, 0x39, 0x1b, 0x92, 0xf0, + 0x45, 0x40, 0x99, 0x24, 0x94, 0x77, 0xbd, 0xd1, 0xbb, 0x76, 0xd7, 0xd7, 0x70, 0xd2, 0xa9, 0xb1, + 0x59, 0xc4, 0xbc, 0x02, 0x3f, 0x13, 0xb0, 0xfa, 0x97, 0x02, 0xbe, 0x5a, 0x7e, 0x73, 0xd7, 0x0d, + 0x2e, 0xad, 0x8b, 0x08, 0x79, 0xd8, 0x72, 0x03, 0xe4, 0x88, 0x21, 0x7d, 0x2a, 0xab, 0xff, 0x39, + 0xe1, 0xf0, 0x56, 0xf9, 0x75, 0x04, 0xed, 0xb9, 0x60, 0x9d, 0x66, 0xa4, 0x94, 0xc3, 0xfb, 0xd5, + 0x05, 0x58, 0x67, 0x54, 0xbb, 0xb8, 0xf7, 0x3f, 0x78, 0xe6, 0x87, 0xe5, 0x8e, 0x4f, 0xde, 0xbc, + 0xd3, 0x6b, 0xb3, 0x77, 0x7a, 0xed, 0xcd, 0x5c, 0x57, 0x66, 0x73, 0x5d, 0xf9, 0x6d, 0xa1, 0xd7, + 0xfe, 0x5c, 0xe8, 0xca, 0x6c, 0xa1, 0xd7, 0xde, 0x2e, 0xf4, 0xda, 0xeb, 0xfb, 0x7d, 0xc2, 0x06, + 0x71, 0xaf, 0x63, 0x07, 0xde, 0x01, 0x1d, 0xfb, 0x36, 0x1b, 0x10, 0xbf, 0xbf, 0xf2, 0x5a, 0xfe, + 0xc1, 0x7a, 0x75, 0xf9, 0xbb, 0x7a, 0xfc, 0x6f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xd8, 0x8c, 0xef, + 0xc0, 0x01, 0x07, 0x00, 0x00, } +func (m *GUIConfiguration) Marshal() (dAtA []byte, err error) { + size := m.ProtoSize() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *GUIConfiguration) MarshalTo(dAtA []byte) (int, error) { + size := m.ProtoSize() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GUIConfiguration) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.InsecureAllowFrameLoading { + i-- + if m.InsecureAllowFrameLoading { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x68 + } + if m.InsecureSkipHostCheck { + i-- + if m.InsecureSkipHostCheck { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x60 + } + if m.Debugging { + i-- + if m.Debugging { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x58 + } + if len(m.Theme) > 0 { + i -= len(m.Theme) + copy(dAtA[i:], m.Theme) + i = encodeVarintGuiconfiguration(dAtA, i, uint64(len(m.Theme))) + i-- + dAtA[i] = 0x52 + } + if m.InsecureAdminAccess { + i-- + if m.InsecureAdminAccess { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x48 + } + if len(m.APIKey) > 0 { + i -= len(m.APIKey) + copy(dAtA[i:], m.APIKey) + i = encodeVarintGuiconfiguration(dAtA, i, uint64(len(m.APIKey))) + i-- + dAtA[i] = 0x42 + } + if m.RawUseTLS { + i-- + if m.RawUseTLS { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x38 + } + if m.AuthMode != 0 { + i = encodeVarintGuiconfiguration(dAtA, i, uint64(m.AuthMode)) + i-- + dAtA[i] = 0x30 + } + if len(m.Password) > 0 { + i -= len(m.Password) + copy(dAtA[i:], m.Password) + i = encodeVarintGuiconfiguration(dAtA, i, uint64(len(m.Password))) + i-- + dAtA[i] = 0x2a + } + if len(m.User) > 0 { + i -= len(m.User) + copy(dAtA[i:], m.User) + i = encodeVarintGuiconfiguration(dAtA, i, uint64(len(m.User))) + i-- + dAtA[i] = 0x22 + } + if len(m.RawUnixSocketPermissions) > 0 { + i -= len(m.RawUnixSocketPermissions) + copy(dAtA[i:], m.RawUnixSocketPermissions) + i = encodeVarintGuiconfiguration(dAtA, i, uint64(len(m.RawUnixSocketPermissions))) + i-- + dAtA[i] = 0x1a + } + if len(m.RawAddress) > 0 { + i -= len(m.RawAddress) + copy(dAtA[i:], m.RawAddress) + i = encodeVarintGuiconfiguration(dAtA, i, uint64(len(m.RawAddress))) + i-- + dAtA[i] = 0x12 + } + if m.Enabled { + i-- + if m.Enabled { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func encodeVarintGuiconfiguration(dAtA []byte, offset int, v uint64) int { + offset -= sovGuiconfiguration(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} func (m *GUIConfiguration) ProtoSize() (n int) { if m == nil { return 0 @@ -185,3 +336,471 @@ func sovGuiconfiguration(x uint64) (n int) { func sozGuiconfiguration(x uint64) (n int) { return sovGuiconfiguration(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } +func (m *GUIConfiguration) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGuiconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: GUIConfiguration: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GUIConfiguration: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Enabled", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGuiconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Enabled = bool(v != 0) + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RawAddress", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGuiconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGuiconfiguration + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGuiconfiguration + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.RawAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RawUnixSocketPermissions", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGuiconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGuiconfiguration + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGuiconfiguration + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.RawUnixSocketPermissions = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field User", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGuiconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGuiconfiguration + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGuiconfiguration + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.User = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Password", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGuiconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGuiconfiguration + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGuiconfiguration + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Password = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field AuthMode", wireType) + } + m.AuthMode = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGuiconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.AuthMode |= AuthMode(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RawUseTLS", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGuiconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.RawUseTLS = bool(v != 0) + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field APIKey", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGuiconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGuiconfiguration + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGuiconfiguration + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.APIKey = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 9: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field InsecureAdminAccess", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGuiconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.InsecureAdminAccess = bool(v != 0) + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Theme", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGuiconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGuiconfiguration + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGuiconfiguration + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Theme = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 11: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Debugging", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGuiconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Debugging = bool(v != 0) + case 12: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field InsecureSkipHostCheck", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGuiconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.InsecureSkipHostCheck = bool(v != 0) + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field InsecureAllowFrameLoading", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGuiconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.InsecureAllowFrameLoading = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := skipGuiconfiguration(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthGuiconfiguration + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthGuiconfiguration + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipGuiconfiguration(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGuiconfiguration + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGuiconfiguration + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGuiconfiguration + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthGuiconfiguration + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupGuiconfiguration + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthGuiconfiguration + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthGuiconfiguration = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowGuiconfiguration = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupGuiconfiguration = fmt.Errorf("proto: unexpected end of group") +) diff --git a/lib/config/ldapconfiguration.pb.go b/lib/config/ldapconfiguration.pb.go index 85f61d904..a97b723fc 100644 --- a/lib/config/ldapconfiguration.pb.go +++ b/lib/config/ldapconfiguration.pb.go @@ -7,6 +7,7 @@ import ( fmt "fmt" proto "github.com/gogo/protobuf/proto" _ "github.com/syncthing/syncthing/proto/ext" + io "io" math "math" math_bits "math/bits" ) @@ -38,16 +39,25 @@ func (*LDAPConfiguration) Descriptor() ([]byte, []int) { return fileDescriptor_9681ad7e41c73956, []int{0} } func (m *LDAPConfiguration) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_LDAPConfiguration.Unmarshal(m, b) + return m.Unmarshal(b) } func (m *LDAPConfiguration) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_LDAPConfiguration.Marshal(b, m, deterministic) + if deterministic { + return xxx_messageInfo_LDAPConfiguration.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } } func (m *LDAPConfiguration) XXX_Merge(src proto.Message) { xxx_messageInfo_LDAPConfiguration.Merge(m, src) } func (m *LDAPConfiguration) XXX_Size() int { - return xxx_messageInfo_LDAPConfiguration.Size(m) + return m.ProtoSize() } func (m *LDAPConfiguration) XXX_DiscardUnknown() { xxx_messageInfo_LDAPConfiguration.DiscardUnknown(m) @@ -64,41 +74,118 @@ func init() { } var fileDescriptor_9681ad7e41c73956 = []byte{ - // 498 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x53, 0x4d, 0x6f, 0xd3, 0x40, - 0x10, 0xb5, 0x81, 0xba, 0xc4, 0x2a, 0x15, 0x35, 0x50, 0x42, 0x55, 0x79, 0x23, 0xcb, 0x87, 0x20, - 0xa1, 0x44, 0x2a, 0xb7, 0x72, 0xaa, 0xa9, 0x40, 0x42, 0x08, 0x21, 0x17, 0x7a, 0xe0, 0x12, 0xf9, - 0x63, 0x9d, 0xac, 0xea, 0xec, 0x5a, 0xbb, 0xeb, 0xaa, 0xe1, 0x57, 0x40, 0x7f, 0x41, 0x6f, 0xfc, - 0x15, 0x6e, 0xc9, 0x91, 0xd3, 0x4a, 0x4d, 0x2e, 0xc8, 0x47, 0x1f, 0x39, 0xa1, 0xac, 0x9d, 0xc6, - 0x4e, 0xa3, 0xde, 0x66, 0xde, 0x9b, 0x79, 0xf3, 0x76, 0x47, 0xa3, 0x5b, 0x31, 0xf2, 0xbb, 0x01, - 0xc1, 0x11, 0xea, 0x77, 0xe3, 0xd0, 0x4b, 0x8a, 0x30, 0xa5, 0x1e, 0x47, 0x04, 0x77, 0x12, 0x4a, - 0x38, 0x31, 0xb4, 0x02, 0xdc, 0x33, 0x57, 0x6a, 0x39, 0xf5, 0x30, 0x4b, 0x08, 0xe5, 0x45, 0xdd, - 0x5e, 0x03, 0x5e, 0x94, 0xa1, 0xf5, 0x53, 0xd3, 0x77, 0x3e, 0x1e, 0x1f, 0x7d, 0x7e, 0x5b, 0x95, - 0x33, 0xbe, 0xea, 0x9b, 0x5e, 0x18, 0x52, 0xc8, 0x58, 0x53, 0x6d, 0xa9, 0xed, 0x86, 0xf3, 0x26, - 0x13, 0x60, 0x01, 0xe5, 0x02, 0x3c, 0xbf, 0x18, 0xc6, 0x87, 0x56, 0x99, 0xbf, 0x22, 0x43, 0xc4, - 0xe1, 0x30, 0xe1, 0x23, 0x2b, 0x1b, 0xdb, 0x3b, 0xb7, 0x50, 0x77, 0xd1, 0x68, 0x10, 0x7d, 0xd3, - 0x47, 0x38, 0xec, 0x85, 0xb8, 0x79, 0x4f, 0xca, 0x9e, 0x4e, 0x05, 0xd0, 0x1c, 0x84, 0xc3, 0xe3, - 0x4f, 0x99, 0x00, 0x9a, 0x2f, 0xa3, 0x5c, 0x80, 0x5d, 0xa9, 0x5f, 0xa4, 0x75, 0xf9, 0xc7, 0xab, - 0x60, 0x3e, 0xb6, 0xcb, 0xbe, 0xcb, 0x89, 0x5d, 0x6a, 0xb9, 0x05, 0x82, 0x8d, 0x73, 0xbd, 0x71, - 0xf3, 0xf6, 0xe6, 0xfd, 0x96, 0xda, 0xde, 0x3e, 0x78, 0xd6, 0x29, 0x3e, 0xa6, 0x33, 0x7f, 0xf5, - 0x97, 0x05, 0xe9, 0x1c, 0x65, 0x02, 0x2c, 0x6b, 0x73, 0x01, 0x5e, 0x48, 0x0b, 0x37, 0x48, 0xdd, - 0xc5, 0x93, 0x35, 0xb8, 0xbb, 0x6c, 0x37, 0x7e, 0xa9, 0xfa, 0x53, 0x84, 0x19, 0x0c, 0x52, 0x0a, - 0x7b, 0xec, 0x0c, 0x25, 0xbd, 0x73, 0x48, 0x51, 0x34, 0x6a, 0x3e, 0x68, 0xa9, 0xed, 0x87, 0x4e, - 0x9a, 0x09, 0x60, 0x2c, 0xf8, 0x93, 0x33, 0x94, 0x9c, 0x4a, 0x36, 0x17, 0xe0, 0x40, 0x4e, 0xbd, - 0x4d, 0x55, 0xc6, 0xb7, 0x42, 0x18, 0x79, 0x69, 0xcc, 0x0f, 0xad, 0xc8, 0x8b, 0x19, 0x9c, 0xdb, - 0xd9, 0xbf, 0xab, 0xe1, 0xdf, 0xd8, 0xde, 0x90, 0x95, 0xee, 0x9a, 0x91, 0xc6, 0x95, 0xaa, 0x6f, - 0x33, 0xe8, 0xd1, 0x60, 0xd0, 0xf3, 0x3d, 0x06, 0xe7, 0xab, 0xd9, 0x90, 0xab, 0xf9, 0x3e, 0x15, - 0x60, 0xeb, 0x44, 0x32, 0x8e, 0xc7, 0xa0, 0x5c, 0xd0, 0x16, 0xab, 0xe4, 0xb9, 0x00, 0xfb, 0xd2, - 0x6d, 0x15, 0xac, 0x7f, 0xd3, 0xee, 0x7a, 0x2a, 0x1f, 0xdb, 0x35, 0xa5, 0xcb, 0x89, 0x5d, 0x9b, - 0xe4, 0x56, 0x59, 0x6c, 0x10, 0xfd, 0x51, 0xe9, 0x30, 0x42, 0x31, 0x87, 0xb4, 0xa9, 0x49, 0x83, - 0x1f, 0x96, 0x86, 0xde, 0x49, 0x7c, 0xc5, 0x50, 0x01, 0xae, 0x35, 0xb4, 0x4a, 0xb9, 0x35, 0x1d, - 0xe7, 0xfd, 0xef, 0x6b, 0x53, 0x99, 0x5c, 0x9b, 0xca, 0xdf, 0xa9, 0xa9, 0xfc, 0x98, 0x99, 0xca, - 0xd5, 0xcc, 0x54, 0x27, 0x33, 0x53, 0xf9, 0x33, 0x33, 0x95, 0x6f, 0x2f, 0xfb, 0x88, 0x0f, 0x52, - 0xbf, 0x13, 0x90, 0x61, 0x97, 0x8d, 0x70, 0xc0, 0x07, 0x08, 0xf7, 0x2b, 0xd1, 0xf2, 0xf6, 0x7c, - 0x4d, 0xde, 0xd8, 0xeb, 0xff, 0x01, 0x00, 0x00, 0xff, 0xff, 0xca, 0xa1, 0xc5, 0x0d, 0xbc, 0x03, - 0x00, 0x00, + // 500 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x53, 0xbf, 0x6f, 0xd3, 0x40, + 0x14, 0xb6, 0x81, 0xba, 0xc4, 0x2a, 0x15, 0x35, 0x50, 0x4c, 0x55, 0xf9, 0x22, 0xcb, 0x43, 0x90, + 0x50, 0x22, 0x95, 0xad, 0x4c, 0x35, 0x15, 0x03, 0x20, 0x84, 0x5c, 0xe8, 0xc0, 0x12, 0xf9, 0xc7, + 0x39, 0x39, 0xd5, 0x39, 0x5b, 0x77, 0xe7, 0xaa, 0xe1, 0xaf, 0x80, 0xfe, 0x05, 0xdd, 0xf8, 0x57, + 0xba, 0xc5, 0x23, 0xd3, 0x49, 0x4d, 0x36, 0x8f, 0x1e, 0x99, 0x50, 0xce, 0x4e, 0x63, 0xa7, 0x51, + 0xb7, 0xf7, 0xbe, 0xef, 0xbd, 0xef, 0x7d, 0x77, 0x4f, 0x4f, 0x35, 0x23, 0xe4, 0xf5, 0xfc, 0x18, + 0x87, 0x68, 0xd0, 0x8b, 0x02, 0x37, 0x29, 0xc3, 0x94, 0xb8, 0x0c, 0xc5, 0xb8, 0x9b, 0x90, 0x98, + 0xc5, 0x9a, 0x52, 0x82, 0x7b, 0xc6, 0x4a, 0x2d, 0x23, 0x2e, 0xa6, 0x49, 0x4c, 0x58, 0x59, 0xb7, + 0xd7, 0x82, 0x17, 0x55, 0x68, 0xfe, 0x56, 0xd4, 0x9d, 0xcf, 0xc7, 0x47, 0x5f, 0xdf, 0xd7, 0xe5, + 0xb4, 0xef, 0xea, 0xa6, 0x1b, 0x04, 0x04, 0x52, 0xaa, 0xcb, 0x6d, 0xb9, 0xd3, 0xb2, 0xdf, 0xe5, + 0x1c, 0x2c, 0xa0, 0x82, 0x83, 0x97, 0x17, 0xa3, 0xe8, 0xd0, 0xac, 0xf2, 0x37, 0xf1, 0x08, 0x31, + 0x38, 0x4a, 0xd8, 0xd8, 0xcc, 0x27, 0xd6, 0xce, 0x1d, 0xd4, 0x59, 0x34, 0x6a, 0xb1, 0xba, 0xe9, + 0x21, 0x1c, 0xf4, 0x03, 0xac, 0x3f, 0x10, 0xb2, 0xa7, 0x53, 0x0e, 0x14, 0x1b, 0xe1, 0xe0, 0xf8, + 0x4b, 0xce, 0x81, 0xe2, 0x89, 0xa8, 0xe0, 0x60, 0x57, 0xe8, 0x97, 0x69, 0x53, 0xfe, 0xe9, 0x2a, + 0x58, 0x4c, 0xac, 0xaa, 0xef, 0x32, 0xb3, 0x2a, 0x2d, 0xa7, 0x44, 0xb0, 0x76, 0xae, 0xb6, 0x6e, + 0xdf, 0xae, 0x3f, 0x6c, 0xcb, 0x9d, 0xed, 0x83, 0x17, 0xdd, 0xf2, 0x63, 0xba, 0xf3, 0x57, 0x7f, + 0x5b, 0x90, 0xf6, 0x51, 0xce, 0xc1, 0xb2, 0xb6, 0xe0, 0xe0, 0x95, 0xb0, 0x70, 0x8b, 0x34, 0x5d, + 0x3c, 0x5b, 0x83, 0x3b, 0xcb, 0x76, 0xed, 0x8f, 0xac, 0x3e, 0x47, 0x98, 0x42, 0x3f, 0x25, 0xb0, + 0x4f, 0xcf, 0x50, 0xd2, 0x3f, 0x87, 0x04, 0x85, 0x63, 0xfd, 0x51, 0x5b, 0xee, 0x3c, 0xb6, 0xd3, + 0x9c, 0x03, 0x6d, 0xc1, 0x9f, 0x9c, 0xa1, 0xe4, 0x54, 0xb0, 0x05, 0x07, 0x07, 0x62, 0xea, 0x5d, + 0xaa, 0x36, 0xbe, 0x1d, 0xc0, 0xd0, 0x4d, 0x23, 0x76, 0x68, 0x86, 0x6e, 0x44, 0xe1, 0xdc, 0xce, + 0xfe, 0x7d, 0x0d, 0xff, 0x26, 0xd6, 0x86, 0xa8, 0x74, 0xd6, 0x8c, 0xd4, 0xae, 0x64, 0x75, 0x9b, + 0x42, 0x97, 0xf8, 0xc3, 0xbe, 0xe7, 0x52, 0x38, 0x5f, 0xcd, 0x86, 0x58, 0xcd, 0xcf, 0x29, 0x07, + 0x5b, 0x27, 0x82, 0xb1, 0x5d, 0x0a, 0xc5, 0x82, 0xb6, 0x68, 0x2d, 0x2f, 0x38, 0xd8, 0x17, 0x6e, + 0xeb, 0x60, 0xf3, 0x9b, 0x76, 0xd7, 0x53, 0xc5, 0xc4, 0x6a, 0x28, 0x5d, 0x66, 0x56, 0x63, 0x92, + 0x53, 0x67, 0xb1, 0x16, 0xab, 0x4f, 0x2a, 0x87, 0x21, 0x8a, 0x18, 0x24, 0xba, 0x22, 0x0c, 0x7e, + 0x5c, 0x1a, 0xfa, 0x20, 0xf0, 0x15, 0x43, 0x25, 0xb8, 0xd6, 0xd0, 0x2a, 0xe5, 0x34, 0x74, 0xec, + 0x4f, 0xd7, 0x37, 0x86, 0x94, 0xdd, 0x18, 0xd2, 0xf5, 0xd4, 0x90, 0xb3, 0xa9, 0x21, 0xff, 0x9a, + 0x19, 0xd2, 0xd5, 0xcc, 0x90, 0xb3, 0x99, 0x21, 0xfd, 0x9d, 0x19, 0xd2, 0x8f, 0xd7, 0x03, 0xc4, + 0x86, 0xa9, 0xd7, 0xf5, 0xe3, 0x51, 0x8f, 0x8e, 0xb1, 0xcf, 0x86, 0x08, 0x0f, 0x6a, 0xd1, 0xf2, + 0xfe, 0x3c, 0x45, 0xdc, 0xd9, 0xdb, 0xff, 0x01, 0x00, 0x00, 0xff, 0xff, 0xbf, 0x64, 0x4b, 0x05, + 0xc0, 0x03, 0x00, 0x00, } +func (m *LDAPConfiguration) Marshal() (dAtA []byte, err error) { + size := m.ProtoSize() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *LDAPConfiguration) MarshalTo(dAtA []byte) (int, error) { + size := m.ProtoSize() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *LDAPConfiguration) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.SearchFilter) > 0 { + i -= len(m.SearchFilter) + copy(dAtA[i:], m.SearchFilter) + i = encodeVarintLdapconfiguration(dAtA, i, uint64(len(m.SearchFilter))) + i-- + dAtA[i] = 0x32 + } + if len(m.SearchBaseDN) > 0 { + i -= len(m.SearchBaseDN) + copy(dAtA[i:], m.SearchBaseDN) + i = encodeVarintLdapconfiguration(dAtA, i, uint64(len(m.SearchBaseDN))) + i-- + dAtA[i] = 0x2a + } + if m.InsecureSkipVerify { + i-- + if m.InsecureSkipVerify { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x20 + } + if m.Transport != 0 { + i = encodeVarintLdapconfiguration(dAtA, i, uint64(m.Transport)) + i-- + dAtA[i] = 0x18 + } + if len(m.BindDN) > 0 { + i -= len(m.BindDN) + copy(dAtA[i:], m.BindDN) + i = encodeVarintLdapconfiguration(dAtA, i, uint64(len(m.BindDN))) + i-- + dAtA[i] = 0x12 + } + if len(m.Address) > 0 { + i -= len(m.Address) + copy(dAtA[i:], m.Address) + i = encodeVarintLdapconfiguration(dAtA, i, uint64(len(m.Address))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func encodeVarintLdapconfiguration(dAtA []byte, offset int, v uint64) int { + offset -= sovLdapconfiguration(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} func (m *LDAPConfiguration) ProtoSize() (n int) { if m == nil { return 0 @@ -136,3 +223,307 @@ func sovLdapconfiguration(x uint64) (n int) { func sozLdapconfiguration(x uint64) (n int) { return sovLdapconfiguration(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } +func (m *LDAPConfiguration) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLdapconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: LDAPConfiguration: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: LDAPConfiguration: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLdapconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthLdapconfiguration + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthLdapconfiguration + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Address = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BindDN", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLdapconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthLdapconfiguration + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthLdapconfiguration + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BindDN = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Transport", wireType) + } + m.Transport = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLdapconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Transport |= LDAPTransport(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field InsecureSkipVerify", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLdapconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.InsecureSkipVerify = bool(v != 0) + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SearchBaseDN", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLdapconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthLdapconfiguration + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthLdapconfiguration + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SearchBaseDN = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SearchFilter", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLdapconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthLdapconfiguration + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthLdapconfiguration + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SearchFilter = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipLdapconfiguration(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthLdapconfiguration + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthLdapconfiguration + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipLdapconfiguration(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowLdapconfiguration + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowLdapconfiguration + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowLdapconfiguration + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthLdapconfiguration + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupLdapconfiguration + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthLdapconfiguration + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthLdapconfiguration = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowLdapconfiguration = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupLdapconfiguration = fmt.Errorf("proto: unexpected end of group") +) diff --git a/lib/config/ldaptransport.pb.go b/lib/config/ldaptransport.pb.go index a5dbe5e29..237d185cb 100644 --- a/lib/config/ldaptransport.pb.go +++ b/lib/config/ldaptransport.pb.go @@ -53,7 +53,7 @@ func init() { func init() { proto.RegisterFile("lib/config/ldaptransport.proto", fileDescriptor_79795fc8505b82bf) } var fileDescriptor_79795fc8505b82bf = []byte{ - // 269 bytes of a gzipped FileDescriptorProto + // 273 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0xcb, 0xc9, 0x4c, 0xd2, 0x4f, 0xce, 0xcf, 0x4b, 0xcb, 0x4c, 0xd7, 0xcf, 0x49, 0x49, 0x2c, 0x28, 0x29, 0x4a, 0xcc, 0x2b, 0x2e, 0xc8, 0x2f, 0x2a, 0xd1, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x83, 0xc8, 0x49, 0x29, @@ -66,9 +66,10 @@ var fileDescriptor_79795fc8505b82bf = []byte{ 0x35, 0x57, 0x41, 0x00, 0x45, 0x7d, 0x88, 0x4f, 0xf0, 0xa5, 0x3e, 0x55, 0x0c, 0x31, 0xa1, 0x00, 0x2e, 0x09, 0x34, 0x13, 0x82, 0x43, 0x1c, 0xa1, 0xe6, 0x30, 0x4b, 0x19, 0x75, 0xcd, 0x55, 0x10, 0x45, 0xd1, 0x13, 0x5c, 0x92, 0x08, 0x33, 0x0c, 0xbb, 0x84, 0x14, 0xcb, 0x8a, 0x25, 0x72, 0x0c, - 0x4e, 0xee, 0x27, 0x1e, 0xca, 0x31, 0x5c, 0x78, 0x28, 0xc7, 0xf0, 0xe2, 0x91, 0x1c, 0xc3, 0x84, - 0xc7, 0x72, 0x0c, 0x0b, 0x1e, 0xcb, 0x31, 0x5e, 0x78, 0x2c, 0xc7, 0x70, 0xe3, 0xb1, 0x1c, 0x43, - 0x94, 0x66, 0x7a, 0x66, 0x49, 0x46, 0x69, 0x92, 0x5e, 0x72, 0x7e, 0xae, 0x7e, 0x71, 0x65, 0x5e, - 0x72, 0x49, 0x46, 0x66, 0x5e, 0x3a, 0x12, 0x0b, 0x11, 0x11, 0x49, 0x6c, 0xe0, 0x30, 0x34, 0x06, - 0x04, 0x00, 0x00, 0xff, 0xff, 0xc8, 0x64, 0xce, 0xb9, 0x9d, 0x01, 0x00, 0x00, + 0x4e, 0xde, 0x27, 0x1e, 0xca, 0x31, 0x5c, 0x78, 0x28, 0xc7, 0x70, 0xe2, 0x91, 0x1c, 0xe3, 0x85, + 0x47, 0x72, 0x8c, 0x13, 0x1e, 0xcb, 0x31, 0x2c, 0x78, 0x2c, 0xc7, 0x78, 0xe1, 0xb1, 0x1c, 0xc3, + 0x8d, 0xc7, 0x72, 0x0c, 0x51, 0x9a, 0xe9, 0x99, 0x25, 0x19, 0xa5, 0x49, 0x7a, 0xc9, 0xf9, 0xb9, + 0xfa, 0xc5, 0x95, 0x79, 0xc9, 0x25, 0x19, 0x99, 0x79, 0xe9, 0x48, 0x2c, 0x44, 0x64, 0x24, 0xb1, + 0x81, 0xc3, 0xd1, 0x18, 0x10, 0x00, 0x00, 0xff, 0xff, 0xc1, 0x56, 0xde, 0x17, 0xa1, 0x01, 0x00, + 0x00, } diff --git a/lib/config/observed.pb.go b/lib/config/observed.pb.go index c078702e7..e345e58ec 100644 --- a/lib/config/observed.pb.go +++ b/lib/config/observed.pb.go @@ -10,6 +10,7 @@ import ( _ "github.com/golang/protobuf/ptypes/timestamp" github_com_syncthing_syncthing_lib_protocol "github.com/syncthing/syncthing/lib/protocol" _ "github.com/syncthing/syncthing/proto/ext" + io "io" math "math" math_bits "math/bits" time "time" @@ -40,16 +41,25 @@ func (*ObservedFolder) Descriptor() ([]byte, []int) { return fileDescriptor_49f68ff7b178722f, []int{0} } func (m *ObservedFolder) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_ObservedFolder.Unmarshal(m, b) + return m.Unmarshal(b) } func (m *ObservedFolder) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_ObservedFolder.Marshal(b, m, deterministic) + if deterministic { + return xxx_messageInfo_ObservedFolder.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } } func (m *ObservedFolder) XXX_Merge(src proto.Message) { xxx_messageInfo_ObservedFolder.Merge(m, src) } func (m *ObservedFolder) XXX_Size() int { - return xxx_messageInfo_ObservedFolder.Size(m) + return m.ProtoSize() } func (m *ObservedFolder) XXX_DiscardUnknown() { xxx_messageInfo_ObservedFolder.DiscardUnknown(m) @@ -71,16 +81,25 @@ func (*ObservedDevice) Descriptor() ([]byte, []int) { return fileDescriptor_49f68ff7b178722f, []int{1} } func (m *ObservedDevice) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_ObservedDevice.Unmarshal(m, b) + return m.Unmarshal(b) } func (m *ObservedDevice) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_ObservedDevice.Marshal(b, m, deterministic) + if deterministic { + return xxx_messageInfo_ObservedDevice.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } } func (m *ObservedDevice) XXX_Merge(src proto.Message) { xxx_messageInfo_ObservedDevice.Merge(m, src) } func (m *ObservedDevice) XXX_Size() int { - return xxx_messageInfo_ObservedDevice.Size(m) + return m.ProtoSize() } func (m *ObservedDevice) XXX_DiscardUnknown() { xxx_messageInfo_ObservedDevice.DiscardUnknown(m) @@ -96,37 +115,148 @@ func init() { func init() { proto.RegisterFile("lib/config/observed.proto", fileDescriptor_49f68ff7b178722f) } var fileDescriptor_49f68ff7b178722f = []byte{ - // 438 bytes of a gzipped FileDescriptorProto + // 440 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x93, 0x3f, 0x6f, 0xd4, 0x30, - 0x00, 0xc5, 0xe3, 0xf4, 0x68, 0x39, 0x53, 0xfe, 0x28, 0xd3, 0x71, 0x43, 0x5c, 0x9d, 0x32, 0x1c, - 0x02, 0x25, 0xfc, 0x9b, 0x10, 0x42, 0x22, 0x8a, 0x40, 0x27, 0x06, 0xa4, 0x88, 0x89, 0x89, 0x24, - 0x76, 0x53, 0x4b, 0x49, 0x5c, 0x25, 0x6e, 0x55, 0x36, 0x46, 0xc6, 0x96, 0x4f, 0xc0, 0xc7, 0xe9, - 0x76, 0x19, 0x11, 0x83, 0x51, 0x9b, 0x05, 0x65, 0x8c, 0xc4, 0x8e, 0x62, 0x27, 0xee, 0x4d, 0x88, - 0xa9, 0x9b, 0xdf, 0xd3, 0xf3, 0x4f, 0x7e, 0x2f, 0x0a, 0xbc, 0x9f, 0xd1, 0xd8, 0x4b, 0x58, 0xb1, - 0x4f, 0x53, 0x8f, 0xc5, 0x15, 0x29, 0x8f, 0x09, 0x76, 0x0f, 0x4b, 0xc6, 0x99, 0xb5, 0xad, 0xec, - 0x39, 0x4a, 0x19, 0x4b, 0x33, 0xe2, 0x49, 0x37, 0x3e, 0xda, 0xf7, 0x38, 0xcd, 0x49, 0xc5, 0xa3, - 0xfc, 0x50, 0x05, 0xe7, 0x53, 0x72, 0xc2, 0xd5, 0x71, 0xf1, 0x07, 0xc0, 0x3b, 0xef, 0x07, 0xcc, - 0x1b, 0x96, 0x61, 0x52, 0x5a, 0x9f, 0xe0, 0xa4, 0xbf, 0x30, 0x03, 0x7b, 0x60, 0x79, 0xeb, 0xe9, - 0xdc, 0x55, 0x34, 0x77, 0xa4, 0xb9, 0x1f, 0x46, 0x9a, 0xff, 0xf8, 0x5c, 0x20, 0xa3, 0x15, 0x48, - 0xe6, 0x3b, 0x81, 0xee, 0x9e, 0xe4, 0xd9, 0x8b, 0x45, 0x2f, 0x1e, 0x45, 0x9c, 0x97, 0x8b, 0xd3, - 0x5f, 0x08, 0xb4, 0x6b, 0x67, 0xaa, 0x9d, 0x50, 0x26, 0xad, 0x57, 0xd0, 0xa4, 0x78, 0x66, 0xee, - 0x81, 0xe5, 0xd4, 0x77, 0x2f, 0x05, 0x32, 0x57, 0x41, 0x2b, 0x90, 0x49, 0x71, 0x27, 0xd0, 0x6d, - 0xc9, 0xa0, 0x58, 0x11, 0xda, 0xb5, 0xb3, 0x33, 0x9c, 0xbf, 0xd5, 0x8e, 0xb9, 0x0a, 0x42, 0x93, - 0x62, 0xeb, 0x35, 0xbc, 0x91, 0x45, 0x31, 0xc9, 0x66, 0x5b, 0x12, 0xf1, 0xb0, 0x15, 0x48, 0x19, - 0x9d, 0x40, 0xf7, 0xe4, 0x7d, 0xa9, 0x34, 0x02, 0x5e, 0xc9, 0x50, 0x05, 0x17, 0x67, 0x5b, 0x57, - 0xbd, 0x03, 0x72, 0x4c, 0x13, 0x72, 0x0d, 0xbd, 0xcf, 0x80, 0x2e, 0xbe, 0xeb, 0x7f, 0x01, 0x3d, - 0xe5, 0xa7, 0x40, 0xcf, 0x53, 0xca, 0x0f, 0x8e, 0x62, 0x37, 0x61, 0xb9, 0x57, 0x7d, 0x2e, 0x12, - 0x7e, 0x40, 0x8b, 0x74, 0xe3, 0xd4, 0x7f, 0x70, 0xf9, 0x88, 0x84, 0x65, 0xae, 0x7a, 0xeb, 0x2a, - 0xd0, 0xab, 0xdd, 0xc4, 0x83, 0xf3, 0xaf, 0xed, 0xba, 0xb5, 0xa3, 0x73, 0x5f, 0x6b, 0x07, 0x6c, - 0x6c, 0xf9, 0x12, 0x4e, 0x8a, 0x28, 0x27, 0xc3, 0x94, 0xcb, 0xbe, 0x55, 0xaf, 0x75, 0xab, 0x5e, - 0x68, 0xde, 0x54, 0xab, 0x50, 0xa6, 0xac, 0x77, 0x70, 0x27, 0xc2, 0xb8, 0x24, 0x55, 0x35, 0x9b, - 0x48, 0xc0, 0x93, 0x56, 0xa0, 0xd1, 0xea, 0x04, 0xb2, 0x24, 0x63, 0xd0, 0x1a, 0xb3, 0xbb, 0x69, - 0x84, 0x63, 0xdc, 0x7f, 0x7b, 0x7e, 0x61, 0x1b, 0xf5, 0x85, 0x6d, 0xfc, 0xbe, 0xb4, 0x8d, 0xd3, - 0xc6, 0x36, 0xbe, 0x37, 0x36, 0xa8, 0x1b, 0xdb, 0xf8, 0xd1, 0xd8, 0xc6, 0xc7, 0x07, 0xff, 0x31, - 0x93, 0xfa, 0x01, 0xe2, 0x6d, 0x39, 0xd7, 0xb3, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, 0xfb, 0xcb, - 0x46, 0x92, 0x2c, 0x03, 0x00, 0x00, + 0x00, 0xc5, 0xe3, 0xf4, 0x68, 0x39, 0x53, 0xfe, 0x28, 0xd3, 0x71, 0x83, 0x5d, 0x9d, 0x32, 0x1c, + 0x02, 0x25, 0xfc, 0x9b, 0x10, 0x42, 0xe2, 0x74, 0x42, 0x3a, 0x75, 0x40, 0x8a, 0x98, 0x98, 0x48, + 0x62, 0x37, 0xb5, 0x94, 0x9c, 0xab, 0xc4, 0xad, 0xca, 0xc6, 0xc8, 0xd8, 0xf2, 0x09, 0xf8, 0x38, + 0xb7, 0x5d, 0x46, 0xc4, 0x60, 0xd4, 0xcb, 0x96, 0x31, 0x12, 0x3b, 0x8a, 0x9d, 0xf8, 0x6e, 0x42, + 0x4c, 0x6c, 0x7e, 0x4f, 0xcf, 0x3f, 0xf9, 0xbd, 0x28, 0xf0, 0x61, 0xca, 0x22, 0x3f, 0xe6, 0xcb, + 0x13, 0x96, 0xf8, 0x3c, 0x2a, 0x68, 0x7e, 0x41, 0x89, 0x77, 0x96, 0x73, 0xc1, 0x9d, 0x7d, 0x6d, + 0x8f, 0x71, 0xc2, 0x79, 0x92, 0x52, 0x5f, 0xb9, 0xd1, 0xf9, 0x89, 0x2f, 0x58, 0x46, 0x0b, 0x11, + 0x66, 0x67, 0x3a, 0x38, 0x1e, 0xd2, 0x4b, 0xa1, 0x8f, 0x93, 0xdf, 0x00, 0xde, 0x7b, 0xdf, 0x61, + 0xde, 0xf1, 0x94, 0xd0, 0xdc, 0xf9, 0x04, 0x07, 0xed, 0x85, 0x11, 0x38, 0x02, 0xd3, 0x3b, 0xcf, + 0xc7, 0x9e, 0xa6, 0x79, 0x3d, 0xcd, 0xfb, 0xd0, 0xd3, 0x66, 0x4f, 0x57, 0x12, 0x5b, 0xb5, 0xc4, + 0x2a, 0xdf, 0x48, 0x7c, 0xff, 0x32, 0x4b, 0x5f, 0x4d, 0x5a, 0xf1, 0x24, 0x14, 0x22, 0x9f, 0x5c, + 0xfd, 0xc2, 0xa0, 0x5e, 0xbb, 0x43, 0xe3, 0x04, 0x2a, 0xe9, 0xbc, 0x81, 0x36, 0x23, 0x23, 0xfb, + 0x08, 0x4c, 0x87, 0x33, 0x6f, 0x23, 0xb1, 0xbd, 0x98, 0xd7, 0x12, 0xdb, 0x8c, 0x34, 0x12, 0xdf, + 0x55, 0x0c, 0x46, 0x34, 0xa1, 0x5e, 0xbb, 0x07, 0xdd, 0xf9, 0x5b, 0xe9, 0xda, 0x8b, 0x79, 0x60, + 0x33, 0xe2, 0xbc, 0x85, 0xb7, 0xd2, 0x30, 0xa2, 0xe9, 0x68, 0x4f, 0x21, 0x1e, 0xd7, 0x12, 0x6b, + 0xa3, 0x91, 0xf8, 0x81, 0xba, 0xaf, 0x94, 0x41, 0xc0, 0xad, 0x0c, 0x74, 0x70, 0x72, 0xbd, 0xb7, + 0xed, 0x3d, 0xa7, 0x17, 0x2c, 0xa6, 0xff, 0xa1, 0xf7, 0x35, 0x30, 0xc5, 0x0f, 0x67, 0x5f, 0x40, + 0x4b, 0xf9, 0x29, 0xf1, 0xcb, 0x84, 0x89, 0xd3, 0xf3, 0xc8, 0x8b, 0x79, 0xe6, 0x17, 0x9f, 0x97, + 0xb1, 0x38, 0x65, 0xcb, 0x64, 0xe7, 0xd4, 0x7e, 0x70, 0xf5, 0x88, 0x98, 0xa7, 0x9e, 0x7e, 0xeb, + 0x62, 0x6e, 0x56, 0xbb, 0x4d, 0x3a, 0xe7, 0x6f, 0xdb, 0x35, 0x6b, 0xd7, 0xe4, 0xbe, 0x96, 0x2e, + 0xd8, 0xd9, 0xf2, 0x35, 0x1c, 0x2c, 0xc3, 0x8c, 0x76, 0x53, 0x4e, 0xdb, 0x56, 0xad, 0x36, 0xad, + 0x5a, 0x61, 0x78, 0x43, 0xa3, 0x02, 0x95, 0x72, 0x8e, 0xe1, 0x41, 0x48, 0x48, 0x4e, 0x8b, 0x62, + 0x34, 0x50, 0x80, 0x67, 0xb5, 0xc4, 0xbd, 0xd5, 0x48, 0xec, 0x28, 0x46, 0xa7, 0x0d, 0xe6, 0x70, + 0xd7, 0x08, 0xfa, 0xf8, 0xec, 0x78, 0x75, 0x83, 0xac, 0xf2, 0x06, 0x59, 0xab, 0x0d, 0x02, 0xe5, + 0x06, 0x81, 0xab, 0x0a, 0x59, 0xdf, 0x2b, 0x04, 0xca, 0x0a, 0x59, 0x3f, 0x2a, 0x64, 0x7d, 0x7c, + 0xf4, 0x0f, 0x53, 0xe9, 0x9f, 0x20, 0xda, 0x57, 0x93, 0xbd, 0xf8, 0x13, 0x00, 0x00, 0xff, 0xff, + 0xd0, 0xf0, 0x82, 0x78, 0x30, 0x03, 0x00, 0x00, } +func (m *ObservedFolder) Marshal() (dAtA []byte, err error) { + size := m.ProtoSize() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ObservedFolder) MarshalTo(dAtA []byte) (int, error) { + size := m.ProtoSize() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ObservedFolder) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Label) > 0 { + i -= len(m.Label) + copy(dAtA[i:], m.Label) + i = encodeVarintObserved(dAtA, i, uint64(len(m.Label))) + i-- + dAtA[i] = 0x1a + } + if len(m.ID) > 0 { + i -= len(m.ID) + copy(dAtA[i:], m.ID) + i = encodeVarintObserved(dAtA, i, uint64(len(m.ID))) + i-- + dAtA[i] = 0x12 + } + n1, err1 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Time, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Time):]) + if err1 != nil { + return 0, err1 + } + i -= n1 + i = encodeVarintObserved(dAtA, i, uint64(n1)) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *ObservedDevice) Marshal() (dAtA []byte, err error) { + size := m.ProtoSize() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ObservedDevice) MarshalTo(dAtA []byte) (int, error) { + size := m.ProtoSize() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ObservedDevice) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Address) > 0 { + i -= len(m.Address) + copy(dAtA[i:], m.Address) + i = encodeVarintObserved(dAtA, i, uint64(len(m.Address))) + i-- + dAtA[i] = 0x22 + } + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintObserved(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0x1a + } + { + size := m.ID.ProtoSize() + i -= size + if _, err := m.ID.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintObserved(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + n2, err2 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Time, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Time):]) + if err2 != nil { + return 0, err2 + } + i -= n2 + i = encodeVarintObserved(dAtA, i, uint64(n2)) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func encodeVarintObserved(dAtA []byte, offset int, v uint64) int { + offset -= sovObserved(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} func (m *ObservedFolder) ProtoSize() (n int) { if m == nil { return 0 @@ -173,3 +303,420 @@ func sovObserved(x uint64) (n int) { func sozObserved(x uint64) (n int) { return sovObserved(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } +func (m *ObservedFolder) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowObserved + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ObservedFolder: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ObservedFolder: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Time", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowObserved + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthObserved + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthObserved + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.Time, dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowObserved + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthObserved + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthObserved + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ID = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Label", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowObserved + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthObserved + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthObserved + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Label = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipObserved(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthObserved + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthObserved + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ObservedDevice) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowObserved + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ObservedDevice: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ObservedDevice: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Time", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowObserved + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthObserved + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthObserved + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.Time, dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowObserved + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthObserved + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthObserved + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.ID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowObserved + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthObserved + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthObserved + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowObserved + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthObserved + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthObserved + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Address = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipObserved(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthObserved + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthObserved + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipObserved(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowObserved + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowObserved + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowObserved + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthObserved + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupObserved + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthObserved + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthObserved = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowObserved = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupObserved = fmt.Errorf("proto: unexpected end of group") +) diff --git a/lib/config/optionsconfiguration.pb.go b/lib/config/optionsconfiguration.pb.go index 0d6685a64..b4aef27bd 100644 --- a/lib/config/optionsconfiguration.pb.go +++ b/lib/config/optionsconfiguration.pb.go @@ -4,9 +4,11 @@ package config import ( + encoding_binary "encoding/binary" fmt "fmt" proto "github.com/gogo/protobuf/proto" _ "github.com/syncthing/syncthing/proto/ext" + io "io" math "math" math_bits "math/bits" ) @@ -88,16 +90,25 @@ func (*OptionsConfiguration) Descriptor() ([]byte, []int) { return fileDescriptor_d09882599506ca03, []int{0} } func (m *OptionsConfiguration) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_OptionsConfiguration.Unmarshal(m, b) + return m.Unmarshal(b) } func (m *OptionsConfiguration) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_OptionsConfiguration.Marshal(b, m, deterministic) + if deterministic { + return xxx_messageInfo_OptionsConfiguration.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } } func (m *OptionsConfiguration) XXX_Merge(src proto.Message) { xxx_messageInfo_OptionsConfiguration.Merge(m, src) } func (m *OptionsConfiguration) XXX_Size() int { - return xxx_messageInfo_OptionsConfiguration.Size(m) + return m.ProtoSize() } func (m *OptionsConfiguration) XXX_DiscardUnknown() { xxx_messageInfo_OptionsConfiguration.DiscardUnknown(m) @@ -114,203 +125,730 @@ func init() { } var fileDescriptor_d09882599506ca03 = []byte{ - // 3101 bytes of a gzipped FileDescriptorProto + // 3103 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x5a, 0x5b, 0x6c, 0x1d, 0x47, 0x19, 0xce, 0x26, 0x4d, 0xda, 0x6c, 0x1c, 0x27, 0x5e, 0x3b, 0xf6, 0x36, 0x49, 0xbd, 0xee, 0xc9, - 0x49, 0xeb, 0xde, 0xe2, 0x4b, 0xda, 0x10, 0x2c, 0x21, 0xf0, 0xa5, 0x6e, 0x4d, 0x6d, 0xc7, 0x1a, - 0xdb, 0x2a, 0x2a, 0x42, 0xab, 0x39, 0x7b, 0xe6, 0xd8, 0x8b, 0xf7, 0xcc, 0x9e, 0xec, 0xce, 0xfa, - 0x52, 0x50, 0xa9, 0x8a, 0xb8, 0xbc, 0x01, 0x16, 0x17, 0x09, 0x10, 0x2a, 0x02, 0x24, 0x4a, 0x29, - 0x42, 0x42, 0x42, 0x82, 0x17, 0x10, 0x12, 0x52, 0x05, 0x0f, 0xf6, 0x23, 0x12, 0x65, 0x51, 0x9d, - 0x3e, 0xa0, 0xf3, 0xc0, 0xc3, 0x79, 0x34, 0x2f, 0xe8, 0x9f, 0xbd, 0xcd, 0xee, 0xce, 0x69, 0xf2, - 0x76, 0xf6, 0xff, 0xfe, 0xf9, 0xe7, 0xfb, 0xe7, 0xf2, 0xcf, 0xff, 0xcf, 0x1c, 0xf5, 0xba, 0x63, - 0xd7, 0xc6, 0x2c, 0x97, 0x36, 0xec, 0x8d, 0x31, 0xb7, 0xc5, 0x6c, 0x97, 0xfa, 0xd1, 0x57, 0xe0, - 0x61, 0xf8, 0xba, 0xd1, 0xf2, 0x5c, 0xe6, 0x6a, 0x67, 0x22, 0xe1, 0xe5, 0x21, 0x41, 0x9d, 0x05, - 0xd4, 0xa6, 0x1b, 0x91, 0xc2, 0xe5, 0x4b, 0x02, 0xe0, 0xdb, 0xaf, 0x93, 0x58, 0x7c, 0x96, 0xec, - 0xb2, 0xe8, 0x67, 0xe5, 0xc7, 0xf3, 0xea, 0xc0, 0x9d, 0xa8, 0x87, 0x59, 0xb1, 0x07, 0xed, 0x27, - 0x8a, 0x7a, 0xd1, 0xb1, 0x7d, 0x46, 0xa8, 0x89, 0xeb, 0x75, 0x8f, 0xf8, 0x3e, 0xf1, 0x75, 0x65, - 0xe4, 0xd4, 0xe8, 0xd9, 0x19, 0xff, 0x28, 0x34, 0x34, 0x84, 0x77, 0x16, 0x39, 0x3c, 0x9d, 0xa0, - 0xed, 0xd0, 0xb8, 0xe0, 0xe4, 0x45, 0x9d, 0xd0, 0xb8, 0xbe, 0xdb, 0x74, 0xa6, 0x2a, 0x39, 0x79, - 0x65, 0xa4, 0x4e, 0x1a, 0x38, 0x70, 0xd8, 0x54, 0x25, 0xfe, 0x51, 0x39, 0x3e, 0xa8, 0x3e, 0x1c, - 0xff, 0xde, 0x3f, 0xac, 0x4a, 0x8c, 0xa3, 0xa2, 0x69, 0xed, 0xbf, 0x8a, 0xaa, 0x6f, 0x38, 0x6e, - 0x0d, 0x3b, 0x66, 0xdd, 0xf6, 0x2d, 0x77, 0x9b, 0x78, 0x7b, 0xa6, 0x4f, 0xbc, 0x6d, 0xe2, 0xf9, - 0xfa, 0x49, 0x4e, 0xf4, 0x77, 0xca, 0x51, 0x68, 0xf4, 0x23, 0xbc, 0xf3, 0x12, 0xd7, 0x9b, 0xa6, - 0x74, 0x35, 0xc2, 0xdb, 0xa1, 0x71, 0x69, 0x23, 0x91, 0xb9, 0x01, 0xb5, 0x48, 0x0c, 0x74, 0x42, - 0xe3, 0x59, 0x4e, 0x58, 0x86, 0x4a, 0x78, 0xb7, 0x0f, 0xaa, 0x03, 0x32, 0xd5, 0xce, 0x41, 0x55, - 0xde, 0x41, 0xde, 0x51, 0x19, 0x37, 0x34, 0x18, 0x35, 0x9c, 0x4b, 0x9c, 0x8a, 0xe5, 0xda, 0x47, - 0x32, 0x87, 0x09, 0xc5, 0x35, 0x87, 0xd4, 0xf5, 0x53, 0x23, 0xca, 0xe8, 0x23, 0x33, 0xef, 0x80, - 0xc3, 0x17, 0x53, 0x8b, 0x2f, 0x46, 0x60, 0xd9, 0xdb, 0x18, 0xe8, 0x84, 0xc6, 0xd3, 0x12, 0x6f, - 0x63, 0x54, 0x70, 0x97, 0x79, 0x01, 0x01, 0x5f, 0xbb, 0x98, 0xe9, 0x06, 0x1c, 0x1f, 0x54, 0x1f, - 0x82, 0xa6, 0xfb, 0x87, 0xd5, 0x12, 0xa9, 0x92, 0x9b, 0xb1, 0x5c, 0xfb, 0x40, 0x51, 0x87, 0x1c, - 0xd7, 0x92, 0x7a, 0xf9, 0x10, 0xf7, 0xf2, 0x67, 0xe0, 0xe5, 0x85, 0x45, 0xd0, 0xc9, 0x39, 0x39, - 0xe0, 0xc4, 0xa2, 0x82, 0x8f, 0x4f, 0x45, 0x4b, 0x50, 0x02, 0x4a, 0x5c, 0x94, 0x1b, 0xe9, 0x22, - 0x17, 0x1c, 0x2c, 0xf2, 0x41, 0x97, 0x78, 0x83, 0x92, 0x7b, 0x7f, 0x57, 0xd4, 0xfe, 0xc8, 0x3d, - 0x1c, 0xdb, 0x32, 0x5b, 0xae, 0xc7, 0xf4, 0xd3, 0x23, 0xca, 0xe8, 0xe9, 0x99, 0x1f, 0x82, 0x6b, - 0x3d, 0x89, 0xa9, 0x15, 0xd7, 0x63, 0xed, 0xd0, 0xe8, 0xcb, 0x75, 0x0d, 0xc2, 0x4e, 0x68, 0x3c, - 0x59, 0x76, 0x0a, 0x10, 0xc1, 0xa3, 0xc9, 0x89, 0xf1, 0xc9, 0x4f, 0x54, 0x8e, 0x43, 0xe3, 0x94, - 0x4d, 0x59, 0xfb, 0xa0, 0x2a, 0x31, 0x23, 0x13, 0x1e, 0x1f, 0x54, 0x4f, 0xf3, 0xa6, 0xfb, 0x87, - 0xd5, 0x1c, 0x13, 0x54, 0xd6, 0xd5, 0xbe, 0x7a, 0x52, 0x1d, 0x29, 0x78, 0xd3, 0x0c, 0x1c, 0x66, - 0x5b, 0xd8, 0x67, 0x49, 0xdc, 0xd0, 0xcf, 0x8c, 0x28, 0xa3, 0x67, 0x67, 0xfe, 0x00, 0xae, 0xf5, - 0x26, 0x06, 0x97, 0x66, 0x61, 0x27, 0xb7, 0x43, 0xa3, 0x3f, 0x67, 0x34, 0x12, 0x77, 0x42, 0xe3, - 0x56, 0xd9, 0xbd, 0x08, 0x13, 0x1c, 0xfc, 0x7c, 0xa3, 0x31, 0x31, 0x39, 0x35, 0x75, 0xfb, 0xe6, - 0xed, 0xe7, 0xbf, 0x30, 0x15, 0x79, 0xdb, 0x3e, 0xa8, 0x4a, 0x0d, 0xca, 0xc5, 0xc7, 0x07, 0x55, - 0xad, 0x6c, 0x64, 0xff, 0xb0, 0x5a, 0xa0, 0x89, 0x1e, 0xcb, 0x37, 0x4e, 0x3c, 0x8c, 0x83, 0x91, - 0x76, 0x47, 0x3d, 0xdf, 0xc4, 0xbb, 0xa6, 0x4f, 0x68, 0xdd, 0xdc, 0xaa, 0xb5, 0x7c, 0xfd, 0x61, - 0x3e, 0x99, 0xcf, 0xb4, 0x43, 0xe3, 0x5c, 0x13, 0xef, 0xae, 0x12, 0x5a, 0x7f, 0xa5, 0xd6, 0x82, - 0xe0, 0xd2, 0xc7, 0xdd, 0x12, 0x64, 0xc9, 0xfc, 0x20, 0x51, 0x31, 0x31, 0xe8, 0x11, 0x6b, 0x3b, - 0x32, 0xf8, 0x48, 0xce, 0x20, 0x22, 0xd6, 0x76, 0xd1, 0x60, 0x22, 0xcb, 0x19, 0x4c, 0x84, 0xda, - 0xef, 0x15, 0x75, 0xc8, 0x23, 0x96, 0x4b, 0x29, 0xb1, 0x20, 0xbc, 0x9b, 0x36, 0x65, 0xc4, 0xdb, - 0xc6, 0x8e, 0xe9, 0xeb, 0x67, 0xb9, 0xed, 0x37, 0x78, 0x50, 0x4f, 0x54, 0x16, 0x62, 0x78, 0x15, - 0x62, 0x87, 0xd8, 0x30, 0x05, 0x3a, 0xa1, 0x31, 0xca, 0xfb, 0x96, 0xa2, 0xc2, 0x2c, 0xdd, 0x1a, - 0x4f, 0x28, 0x1d, 0x1f, 0x54, 0x4f, 0xde, 0x1a, 0xe7, 0xf1, 0xbd, 0xd4, 0x0f, 0x92, 0xf7, 0xa2, - 0x35, 0xd4, 0x5e, 0x8f, 0x38, 0x78, 0xcf, 0x4f, 0x63, 0x80, 0xca, 0x63, 0xc0, 0xa7, 0xdb, 0xa1, - 0x71, 0x3e, 0x42, 0xb2, 0x8d, 0x5e, 0x89, 0x09, 0x09, 0xd2, 0xe2, 0x0e, 0x4f, 0x76, 0x2c, 0xca, - 0x37, 0xd6, 0xde, 0x3a, 0xa9, 0x5e, 0x89, 0x3b, 0x4a, 0x89, 0x64, 0x83, 0xd4, 0xd4, 0xcf, 0xf1, - 0x41, 0xfa, 0x0b, 0xac, 0xe1, 0x21, 0x04, 0x7a, 0x25, 0x17, 0x96, 0xda, 0xa1, 0x31, 0xe4, 0xc9, - 0xa1, 0x34, 0xd0, 0x76, 0xc1, 0x05, 0x96, 0x13, 0xe3, 0xc2, 0x96, 0xed, 0x6a, 0xaf, 0x3b, 0x04, - 0x83, 0x3c, 0x01, 0x83, 0xdc, 0x8d, 0x26, 0xd2, 0x23, 0x3f, 0xcb, 0x88, 0x56, 0x53, 0xcf, 0xfb, - 0x0c, 0x7b, 0xcc, 0xac, 0x79, 0xee, 0x8e, 0x4f, 0x3c, 0xbd, 0x87, 0x8f, 0xf5, 0xa7, 0xda, 0xa1, - 0xd1, 0xc3, 0x81, 0x99, 0x48, 0xde, 0x09, 0x8d, 0xc7, 0xb9, 0x3b, 0xa2, 0xb0, 0xeb, 0x48, 0xe7, - 0x9a, 0x6a, 0xbf, 0x50, 0xd4, 0x4b, 0x14, 0x33, 0x93, 0x79, 0x18, 0x4e, 0x35, 0xec, 0xa4, 0x13, - 0xdb, 0xcb, 0x3b, 0xbb, 0x7b, 0x14, 0x1a, 0xea, 0xf2, 0xf4, 0x5a, 0x16, 0xd6, 0x55, 0x8a, 0x59, - 0x36, 0xc7, 0x06, 0xef, 0x38, 0x13, 0x49, 0x42, 0xb8, 0xd8, 0x20, 0xf7, 0x25, 0x84, 0x6b, 0xa1, - 0x0b, 0xd4, 0x4f, 0x31, 0x5b, 0x4b, 0xe8, 0x24, 0x0b, 0xe2, 0x8f, 0x25, 0x9e, 0x0e, 0xc1, 0x3e, - 0x31, 0x9b, 0xfa, 0x05, 0xbe, 0x14, 0xbe, 0x0e, 0x4b, 0xe1, 0xec, 0xf2, 0xf4, 0xda, 0x22, 0x88, - 0x61, 0xf2, 0x2f, 0x50, 0xcc, 0xa2, 0x0f, 0x9b, 0x06, 0x8c, 0x27, 0x3f, 0x95, 0x84, 0xac, 0x28, - 0x97, 0xee, 0x8d, 0xf6, 0x41, 0xb5, 0xd4, 0xbe, 0x2c, 0x4a, 0x77, 0x50, 0xd6, 0x31, 0xd2, 0x44, - 0xf6, 0x91, 0x4c, 0xfb, 0x9b, 0xa2, 0x0e, 0xe5, 0xc9, 0x7b, 0x84, 0x92, 0x1d, 0xbe, 0x92, 0x2f, - 0x72, 0xfa, 0xfb, 0x40, 0xff, 0xdc, 0xf2, 0xf4, 0x1a, 0x8a, 0x00, 0x70, 0xa0, 0x8f, 0x62, 0x96, - 0x7c, 0xa6, 0x2e, 0x54, 0x13, 0x17, 0xf2, 0x88, 0xe0, 0xc4, 0x4d, 0xd1, 0x09, 0x89, 0x0d, 0x99, - 0x10, 0x1c, 0xb9, 0x09, 0x8e, 0x88, 0x14, 0xd0, 0x80, 0xe8, 0x4a, 0x22, 0x95, 0x38, 0xc3, 0xec, - 0x26, 0x71, 0x03, 0x66, 0xfa, 0x7a, 0x5f, 0xde, 0x99, 0xb5, 0x08, 0x58, 0x8d, 0x9d, 0x49, 0x3e, - 0x61, 0xa5, 0xd7, 0x73, 0xce, 0xe4, 0x91, 0x6e, 0xdb, 0x4f, 0x62, 0x43, 0x26, 0x4c, 0xb7, 0x9c, - 0x48, 0x21, 0xef, 0x4c, 0x22, 0xd5, 0x7e, 0xa4, 0xa8, 0x7a, 0xe0, 0xe3, 0x0d, 0x62, 0x7a, 0x04, - 0xce, 0x7d, 0x9b, 0x6e, 0x98, 0xd8, 0xb2, 0x48, 0x8b, 0x91, 0xba, 0xae, 0x71, 0x6f, 0x30, 0xec, - 0x80, 0x75, 0x34, 0x1d, 0x4b, 0x61, 0x07, 0x04, 0x5e, 0xf2, 0xd5, 0x09, 0x8d, 0x8b, 0xdc, 0x89, - 0x4c, 0x24, 0x10, 0x16, 0x15, 0x73, 0x5f, 0xb0, 0xe2, 0x33, 0x93, 0x68, 0x90, 0x53, 0x40, 0x09, - 0x83, 0x44, 0xae, 0x7d, 0x49, 0x1d, 0x28, 0x92, 0xf3, 0x09, 0xa1, 0x7a, 0x3f, 0x27, 0xb6, 0x70, - 0x14, 0x1a, 0x67, 0xd6, 0xd1, 0x2a, 0x21, 0xb4, 0x1d, 0x1a, 0x67, 0x02, 0x0f, 0x7e, 0x75, 0x42, - 0xa3, 0x27, 0x26, 0x04, 0x9f, 0x02, 0x99, 0x44, 0x21, 0xfd, 0xb5, 0x7f, 0x58, 0x8d, 0x9b, 0x23, - 0x2d, 0x4f, 0x00, 0x64, 0xda, 0xf7, 0x14, 0xf5, 0xd1, 0x62, 0xef, 0x01, 0xb5, 0xef, 0x06, 0xc4, - 0xb4, 0xeb, 0xfa, 0x00, 0x4f, 0x22, 0x5e, 0x8b, 0xc6, 0x66, 0x9d, 0x8b, 0x17, 0xe6, 0xa2, 0xb1, - 0x89, 0xbf, 0xc4, 0xb1, 0x49, 0x14, 0x2a, 0xd1, 0xa0, 0x24, 0x9f, 0x1d, 0xf1, 0x2b, 0x1e, 0x94, - 0x04, 0x2b, 0x0e, 0x4a, 0xa2, 0xa5, 0xfd, 0x59, 0x51, 0xfb, 0x4b, 0xbc, 0x3c, 0x47, 0xbf, 0xc4, - 0x19, 0x7d, 0x0b, 0xd6, 0xde, 0xe9, 0x75, 0xb4, 0x8e, 0x16, 0xdb, 0xa1, 0x71, 0x3a, 0xf0, 0xd6, - 0xd1, 0x62, 0x27, 0x34, 0x6e, 0x27, 0x44, 0xd0, 0xa2, 0xb0, 0xba, 0x36, 0x19, 0x6b, 0xf9, 0x53, - 0x63, 0x63, 0x75, 0xcc, 0xf0, 0x0d, 0x7f, 0x8f, 0x5a, 0x6c, 0x13, 0x8a, 0x35, 0x4a, 0xd8, 0x18, - 0x25, 0x3b, 0x20, 0x05, 0xc2, 0xb1, 0x91, 0xe4, 0xc7, 0xf1, 0x41, 0xf5, 0x01, 0x1a, 0xee, 0x1f, - 0x56, 0x23, 0x16, 0xa8, 0xaf, 0xe0, 0x87, 0xe7, 0x68, 0xff, 0x56, 0x54, 0xa3, 0xe8, 0x42, 0xcb, - 0xf5, 0xe1, 0x84, 0xf3, 0x89, 0x15, 0x78, 0xc4, 0xd9, 0xd3, 0x07, 0x79, 0xf8, 0xfd, 0x01, 0xaf, - 0x20, 0xd6, 0xd1, 0x8a, 0xeb, 0xb3, 0x85, 0x14, 0x6c, 0x87, 0xc6, 0xc5, 0xc0, 0xcb, 0xcb, 0x3a, - 0xa1, 0xf1, 0x44, 0xec, 0x64, 0x1e, 0x10, 0xfc, 0x6d, 0x60, 0xc7, 0xe7, 0x21, 0xb9, 0xdc, 0x5a, - 0x22, 0x83, 0xcc, 0x93, 0xb7, 0x80, 0x7a, 0xa1, 0x48, 0x01, 0x5d, 0xcd, 0xbb, 0x95, 0x47, 0xb5, - 0x7f, 0x49, 0x3c, 0xb4, 0xa9, 0xcd, 0x6c, 0xa8, 0x23, 0xe0, 0xbc, 0x33, 0x7d, 0x7d, 0x88, 0xaf, - 0xe2, 0xef, 0xf3, 0xea, 0x61, 0x1d, 0x2d, 0x44, 0xe8, 0x1c, 0x80, 0x10, 0x30, 0x2e, 0x04, 0x5e, - 0x4e, 0x94, 0x86, 0x8b, 0x82, 0x5c, 0x0c, 0x16, 0xb7, 0xc7, 0x73, 0x01, 0xbc, 0x68, 0xa1, 0x2c, - 0x82, 0x13, 0x08, 0x5a, 0x41, 0xc1, 0x50, 0xa0, 0x80, 0xae, 0xe4, 0x1d, 0xcc, 0x81, 0x9a, 0xab, - 0xf6, 0x79, 0x24, 0x3a, 0x9c, 0x5d, 0x6a, 0xee, 0xe0, 0x2d, 0x12, 0xb4, 0x74, 0x9d, 0x4f, 0xd9, - 0x2c, 0x90, 0x8f, 0xc1, 0x3b, 0xf4, 0x55, 0x0e, 0xa5, 0xe4, 0x0b, 0xf2, 0xae, 0x87, 0x74, 0xd1, - 0x80, 0xf6, 0x0d, 0x45, 0x1d, 0xc2, 0x01, 0x73, 0xcd, 0xa0, 0xb5, 0xe1, 0xe1, 0x3a, 0xc9, 0x92, - 0xa1, 0x4d, 0xfd, 0x51, 0x3e, 0x90, 0x2b, 0x50, 0x72, 0x81, 0xca, 0x7a, 0xa4, 0x91, 0xe4, 0x11, - 0x2f, 0xa7, 0xd5, 0x89, 0x0c, 0x14, 0x87, 0x6f, 0x52, 0xcc, 0x0c, 0x27, 0x26, 0x91, 0xd4, 0x9a, - 0xd6, 0x54, 0x87, 0x12, 0x0e, 0xcc, 0x35, 0x5b, 0x1e, 0x4c, 0x31, 0x3f, 0x8b, 0x7d, 0xfd, 0x32, - 0x1f, 0x80, 0x5b, 0x40, 0x24, 0x56, 0x59, 0x73, 0x57, 0x3c, 0x82, 0x62, 0xbc, 0x13, 0x1a, 0x97, - 0xa3, 0x29, 0x94, 0x80, 0x15, 0x24, 0x6d, 0xa3, 0x6d, 0xab, 0xda, 0x16, 0x21, 0x2d, 0x93, 0x91, - 0x66, 0xcb, 0xf5, 0xb0, 0x67, 0x13, 0xdf, 0xdc, 0xd4, 0xaf, 0x70, 0x97, 0x5f, 0x86, 0x8d, 0x00, - 0xe8, 0x5a, 0x06, 0x82, 0xbb, 0xd7, 0x78, 0x2f, 0x45, 0x40, 0xac, 0xc5, 0x9e, 0x17, 0x5d, 0x9d, - 0x7c, 0x1e, 0x95, 0xac, 0x68, 0x7b, 0x6a, 0xbf, 0x85, 0xad, 0x4d, 0x62, 0xda, 0x1b, 0xd4, 0xf5, - 0x48, 0xdd, 0x6c, 0xd8, 0x0e, 0xf1, 0xf5, 0xab, 0xdc, 0xc5, 0x05, 0x38, 0xd1, 0x38, 0xbc, 0x10, - 0xa1, 0xf3, 0x00, 0xa6, 0x03, 0x5d, 0x42, 0x4a, 0x7b, 0x30, 0xdd, 0x5b, 0xa8, 0x6c, 0x46, 0xfb, - 0x8e, 0xa2, 0x5e, 0x6e, 0x79, 0xee, 0x06, 0x14, 0x33, 0x66, 0xd0, 0xaa, 0x63, 0x46, 0xc4, 0x02, - 0xe1, 0x31, 0xee, 0xfb, 0x1a, 0xe4, 0xb7, 0x89, 0xd6, 0x3a, 0x57, 0x12, 0x8b, 0x81, 0xa8, 0xc8, - 0xee, 0x82, 0x0b, 0x74, 0x5e, 0x10, 0x06, 0x42, 0x79, 0x01, 0x75, 0xb3, 0xa8, 0xbd, 0xa5, 0xa8, - 0x83, 0x8e, 0xdd, 0xb4, 0x99, 0x59, 0xc3, 0xb4, 0xbe, 0x63, 0xd7, 0xd9, 0xa6, 0x69, 0x53, 0xd3, - 0xc1, 0x54, 0x1f, 0xe6, 0x43, 0xb2, 0xc4, 0x8b, 0x47, 0xd0, 0x98, 0x49, 0x14, 0x16, 0xe8, 0x22, - 0xa6, 0x59, 0xc1, 0x5f, 0xc6, 0x3e, 0x66, 0x58, 0x64, 0xa6, 0xb4, 0x37, 0x15, 0x55, 0x6b, 0xda, - 0xd4, 0xdc, 0x74, 0x9b, 0xc4, 0xac, 0xdb, 0xfe, 0x96, 0xd9, 0xf0, 0x08, 0xd1, 0x8d, 0x11, 0x65, - 0xf4, 0xdc, 0x64, 0xcf, 0x8d, 0xe8, 0x66, 0xed, 0xc6, 0xaa, 0xfd, 0x3a, 0x99, 0x79, 0xf1, 0xfd, - 0xd0, 0x38, 0x01, 0x3b, 0xb1, 0x69, 0xd3, 0x97, 0xdd, 0x26, 0x99, 0xb3, 0xfd, 0xad, 0x79, 0x8f, - 0x90, 0x74, 0x75, 0x14, 0xe4, 0xe2, 0x3e, 0x18, 0xb9, 0x0e, 0x44, 0x4e, 0x4d, 0x8c, 0x5c, 0x47, - 0xc5, 0xe6, 0xda, 0x3d, 0x45, 0xed, 0x49, 0xd6, 0x3b, 0x3f, 0x76, 0x46, 0xf8, 0xb1, 0xf3, 0x27, - 0x9e, 0xf2, 0x24, 0x8b, 0x36, 0x3a, 0x7c, 0xce, 0x79, 0xd9, 0x67, 0x27, 0x34, 0xe6, 0x92, 0x8a, - 0x23, 0x91, 0x49, 0x0e, 0xa2, 0x78, 0x07, 0xf8, 0x85, 0x33, 0xa5, 0x49, 0x18, 0xbe, 0xf1, 0x45, - 0xdf, 0xa5, 0x10, 0xbb, 0x73, 0x66, 0xf3, 0x9f, 0xc7, 0x07, 0xd5, 0xd1, 0x07, 0x35, 0x05, 0xf9, - 0x91, 0xc0, 0x17, 0x65, 0x76, 0x3c, 0x47, 0x7b, 0x55, 0xed, 0xc3, 0xce, 0x0e, 0x54, 0x5f, 0xd1, - 0x6d, 0x02, 0x25, 0xcc, 0xd7, 0x1f, 0xe7, 0x97, 0x78, 0x50, 0xf4, 0x5e, 0x88, 0x40, 0x5e, 0x95, - 0x2f, 0x13, 0x06, 0x0b, 0x7f, 0x20, 0x8a, 0x30, 0x39, 0x79, 0x05, 0x15, 0x15, 0xb5, 0xff, 0x29, - 0xea, 0xa8, 0xbb, 0x4d, 0xbc, 0x1d, 0xcf, 0x66, 0x10, 0x38, 0x9a, 0x2e, 0x23, 0x66, 0x9d, 0x6c, - 0xdb, 0x16, 0x31, 0x29, 0x6e, 0x12, 0x1f, 0xc2, 0x69, 0x5c, 0x08, 0xe9, 0x95, 0xec, 0x7a, 0x69, - 0xe8, 0x4e, 0xd2, 0x08, 0xf1, 0x36, 0x73, 0x64, 0x7b, 0x19, 0xd4, 0xdb, 0xa1, 0x71, 0xcd, 0x2d, - 0x41, 0xb6, 0x45, 0x38, 0x7a, 0x87, 0xce, 0x46, 0xa6, 0x3a, 0xa1, 0xf1, 0x49, 0x4e, 0xf0, 0x01, - 0x74, 0xbb, 0x2f, 0x4a, 0xa8, 0xe2, 0xba, 0xf0, 0x40, 0x0f, 0xc2, 0x42, 0xfb, 0x8a, 0x7a, 0x09, - 0xc2, 0x98, 0x69, 0xd3, 0x3a, 0xd9, 0x35, 0x61, 0x25, 0xd7, 0x1c, 0xd7, 0xda, 0xf2, 0xf5, 0x6b, - 0x7c, 0x4b, 0xc3, 0xa2, 0xd1, 0x40, 0x61, 0x01, 0xf0, 0x25, 0x9b, 0xce, 0x70, 0x34, 0xbd, 0xb5, - 0x2d, 0x43, 0xd2, 0x4c, 0x39, 0xca, 0x7f, 0x91, 0xc4, 0x92, 0xf6, 0x4f, 0x48, 0x77, 0x29, 0xb6, - 0xb6, 0x48, 0xdd, 0xa4, 0x2e, 0xb3, 0x1b, 0xb6, 0x85, 0xa3, 0xfb, 0x87, 0xba, 0xaf, 0x57, 0xf9, - 0xfc, 0xbe, 0x0d, 0xc3, 0x3d, 0xb8, 0x1e, 0x29, 0x2d, 0x0b, 0x3a, 0x0b, 0x73, 0x30, 0xda, 0x83, - 0x81, 0x14, 0xe9, 0x84, 0xc6, 0x95, 0x28, 0xb4, 0xcb, 0x60, 0x7e, 0x57, 0x29, 0x45, 0x3a, 0x07, - 0xd5, 0x2e, 0x16, 0xf7, 0x0f, 0xab, 0x5d, 0x58, 0x20, 0x69, 0x8b, 0xba, 0xaf, 0x21, 0xf5, 0x3c, - 0xf3, 0x70, 0xa3, 0x61, 0x5b, 0xa6, 0xe5, 0x60, 0xdf, 0xd7, 0xaf, 0xf3, 0x61, 0x7d, 0x0e, 0xea, - 0xe5, 0x18, 0x98, 0x05, 0x79, 0x27, 0x34, 0xb4, 0x68, 0x40, 0x05, 0x61, 0x7a, 0x51, 0x93, 0x53, - 0xd5, 0xee, 0xaa, 0xfd, 0xf1, 0x10, 0x9b, 0x0d, 0xd7, 0xa9, 0x13, 0xcf, 0x6c, 0x61, 0xb6, 0xa9, - 0x3f, 0xc1, 0x77, 0xfd, 0x34, 0x1c, 0x03, 0x31, 0x3c, 0xcf, 0xd1, 0x15, 0xcc, 0x36, 0xd3, 0x10, - 0x53, 0x42, 0x84, 0xe9, 0x7a, 0x03, 0x96, 0x95, 0xf2, 0x06, 0x2a, 0x37, 0xd7, 0xb6, 0xd4, 0x8b, - 0x3e, 0x61, 0xa6, 0xe3, 0xee, 0x98, 0x2d, 0xcf, 0x76, 0x3d, 0x9b, 0xed, 0xe9, 0x4f, 0xf2, 0xad, - 0x00, 0xfd, 0xf5, 0xfa, 0x84, 0x2d, 0xba, 0x3b, 0x2b, 0x31, 0x92, 0x76, 0x96, 0x17, 0x77, 0x4d, - 0x2c, 0x0a, 0xcd, 0xb5, 0x77, 0x14, 0x75, 0xb0, 0x89, 0x77, 0x13, 0xe7, 0x2c, 0x97, 0x5a, 0x81, - 0xe7, 0x11, 0x6a, 0xed, 0xe9, 0xa3, 0x7c, 0xf4, 0x7c, 0x7e, 0xc5, 0x82, 0x77, 0x96, 0xf0, 0x6e, - 0xc4, 0x71, 0x36, 0x53, 0x81, 0x83, 0xbe, 0x29, 0x91, 0xa7, 0x07, 0xbd, 0x0c, 0x4c, 0x06, 0x9a, - 0xdf, 0x89, 0xc8, 0xed, 0x22, 0xa9, 0x55, 0xed, 0x03, 0x45, 0xed, 0xb7, 0x3c, 0xec, 0x6f, 0x16, - 0x32, 0xff, 0xa7, 0xf8, 0x64, 0xbc, 0xcb, 0x33, 0xff, 0xd9, 0x24, 0xf3, 0xb7, 0xe2, 0xcc, 0x7f, - 0x3e, 0x3a, 0x91, 0xa1, 0x59, 0x96, 0x83, 0x4b, 0x83, 0x2f, 0xd7, 0x29, 0x67, 0xf3, 0x5c, 0x0c, - 0x2b, 0xb8, 0xaf, 0x64, 0x04, 0x6a, 0x02, 0x2b, 0xae, 0x09, 0xaa, 0x0f, 0x62, 0x06, 0xaa, 0x82, - 0xd9, 0xa8, 0x2a, 0x28, 0x18, 0xf3, 0x1c, 0xed, 0xa7, 0x8a, 0x3a, 0x54, 0x74, 0x2f, 0xb9, 0x8c, - 0x79, 0x9a, 0xcf, 0xbf, 0x7d, 0x14, 0x1a, 0x67, 0x67, 0x91, 0xf0, 0x8e, 0x90, 0xb7, 0x52, 0x7c, - 0x47, 0x90, 0xa2, 0xdd, 0x96, 0xc6, 0xfe, 0x61, 0x35, 0xb3, 0x8d, 0xe4, 0x96, 0xb5, 0xaf, 0x29, - 0xea, 0xa0, 0xcf, 0x02, 0x6a, 0x42, 0xbe, 0x84, 0x1d, 0x7b, 0x9b, 0x98, 0x51, 0x16, 0xec, 0xeb, - 0xcf, 0xa4, 0x59, 0x68, 0x3f, 0x68, 0xbc, 0x92, 0x28, 0xac, 0x02, 0xbe, 0x9a, 0xe6, 0x46, 0x12, - 0x2c, 0x9f, 0xc2, 0x0b, 0x61, 0xec, 0xd4, 0xc4, 0xed, 0x71, 0x24, 0xb3, 0x06, 0x95, 0x71, 0x81, - 0x06, 0x44, 0x53, 0x5f, 0x7f, 0x96, 0x93, 0xf8, 0x2c, 0xec, 0xcb, 0x5c, 0xb3, 0x25, 0x9b, 0x66, - 0x15, 0x44, 0x09, 0x11, 0x33, 0xc3, 0x5c, 0x18, 0x9d, 0x1c, 0x47, 0x65, 0x3b, 0x90, 0x8b, 0xf7, - 0xf0, 0xde, 0x93, 0xe7, 0xad, 0xe7, 0x78, 0xe4, 0xac, 0x1f, 0x85, 0x46, 0x2f, 0xc2, 0x3b, 0xab, - 0x2c, 0x10, 0x1e, 0xb6, 0xce, 0xf9, 0xd9, 0x67, 0x7a, 0x05, 0x95, 0xc9, 0xee, 0xfb, 0xf8, 0x56, - 0xb0, 0x88, 0x44, 0x7b, 0xda, 0xb6, 0x7a, 0x01, 0x8a, 0xcd, 0x1a, 0xf6, 0x89, 0x19, 0xbd, 0x34, - 0xea, 0x37, 0x46, 0x94, 0xd1, 0xde, 0xc9, 0xde, 0x24, 0x19, 0x5a, 0xe3, 0x52, 0x7e, 0x67, 0xd8, - 0x9b, 0xa8, 0x46, 0xb2, 0x2c, 0x4c, 0xe5, 0xc4, 0x95, 0x91, 0xb8, 0xf4, 0x88, 0x97, 0xc7, 0x9b, - 0x87, 0x55, 0x05, 0x15, 0x9a, 0x6a, 0xdf, 0x3d, 0xa9, 0x5e, 0x83, 0xa8, 0x91, 0x86, 0x0b, 0x28, - 0x5d, 0x2d, 0xb7, 0x09, 0x4b, 0xd6, 0x23, 0x77, 0x03, 0xe2, 0x33, 0x73, 0xcb, 0xae, 0xe9, 0x63, - 0x7c, 0x3a, 0xfe, 0xaa, 0xc4, 0x2f, 0x94, 0x4b, 0x78, 0x77, 0x76, 0x01, 0x45, 0xf8, 0x2b, 0xf6, - 0x4c, 0x3b, 0x34, 0x8c, 0x26, 0xde, 0x4d, 0xb7, 0x38, 0x5b, 0x88, 0x6d, 0x64, 0x2a, 0xe9, 0xd9, - 0x77, 0x1f, 0x3d, 0xa1, 0xec, 0xbb, 0xaf, 0xc9, 0xfb, 0xab, 0xc4, 0x6f, 0x9e, 0x05, 0xba, 0xe8, - 0x3e, 0xcd, 0x6a, 0xda, 0x47, 0x8a, 0x3a, 0x98, 0x3e, 0xbc, 0x38, 0x58, 0x7c, 0xaa, 0x1d, 0xe7, - 0x1b, 0xf8, 0x3d, 0x18, 0x89, 0x81, 0xe4, 0xe1, 0x62, 0x71, 0x7a, 0x59, 0x7c, 0xad, 0x1d, 0xc0, - 0x12, 0x79, 0x9a, 0x3e, 0xcb, 0x40, 0xd9, 0x7b, 0x99, 0xd4, 0x48, 0x17, 0xb9, 0xb0, 0xf5, 0xa5, - 0xa4, 0x50, 0xd6, 0x0a, 0x0b, 0x4f, 0xbd, 0xdb, 0xea, 0x65, 0xfe, 0xb6, 0xd2, 0x08, 0x1c, 0x27, - 0xce, 0x65, 0x5c, 0x9a, 0x14, 0xa6, 0xfa, 0x04, 0xf7, 0x74, 0x0a, 0x72, 0x05, 0xd0, 0x9a, 0x0f, - 0x1c, 0x87, 0x67, 0x21, 0x77, 0x68, 0x5c, 0x4a, 0x76, 0x42, 0xe3, 0x6a, 0x7c, 0x64, 0xc9, 0xe0, - 0x0a, 0xea, 0xd2, 0x4e, 0xfb, 0xb2, 0xda, 0x13, 0xb4, 0x68, 0x2b, 0x0d, 0x8a, 0xbf, 0x9c, 0xe7, - 0x5d, 0x7d, 0xee, 0x28, 0x34, 0x2e, 0xcd, 0x91, 0x96, 0x47, 0x2c, 0xcc, 0x48, 0x7d, 0x7d, 0x85, - 0xae, 0x64, 0x11, 0x52, 0x79, 0x2e, 0x4b, 0x4d, 0x5a, 0xb4, 0x15, 0x03, 0xcf, 0xba, 0x4d, 0x1b, - 0xd2, 0x23, 0xb6, 0x57, 0xd9, 0x3f, 0xac, 0xca, 0x1b, 0xeb, 0x0a, 0x3a, 0x27, 0x34, 0xd1, 0x7e, - 0xae, 0xc4, 0xdd, 0x27, 0x17, 0xcf, 0xef, 0xcc, 0xf3, 0xd5, 0xfd, 0x26, 0x9f, 0xd3, 0xbc, 0x89, - 0xf4, 0x12, 0x9a, 0x77, 0x3f, 0x92, 0x76, 0x2f, 0x5e, 0x1e, 0x0b, 0x1c, 0xb2, 0xc5, 0x7b, 0xb9, - 0xbb, 0x16, 0x4c, 0x92, 0xac, 0x17, 0x5d, 0x41, 0x6a, 0xd6, 0x4a, 0xfb, 0xad, 0xa2, 0xf6, 0x72, - 0x9a, 0xd9, 0x15, 0xf3, 0xaf, 0x22, 0xa2, 0xdf, 0xe4, 0x99, 0x5d, 0xde, 0x84, 0x70, 0xdd, 0xcc, - 0xa9, 0x56, 0x52, 0xaa, 0xf9, 0x0b, 0x62, 0x29, 0xd9, 0xab, 0x1f, 0xa7, 0x07, 0xf9, 0x9b, 0xbc, - 0x2f, 0x5d, 0x41, 0x3d, 0x62, 0xcb, 0x8c, 0x72, 0x76, 0x91, 0xfc, 0x6e, 0x77, 0xca, 0xc2, 0xa5, - 0x72, 0x81, 0x72, 0xfe, 0x1a, 0xb8, 0x3b, 0xe5, 0x6e, 0x7a, 0x65, 0xca, 0x89, 0x66, 0x42, 0x39, - 0xbd, 0x37, 0x6e, 0xa8, 0xd1, 0x83, 0x55, 0x7a, 0x04, 0xfc, 0x7a, 0x9e, 0x9f, 0x01, 0x9f, 0xc9, - 0xf3, 0xe5, 0x6f, 0x3e, 0xd9, 0x59, 0x20, 0x2c, 0x46, 0x2f, 0x43, 0x04, 0xa2, 0xd0, 0x8f, 0x80, - 0xf8, 0xbc, 0xec, 0x2e, 0x57, 0xbc, 0x66, 0xcb, 0x62, 0xfa, 0x7b, 0x30, 0x44, 0xca, 0xcc, 0xd2, - 0x51, 0x68, 0x5c, 0xcd, 0x7a, 0x5c, 0xca, 0xd7, 0xab, 0x2b, 0x16, 0xcb, 0x8f, 0x53, 0xb3, 0x84, - 0xe7, 0xbb, 0xd7, 0xca, 0x0a, 0x70, 0xde, 0x0d, 0x14, 0xa2, 0xbd, 0x6f, 0x61, 0xea, 0xeb, 0xbf, - 0x89, 0x66, 0x69, 0xad, 0x40, 0x41, 0x8c, 0x92, 0xab, 0xa0, 0x58, 0xa0, 0x50, 0xc2, 0xcb, 0x53, - 0xc5, 0x99, 0x94, 0xf4, 0x66, 0x5e, 0x7a, 0xff, 0xc3, 0xe1, 0x13, 0x87, 0x1f, 0x0e, 0x9f, 0xf8, - 0xcf, 0xd1, 0xf0, 0x89, 0x6f, 0xdf, 0x1b, 0x3e, 0xf1, 0xf6, 0xbd, 0x61, 0xe5, 0xf0, 0xde, 0xf0, - 0x89, 0x7f, 0xdc, 0x1b, 0x3e, 0xf1, 0xda, 0x53, 0x1b, 0x36, 0xdb, 0x0c, 0x6a, 0x37, 0x2c, 0xb7, - 0x39, 0x96, 0xe6, 0x5f, 0xc2, 0xaf, 0xec, 0xdf, 0x37, 0xb5, 0x33, 0xfc, 0xef, 0x36, 0x37, 0xff, - 0x1f, 0x00, 0x00, 0xff, 0xff, 0x0b, 0x9c, 0x92, 0x45, 0xda, 0x23, 0x00, 0x00, + 0x49, 0xeb, 0xde, 0xe2, 0x4b, 0xda, 0x10, 0x2c, 0x21, 0xf0, 0xa5, 0xa6, 0x26, 0xb6, 0x63, 0x8d, + 0x6d, 0x15, 0x15, 0xa1, 0xd5, 0x9c, 0x3d, 0x73, 0xec, 0xc5, 0x7b, 0x66, 0x4f, 0x76, 0x67, 0x7d, + 0x29, 0xa8, 0x54, 0x45, 0x5c, 0xde, 0x00, 0x8b, 0x8b, 0x04, 0x08, 0x15, 0x01, 0x12, 0xa5, 0x14, + 0x21, 0x21, 0x21, 0xc1, 0x0b, 0x08, 0x09, 0xa9, 0x82, 0x07, 0xfb, 0x11, 0x89, 0xb2, 0xa8, 0x4e, + 0x9f, 0xce, 0x03, 0x0f, 0xe7, 0xd1, 0xbc, 0xa0, 0x7f, 0xf6, 0x36, 0xbb, 0x3b, 0xa7, 0xc9, 0xdb, + 0xd9, 0xff, 0xfb, 0xe7, 0x9f, 0xef, 0x9f, 0xcb, 0x3f, 0xff, 0x3f, 0x73, 0xd4, 0xeb, 0x8e, 0x5d, + 0x1b, 0xb3, 0x5c, 0xda, 0xb0, 0x37, 0xc6, 0xdc, 0x16, 0xb3, 0x5d, 0xea, 0x47, 0x5f, 0x81, 0x87, + 0xe1, 0xeb, 0x46, 0xcb, 0x73, 0x99, 0xab, 0x9d, 0x89, 0x84, 0x97, 0x87, 0x04, 0x75, 0x16, 0x50, + 0x9b, 0x6e, 0x44, 0x0a, 0x97, 0x2f, 0x09, 0x80, 0x6f, 0xbf, 0x4e, 0x62, 0xf1, 0x59, 0xb2, 0xcb, + 0xa2, 0x9f, 0x95, 0x9f, 0xcc, 0xab, 0x03, 0x77, 0xa3, 0x1e, 0x66, 0xc5, 0x1e, 0xb4, 0x9f, 0x2a, + 0xea, 0x45, 0xc7, 0xf6, 0x19, 0xa1, 0x26, 0xae, 0xd7, 0x3d, 0xe2, 0xfb, 0xc4, 0xd7, 0x95, 0x91, + 0x53, 0xa3, 0x67, 0x67, 0xfc, 0xa3, 0xd0, 0xd0, 0x10, 0xde, 0x59, 0xe4, 0xf0, 0x74, 0x82, 0xb6, + 0x43, 0xe3, 0x82, 0x93, 0x17, 0x75, 0x42, 0xe3, 0xfa, 0x6e, 0xd3, 0x99, 0xaa, 0xe4, 0xe4, 0x95, + 0x91, 0x3a, 0x69, 0xe0, 0xc0, 0x61, 0x53, 0x95, 0xf8, 0x47, 0xe5, 0xf8, 0xa0, 0xfa, 0x68, 0xfc, + 0x7b, 0xff, 0xb0, 0x2a, 0x31, 0x8e, 0x8a, 0xa6, 0xb5, 0xff, 0x2a, 0xaa, 0xbe, 0xe1, 0xb8, 0x35, + 0xec, 0x98, 0x75, 0xdb, 0xb7, 0xdc, 0x6d, 0xe2, 0xed, 0x99, 0x3e, 0xf1, 0xb6, 0x89, 0xe7, 0xeb, + 0x27, 0x39, 0xd1, 0xdf, 0x2b, 0x47, 0xa1, 0xd1, 0x8f, 0xf0, 0xce, 0x67, 0xb9, 0xde, 0x34, 0xa5, + 0xab, 0x11, 0xde, 0x0e, 0x8d, 0x4b, 0x1b, 0x89, 0xcc, 0x0d, 0xa8, 0x45, 0x62, 0xa0, 0x13, 0x1a, + 0xcf, 0x73, 0xc2, 0x32, 0x54, 0xc2, 0xbb, 0x7d, 0x50, 0x1d, 0x90, 0xa9, 0x76, 0x0e, 0xaa, 0xf2, + 0x0e, 0xf2, 0x8e, 0xca, 0xb8, 0xa1, 0xc1, 0xa8, 0xe1, 0x5c, 0xe2, 0x54, 0x2c, 0xd7, 0x3e, 0x92, + 0x39, 0x4c, 0x28, 0xae, 0x39, 0xa4, 0xae, 0x9f, 0x1a, 0x51, 0x46, 0x1f, 0x9b, 0x79, 0x07, 0x1c, + 0xbe, 0x98, 0x5a, 0x7c, 0x39, 0x02, 0xcb, 0xde, 0xc6, 0x40, 0x27, 0x34, 0x9e, 0x95, 0x78, 0x1b, + 0xa3, 0x82, 0xbb, 0xcc, 0x0b, 0x08, 0xf8, 0xda, 0xc5, 0x4c, 0x37, 0xe0, 0xf8, 0xa0, 0xfa, 0x08, + 0x34, 0xdd, 0x3f, 0xac, 0x96, 0x48, 0x95, 0xdc, 0x8c, 0xe5, 0xda, 0x07, 0x8a, 0x3a, 0xe4, 0xb8, + 0x96, 0xd4, 0xcb, 0x47, 0xb8, 0x97, 0x3f, 0x07, 0x2f, 0x2f, 0x2c, 0x82, 0x4e, 0xce, 0xc9, 0x01, + 0x27, 0x16, 0x15, 0x7c, 0x7c, 0x26, 0x5a, 0x82, 0x12, 0x50, 0xe2, 0xa2, 0xdc, 0x48, 0x17, 0xb9, + 0xe0, 0x60, 0x91, 0x0f, 0xba, 0xc4, 0x1b, 0x94, 0xdc, 0xfb, 0x87, 0xa2, 0xf6, 0x47, 0xee, 0xe1, + 0xd8, 0x96, 0xd9, 0x72, 0x3d, 0xa6, 0x9f, 0x1e, 0x51, 0x46, 0x4f, 0xcf, 0xfc, 0x08, 0x5c, 0xeb, + 0x49, 0x4c, 0xad, 0xb8, 0x1e, 0x6b, 0x87, 0x46, 0x5f, 0xae, 0x6b, 0x10, 0x76, 0x42, 0xe3, 0xe9, + 0xb2, 0x53, 0x80, 0x08, 0x1e, 0x4d, 0x4e, 0x8c, 0x4f, 0x7e, 0xa2, 0x72, 0x1c, 0x1a, 0xa7, 0x6c, + 0xca, 0xda, 0x07, 0x55, 0x89, 0x19, 0x99, 0xf0, 0xf8, 0xa0, 0x7a, 0x9a, 0x37, 0xdd, 0x3f, 0xac, + 0xe6, 0x98, 0xa0, 0xb2, 0xae, 0xf6, 0xb5, 0x93, 0xea, 0x48, 0xc1, 0x9b, 0x66, 0xe0, 0x30, 0xdb, + 0xc2, 0x3e, 0x4b, 0xe2, 0x86, 0x7e, 0x66, 0x44, 0x19, 0x3d, 0x3b, 0xf3, 0x47, 0x70, 0xad, 0x37, + 0x31, 0xb8, 0x34, 0x0b, 0x3b, 0xb9, 0x1d, 0x1a, 0xfd, 0x39, 0xa3, 0x91, 0xb8, 0x13, 0x1a, 0xb7, + 0xca, 0xee, 0x45, 0x98, 0xe0, 0xe0, 0x17, 0x1a, 0x8d, 0x89, 0xc9, 0xa9, 0xa9, 0xdb, 0x37, 0x6f, + 0xbf, 0xf8, 0xc5, 0xa9, 0xc8, 0xdb, 0xf6, 0x41, 0x55, 0x6a, 0x50, 0x2e, 0x3e, 0x3e, 0xa8, 0x6a, + 0x65, 0x23, 0xfb, 0x87, 0xd5, 0x02, 0x4d, 0xf4, 0x44, 0xbe, 0x71, 0xe2, 0x61, 0x1c, 0x8c, 0xb4, + 0xbb, 0xea, 0xf9, 0x26, 0xde, 0x35, 0x7d, 0x42, 0xeb, 0xe6, 0x56, 0xad, 0xe5, 0xeb, 0x8f, 0xf2, + 0xc9, 0x7c, 0xae, 0x1d, 0x1a, 0xe7, 0x9a, 0x78, 0x77, 0x95, 0xd0, 0xfa, 0x9d, 0x5a, 0x0b, 0x82, + 0x4b, 0x1f, 0x77, 0x4b, 0x90, 0x25, 0xf3, 0x83, 0x44, 0xc5, 0xc4, 0xa0, 0x47, 0xac, 0xed, 0xc8, + 0xe0, 0x63, 0x39, 0x83, 0x88, 0x58, 0xdb, 0x45, 0x83, 0x89, 0x2c, 0x67, 0x30, 0x11, 0x6a, 0x7f, + 0x50, 0xd4, 0x21, 0x8f, 0x58, 0x2e, 0xa5, 0xc4, 0x82, 0xf0, 0x6e, 0xda, 0x94, 0x11, 0x6f, 0x1b, + 0x3b, 0xa6, 0xaf, 0x9f, 0xe5, 0xb6, 0xdf, 0xe0, 0x41, 0x3d, 0x51, 0x59, 0x88, 0xe1, 0x55, 0x88, + 0x1d, 0x62, 0xc3, 0x14, 0xe8, 0x84, 0xc6, 0x28, 0xef, 0x5b, 0x8a, 0x0a, 0xb3, 0x74, 0x6b, 0x3c, + 0xa1, 0x74, 0x7c, 0x50, 0x3d, 0x79, 0x6b, 0x9c, 0xc7, 0xf7, 0x52, 0x3f, 0x48, 0xde, 0x8b, 0xd6, + 0x50, 0x7b, 0x3d, 0xe2, 0xe0, 0x3d, 0x3f, 0x8d, 0x01, 0x2a, 0x8f, 0x01, 0x9f, 0x6e, 0x87, 0xc6, + 0xf9, 0x08, 0xc9, 0x36, 0x7a, 0x25, 0x26, 0x24, 0x48, 0x8b, 0x3b, 0x3c, 0xd9, 0xb1, 0x28, 0xdf, + 0x58, 0x7b, 0xeb, 0xa4, 0x7a, 0x25, 0xee, 0x28, 0x25, 0x92, 0x0d, 0x52, 0x53, 0x3f, 0xc7, 0x07, + 0xe9, 0xaf, 0xb0, 0x86, 0x87, 0x10, 0xe8, 0x95, 0x5c, 0x58, 0x6a, 0x87, 0xc6, 0x90, 0x27, 0x87, + 0xd2, 0x40, 0xdb, 0x05, 0x17, 0x58, 0x4e, 0x8c, 0x0b, 0x5b, 0xb6, 0xab, 0xbd, 0xee, 0x10, 0x0c, + 0xf2, 0x04, 0x0c, 0x72, 0x37, 0x9a, 0x48, 0x8f, 0xfc, 0x2c, 0x23, 0x5a, 0x4d, 0x3d, 0xef, 0x33, + 0xec, 0x31, 0xb3, 0xe6, 0xb9, 0x3b, 0x3e, 0xf1, 0xf4, 0x1e, 0x3e, 0xd6, 0x9f, 0x6a, 0x87, 0x46, + 0x0f, 0x07, 0x66, 0x22, 0x79, 0x27, 0x34, 0x9e, 0xe4, 0xee, 0x88, 0xc2, 0xae, 0x23, 0x9d, 0x6b, + 0xaa, 0xfd, 0x52, 0x51, 0x2f, 0x51, 0xcc, 0x4c, 0xe6, 0x61, 0x38, 0xd5, 0xb0, 0x93, 0x4e, 0x6c, + 0x2f, 0xef, 0xec, 0xde, 0x51, 0x68, 0xa8, 0xcb, 0xd3, 0x6b, 0x59, 0x58, 0x57, 0x29, 0x66, 0xd9, + 0x1c, 0x1b, 0xbc, 0xe3, 0x4c, 0x24, 0x09, 0xe1, 0x62, 0x83, 0xdc, 0x97, 0x10, 0xae, 0x85, 0x2e, + 0x50, 0x3f, 0xc5, 0x6c, 0x2d, 0xa1, 0x93, 0x2c, 0x88, 0x3f, 0x95, 0x78, 0x3a, 0x04, 0xfb, 0xc4, + 0x6c, 0xea, 0x17, 0xf8, 0x52, 0xf8, 0x06, 0x2c, 0x85, 0xb3, 0xcb, 0xd3, 0x6b, 0x8b, 0x20, 0x86, + 0xc9, 0xbf, 0x40, 0x31, 0x8b, 0x3e, 0x6c, 0x1a, 0x30, 0x9e, 0xfc, 0x54, 0x12, 0xb2, 0xa2, 0x5c, + 0xba, 0x37, 0xda, 0x07, 0xd5, 0x52, 0xfb, 0xb2, 0x28, 0xdd, 0x41, 0x59, 0xc7, 0x48, 0x13, 0xd9, + 0x47, 0x32, 0xed, 0xef, 0x8a, 0x3a, 0x94, 0x27, 0xef, 0x11, 0x4a, 0x76, 0xf8, 0x4a, 0xbe, 0xc8, + 0xe9, 0xef, 0x03, 0xfd, 0x73, 0xcb, 0xd3, 0x6b, 0x28, 0x02, 0xc0, 0x81, 0x3e, 0x8a, 0x59, 0xf2, + 0x99, 0xba, 0x50, 0x4d, 0x5c, 0xc8, 0x23, 0x82, 0x13, 0x37, 0x45, 0x27, 0x24, 0x36, 0x64, 0x42, + 0x70, 0xe4, 0x26, 0x38, 0x22, 0x52, 0x40, 0x03, 0xa2, 0x2b, 0x89, 0x54, 0xe2, 0x0c, 0xb3, 0x9b, + 0xc4, 0x0d, 0x98, 0xe9, 0xeb, 0x7d, 0x79, 0x67, 0xd6, 0x22, 0x60, 0x35, 0x76, 0x26, 0xf9, 0x84, + 0x95, 0x5e, 0xcf, 0x39, 0x93, 0x47, 0xba, 0x6d, 0x3f, 0x89, 0x0d, 0x99, 0x30, 0xdd, 0x72, 0x22, + 0x85, 0xbc, 0x33, 0x89, 0x54, 0xfb, 0xb1, 0xa2, 0xea, 0x81, 0x8f, 0x37, 0x88, 0xe9, 0x11, 0x38, + 0xf7, 0x6d, 0xba, 0x61, 0x62, 0xcb, 0x22, 0x2d, 0x46, 0xea, 0xba, 0xc6, 0xbd, 0xc1, 0xb0, 0x03, + 0xd6, 0xd1, 0x74, 0x2c, 0x85, 0x1d, 0x10, 0x78, 0xc9, 0x57, 0x27, 0x34, 0x2e, 0x72, 0x27, 0x32, + 0x91, 0x40, 0x58, 0x54, 0xcc, 0x7d, 0xc1, 0x8a, 0xcf, 0x4c, 0xa2, 0x41, 0x4e, 0x01, 0x25, 0x0c, + 0x12, 0xb9, 0xf6, 0x65, 0x75, 0xa0, 0x48, 0xce, 0x27, 0x84, 0xea, 0xfd, 0x9c, 0xd8, 0xc2, 0x51, + 0x68, 0x9c, 0x59, 0x47, 0xab, 0x84, 0xd0, 0x76, 0x68, 0x9c, 0x09, 0x3c, 0xf8, 0xd5, 0x09, 0x8d, + 0x9e, 0x98, 0x10, 0x7c, 0x0a, 0x64, 0x12, 0x85, 0xf4, 0xd7, 0xfe, 0x61, 0x35, 0x6e, 0x8e, 0xb4, + 0x3c, 0x01, 0x90, 0x69, 0xdf, 0x57, 0xd4, 0xc7, 0x8b, 0xbd, 0x07, 0xd4, 0xbe, 0x17, 0x10, 0xd3, + 0xae, 0xeb, 0x03, 0x3c, 0x89, 0x78, 0x2d, 0x1a, 0x9b, 0x75, 0x2e, 0x5e, 0x98, 0x8b, 0xc6, 0x26, + 0xfe, 0x12, 0xc7, 0x26, 0x51, 0xa8, 0x44, 0x83, 0x92, 0x7c, 0x76, 0xc4, 0xaf, 0x78, 0x50, 0x12, + 0xac, 0x38, 0x28, 0x89, 0x96, 0xf6, 0x17, 0x45, 0xed, 0x2f, 0xf1, 0xf2, 0x1c, 0xfd, 0x12, 0x67, + 0xf4, 0x6d, 0x58, 0x7b, 0xa7, 0xd7, 0xd1, 0x3a, 0x5a, 0x6c, 0x87, 0xc6, 0xe9, 0xc0, 0x5b, 0x47, + 0x8b, 0x9d, 0xd0, 0xb8, 0x9d, 0x10, 0x41, 0x8b, 0xc2, 0xea, 0xda, 0x64, 0xac, 0xe5, 0x4f, 0x8d, + 0x8d, 0xd5, 0x31, 0xc3, 0x37, 0xfc, 0x3d, 0x6a, 0xb1, 0x4d, 0x28, 0xd6, 0x28, 0x61, 0x63, 0x94, + 0xec, 0x80, 0x14, 0x08, 0xc7, 0x46, 0x92, 0x1f, 0xc7, 0x07, 0xd5, 0x87, 0x68, 0xb8, 0x7f, 0x58, + 0x8d, 0x58, 0xa0, 0xbe, 0x82, 0x1f, 0x9e, 0xa3, 0xfd, 0x47, 0x51, 0x8d, 0xa2, 0x0b, 0x2d, 0xd7, + 0x87, 0x13, 0xce, 0x27, 0x56, 0xe0, 0x11, 0x67, 0x4f, 0x1f, 0xe4, 0xe1, 0xf7, 0x87, 0xbc, 0x82, + 0x58, 0x47, 0x2b, 0xae, 0xcf, 0x16, 0x52, 0xb0, 0x1d, 0x1a, 0x17, 0x03, 0x2f, 0x2f, 0xeb, 0x84, + 0xc6, 0x53, 0xb1, 0x93, 0x79, 0x40, 0xf0, 0xb7, 0x81, 0x1d, 0x9f, 0x87, 0xe4, 0x72, 0x6b, 0x89, + 0x0c, 0x32, 0x4f, 0xde, 0x02, 0xea, 0x85, 0x22, 0x05, 0x74, 0x35, 0xef, 0x56, 0x1e, 0xd5, 0xfe, + 0x2d, 0xf1, 0xd0, 0xa6, 0x36, 0xb3, 0xa1, 0x8e, 0x80, 0xf3, 0xce, 0xf4, 0xf5, 0x21, 0xbe, 0x8a, + 0x7f, 0xc0, 0xab, 0x87, 0x75, 0xb4, 0x10, 0xa1, 0x73, 0x00, 0x42, 0xc0, 0xb8, 0x10, 0x78, 0x39, + 0x51, 0x1a, 0x2e, 0x0a, 0x72, 0x31, 0x58, 0xdc, 0x1e, 0xcf, 0x05, 0xf0, 0xa2, 0x85, 0xb2, 0x08, + 0x4e, 0x20, 0x68, 0x05, 0x05, 0x43, 0x81, 0x02, 0xba, 0x92, 0x77, 0x30, 0x07, 0x6a, 0xae, 0xda, + 0xe7, 0x91, 0xe8, 0x70, 0x76, 0xa9, 0xb9, 0x83, 0xb7, 0x48, 0xd0, 0xd2, 0x75, 0x3e, 0x65, 0xb3, + 0x40, 0x3e, 0x06, 0xef, 0xd2, 0x57, 0x39, 0x94, 0x92, 0x2f, 0xc8, 0xbb, 0x1e, 0xd2, 0x45, 0x03, + 0xda, 0x37, 0x15, 0x75, 0x08, 0x07, 0xcc, 0x35, 0x83, 0xd6, 0x86, 0x87, 0xeb, 0x24, 0x4b, 0x86, + 0x36, 0xf5, 0xc7, 0xf9, 0x40, 0xae, 0x40, 0xc9, 0x05, 0x2a, 0xeb, 0x91, 0x46, 0x92, 0x47, 0xbc, + 0x92, 0x56, 0x27, 0x32, 0x50, 0x1c, 0xbe, 0x49, 0x31, 0x33, 0x9c, 0x98, 0x44, 0x52, 0x6b, 0x5a, + 0x53, 0x1d, 0x4a, 0x38, 0x30, 0xd7, 0x6c, 0x79, 0x30, 0xc5, 0xfc, 0x2c, 0xf6, 0xf5, 0xcb, 0x7c, + 0x00, 0x6e, 0x01, 0x91, 0x58, 0x65, 0xcd, 0x5d, 0xf1, 0x08, 0x8a, 0xf1, 0x4e, 0x68, 0x5c, 0x8e, + 0xa6, 0x50, 0x02, 0x56, 0x90, 0xb4, 0x8d, 0xb6, 0xad, 0x6a, 0x5b, 0x84, 0xb4, 0x4c, 0x46, 0x9a, + 0x2d, 0xd7, 0xc3, 0x9e, 0x4d, 0x7c, 0x73, 0x53, 0xbf, 0xc2, 0x5d, 0x7e, 0x05, 0x36, 0x02, 0xa0, + 0x6b, 0x19, 0x08, 0xee, 0x5e, 0xe3, 0xbd, 0x14, 0x01, 0xb1, 0x16, 0x7b, 0x51, 0x74, 0x75, 0xf2, + 0x45, 0x54, 0xb2, 0xa2, 0xed, 0xa9, 0xfd, 0x16, 0xb6, 0x36, 0x89, 0x69, 0x6f, 0x50, 0xd7, 0x23, + 0x75, 0xb3, 0x61, 0x3b, 0xc4, 0xd7, 0xaf, 0x72, 0x17, 0x17, 0xe0, 0x44, 0xe3, 0xf0, 0x42, 0x84, + 0xce, 0x03, 0x98, 0x0e, 0x74, 0x09, 0x29, 0xed, 0xc1, 0x74, 0x6f, 0xa1, 0xb2, 0x19, 0xed, 0xbb, + 0x8a, 0x7a, 0xb9, 0xe5, 0xb9, 0x1b, 0x50, 0xcc, 0x98, 0x41, 0xab, 0x8e, 0x19, 0x11, 0x0b, 0x84, + 0x27, 0xb8, 0xef, 0x6b, 0x90, 0xdf, 0x26, 0x5a, 0xeb, 0x5c, 0x49, 0x2c, 0x06, 0xa2, 0x22, 0xbb, + 0x0b, 0x2e, 0xd0, 0x79, 0x49, 0x18, 0x08, 0xe5, 0x25, 0xd4, 0xcd, 0xa2, 0xf6, 0x96, 0xa2, 0x0e, + 0x3a, 0x76, 0xd3, 0x66, 0x66, 0x0d, 0xd3, 0xfa, 0x8e, 0x5d, 0x67, 0x9b, 0xa6, 0x4d, 0x4d, 0x07, + 0x53, 0x7d, 0x98, 0x0f, 0xc9, 0x12, 0x2f, 0x1e, 0x41, 0x63, 0x26, 0x51, 0x58, 0xa0, 0x8b, 0x98, + 0x66, 0x05, 0x7f, 0x19, 0xfb, 0x98, 0x61, 0x91, 0x99, 0xd2, 0xde, 0x54, 0x54, 0xad, 0x69, 0x53, + 0x73, 0xd3, 0x6d, 0x12, 0xb3, 0x6e, 0xfb, 0x5b, 0x66, 0xc3, 0x23, 0x44, 0x37, 0x46, 0x94, 0xd1, + 0x73, 0x93, 0x3d, 0x37, 0xa2, 0x9b, 0xb5, 0x1b, 0xab, 0xf6, 0xeb, 0x64, 0xe6, 0xe5, 0xf7, 0x43, + 0xe3, 0x04, 0xec, 0xc4, 0xa6, 0x4d, 0x5f, 0x71, 0x9b, 0x64, 0xce, 0xf6, 0xb7, 0xe6, 0x3d, 0x42, + 0xd2, 0xd5, 0x51, 0x90, 0x8b, 0xfb, 0x60, 0xe4, 0x3a, 0x10, 0x39, 0x35, 0x31, 0x72, 0x1d, 0x15, + 0x9b, 0x6b, 0xf7, 0x15, 0xb5, 0x27, 0x59, 0xef, 0xfc, 0xd8, 0x19, 0xe1, 0xc7, 0xce, 0x9f, 0x79, + 0xca, 0x93, 0x2c, 0xda, 0xe8, 0xf0, 0x39, 0xe7, 0x65, 0x9f, 0x9d, 0xd0, 0x98, 0x4b, 0x2a, 0x8e, + 0x44, 0x26, 0x39, 0x88, 0xe2, 0x1d, 0xe0, 0x17, 0xce, 0x94, 0x26, 0x61, 0xf8, 0xc6, 0x97, 0x7c, + 0x97, 0x42, 0xec, 0xce, 0x99, 0xcd, 0x7f, 0x1e, 0x1f, 0x54, 0x47, 0x1f, 0xd6, 0x14, 0xe4, 0x47, + 0x02, 0x5f, 0x94, 0xd9, 0xf1, 0x1c, 0xed, 0x55, 0xb5, 0x0f, 0x3b, 0x3b, 0x50, 0x7d, 0x45, 0xb7, + 0x09, 0x94, 0x30, 0x5f, 0x7f, 0x92, 0x5f, 0xe2, 0x41, 0xd1, 0x7b, 0x21, 0x02, 0x79, 0x55, 0xbe, + 0x4c, 0x18, 0x2c, 0xfc, 0x81, 0x28, 0xc2, 0xe4, 0xe4, 0x15, 0x54, 0x54, 0xd4, 0xfe, 0xa7, 0xa8, + 0xa3, 0xee, 0x36, 0xf1, 0x76, 0x3c, 0x9b, 0x41, 0xe0, 0x68, 0xba, 0x8c, 0x98, 0x75, 0xb2, 0x6d, + 0x5b, 0xc4, 0xa4, 0xb8, 0x49, 0x7c, 0x08, 0xa7, 0x71, 0x21, 0xa4, 0x57, 0xb2, 0xeb, 0xa5, 0xa1, + 0xbb, 0x49, 0x23, 0xc4, 0xdb, 0xcc, 0x91, 0xed, 0x65, 0x50, 0x6f, 0x87, 0xc6, 0x35, 0xb7, 0x04, + 0xd9, 0x16, 0xe1, 0xe8, 0x5d, 0x3a, 0x1b, 0x99, 0xea, 0x84, 0xc6, 0x27, 0x39, 0xc1, 0x87, 0xd0, + 0xed, 0xbe, 0x28, 0xa1, 0x8a, 0xeb, 0xc2, 0x03, 0x3d, 0x0c, 0x0b, 0xed, 0xab, 0xea, 0x25, 0x08, + 0x63, 0xa6, 0x4d, 0xeb, 0x64, 0xd7, 0x84, 0x95, 0x5c, 0x73, 0x5c, 0x6b, 0xcb, 0xd7, 0xaf, 0xf1, + 0x2d, 0x0d, 0x8b, 0x46, 0x03, 0x85, 0x05, 0xc0, 0x97, 0x6c, 0x3a, 0xc3, 0xd1, 0xf4, 0xd6, 0xb6, + 0x0c, 0x49, 0x33, 0xe5, 0x28, 0xff, 0x45, 0x12, 0x4b, 0xda, 0xbf, 0x20, 0xdd, 0xa5, 0xd8, 0xda, + 0x22, 0x75, 0x93, 0xba, 0xcc, 0x6e, 0xd8, 0x16, 0x8e, 0xee, 0x1f, 0xea, 0xbe, 0x5e, 0xe5, 0xf3, + 0xfb, 0x36, 0x0c, 0xf7, 0xe0, 0x7a, 0xa4, 0xb4, 0x2c, 0xe8, 0x2c, 0xcc, 0xc1, 0x68, 0x0f, 0x06, + 0x52, 0xa4, 0x13, 0x1a, 0x57, 0xa2, 0xd0, 0x2e, 0x83, 0xf9, 0x5d, 0xa5, 0x14, 0xe9, 0x1c, 0x54, + 0xbb, 0x58, 0xdc, 0x3f, 0xac, 0x76, 0x61, 0x81, 0xa4, 0x2d, 0xea, 0xbe, 0x86, 0xd4, 0xf3, 0xcc, + 0xc3, 0x8d, 0x86, 0x6d, 0x99, 0x96, 0x83, 0x7d, 0x5f, 0xbf, 0xce, 0x87, 0xf5, 0x05, 0xa8, 0x97, + 0x63, 0x60, 0x16, 0xe4, 0x9d, 0xd0, 0xd0, 0xa2, 0x01, 0x15, 0x84, 0xe9, 0x45, 0x4d, 0x4e, 0x55, + 0xbb, 0xa7, 0xf6, 0xc7, 0x43, 0x6c, 0x36, 0x5c, 0xa7, 0x4e, 0x3c, 0xb3, 0x85, 0xd9, 0xa6, 0xfe, + 0x14, 0xdf, 0xf5, 0xd3, 0x70, 0x0c, 0xc4, 0xf0, 0x3c, 0x47, 0x57, 0x30, 0xdb, 0x4c, 0x43, 0x4c, + 0x09, 0x11, 0xa6, 0xeb, 0x0d, 0x58, 0x56, 0xca, 0x1b, 0xa8, 0xdc, 0x5c, 0xdb, 0x52, 0x2f, 0xfa, + 0x84, 0x99, 0x8e, 0xbb, 0x63, 0xb6, 0x3c, 0xdb, 0xf5, 0x6c, 0xb6, 0xa7, 0x3f, 0xcd, 0xb7, 0x02, + 0xf4, 0xd7, 0xeb, 0x13, 0xb6, 0xe8, 0xee, 0xac, 0xc4, 0x48, 0xda, 0x59, 0x5e, 0xdc, 0x35, 0xb1, + 0x28, 0x34, 0xd7, 0xde, 0x51, 0xd4, 0xc1, 0x26, 0xde, 0x4d, 0x9c, 0xb3, 0x5c, 0x6a, 0x05, 0x9e, + 0x47, 0xa8, 0xb5, 0xa7, 0x8f, 0xf2, 0xd1, 0xf3, 0xf9, 0x15, 0x0b, 0xde, 0x59, 0xc2, 0xbb, 0x11, + 0xc7, 0xd9, 0x4c, 0x05, 0x0e, 0xfa, 0xa6, 0x44, 0x9e, 0x1e, 0xf4, 0x32, 0x30, 0x19, 0x68, 0x7e, + 0x27, 0x22, 0xb7, 0x8b, 0xa4, 0x56, 0xb5, 0x0f, 0x14, 0xb5, 0xdf, 0xf2, 0xb0, 0xbf, 0x59, 0xc8, + 0xfc, 0x9f, 0xe1, 0x93, 0xf1, 0x2e, 0xcf, 0xfc, 0x67, 0x93, 0xcc, 0xdf, 0x8a, 0x33, 0xff, 0xf9, + 0xe8, 0x44, 0x86, 0x66, 0x59, 0x0e, 0x2e, 0x0d, 0xbe, 0x5c, 0xa7, 0x9c, 0xcd, 0x73, 0x31, 0xac, + 0xe0, 0xbe, 0x92, 0x11, 0xa8, 0x09, 0xac, 0xb8, 0x26, 0xa8, 0x3e, 0x8c, 0x19, 0xa8, 0x0a, 0x66, + 0xa3, 0xaa, 0xa0, 0x60, 0xcc, 0x73, 0xb4, 0x9f, 0x29, 0xea, 0x50, 0xd1, 0xbd, 0xe4, 0x32, 0xe6, + 0x59, 0x3e, 0xff, 0xf6, 0x51, 0x68, 0x9c, 0x9d, 0x45, 0xc2, 0x3b, 0x42, 0xde, 0x4a, 0xf1, 0x1d, + 0x41, 0x8a, 0x76, 0x5b, 0x1a, 0xfb, 0x87, 0xd5, 0xcc, 0x36, 0x92, 0x5b, 0xd6, 0xbe, 0xae, 0xa8, + 0x83, 0x3e, 0x0b, 0xa8, 0x09, 0xf9, 0x12, 0x76, 0xec, 0x6d, 0x62, 0x46, 0x59, 0xb0, 0xaf, 0x3f, + 0x97, 0x66, 0xa1, 0xfd, 0xa0, 0x71, 0x27, 0x51, 0x58, 0x05, 0x7c, 0x35, 0xcd, 0x8d, 0x24, 0x58, + 0x3e, 0x85, 0x17, 0xc2, 0xd8, 0xa9, 0x89, 0xdb, 0xe3, 0x48, 0x66, 0x0d, 0x2a, 0xe3, 0x02, 0x0d, + 0x88, 0xa6, 0xbe, 0xfe, 0x3c, 0x27, 0xf1, 0x39, 0xd8, 0x97, 0xb9, 0x66, 0x4b, 0x36, 0xcd, 0x2a, + 0x88, 0x12, 0x22, 0x66, 0x86, 0xb9, 0x30, 0x3a, 0x39, 0x8e, 0xca, 0x76, 0x20, 0x17, 0xef, 0xe1, + 0xbd, 0x27, 0xcf, 0x5b, 0x2f, 0xf0, 0xc8, 0x59, 0x3f, 0x0a, 0x8d, 0x5e, 0x84, 0x77, 0x56, 0x59, + 0x20, 0x3c, 0x6c, 0x9d, 0xf3, 0xb3, 0xcf, 0xf4, 0x0a, 0x2a, 0x93, 0x3d, 0xf0, 0xf1, 0xad, 0x60, + 0x11, 0x89, 0xf6, 0xb4, 0x6d, 0xf5, 0x02, 0x14, 0x9b, 0x35, 0xec, 0x13, 0x33, 0x7a, 0x69, 0xd4, + 0x6f, 0x8c, 0x28, 0xa3, 0xbd, 0x93, 0xbd, 0x49, 0x32, 0xb4, 0xc6, 0xa5, 0xfc, 0xce, 0xb0, 0x37, + 0x51, 0x8d, 0x64, 0x59, 0x98, 0xca, 0x89, 0x2b, 0x23, 0x71, 0xe9, 0x11, 0x2f, 0x8f, 0x37, 0x0f, + 0xab, 0x0a, 0x2a, 0x34, 0xd5, 0xbe, 0x77, 0x52, 0xbd, 0x06, 0x51, 0x23, 0x0d, 0x17, 0x50, 0xba, + 0x5a, 0x6e, 0x13, 0x96, 0xac, 0x47, 0xee, 0x05, 0xc4, 0x67, 0xe6, 0x96, 0x5d, 0xd3, 0xc7, 0xf8, + 0x74, 0xfc, 0x4d, 0x89, 0x5f, 0x28, 0x97, 0xf0, 0xee, 0xec, 0x02, 0x8a, 0xf0, 0x3b, 0xf6, 0x4c, + 0x3b, 0x34, 0x8c, 0x26, 0xde, 0x4d, 0xb7, 0x38, 0x5b, 0x88, 0x6d, 0x64, 0x2a, 0xe9, 0xd9, 0xf7, + 0x00, 0x3d, 0xa1, 0xec, 0x7b, 0xa0, 0xc9, 0x07, 0xab, 0xc4, 0x6f, 0x9e, 0x05, 0xba, 0xe8, 0x01, + 0xcd, 0x6a, 0xda, 0x47, 0x8a, 0x3a, 0x98, 0x3e, 0xbc, 0x38, 0x58, 0x7c, 0xaa, 0x1d, 0xe7, 0x1b, + 0xf8, 0x3d, 0x18, 0x89, 0x81, 0xe4, 0xe1, 0x62, 0x71, 0x7a, 0x59, 0x7c, 0xad, 0x1d, 0xc0, 0x12, + 0x79, 0x9a, 0x3e, 0xcb, 0x40, 0xd9, 0x7b, 0x99, 0xd4, 0x48, 0x17, 0xb9, 0xb0, 0xf5, 0xa5, 0xa4, + 0x50, 0xd6, 0x0a, 0x0b, 0x4f, 0xbd, 0xdb, 0xea, 0x65, 0xfe, 0xb6, 0xd2, 0x08, 0x1c, 0x27, 0xce, + 0x65, 0x5c, 0x9a, 0x14, 0xa6, 0xfa, 0x04, 0xf7, 0x74, 0x0a, 0x72, 0x05, 0xd0, 0x9a, 0x0f, 0x1c, + 0x87, 0x67, 0x21, 0x77, 0x69, 0x5c, 0x4a, 0x76, 0x42, 0xe3, 0x6a, 0x7c, 0x64, 0xc9, 0xe0, 0x0a, + 0xea, 0xd2, 0x4e, 0xfb, 0x8a, 0xda, 0x13, 0xb4, 0x68, 0x2b, 0x0d, 0x8a, 0xbf, 0x9a, 0xe7, 0x5d, + 0x7d, 0xfe, 0x28, 0x34, 0x2e, 0xcd, 0x91, 0x96, 0x47, 0x2c, 0xcc, 0x48, 0x7d, 0x7d, 0x85, 0xae, + 0x64, 0x11, 0x52, 0x79, 0x21, 0x4b, 0x4d, 0x5a, 0xb4, 0x15, 0x03, 0xcf, 0xbb, 0x4d, 0x1b, 0xd2, + 0x23, 0xb6, 0x57, 0xd9, 0x3f, 0xac, 0xca, 0x1b, 0xeb, 0x0a, 0x3a, 0x27, 0x34, 0xd1, 0x7e, 0xa1, + 0xc4, 0xdd, 0x27, 0x17, 0xcf, 0xef, 0xcc, 0xf3, 0xd5, 0xfd, 0x26, 0x9f, 0xd3, 0xbc, 0x89, 0xf4, + 0x12, 0x9a, 0x77, 0x3f, 0x92, 0x76, 0x2f, 0x5e, 0x1e, 0x0b, 0x1c, 0xb2, 0xc5, 0x7b, 0xb9, 0xbb, + 0x16, 0x4c, 0x92, 0xac, 0x17, 0x5d, 0x41, 0x6a, 0xd6, 0x4a, 0xfb, 0x9d, 0xa2, 0xf6, 0x72, 0x9a, + 0xd9, 0x15, 0xf3, 0xaf, 0x23, 0xa2, 0xdf, 0xe2, 0x99, 0x5d, 0xde, 0x84, 0x70, 0xdd, 0xcc, 0xa9, + 0x56, 0x52, 0xaa, 0xf9, 0x0b, 0x62, 0x29, 0xd9, 0xab, 0x1f, 0xa7, 0x07, 0xf9, 0x9b, 0xbc, 0x2f, + 0x5d, 0x41, 0x3d, 0x62, 0xcb, 0x8c, 0x72, 0x76, 0x91, 0xfc, 0x6e, 0x77, 0xca, 0xc2, 0xa5, 0x72, + 0x81, 0x72, 0xfe, 0x1a, 0xb8, 0x3b, 0xe5, 0x6e, 0x7a, 0x65, 0xca, 0x89, 0x66, 0x42, 0x39, 0xbd, + 0x37, 0x6e, 0xa8, 0xd1, 0x83, 0x55, 0x7a, 0x04, 0xfc, 0x66, 0x9e, 0x9f, 0x01, 0x9f, 0xc9, 0xf3, + 0xe5, 0x6f, 0x3e, 0xd9, 0x59, 0x20, 0x2c, 0x46, 0x2f, 0x43, 0x04, 0xa2, 0xd0, 0x8f, 0x80, 0xf8, + 0xbc, 0xec, 0x2e, 0x57, 0xbc, 0x66, 0xcb, 0x62, 0xfa, 0x7b, 0x30, 0x44, 0xca, 0xcc, 0xd2, 0x51, + 0x68, 0x5c, 0xcd, 0x7a, 0x5c, 0xca, 0xd7, 0xab, 0x2b, 0x16, 0xcb, 0x8f, 0x53, 0xb3, 0x84, 0xe7, + 0xbb, 0xd7, 0xca, 0x0a, 0x70, 0xde, 0x0d, 0x14, 0xa2, 0xbd, 0x6f, 0x61, 0xea, 0xeb, 0xbf, 0x8d, + 0x66, 0x69, 0xad, 0x40, 0x41, 0x8c, 0x92, 0xab, 0xa0, 0x58, 0xa0, 0x50, 0xc2, 0xcb, 0x53, 0xc5, + 0x99, 0x94, 0xf4, 0x66, 0xee, 0xbc, 0xff, 0xe1, 0xf0, 0x89, 0xc3, 0x0f, 0x87, 0x4f, 0xbc, 0x7f, + 0x34, 0xac, 0x1c, 0x1e, 0x0d, 0x2b, 0xdf, 0xb9, 0x3f, 0x7c, 0xe2, 0xed, 0xfb, 0xc3, 0xca, 0xe1, + 0xfd, 0xe1, 0x13, 0xff, 0xbc, 0x3f, 0x7c, 0xe2, 0xb5, 0x67, 0x36, 0x6c, 0xb6, 0x19, 0xd4, 0x6e, + 0x58, 0x6e, 0x73, 0x2c, 0xcd, 0xc1, 0x84, 0x5f, 0xd9, 0x3f, 0x70, 0x6a, 0x67, 0xf8, 0x5f, 0x6e, + 0x6e, 0xfe, 0x3f, 0x00, 0x00, 0xff, 0xff, 0x2e, 0x99, 0xf4, 0x6a, 0xde, 0x23, 0x00, 0x00, } +func (m *OptionsConfiguration) Marshal() (dAtA []byte, err error) { + size := m.ProtoSize() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *OptionsConfiguration) MarshalTo(dAtA []byte) (int, error) { + size := m.ProtoSize() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *OptionsConfiguration) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.DeprecatedMaxConcurrentScans != 0 { + i = encodeVarintOptionsconfiguration(dAtA, i, uint64(m.DeprecatedMaxConcurrentScans)) + i-- + dAtA[i] = 0x4 + i-- + dAtA[i] = 0xb2 + i-- + dAtA[i] = 0xf0 + } + if m.DeprecatedMinHomeDiskFreePct != 0 { + i -= 8 + encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.DeprecatedMinHomeDiskFreePct)))) + i-- + dAtA[i] = 0x4 + i-- + dAtA[i] = 0xb2 + i-- + dAtA[i] = 0xe9 + } + if len(m.DeprecatedRelayServers) > 0 { + for iNdEx := len(m.DeprecatedRelayServers) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.DeprecatedRelayServers[iNdEx]) + copy(dAtA[i:], m.DeprecatedRelayServers[iNdEx]) + i = encodeVarintOptionsconfiguration(dAtA, i, uint64(len(m.DeprecatedRelayServers[iNdEx]))) + i-- + dAtA[i] = 0x4 + i-- + dAtA[i] = 0xb2 + i-- + dAtA[i] = 0xe2 + } + } + if m.DeprecatedUPnPTimeoutS != 0 { + i = encodeVarintOptionsconfiguration(dAtA, i, uint64(m.DeprecatedUPnPTimeoutS)) + i-- + dAtA[i] = 0x4 + i-- + dAtA[i] = 0xb2 + i-- + dAtA[i] = 0xd8 + } + if m.DeprecatedUPnPRenewalM != 0 { + i = encodeVarintOptionsconfiguration(dAtA, i, uint64(m.DeprecatedUPnPRenewalM)) + i-- + dAtA[i] = 0x4 + i-- + dAtA[i] = 0xb2 + i-- + dAtA[i] = 0xd0 + } + if m.DeprecatedUPnPLeaseM != 0 { + i = encodeVarintOptionsconfiguration(dAtA, i, uint64(m.DeprecatedUPnPLeaseM)) + i-- + dAtA[i] = 0x4 + i-- + dAtA[i] = 0xb2 + i-- + dAtA[i] = 0xc8 + } + if m.DeprecatedUPnPEnabled { + i-- + if m.DeprecatedUPnPEnabled { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x4 + i-- + dAtA[i] = 0xb2 + i-- + dAtA[i] = 0xc0 + } + if m.SendFullIndexOnUpgrade { + i-- + if m.SendFullIndexOnUpgrade { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x3 + i-- + dAtA[i] = 0x88 + } + if m.AnnounceLANAddresses { + i-- + if m.AnnounceLANAddresses { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x3 + i-- + dAtA[i] = 0x80 + } + if m.RawMaxCIRequestKiB != 0 { + i = encodeVarintOptionsconfiguration(dAtA, i, uint64(m.RawMaxCIRequestKiB)) + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0xf8 + } + if m.DatabaseTuning != 0 { + i = encodeVarintOptionsconfiguration(dAtA, i, uint64(m.DatabaseTuning)) + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0xf0 + } + if len(m.RawStunServers) > 0 { + for iNdEx := len(m.RawStunServers) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.RawStunServers[iNdEx]) + copy(dAtA[i:], m.RawStunServers[iNdEx]) + i = encodeVarintOptionsconfiguration(dAtA, i, uint64(len(m.RawStunServers[iNdEx]))) + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0xea + } + } + if m.StunKeepaliveMinS != 0 { + i = encodeVarintOptionsconfiguration(dAtA, i, uint64(m.StunKeepaliveMinS)) + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0xe0 + } + if m.StunKeepaliveStartS != 0 { + i = encodeVarintOptionsconfiguration(dAtA, i, uint64(m.StunKeepaliveStartS)) + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0xd8 + } + if m.CREnabled { + i-- + if m.CREnabled { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0xd0 + } + if len(m.CRURL) > 0 { + i -= len(m.CRURL) + copy(dAtA[i:], m.CRURL) + i = encodeVarintOptionsconfiguration(dAtA, i, uint64(len(m.CRURL))) + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0xca + } + if m.RawMaxFolderConcurrency != 0 { + i = encodeVarintOptionsconfiguration(dAtA, i, uint64(m.RawMaxFolderConcurrency)) + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0xc0 + } + if m.SetLowPriority { + i-- + if m.SetLowPriority { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0xb8 + } + if len(m.DefaultFolderPath) > 0 { + i -= len(m.DefaultFolderPath) + copy(dAtA[i:], m.DefaultFolderPath) + i = encodeVarintOptionsconfiguration(dAtA, i, uint64(len(m.DefaultFolderPath))) + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0xb2 + } + if m.TrafficClass != 0 { + i = encodeVarintOptionsconfiguration(dAtA, i, uint64(m.TrafficClass)) + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0xa8 + } + if len(m.UnackedNotificationIDs) > 0 { + for iNdEx := len(m.UnackedNotificationIDs) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.UnackedNotificationIDs[iNdEx]) + copy(dAtA[i:], m.UnackedNotificationIDs[iNdEx]) + i = encodeVarintOptionsconfiguration(dAtA, i, uint64(len(m.UnackedNotificationIDs[iNdEx]))) + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0xa2 + } + } + if m.TempIndexMinBlocks != 0 { + i = encodeVarintOptionsconfiguration(dAtA, i, uint64(m.TempIndexMinBlocks)) + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0x98 + } + if m.OverwriteRemoteDevNames { + i-- + if m.OverwriteRemoteDevNames { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0x90 + } + if len(m.AlwaysLocalNets) > 0 { + for iNdEx := len(m.AlwaysLocalNets) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.AlwaysLocalNets[iNdEx]) + copy(dAtA[i:], m.AlwaysLocalNets[iNdEx]) + i = encodeVarintOptionsconfiguration(dAtA, i, uint64(len(m.AlwaysLocalNets[iNdEx]))) + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0x8a + } + } + if len(m.ReleasesURL) > 0 { + i -= len(m.ReleasesURL) + copy(dAtA[i:], m.ReleasesURL) + i = encodeVarintOptionsconfiguration(dAtA, i, uint64(len(m.ReleasesURL))) + i-- + dAtA[i] = 0x2 + i-- + dAtA[i] = 0x82 + } + { + size, err := m.MinHomeDiskFree.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintOptionsconfiguration(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xfa + if m.LimitBandwidthInLan { + i-- + if m.LimitBandwidthInLan { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xf0 + } + if m.ProgressUpdateIntervalS != 0 { + i = encodeVarintOptionsconfiguration(dAtA, i, uint64(m.ProgressUpdateIntervalS)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xe8 + } + if m.CacheIgnoredFiles { + i-- + if m.CacheIgnoredFiles { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xe0 + } + if m.KeepTemporariesH != 0 { + i = encodeVarintOptionsconfiguration(dAtA, i, uint64(m.KeepTemporariesH)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xd8 + } + if m.UpgradeToPreReleases { + i-- + if m.UpgradeToPreReleases { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xd0 + } + if m.AutoUpgradeIntervalH != 0 { + i = encodeVarintOptionsconfiguration(dAtA, i, uint64(m.AutoUpgradeIntervalH)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xc8 + } + if m.RestartOnWakeup { + i-- + if m.RestartOnWakeup { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xc0 + } + if m.URInitialDelayS != 0 { + i = encodeVarintOptionsconfiguration(dAtA, i, uint64(m.URInitialDelayS)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xb8 + } + if m.URPostInsecurely { + i-- + if m.URPostInsecurely { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xb0 + } + if len(m.URURL) > 0 { + i -= len(m.URURL) + copy(dAtA[i:], m.URURL) + i = encodeVarintOptionsconfiguration(dAtA, i, uint64(len(m.URURL))) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xaa + } + if len(m.URUniqueID) > 0 { + i -= len(m.URUniqueID) + copy(dAtA[i:], m.URUniqueID) + i = encodeVarintOptionsconfiguration(dAtA, i, uint64(len(m.URUniqueID))) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xa2 + } + if m.URSeen != 0 { + i = encodeVarintOptionsconfiguration(dAtA, i, uint64(m.URSeen)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x98 + } + if m.URAccepted != 0 { + i = encodeVarintOptionsconfiguration(dAtA, i, uint64(m.URAccepted)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x90 + } + if m.NATTimeoutS != 0 { + i = encodeVarintOptionsconfiguration(dAtA, i, uint64(m.NATTimeoutS)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x88 + } + if m.NATRenewalM != 0 { + i = encodeVarintOptionsconfiguration(dAtA, i, uint64(m.NATRenewalM)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x80 + } + if m.NATLeaseM != 0 { + i = encodeVarintOptionsconfiguration(dAtA, i, uint64(m.NATLeaseM)) + i-- + dAtA[i] = 0x78 + } + if m.NATEnabled { + i-- + if m.NATEnabled { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x70 + } + if m.StartBrowser { + i-- + if m.StartBrowser { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x60 + } + if m.RelayReconnectIntervalM != 0 { + i = encodeVarintOptionsconfiguration(dAtA, i, uint64(m.RelayReconnectIntervalM)) + i-- + dAtA[i] = 0x58 + } + if m.RelaysEnabled { + i-- + if m.RelaysEnabled { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x50 + } + if m.ReconnectIntervalS != 0 { + i = encodeVarintOptionsconfiguration(dAtA, i, uint64(m.ReconnectIntervalS)) + i-- + dAtA[i] = 0x48 + } + if m.MaxRecvKbps != 0 { + i = encodeVarintOptionsconfiguration(dAtA, i, uint64(m.MaxRecvKbps)) + i-- + dAtA[i] = 0x40 + } + if m.MaxSendKbps != 0 { + i = encodeVarintOptionsconfiguration(dAtA, i, uint64(m.MaxSendKbps)) + i-- + dAtA[i] = 0x38 + } + if len(m.LocalAnnMCAddr) > 0 { + i -= len(m.LocalAnnMCAddr) + copy(dAtA[i:], m.LocalAnnMCAddr) + i = encodeVarintOptionsconfiguration(dAtA, i, uint64(len(m.LocalAnnMCAddr))) + i-- + dAtA[i] = 0x32 + } + if m.LocalAnnPort != 0 { + i = encodeVarintOptionsconfiguration(dAtA, i, uint64(m.LocalAnnPort)) + i-- + dAtA[i] = 0x28 + } + if m.LocalAnnEnabled { + i-- + if m.LocalAnnEnabled { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x20 + } + if m.GlobalAnnEnabled { + i-- + if m.GlobalAnnEnabled { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x18 + } + if len(m.RawGlobalAnnServers) > 0 { + for iNdEx := len(m.RawGlobalAnnServers) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.RawGlobalAnnServers[iNdEx]) + copy(dAtA[i:], m.RawGlobalAnnServers[iNdEx]) + i = encodeVarintOptionsconfiguration(dAtA, i, uint64(len(m.RawGlobalAnnServers[iNdEx]))) + i-- + dAtA[i] = 0x12 + } + } + if len(m.RawListenAddresses) > 0 { + for iNdEx := len(m.RawListenAddresses) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.RawListenAddresses[iNdEx]) + copy(dAtA[i:], m.RawListenAddresses[iNdEx]) + i = encodeVarintOptionsconfiguration(dAtA, i, uint64(len(m.RawListenAddresses[iNdEx]))) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func encodeVarintOptionsconfiguration(dAtA []byte, offset int, v uint64) int { + offset -= sovOptionsconfiguration(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} func (m *OptionsConfiguration) ProtoSize() (n int) { if m == nil { return 0 @@ -514,3 +1052,1363 @@ func sovOptionsconfiguration(x uint64) (n int) { func sozOptionsconfiguration(x uint64) (n int) { return sovOptionsconfiguration(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } +func (m *OptionsConfiguration) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOptionsconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: OptionsConfiguration: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: OptionsConfiguration: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RawListenAddresses", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOptionsconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthOptionsconfiguration + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthOptionsconfiguration + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.RawListenAddresses = append(m.RawListenAddresses, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RawGlobalAnnServers", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOptionsconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthOptionsconfiguration + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthOptionsconfiguration + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.RawGlobalAnnServers = append(m.RawGlobalAnnServers, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field GlobalAnnEnabled", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOptionsconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.GlobalAnnEnabled = bool(v != 0) + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field LocalAnnEnabled", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOptionsconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.LocalAnnEnabled = bool(v != 0) + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field LocalAnnPort", wireType) + } + m.LocalAnnPort = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOptionsconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.LocalAnnPort |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LocalAnnMCAddr", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOptionsconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthOptionsconfiguration + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthOptionsconfiguration + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.LocalAnnMCAddr = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MaxSendKbps", wireType) + } + m.MaxSendKbps = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOptionsconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.MaxSendKbps |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MaxRecvKbps", wireType) + } + m.MaxRecvKbps = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOptionsconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.MaxRecvKbps |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 9: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ReconnectIntervalS", wireType) + } + m.ReconnectIntervalS = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOptionsconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ReconnectIntervalS |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 10: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RelaysEnabled", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOptionsconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.RelaysEnabled = bool(v != 0) + case 11: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RelayReconnectIntervalM", wireType) + } + m.RelayReconnectIntervalM = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOptionsconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.RelayReconnectIntervalM |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 12: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field StartBrowser", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOptionsconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.StartBrowser = bool(v != 0) + case 14: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field NATEnabled", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOptionsconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.NATEnabled = bool(v != 0) + case 15: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field NATLeaseM", wireType) + } + m.NATLeaseM = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOptionsconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.NATLeaseM |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 16: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field NATRenewalM", wireType) + } + m.NATRenewalM = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOptionsconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.NATRenewalM |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 17: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field NATTimeoutS", wireType) + } + m.NATTimeoutS = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOptionsconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.NATTimeoutS |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 18: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field URAccepted", wireType) + } + m.URAccepted = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOptionsconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.URAccepted |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 19: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field URSeen", wireType) + } + m.URSeen = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOptionsconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.URSeen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 20: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field URUniqueID", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOptionsconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthOptionsconfiguration + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthOptionsconfiguration + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.URUniqueID = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 21: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field URURL", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOptionsconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthOptionsconfiguration + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthOptionsconfiguration + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.URURL = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 22: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field URPostInsecurely", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOptionsconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.URPostInsecurely = bool(v != 0) + case 23: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field URInitialDelayS", wireType) + } + m.URInitialDelayS = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOptionsconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.URInitialDelayS |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 24: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RestartOnWakeup", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOptionsconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.RestartOnWakeup = bool(v != 0) + case 25: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field AutoUpgradeIntervalH", wireType) + } + m.AutoUpgradeIntervalH = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOptionsconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.AutoUpgradeIntervalH |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 26: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field UpgradeToPreReleases", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOptionsconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.UpgradeToPreReleases = bool(v != 0) + case 27: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field KeepTemporariesH", wireType) + } + m.KeepTemporariesH = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOptionsconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.KeepTemporariesH |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 28: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CacheIgnoredFiles", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOptionsconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.CacheIgnoredFiles = bool(v != 0) + case 29: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ProgressUpdateIntervalS", wireType) + } + m.ProgressUpdateIntervalS = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOptionsconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ProgressUpdateIntervalS |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 30: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field LimitBandwidthInLan", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOptionsconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.LimitBandwidthInLan = bool(v != 0) + case 31: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MinHomeDiskFree", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOptionsconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthOptionsconfiguration + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthOptionsconfiguration + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.MinHomeDiskFree.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 32: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ReleasesURL", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOptionsconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthOptionsconfiguration + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthOptionsconfiguration + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ReleasesURL = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 33: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AlwaysLocalNets", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOptionsconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthOptionsconfiguration + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthOptionsconfiguration + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.AlwaysLocalNets = append(m.AlwaysLocalNets, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 34: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field OverwriteRemoteDevNames", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOptionsconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.OverwriteRemoteDevNames = bool(v != 0) + case 35: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field TempIndexMinBlocks", wireType) + } + m.TempIndexMinBlocks = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOptionsconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.TempIndexMinBlocks |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 36: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field UnackedNotificationIDs", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOptionsconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthOptionsconfiguration + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthOptionsconfiguration + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.UnackedNotificationIDs = append(m.UnackedNotificationIDs, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 37: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field TrafficClass", wireType) + } + m.TrafficClass = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOptionsconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.TrafficClass |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 38: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DefaultFolderPath", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOptionsconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthOptionsconfiguration + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthOptionsconfiguration + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DefaultFolderPath = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 39: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field SetLowPriority", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOptionsconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.SetLowPriority = bool(v != 0) + case 40: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RawMaxFolderConcurrency", wireType) + } + m.RawMaxFolderConcurrency = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOptionsconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.RawMaxFolderConcurrency |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 41: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CRURL", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOptionsconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthOptionsconfiguration + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthOptionsconfiguration + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.CRURL = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 42: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CREnabled", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOptionsconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.CREnabled = bool(v != 0) + case 43: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field StunKeepaliveStartS", wireType) + } + m.StunKeepaliveStartS = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOptionsconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.StunKeepaliveStartS |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 44: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field StunKeepaliveMinS", wireType) + } + m.StunKeepaliveMinS = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOptionsconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.StunKeepaliveMinS |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 45: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RawStunServers", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOptionsconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthOptionsconfiguration + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthOptionsconfiguration + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.RawStunServers = append(m.RawStunServers, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 46: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field DatabaseTuning", wireType) + } + m.DatabaseTuning = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOptionsconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.DatabaseTuning |= Tuning(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 47: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RawMaxCIRequestKiB", wireType) + } + m.RawMaxCIRequestKiB = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOptionsconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.RawMaxCIRequestKiB |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 48: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field AnnounceLANAddresses", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOptionsconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.AnnounceLANAddresses = bool(v != 0) + case 49: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field SendFullIndexOnUpgrade", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOptionsconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.SendFullIndexOnUpgrade = bool(v != 0) + case 9000: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field DeprecatedUPnPEnabled", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOptionsconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.DeprecatedUPnPEnabled = bool(v != 0) + case 9001: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field DeprecatedUPnPLeaseM", wireType) + } + m.DeprecatedUPnPLeaseM = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOptionsconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.DeprecatedUPnPLeaseM |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 9002: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field DeprecatedUPnPRenewalM", wireType) + } + m.DeprecatedUPnPRenewalM = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOptionsconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.DeprecatedUPnPRenewalM |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 9003: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field DeprecatedUPnPTimeoutS", wireType) + } + m.DeprecatedUPnPTimeoutS = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOptionsconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.DeprecatedUPnPTimeoutS |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 9004: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DeprecatedRelayServers", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOptionsconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthOptionsconfiguration + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthOptionsconfiguration + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DeprecatedRelayServers = append(m.DeprecatedRelayServers, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 9005: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field DeprecatedMinHomeDiskFreePct", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) + iNdEx += 8 + m.DeprecatedMinHomeDiskFreePct = float64(math.Float64frombits(v)) + case 9006: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field DeprecatedMaxConcurrentScans", wireType) + } + m.DeprecatedMaxConcurrentScans = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOptionsconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.DeprecatedMaxConcurrentScans |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipOptionsconfiguration(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthOptionsconfiguration + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthOptionsconfiguration + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipOptionsconfiguration(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowOptionsconfiguration + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowOptionsconfiguration + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowOptionsconfiguration + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthOptionsconfiguration + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupOptionsconfiguration + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthOptionsconfiguration + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthOptionsconfiguration = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowOptionsconfiguration = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupOptionsconfiguration = fmt.Errorf("proto: unexpected end of group") +) diff --git a/lib/config/pullorder.pb.go b/lib/config/pullorder.pb.go index 0a95b73e8..10a1cafee 100644 --- a/lib/config/pullorder.pb.go +++ b/lib/config/pullorder.pb.go @@ -61,27 +61,27 @@ func init() { func init() { proto.RegisterFile("lib/config/pullorder.proto", fileDescriptor_2fa3f5222a7755bf) } var fileDescriptor_2fa3f5222a7755bf = []byte{ - // 343 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0xca, 0xc9, 0x4c, 0xd2, - 0x4f, 0xce, 0xcf, 0x4b, 0xcb, 0x4c, 0xd7, 0x2f, 0x28, 0xcd, 0xc9, 0xc9, 0x2f, 0x4a, 0x49, 0x2d, - 0xd2, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x83, 0x88, 0x4b, 0x29, 0x17, 0xa5, 0x16, 0xe4, - 0x17, 0xeb, 0x83, 0x05, 0x93, 0x4a, 0xd3, 0xf4, 0xd3, 0xf3, 0xd3, 0xf3, 0xc1, 0x1c, 0x30, 0x0b, - 0xa2, 0x58, 0xeb, 0x32, 0x13, 0x17, 0x67, 0x40, 0x69, 0x4e, 0x8e, 0x3f, 0xc8, 0x00, 0x21, 0x2d, - 0x2e, 0xc1, 0x80, 0x50, 0x1f, 0x9f, 0x78, 0xff, 0x20, 0x17, 0xd7, 0xa0, 0xf8, 0x20, 0x47, 0x3f, - 0x17, 0x7f, 0x5f, 0x01, 0x06, 0x29, 0xe1, 0xae, 0xb9, 0x0a, 0xfc, 0x70, 0x55, 0x41, 0x89, 0x79, - 0x29, 0xf9, 0xb9, 0x42, 0x46, 0x5c, 0xa2, 0x48, 0x6a, 0x1d, 0x7d, 0x02, 0x3c, 0x1c, 0x9d, 0x5c, - 0x43, 0x3c, 0x9d, 0x05, 0x18, 0xa5, 0xc4, 0xbb, 0xe6, 0x2a, 0x08, 0xc3, 0xd5, 0x3b, 0xe6, 0x14, - 0x64, 0x24, 0x26, 0xa5, 0x96, 0x64, 0x26, 0x0b, 0x59, 0x72, 0x49, 0x22, 0xe9, 0x09, 0xf6, 0x75, - 0xf4, 0xf1, 0x71, 0x0d, 0x0e, 0x89, 0x77, 0xf3, 0x0c, 0x0a, 0x0e, 0x11, 0x60, 0x92, 0x92, 0xea, - 0x9a, 0xab, 0x20, 0x06, 0xd7, 0x17, 0x9c, 0x9b, 0x98, 0x93, 0x93, 0x5a, 0x5c, 0xe2, 0x96, 0x59, - 0x54, 0x5c, 0x22, 0x64, 0xce, 0x25, 0x81, 0xa4, 0xd5, 0xc7, 0x31, 0xc8, 0x1d, 0xa1, 0x93, 0x59, - 0x4a, 0xb2, 0x6b, 0xae, 0x82, 0x28, 0x5c, 0xa7, 0x4f, 0x62, 0x51, 0x3a, 0x5c, 0xa3, 0x29, 0x97, - 0x38, 0x92, 0x46, 0x7f, 0x1f, 0x17, 0x84, 0x3e, 0x16, 0x29, 0x89, 0xae, 0xb9, 0x0a, 0x22, 0x70, - 0x7d, 0xfe, 0x39, 0x29, 0x38, 0xb4, 0xf9, 0xb9, 0x86, 0x23, 0xb4, 0xb1, 0xa2, 0x69, 0xf3, 0x4b, - 0x2d, 0x87, 0x69, 0x93, 0x62, 0x59, 0xb1, 0x44, 0x8e, 0xc1, 0xc9, 0xfd, 0xc4, 0x43, 0x39, 0x86, - 0x0b, 0x0f, 0xe5, 0x18, 0x5e, 0x3c, 0x92, 0x63, 0x98, 0xf0, 0x58, 0x8e, 0x61, 0xc1, 0x63, 0x39, - 0xc6, 0x0b, 0x8f, 0xe5, 0x18, 0x6e, 0x3c, 0x96, 0x63, 0x88, 0xd2, 0x4c, 0xcf, 0x2c, 0xc9, 0x28, - 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0x2f, 0xae, 0xcc, 0x4b, 0x2e, 0xc9, 0xc8, 0xcc, 0x4b, 0x47, - 0x62, 0x21, 0xe2, 0x36, 0x89, 0x0d, 0x1c, 0x4b, 0xc6, 0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0x34, - 0x1f, 0xbc, 0x31, 0xf0, 0x01, 0x00, 0x00, + // 347 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0xd1, 0xbf, 0x4a, 0xc3, 0x40, + 0x1c, 0xc0, 0xf1, 0xa4, 0xd6, 0x82, 0xb7, 0x58, 0x53, 0x6b, 0xdb, 0x1b, 0x8e, 0x80, 0x93, 0x1d, + 0x1a, 0x50, 0x44, 0x1c, 0x53, 0x9b, 0x6a, 0xf1, 0xda, 0x94, 0xa4, 0x22, 0xb8, 0x94, 0x24, 0x4d, + 0xd3, 0xc0, 0x35, 0x17, 0xf2, 0x07, 0xf1, 0x15, 0x32, 0xf9, 0x02, 0x01, 0x07, 0x07, 0x1f, 0xa5, + 0x63, 0xc1, 0xc5, 0xb5, 0xcd, 0x8b, 0x88, 0x29, 0x26, 0x41, 0x70, 0xfb, 0xdd, 0x8f, 0xef, 0xe7, + 0x96, 0x1f, 0x80, 0xc4, 0xd6, 0x05, 0x83, 0x3a, 0x73, 0xdb, 0x12, 0xdc, 0x90, 0x10, 0xea, 0xcd, + 0x4c, 0xaf, 0xe3, 0x7a, 0x34, 0xa0, 0x5c, 0x65, 0xb7, 0x87, 0xa7, 0x9e, 0xe9, 0x52, 0x5f, 0x48, + 0x97, 0x7a, 0x38, 0x17, 0x2c, 0x6a, 0xd1, 0xf4, 0x91, 0x4e, 0xbb, 0xb8, 0xfd, 0x59, 0x02, 0x07, + 0xe3, 0x90, 0x10, 0xf9, 0xe7, 0x03, 0xae, 0x0d, 0x8e, 0xc6, 0x0f, 0x18, 0x4f, 0x65, 0xa5, 0x27, + 0x29, 0x53, 0x45, 0x1c, 0xf5, 0xe4, 0x61, 0x95, 0x81, 0xb5, 0x28, 0xe6, 0x0f, 0xb3, 0x4a, 0xd1, + 0x9c, 0x19, 0x5d, 0x72, 0xe7, 0xa0, 0x5e, 0x68, 0x45, 0x3c, 0xbe, 0x13, 0xbb, 0xd2, 0x64, 0x70, + 0x53, 0x65, 0x61, 0x23, 0x8a, 0xf9, 0x5a, 0xd6, 0x8b, 0xc4, 0x5d, 0x68, 0xba, 0x19, 0xd8, 0x06, + 0x77, 0x0d, 0x5a, 0x05, 0xa3, 0x0e, 0x45, 0x8c, 0x25, 0x75, 0x32, 0xed, 0x0f, 0x14, 0x75, 0x52, + 0x2d, 0x41, 0x18, 0xc5, 0xfc, 0x49, 0xe6, 0xd4, 0xa5, 0x46, 0x88, 0xe9, 0x07, 0x7d, 0xdb, 0xf3, + 0x03, 0xee, 0x0a, 0x34, 0x0b, 0x14, 0x8b, 0xca, 0x6d, 0x2e, 0xf7, 0x60, 0x2b, 0x8a, 0xf9, 0x7a, + 0x26, 0xb1, 0xe6, 0x59, 0x19, 0xbc, 0x04, 0x8d, 0x02, 0x94, 0x71, 0x2f, 0x77, 0x65, 0xd8, 0x8c, + 0x62, 0xfe, 0x38, 0x73, 0x32, 0x99, 0xfd, 0xc3, 0x46, 0xd2, 0x63, 0xce, 0xf6, 0xff, 0xb0, 0x91, + 0xf9, 0xfc, 0xcb, 0x60, 0xf9, 0xe3, 0x1d, 0x31, 0xdd, 0xfb, 0xd5, 0x06, 0x31, 0xeb, 0x0d, 0x62, + 0x56, 0x5b, 0xc4, 0xae, 0xb7, 0x88, 0x7d, 0x4d, 0x10, 0xf3, 0x96, 0x20, 0x76, 0x9d, 0x20, 0xe6, + 0x2b, 0x41, 0xcc, 0xd3, 0x99, 0x65, 0x07, 0x8b, 0x50, 0xef, 0x18, 0x74, 0x29, 0xf8, 0x2f, 0x8e, + 0x11, 0x2c, 0x6c, 0xc7, 0x2a, 0x4c, 0xf9, 0x7d, 0xf5, 0x4a, 0x7a, 0xa9, 0x8b, 0xef, 0x00, 0x00, + 0x00, 0xff, 0xff, 0x09, 0x68, 0xa0, 0x7d, 0xf4, 0x01, 0x00, 0x00, } diff --git a/lib/config/size.pb.go b/lib/config/size.pb.go index 6956197ce..c1d527c46 100644 --- a/lib/config/size.pb.go +++ b/lib/config/size.pb.go @@ -4,10 +4,12 @@ package config import ( + encoding_binary "encoding/binary" fmt "fmt" _ "github.com/gogo/protobuf/gogoproto" proto "github.com/gogo/protobuf/proto" _ "github.com/syncthing/syncthing/proto/ext" + io "io" math "math" math_bits "math/bits" ) @@ -34,16 +36,25 @@ func (*Size) Descriptor() ([]byte, []int) { return fileDescriptor_4d75cb8f619bd299, []int{0} } func (m *Size) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_Size.Unmarshal(m, b) + return m.Unmarshal(b) } func (m *Size) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_Size.Marshal(b, m, deterministic) + if deterministic { + return xxx_messageInfo_Size.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } } func (m *Size) XXX_Merge(src proto.Message) { xxx_messageInfo_Size.Merge(m, src) } func (m *Size) XXX_Size() int { - return xxx_messageInfo_Size.Size(m) + return m.ProtoSize() } func (m *Size) XXX_DiscardUnknown() { xxx_messageInfo_Size.DiscardUnknown(m) @@ -58,7 +69,7 @@ func init() { func init() { proto.RegisterFile("lib/config/size.proto", fileDescriptor_4d75cb8f619bd299) } var fileDescriptor_4d75cb8f619bd299 = []byte{ - // 246 bytes of a gzipped FileDescriptorProto + // 251 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0xcd, 0xc9, 0x4c, 0xd2, 0x4f, 0xce, 0xcf, 0x4b, 0xcb, 0x4c, 0xd7, 0x2f, 0xce, 0xac, 0x4a, 0xd5, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x83, 0x08, 0x49, 0x29, 0x17, 0xa5, 0x16, 0xe4, 0x17, 0xeb, 0x83, 0x05, 0x93, @@ -69,14 +80,61 @@ var fileDescriptor_4d75cb8f619bd299 = []byte{ 0x51, 0x4a, 0x62, 0x49, 0xa2, 0xd2, 0xab, 0xf3, 0x2a, 0x9c, 0x70, 0x5e, 0x10, 0x44, 0x99, 0x90, 0x0d, 0x17, 0x4b, 0x69, 0x5e, 0x66, 0x89, 0x04, 0x93, 0x02, 0xa3, 0x06, 0xa7, 0x93, 0xc6, 0xab, 0x7b, 0xf2, 0x60, 0x3e, 0x5c, 0x3b, 0x88, 0xa3, 0x93, 0x58, 0x52, 0x52, 0x04, 0xd6, 0x0e, 0xe7, - 0x05, 0x81, 0x55, 0x59, 0xb1, 0xcc, 0x58, 0x20, 0xcf, 0xe0, 0xe4, 0x7e, 0xe2, 0xa1, 0x1c, 0xc3, - 0x85, 0x87, 0x72, 0x0c, 0x2f, 0x1e, 0xc9, 0x31, 0x4c, 0x78, 0x2c, 0xc7, 0xb0, 0xe0, 0xb1, 0x1c, - 0xe3, 0x85, 0xc7, 0x72, 0x0c, 0x37, 0x1e, 0xcb, 0x31, 0x44, 0x69, 0xa6, 0x67, 0x96, 0x64, 0x94, - 0x26, 0xe9, 0x25, 0xe7, 0xe7, 0xea, 0x17, 0x57, 0xe6, 0x25, 0x97, 0x64, 0x64, 0xe6, 0xa5, 0x23, - 0xb1, 0x10, 0x21, 0x93, 0xc4, 0x06, 0xf6, 0x9d, 0x31, 0x20, 0x00, 0x00, 0xff, 0xff, 0x67, 0x60, - 0xd6, 0x9a, 0x2e, 0x01, 0x00, 0x00, + 0x05, 0x81, 0x55, 0x59, 0xb1, 0xcc, 0x58, 0x20, 0xcf, 0xe0, 0xe4, 0x7d, 0xe2, 0xa1, 0x1c, 0xc3, + 0x85, 0x87, 0x72, 0x0c, 0x27, 0x1e, 0xc9, 0x31, 0x5e, 0x78, 0x24, 0xc7, 0x38, 0xe1, 0xb1, 0x1c, + 0xc3, 0x82, 0xc7, 0x72, 0x8c, 0x17, 0x1e, 0xcb, 0x31, 0xdc, 0x78, 0x2c, 0xc7, 0x10, 0xa5, 0x99, + 0x9e, 0x59, 0x92, 0x51, 0x9a, 0xa4, 0x97, 0x9c, 0x9f, 0xab, 0x5f, 0x5c, 0x99, 0x97, 0x5c, 0x92, + 0x91, 0x99, 0x97, 0x8e, 0xc4, 0x42, 0x84, 0x4e, 0x12, 0x1b, 0xd8, 0x87, 0xc6, 0x80, 0x00, 0x00, + 0x00, 0xff, 0xff, 0x65, 0x1e, 0xa3, 0x25, 0x32, 0x01, 0x00, 0x00, } +func (m *Size) Marshal() (dAtA []byte, err error) { + size := m.ProtoSize() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Size) MarshalTo(dAtA []byte) (int, error) { + size := m.ProtoSize() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Size) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Unit) > 0 { + i -= len(m.Unit) + copy(dAtA[i:], m.Unit) + i = encodeVarintSize(dAtA, i, uint64(len(m.Unit))) + i-- + dAtA[i] = 0x12 + } + if m.Value != 0 { + i -= 8 + encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Value)))) + i-- + dAtA[i] = 0x9 + } + return len(dAtA) - i, nil +} + +func encodeVarintSize(dAtA []byte, offset int, v uint64) int { + offset -= sovSize(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} func (m *Size) ProtoSize() (n int) { if m == nil { return 0 @@ -99,3 +157,183 @@ func sovSize(x uint64) (n int) { func sozSize(x uint64) (n int) { return sovSize(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } +func (m *Size) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSize + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Size: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Size: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) + iNdEx += 8 + m.Value = float64(math.Float64frombits(v)) + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Unit", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSize + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthSize + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthSize + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Unit = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipSize(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthSize + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthSize + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipSize(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowSize + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowSize + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowSize + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthSize + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupSize + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthSize + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthSize = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowSize = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupSize = fmt.Errorf("proto: unexpected end of group") +) diff --git a/lib/config/tuning.pb.go b/lib/config/tuning.pb.go index c6610d409..ff1934fc4 100644 --- a/lib/config/tuning.pb.go +++ b/lib/config/tuning.pb.go @@ -52,7 +52,7 @@ func init() { func init() { proto.RegisterFile("lib/config/tuning.proto", fileDescriptor_204cfa1615fdfefd) } var fileDescriptor_204cfa1615fdfefd = []byte{ - // 224 bytes of a gzipped FileDescriptorProto + // 228 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0xcf, 0xc9, 0x4c, 0xd2, 0x4f, 0xce, 0xcf, 0x4b, 0xcb, 0x4c, 0xd7, 0x2f, 0x29, 0xcd, 0xcb, 0xcc, 0x4b, 0xd7, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x83, 0x08, 0x4a, 0x29, 0x17, 0xa5, 0x16, 0xe4, 0x17, 0xeb, 0x83, @@ -62,9 +62,10 @@ var fileDescriptor_204cfa1615fdfefd = []byte{ 0xb4, 0x24, 0x5f, 0x48, 0x91, 0x8b, 0x07, 0xaa, 0x20, 0xd8, 0xd7, 0xd1, 0xc7, 0x47, 0x80, 0x51, 0x8a, 0xbf, 0x6b, 0xae, 0x02, 0x37, 0x44, 0x45, 0x70, 0x6e, 0x62, 0x4e, 0x0e, 0x92, 0x12, 0x1f, 0xc7, 0x20, 0x77, 0x57, 0x01, 0x26, 0x64, 0x25, 0x3e, 0x89, 0x45, 0xe9, 0xa9, 0x52, 0x2c, 0x2b, - 0x96, 0xc8, 0x31, 0x38, 0xb9, 0x9f, 0x78, 0x28, 0xc7, 0x70, 0xe1, 0xa1, 0x1c, 0xc3, 0x8b, 0x47, - 0x72, 0x0c, 0x13, 0x1e, 0xcb, 0x31, 0x2c, 0x78, 0x2c, 0xc7, 0x78, 0xe1, 0xb1, 0x1c, 0xc3, 0x8d, - 0xc7, 0x72, 0x0c, 0x51, 0x9a, 0xe9, 0x99, 0x25, 0x19, 0xa5, 0x49, 0x7a, 0xc9, 0xf9, 0xb9, 0xfa, - 0xc5, 0x95, 0x79, 0xc9, 0x25, 0x19, 0x99, 0x79, 0xe9, 0x48, 0x2c, 0x84, 0xcf, 0x93, 0xd8, 0xc0, - 0xde, 0x30, 0x06, 0x04, 0x00, 0x00, 0xff, 0xff, 0xfe, 0xdf, 0xc4, 0xd9, 0x0e, 0x01, 0x00, 0x00, + 0x96, 0xc8, 0x31, 0x38, 0x79, 0x9f, 0x78, 0x28, 0xc7, 0x70, 0xe1, 0xa1, 0x1c, 0xc3, 0x89, 0x47, + 0x72, 0x8c, 0x17, 0x1e, 0xc9, 0x31, 0x4e, 0x78, 0x2c, 0xc7, 0xb0, 0xe0, 0xb1, 0x1c, 0xe3, 0x85, + 0xc7, 0x72, 0x0c, 0x37, 0x1e, 0xcb, 0x31, 0x44, 0x69, 0xa6, 0x67, 0x96, 0x64, 0x94, 0x26, 0xe9, + 0x25, 0xe7, 0xe7, 0xea, 0x17, 0x57, 0xe6, 0x25, 0x97, 0x64, 0x64, 0xe6, 0xa5, 0x23, 0xb1, 0x10, + 0xbe, 0x4f, 0x62, 0x03, 0x7b, 0xc5, 0x18, 0x10, 0x00, 0x00, 0xff, 0xff, 0x9f, 0x69, 0xc8, 0xbc, + 0x12, 0x01, 0x00, 0x00, } diff --git a/lib/config/versioningconfiguration.pb.go b/lib/config/versioningconfiguration.pb.go index 48ba6533a..1bbfca797 100644 --- a/lib/config/versioningconfiguration.pb.go +++ b/lib/config/versioningconfiguration.pb.go @@ -7,6 +7,7 @@ import ( fmt "fmt" proto "github.com/gogo/protobuf/proto" _ "github.com/syncthing/syncthing/proto/ext" + io "io" math "math" math_bits "math/bits" ) @@ -36,16 +37,25 @@ func (*VersioningConfiguration) Descriptor() ([]byte, []int) { return fileDescriptor_95ba6bdb22ffea81, []int{0} } func (m *VersioningConfiguration) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_VersioningConfiguration.Unmarshal(m, b) + return m.Unmarshal(b) } func (m *VersioningConfiguration) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_VersioningConfiguration.Marshal(b, m, deterministic) + if deterministic { + return xxx_messageInfo_VersioningConfiguration.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } } func (m *VersioningConfiguration) XXX_Merge(src proto.Message) { xxx_messageInfo_VersioningConfiguration.Merge(m, src) } func (m *VersioningConfiguration) XXX_Size() int { - return xxx_messageInfo_VersioningConfiguration.Size(m) + return m.ProtoSize() } func (m *VersioningConfiguration) XXX_DiscardUnknown() { xxx_messageInfo_VersioningConfiguration.DiscardUnknown(m) @@ -63,33 +73,99 @@ func init() { } var fileDescriptor_95ba6bdb22ffea81 = []byte{ - // 383 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x52, 0xcf, 0x8b, 0x9b, 0x40, - 0x18, 0x1d, 0x63, 0x22, 0x64, 0xd2, 0x5f, 0x78, 0xa9, 0x04, 0xea, 0x48, 0xea, 0xc1, 0x5e, 0x34, - 0x34, 0xb4, 0x94, 0x1c, 0x2d, 0xa5, 0xf4, 0x56, 0x52, 0x28, 0xb4, 0x97, 0x60, 0xec, 0xc4, 0x0c, - 0x35, 0xa3, 0xe8, 0x18, 0xea, 0xb1, 0x87, 0x42, 0x8f, 0xed, 0xfe, 0x05, 0xfb, 0xe7, 0xe4, 0x96, - 0x1c, 0xf7, 0x34, 0x90, 0x78, 0x59, 0x3c, 0xe6, 0x98, 0xd3, 0xe2, 0x28, 0xd9, 0xb0, 0xcb, 0xde, - 0xde, 0x7b, 0xdf, 0x7b, 0xdf, 0x93, 0xcf, 0x81, 0x56, 0x48, 0x66, 0x8e, 0x1f, 0xd1, 0x39, 0x09, - 0x9c, 0x15, 0x4e, 0x52, 0x12, 0x51, 0x42, 0x83, 0x5a, 0xc8, 0x12, 0x8f, 0x91, 0x88, 0xda, 0x71, - 0x12, 0xb1, 0x48, 0x55, 0x6a, 0xb1, 0xdf, 0xc5, 0xbf, 0x58, 0x2d, 0x0d, 0xfe, 0xc8, 0xf0, 0xf9, - 0xd7, 0x53, 0xe8, 0xfd, 0x79, 0x48, 0x35, 0x60, 0x9b, 0xe5, 0x31, 0xd6, 0x24, 0x43, 0xb2, 0xba, - 0xee, 0xa3, 0x92, 0x23, 0xc1, 0x0f, 0x1c, 0x81, 0x89, 0x40, 0xea, 0x6f, 0x09, 0xc2, 0xd8, 0x4b, - 0xbc, 0x25, 0x66, 0x38, 0x49, 0xb5, 0x96, 0x21, 0x5b, 0xbd, 0xd7, 0x8e, 0x5d, 0xd7, 0xd8, 0x0f, - 0xec, 0xb5, 0x3f, 0x9f, 0x12, 0x1f, 0x28, 0x4b, 0x72, 0x77, 0xb8, 0xe6, 0x08, 0xec, 0x39, 0x52, - 0xc4, 0x20, 0x2d, 0x39, 0x52, 0xc4, 0xd2, 0xb4, 0x6a, 0x3a, 0x6c, 0xcc, 0x86, 0x5d, 0x6c, 0xcd, - 0xc6, 0x31, 0x39, 0x2b, 0x55, 0x7d, 0xa8, 0xfa, 0x21, 0xf6, 0x68, 0x16, 0x4f, 0x09, 0x65, 0x38, - 0x59, 0x79, 0xe1, 0x34, 0xd5, 0x64, 0x43, 0xb2, 0x3a, 0xee, 0x9b, 0x92, 0xa3, 0x67, 0xcd, 0xf4, - 0x53, 0x33, 0xfc, 0x72, 0xe0, 0xe8, 0xc9, 0x0f, 0x3c, 0xf7, 0xb2, 0x90, 0x8d, 0x07, 0xa3, 0xb7, - 0xc3, 0xe1, 0xe0, 0xc8, 0x91, 0x4c, 0x28, 0x3b, 0x6e, 0xcc, 0x76, 0xc5, 0x27, 0xf7, 0x22, 0xfd, - 0x6f, 0xf0, 0xe9, 0x9d, 0xaf, 0x56, 0x5f, 0x40, 0xf9, 0x27, 0xce, 0x9b, 0xe3, 0xf4, 0x4a, 0x8e, - 0x2a, 0x2a, 0x6e, 0x53, 0x01, 0xf5, 0x25, 0xec, 0xac, 0xbc, 0x30, 0xc3, 0x5a, 0x4b, 0x18, 0x1e, - 0x97, 0x1c, 0xd5, 0x82, 0xb0, 0xd4, 0x70, 0xdc, 0x7a, 0x27, 0x8d, 0xdb, 0x7f, 0xff, 0x9b, 0xc0, - 0xfd, 0xb8, 0xde, 0xe9, 0x60, 0xbb, 0xd3, 0xc1, 0xf5, 0x5e, 0x07, 0xff, 0x0a, 0x1d, 0x5c, 0x16, - 0xba, 0xb4, 0x2d, 0x74, 0x70, 0x55, 0xe8, 0xe0, 0xfb, 0xab, 0x80, 0xb0, 0x45, 0x36, 0xb3, 0xfd, - 0x68, 0xe9, 0xa4, 0x39, 0xf5, 0xd9, 0x82, 0xd0, 0xe0, 0x0c, 0xdd, 0xbe, 0x80, 0x99, 0x22, 0xfe, - 0xeb, 0xe8, 0x26, 0x00, 0x00, 0xff, 0xff, 0x08, 0x18, 0x19, 0x5e, 0x16, 0x02, 0x00, 0x00, + // 385 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x52, 0xbf, 0xcb, 0xd3, 0x40, + 0x18, 0xbe, 0x6b, 0xfa, 0x05, 0xbe, 0xfb, 0xfc, 0x45, 0x16, 0xc3, 0x07, 0xde, 0x85, 0x9a, 0x21, + 0x2e, 0x49, 0xf1, 0x43, 0x91, 0x8e, 0x11, 0x07, 0x71, 0x91, 0x0a, 0x82, 0x2e, 0x25, 0x8d, 0xd7, + 0xf4, 0x30, 0xbd, 0x84, 0xe4, 0x52, 0xcc, 0xe8, 0x20, 0x38, 0xaa, 0x7f, 0x81, 0x7f, 0x4e, 0xb7, + 0x66, 0x74, 0x3a, 0x68, 0xb3, 0x65, 0xec, 0xd8, 0x49, 0x72, 0x09, 0xb5, 0x28, 0x6e, 0xcf, 0xf3, + 0xbc, 0xcf, 0xf3, 0x3e, 0xe1, 0xcd, 0x21, 0x27, 0x66, 0x73, 0x2f, 0x4c, 0xf8, 0x82, 0x45, 0xde, + 0x9a, 0x66, 0x39, 0x4b, 0x38, 0xe3, 0x51, 0x27, 0x14, 0x59, 0x20, 0x58, 0xc2, 0xdd, 0x34, 0x4b, + 0x44, 0x62, 0xe8, 0x9d, 0x78, 0x7d, 0x49, 0x3f, 0x89, 0x4e, 0x1a, 0x7d, 0xd1, 0xd0, 0xfd, 0xb7, + 0xa7, 0xd0, 0xf3, 0xf3, 0x90, 0x61, 0xa1, 0xa1, 0x28, 0x53, 0x6a, 0x42, 0x0b, 0x3a, 0x97, 0xfe, + 0xad, 0x46, 0x12, 0xc5, 0x0f, 0x92, 0x80, 0xa9, 0x42, 0xc6, 0x67, 0x88, 0x50, 0x1a, 0x64, 0xc1, + 0x8a, 0x0a, 0x9a, 0xe5, 0xe6, 0xc0, 0xd2, 0x9c, 0xab, 0xc7, 0x9e, 0xdb, 0xd5, 0xb8, 0xff, 0xd9, + 0xeb, 0xbe, 0x3e, 0x25, 0x5e, 0x70, 0x91, 0x95, 0xfe, 0x78, 0x23, 0x09, 0xd8, 0x4b, 0xa2, 0xab, + 0x41, 0xde, 0x48, 0xa2, 0xab, 0xa5, 0x79, 0xdb, 0x74, 0xd8, 0xda, 0x3d, 0xfb, 0x51, 0xd9, 0xbd, + 0x63, 0x7a, 0x56, 0x6a, 0x84, 0xc8, 0x08, 0x63, 0x1a, 0xf0, 0x22, 0x9d, 0x31, 0x2e, 0x68, 0xb6, + 0x0e, 0xe2, 0x59, 0x6e, 0x6a, 0x16, 0x74, 0x2e, 0xfc, 0x27, 0x8d, 0x24, 0xf7, 0xfa, 0xe9, 0xcb, + 0x7e, 0xf8, 0xe6, 0x20, 0xc9, 0x9d, 0x0f, 0x74, 0x11, 0x14, 0xb1, 0x98, 0x8c, 0x6e, 0x9e, 0x8e, + 0xc7, 0xa3, 0xa3, 0x24, 0x1a, 0xe3, 0xe2, 0xb8, 0xb5, 0x87, 0x2d, 0x9f, 0xfe, 0x13, 0xb9, 0x7e, + 0x87, 0xee, 0xfe, 0xf5, 0xd5, 0xc6, 0x03, 0xa4, 0x7d, 0xa4, 0x65, 0x7f, 0x9c, 0xab, 0x46, 0x92, + 0x96, 0xaa, 0xdb, 0xb4, 0xc0, 0x78, 0x88, 0x2e, 0xd6, 0x41, 0x5c, 0x50, 0x73, 0xa0, 0x0c, 0xb7, + 0x1b, 0x49, 0x3a, 0x41, 0x59, 0x3a, 0x38, 0x19, 0x3c, 0x83, 0x93, 0xe1, 0xd7, 0xef, 0x36, 0xf0, + 0x5f, 0x6d, 0x76, 0x18, 0x54, 0x3b, 0x0c, 0x36, 0x7b, 0x0c, 0xab, 0x3d, 0x86, 0xdf, 0x6a, 0x0c, + 0x7e, 0xd6, 0x18, 0x56, 0x35, 0x06, 0xbf, 0x6a, 0x0c, 0xde, 0x3f, 0x8a, 0x98, 0x58, 0x16, 0x73, + 0x37, 0x4c, 0x56, 0x5e, 0x5e, 0xf2, 0x50, 0x2c, 0x19, 0x8f, 0xce, 0xd0, 0x9f, 0x57, 0x30, 0xd7, + 0xd5, 0xbf, 0xbd, 0xf9, 0x1d, 0x00, 0x00, 0xff, 0xff, 0xf0, 0x0d, 0x6f, 0xcc, 0x1a, 0x02, 0x00, + 0x00, } +func (m *VersioningConfiguration) Marshal() (dAtA []byte, err error) { + size := m.ProtoSize() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *VersioningConfiguration) MarshalTo(dAtA []byte) (int, error) { + size := m.ProtoSize() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *VersioningConfiguration) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.CleanupIntervalS != 0 { + i = encodeVarintVersioningconfiguration(dAtA, i, uint64(m.CleanupIntervalS)) + i-- + dAtA[i] = 0x18 + } + if len(m.Params) > 0 { + for k := range m.Params { + v := m.Params[k] + baseI := i + i -= len(v) + copy(dAtA[i:], v) + i = encodeVarintVersioningconfiguration(dAtA, i, uint64(len(v))) + i-- + dAtA[i] = 0x12 + i -= len(k) + copy(dAtA[i:], k) + i = encodeVarintVersioningconfiguration(dAtA, i, uint64(len(k))) + i-- + dAtA[i] = 0xa + i = encodeVarintVersioningconfiguration(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0x12 + } + } + if len(m.Type) > 0 { + i -= len(m.Type) + copy(dAtA[i:], m.Type) + i = encodeVarintVersioningconfiguration(dAtA, i, uint64(len(m.Type))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func encodeVarintVersioningconfiguration(dAtA []byte, offset int, v uint64) int { + offset -= sovVersioningconfiguration(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} func (m *VersioningConfiguration) ProtoSize() (n int) { if m == nil { return 0 @@ -120,3 +196,318 @@ func sovVersioningconfiguration(x uint64) (n int) { func sozVersioningconfiguration(x uint64) (n int) { return sovVersioningconfiguration(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } +func (m *VersioningConfiguration) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowVersioningconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: VersioningConfiguration: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: VersioningConfiguration: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowVersioningconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthVersioningconfiguration + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthVersioningconfiguration + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Type = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowVersioningconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthVersioningconfiguration + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthVersioningconfiguration + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Params == nil { + m.Params = make(map[string]string) + } + var mapkey string + var mapvalue string + for iNdEx < postIndex { + entryPreIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowVersioningconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + if fieldNum == 1 { + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowVersioningconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapkey |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthVersioningconfiguration + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey < 0 { + return ErrInvalidLengthVersioningconfiguration + } + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + } else if fieldNum == 2 { + var stringLenmapvalue uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowVersioningconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapvalue |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapvalue := int(stringLenmapvalue) + if intStringLenmapvalue < 0 { + return ErrInvalidLengthVersioningconfiguration + } + postStringIndexmapvalue := iNdEx + intStringLenmapvalue + if postStringIndexmapvalue < 0 { + return ErrInvalidLengthVersioningconfiguration + } + if postStringIndexmapvalue > l { + return io.ErrUnexpectedEOF + } + mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) + iNdEx = postStringIndexmapvalue + } else { + iNdEx = entryPreIndex + skippy, err := skipVersioningconfiguration(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthVersioningconfiguration + } + if (iNdEx + skippy) > postIndex { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + m.Params[mapkey] = mapvalue + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CleanupIntervalS", wireType) + } + m.CleanupIntervalS = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowVersioningconfiguration + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.CleanupIntervalS |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipVersioningconfiguration(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthVersioningconfiguration + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthVersioningconfiguration + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipVersioningconfiguration(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowVersioningconfiguration + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowVersioningconfiguration + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowVersioningconfiguration + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthVersioningconfiguration + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupVersioningconfiguration + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthVersioningconfiguration + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthVersioningconfiguration = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowVersioningconfiguration = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupVersioningconfiguration = fmt.Errorf("proto: unexpected end of group") +) diff --git a/lib/db/db_test.go b/lib/db/db_test.go index 31f1c1f9d..2c32d422b 100644 --- a/lib/db/db_test.go +++ b/lib/db/db_test.go @@ -25,7 +25,7 @@ func genBlocks(n int) []protocol.BlockInfo { for j := range h { h[j] = byte(i + j) } - b[i].Size = int32(i) + b[i].Size = i b[i].Hash = h } return b diff --git a/lib/db/schemaupdater.go b/lib/db/schemaupdater.go index 3c66ddf83..6a998d2a4 100644 --- a/lib/db/schemaupdater.go +++ b/lib/db/schemaupdater.go @@ -198,7 +198,7 @@ func (db *schemaUpdater) updateSchema0to1(_ int) error { // probably can't happen continue } - if f.Type == protocol.FileInfoTypeDeprecatedSymlinkDirectory || f.Type == protocol.FileInfoTypeDeprecatedSymlinkFile { + if f.Type == protocol.FileInfoTypeSymlinkDirectory || f.Type == protocol.FileInfoTypeSymlinkFile { f.Type = protocol.FileInfoTypeSymlink bs, err := f.Marshal() if err != nil { diff --git a/lib/db/set_test.go b/lib/db/set_test.go index be82eb9ec..1362f9873 100644 --- a/lib/db/set_test.go +++ b/lib/db/set_test.go @@ -38,7 +38,7 @@ func genBlocks(n int) []protocol.BlockInfo { for j := range h { h[j] = byte(i + j) } - b[i].Size = int32(i) + b[i].Size = i b[i].Hash = h } return b @@ -227,7 +227,8 @@ func TestGlobalSet(t *testing.T) { t.Errorf("Global incorrect;\n A: %v !=\n E: %v", g, expectedGlobal) } - globalFiles, globalDirectories, globalDeleted, globalBytes := int32(0), int32(0), int32(0), int64(0) + var globalFiles, globalDirectories, globalDeleted int + var globalBytes int64 for _, f := range g { if f.IsInvalid() { continue @@ -263,7 +264,8 @@ func TestGlobalSet(t *testing.T) { t.Errorf("Have incorrect (local);\n A: %v !=\n E: %v", h, localTot) } - haveFiles, haveDirectories, haveDeleted, haveBytes := int32(0), int32(0), int32(0), int64(0) + var haveFiles, haveDirectories, haveDeleted int + var haveBytes int64 for _, f := range h { if f.IsInvalid() { continue diff --git a/lib/db/structs.go b/lib/db/structs.go index ae880b827..b807cd11c 100644 --- a/lib/db/structs.go +++ b/lib/db/structs.go @@ -4,9 +4,6 @@ // License, v. 2.0. If a copy of the MPL was not distributed with this file, // You can obtain one at https://mozilla.org/MPL/2.0/. -//go:generate go run ../../proto/scripts/protofmt.go structs.proto -//go:generate protoc -I ../../ -I ../../proto -I . --gogofast_out=Mlib/protocol/bep.proto=github.com/syncthing/syncthing/lib/protocol:. structs.proto - package db import ( @@ -26,7 +23,7 @@ func (f FileInfoTruncated) String() string { case protocol.FileInfoTypeFile: return fmt.Sprintf("File{Name:%q, Sequence:%d, Permissions:0%o, ModTime:%v, Version:%v, Length:%d, Deleted:%v, Invalid:%v, LocalFlags:0x%x, NoPermissions:%v, BlockSize:%d}", f.Name, f.Sequence, f.Permissions, f.ModTime(), f.Version, f.Size, f.Deleted, f.RawInvalid, f.LocalFlags, f.NoPermissions, f.RawBlockSize) - case protocol.FileInfoTypeSymlink, protocol.FileInfoTypeDeprecatedSymlinkDirectory, protocol.FileInfoTypeDeprecatedSymlinkFile: + case protocol.FileInfoTypeSymlink, protocol.FileInfoTypeSymlinkDirectory, protocol.FileInfoTypeSymlinkFile: return fmt.Sprintf("Symlink{Name:%q, Type:%v, Sequence:%d, Version:%v, Deleted:%v, Invalid:%v, LocalFlags:0x%x, NoPermissions:%v, SymlinkTarget:%q}", f.Name, f.Type, f.Sequence, f.Version, f.Deleted, f.RawInvalid, f.LocalFlags, f.NoPermissions, f.SymlinkTarget) default: @@ -64,7 +61,7 @@ func (f FileInfoTruncated) IsDirectory() bool { func (f FileInfoTruncated) IsSymlink() bool { switch f.Type { - case protocol.FileInfoTypeSymlink, protocol.FileInfoTypeDeprecatedSymlinkDirectory, protocol.FileInfoTypeDeprecatedSymlinkFile: + case protocol.FileInfoTypeSymlink, protocol.FileInfoTypeSymlinkDirectory, protocol.FileInfoTypeSymlinkFile: return true default: return false @@ -183,7 +180,7 @@ func (c Counts) Add(other Counts) Counts { } } -func (c Counts) TotalItems() int32 { +func (c Counts) TotalItems() int { return c.Files + c.Directories + c.Symlinks + c.Deleted } diff --git a/lib/db/structs.pb.go b/lib/db/structs.pb.go index e8b1e197a..2b34e673b 100644 --- a/lib/db/structs.pb.go +++ b/lib/db/structs.pb.go @@ -1,5 +1,5 @@ // Code generated by protoc-gen-gogo. DO NOT EDIT. -// source: structs.proto +// source: lib/db/structs.proto package db @@ -9,6 +9,7 @@ import ( proto "github.com/gogo/protobuf/proto" github_com_syncthing_syncthing_lib_protocol "github.com/syncthing/syncthing/lib/protocol" protocol "github.com/syncthing/syncthing/lib/protocol" + _ "github.com/syncthing/syncthing/proto/ext" io "io" math "math" math_bits "math/bits" @@ -26,17 +27,17 @@ var _ = math.Inf const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package type FileVersion struct { - Version protocol.Vector `protobuf:"bytes,1,opt,name=version,proto3" json:"version"` - Deleted bool `protobuf:"varint,2,opt,name=deleted,proto3" json:"deleted,omitempty"` - Devices [][]byte `protobuf:"bytes,3,rep,name=devices,proto3" json:"devices,omitempty"` - InvalidDevices [][]byte `protobuf:"bytes,4,rep,name=invalid_devices,json=invalidDevices,proto3" json:"invalid_devices,omitempty"` + Version protocol.Vector `protobuf:"bytes,1,opt,name=version,proto3" json:"version" xml:"version"` + Deleted bool `protobuf:"varint,2,opt,name=deleted,proto3" json:"deleted" xml:"deleted"` + Devices [][]byte `protobuf:"bytes,3,rep,name=devices,proto3" json:"devices" xml:"device"` + InvalidDevices [][]byte `protobuf:"bytes,4,rep,name=invalid_devices,json=invalidDevices,proto3" json:"invalidDevices" xml:"invalidDevice"` } func (m *FileVersion) Reset() { *m = FileVersion{} } func (m *FileVersion) String() string { return proto.CompactTextString(m) } func (*FileVersion) ProtoMessage() {} func (*FileVersion) Descriptor() ([]byte, []int) { - return fileDescriptor_e774e8f5f348d14d, []int{0} + return fileDescriptor_5465d80e8cba02e3, []int{0} } func (m *FileVersion) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -66,13 +67,13 @@ func (m *FileVersion) XXX_DiscardUnknown() { var xxx_messageInfo_FileVersion proto.InternalMessageInfo type VersionList struct { - RawVersions []FileVersion `protobuf:"bytes,1,rep,name=versions,proto3" json:"versions"` + RawVersions []FileVersion `protobuf:"bytes,1,rep,name=versions,proto3" json:"versions" xml:"version"` } func (m *VersionList) Reset() { *m = VersionList{} } func (*VersionList) ProtoMessage() {} func (*VersionList) Descriptor() ([]byte, []int) { - return fileDescriptor_e774e8f5f348d14d, []int{1} + return fileDescriptor_5465d80e8cba02e3, []int{1} } func (m *VersionList) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -103,31 +104,31 @@ var xxx_messageInfo_VersionList proto.InternalMessageInfo // Must be the same as FileInfo but without the blocks field type FileInfoTruncated struct { - Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` - Size int64 `protobuf:"varint,3,opt,name=size,proto3" json:"size,omitempty"` - ModifiedS int64 `protobuf:"varint,5,opt,name=modified_s,json=modifiedS,proto3" json:"modified_s,omitempty"` - ModifiedBy github_com_syncthing_syncthing_lib_protocol.ShortID `protobuf:"varint,12,opt,name=modified_by,json=modifiedBy,proto3,customtype=github.com/syncthing/syncthing/lib/protocol.ShortID" json:"modified_by"` - Version protocol.Vector `protobuf:"bytes,9,opt,name=version,proto3" json:"version"` - Sequence int64 `protobuf:"varint,10,opt,name=sequence,proto3" json:"sequence,omitempty"` + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name" xml:"name"` + Size int64 `protobuf:"varint,3,opt,name=size,proto3" json:"size" xml:"size"` + ModifiedS int64 `protobuf:"varint,5,opt,name=modified_s,json=modifiedS,proto3" json:"modifiedS" xml:"modifiedS"` + ModifiedBy github_com_syncthing_syncthing_lib_protocol.ShortID `protobuf:"varint,12,opt,name=modified_by,json=modifiedBy,proto3,customtype=github.com/syncthing/syncthing/lib/protocol.ShortID" json:"modifiedBy" xml:"modifiedBy"` + Version protocol.Vector `protobuf:"bytes,9,opt,name=version,proto3" json:"version" xml:"version"` + Sequence int64 `protobuf:"varint,10,opt,name=sequence,proto3" json:"sequence" xml:"sequence"` // repeated BlockInfo Blocks = 16 - SymlinkTarget string `protobuf:"bytes,17,opt,name=symlink_target,json=symlinkTarget,proto3" json:"symlink_target,omitempty"` - BlocksHash []byte `protobuf:"bytes,18,opt,name=blocks_hash,json=blocksHash,proto3" json:"blocks_hash,omitempty"` - Type protocol.FileInfoType `protobuf:"varint,2,opt,name=type,proto3,enum=protocol.FileInfoType" json:"type,omitempty"` - Permissions uint32 `protobuf:"varint,4,opt,name=permissions,proto3" json:"permissions,omitempty"` - ModifiedNs int32 `protobuf:"varint,11,opt,name=modified_ns,json=modifiedNs,proto3" json:"modified_ns,omitempty"` - RawBlockSize int32 `protobuf:"varint,13,opt,name=block_size,json=blockSize,proto3" json:"block_size,omitempty"` + SymlinkTarget string `protobuf:"bytes,17,opt,name=symlink_target,json=symlinkTarget,proto3" json:"symlinkTarget" xml:"symlinkTarget"` + BlocksHash []byte `protobuf:"bytes,18,opt,name=blocks_hash,json=blocksHash,proto3" json:"blocksHash" xml:"blocksHash"` + Type protocol.FileInfoType `protobuf:"varint,2,opt,name=type,proto3,enum=protocol.FileInfoType" json:"type" xml:"type"` + Permissions uint32 `protobuf:"varint,4,opt,name=permissions,proto3" json:"permissions" xml:"permissions"` + ModifiedNs int `protobuf:"varint,11,opt,name=modified_ns,json=modifiedNs,proto3,casttype=int" json:"modifiedNs" xml:"modifiedNs"` + RawBlockSize int `protobuf:"varint,13,opt,name=block_size,json=blockSize,proto3,casttype=int" json:"blockSize" xml:"blockSize"` // see bep.proto - LocalFlags uint32 `protobuf:"varint,1000,opt,name=local_flags,json=localFlags,proto3" json:"local_flags,omitempty"` - VersionHash []byte `protobuf:"bytes,1001,opt,name=version_hash,json=versionHash,proto3" json:"version_hash,omitempty"` - Deleted bool `protobuf:"varint,6,opt,name=deleted,proto3" json:"deleted,omitempty"` - RawInvalid bool `protobuf:"varint,7,opt,name=invalid,proto3" json:"invalid,omitempty"` - NoPermissions bool `protobuf:"varint,8,opt,name=no_permissions,json=noPermissions,proto3" json:"no_permissions,omitempty"` + LocalFlags uint32 `protobuf:"varint,1000,opt,name=local_flags,json=localFlags,proto3" json:"localFlags" xml:"localFlags"` + VersionHash []byte `protobuf:"bytes,1001,opt,name=version_hash,json=versionHash,proto3" json:"versionHash" xml:"versionHash"` + Deleted bool `protobuf:"varint,6,opt,name=deleted,proto3" json:"deleted" xml:"deleted"` + RawInvalid bool `protobuf:"varint,7,opt,name=invalid,proto3" json:"invalid" xml:"invalid"` + NoPermissions bool `protobuf:"varint,8,opt,name=no_permissions,json=noPermissions,proto3" json:"noPermissions" xml:"noPermissions"` } func (m *FileInfoTruncated) Reset() { *m = FileInfoTruncated{} } func (*FileInfoTruncated) ProtoMessage() {} func (*FileInfoTruncated) Descriptor() ([]byte, []int) { - return fileDescriptor_e774e8f5f348d14d, []int{2} + return fileDescriptor_5465d80e8cba02e3, []int{2} } func (m *FileInfoTruncated) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -158,14 +159,14 @@ var xxx_messageInfo_FileInfoTruncated proto.InternalMessageInfo // BlockList is the structure used to store block lists type BlockList struct { - Blocks []protocol.BlockInfo `protobuf:"bytes,1,rep,name=Blocks,proto3" json:"Blocks"` + Blocks []protocol.BlockInfo `protobuf:"bytes,1,rep,name=blocks,proto3" json:"blocks" xml:"block"` } func (m *BlockList) Reset() { *m = BlockList{} } func (m *BlockList) String() string { return proto.CompactTextString(m) } func (*BlockList) ProtoMessage() {} func (*BlockList) Descriptor() ([]byte, []int) { - return fileDescriptor_e774e8f5f348d14d, []int{3} + return fileDescriptor_5465d80e8cba02e3, []int{3} } func (m *BlockList) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -197,15 +198,15 @@ var xxx_messageInfo_BlockList proto.InternalMessageInfo // IndirectionHashesOnly is used to only unmarshal the indirection hashes // from a FileInfo type IndirectionHashesOnly struct { - BlocksHash []byte `protobuf:"bytes,18,opt,name=blocks_hash,json=blocksHash,proto3" json:"blocks_hash,omitempty"` - VersionHash []byte `protobuf:"bytes,1001,opt,name=version_hash,json=versionHash,proto3" json:"version_hash,omitempty"` + BlocksHash []byte `protobuf:"bytes,18,opt,name=blocks_hash,json=blocksHash,proto3" json:"blocksHash" xml:"blocksHash"` + VersionHash []byte `protobuf:"bytes,1001,opt,name=version_hash,json=versionHash,proto3" json:"versionHash" xml:"versionHash"` } func (m *IndirectionHashesOnly) Reset() { *m = IndirectionHashesOnly{} } func (m *IndirectionHashesOnly) String() string { return proto.CompactTextString(m) } func (*IndirectionHashesOnly) ProtoMessage() {} func (*IndirectionHashesOnly) Descriptor() ([]byte, []int) { - return fileDescriptor_e774e8f5f348d14d, []int{4} + return fileDescriptor_5465d80e8cba02e3, []int{4} } func (m *IndirectionHashesOnly) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -237,20 +238,20 @@ var xxx_messageInfo_IndirectionHashesOnly proto.InternalMessageInfo // For each folder and device we keep one of these to track the current // counts and sequence. We also keep one for the global state of the folder. type Counts struct { - Files int32 `protobuf:"varint,1,opt,name=files,proto3" json:"files,omitempty"` - Directories int32 `protobuf:"varint,2,opt,name=directories,proto3" json:"directories,omitempty"` - Symlinks int32 `protobuf:"varint,3,opt,name=symlinks,proto3" json:"symlinks,omitempty"` - Deleted int32 `protobuf:"varint,4,opt,name=deleted,proto3" json:"deleted,omitempty"` - Bytes int64 `protobuf:"varint,5,opt,name=bytes,proto3" json:"bytes,omitempty"` - Sequence int64 `protobuf:"varint,6,opt,name=sequence,proto3" json:"sequence,omitempty"` - DeviceID []byte `protobuf:"bytes,17,opt,name=deviceID,proto3" json:"deviceID,omitempty"` - LocalFlags uint32 `protobuf:"varint,18,opt,name=localFlags,proto3" json:"localFlags,omitempty"` + Files int `protobuf:"varint,1,opt,name=files,proto3,casttype=int" json:"files" xml:"files"` + Directories int `protobuf:"varint,2,opt,name=directories,proto3,casttype=int" json:"directories" xml:"directories"` + Symlinks int `protobuf:"varint,3,opt,name=symlinks,proto3,casttype=int" json:"symlinks" xml:"symlinks"` + Deleted int `protobuf:"varint,4,opt,name=deleted,proto3,casttype=int" json:"deleted" xml:"deleted"` + Bytes int64 `protobuf:"varint,5,opt,name=bytes,proto3" json:"bytes" xml:"bytes"` + Sequence int64 `protobuf:"varint,6,opt,name=sequence,proto3" json:"sequence" xml:"sequence"` + DeviceID []byte `protobuf:"bytes,17,opt,name=device_id,json=deviceId,proto3" json:"deviceId" xml:"deviceId"` + LocalFlags uint32 `protobuf:"varint,18,opt,name=local_flags,json=localFlags,proto3" json:"localFlags" xml:"localFlags"` } func (m *Counts) Reset() { *m = Counts{} } func (*Counts) ProtoMessage() {} func (*Counts) Descriptor() ([]byte, []int) { - return fileDescriptor_e774e8f5f348d14d, []int{5} + return fileDescriptor_5465d80e8cba02e3, []int{5} } func (m *Counts) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -280,15 +281,15 @@ func (m *Counts) XXX_DiscardUnknown() { var xxx_messageInfo_Counts proto.InternalMessageInfo type CountsSet struct { - Counts []Counts `protobuf:"bytes,1,rep,name=counts,proto3" json:"counts"` - Created int64 `protobuf:"varint,2,opt,name=created,proto3" json:"created,omitempty"` + Counts []Counts `protobuf:"bytes,1,rep,name=counts,proto3" json:"counts" xml:"count"` + Created int64 `protobuf:"varint,2,opt,name=created,proto3" json:"created" xml:"created"` } func (m *CountsSet) Reset() { *m = CountsSet{} } func (m *CountsSet) String() string { return proto.CompactTextString(m) } func (*CountsSet) ProtoMessage() {} func (*CountsSet) Descriptor() ([]byte, []int) { - return fileDescriptor_e774e8f5f348d14d, []int{6} + return fileDescriptor_5465d80e8cba02e3, []int{6} } func (m *CountsSet) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -318,17 +319,17 @@ func (m *CountsSet) XXX_DiscardUnknown() { var xxx_messageInfo_CountsSet proto.InternalMessageInfo type FileVersionDeprecated struct { - Version protocol.Vector `protobuf:"bytes,1,opt,name=version,proto3" json:"version"` - Device []byte `protobuf:"bytes,2,opt,name=device,proto3" json:"device,omitempty"` - Invalid bool `protobuf:"varint,3,opt,name=invalid,proto3" json:"invalid,omitempty"` - Deleted bool `protobuf:"varint,4,opt,name=deleted,proto3" json:"deleted,omitempty"` + Version protocol.Vector `protobuf:"bytes,1,opt,name=version,proto3" json:"version" xml:"version"` + Device []byte `protobuf:"bytes,2,opt,name=device,proto3" json:"device" xml:"device"` + Invalid bool `protobuf:"varint,3,opt,name=invalid,proto3" json:"invalid" xml:"invalid"` + Deleted bool `protobuf:"varint,4,opt,name=deleted,proto3" json:"deleted" xml:"deleted"` } func (m *FileVersionDeprecated) Reset() { *m = FileVersionDeprecated{} } func (m *FileVersionDeprecated) String() string { return proto.CompactTextString(m) } func (*FileVersionDeprecated) ProtoMessage() {} func (*FileVersionDeprecated) Descriptor() ([]byte, []int) { - return fileDescriptor_e774e8f5f348d14d, []int{7} + return fileDescriptor_5465d80e8cba02e3, []int{7} } func (m *FileVersionDeprecated) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -358,13 +359,13 @@ func (m *FileVersionDeprecated) XXX_DiscardUnknown() { var xxx_messageInfo_FileVersionDeprecated proto.InternalMessageInfo type VersionListDeprecated struct { - Versions []FileVersionDeprecated `protobuf:"bytes,1,rep,name=versions,proto3" json:"versions"` + Versions []FileVersionDeprecated `protobuf:"bytes,1,rep,name=versions,proto3" json:"versions" xml:"version"` } func (m *VersionListDeprecated) Reset() { *m = VersionListDeprecated{} } func (*VersionListDeprecated) ProtoMessage() {} func (*VersionListDeprecated) Descriptor() ([]byte, []int) { - return fileDescriptor_e774e8f5f348d14d, []int{8} + return fileDescriptor_5465d80e8cba02e3, []int{8} } func (m *VersionListDeprecated) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -405,64 +406,90 @@ func init() { proto.RegisterType((*VersionListDeprecated)(nil), "db.VersionListDeprecated") } -func init() { proto.RegisterFile("structs.proto", fileDescriptor_e774e8f5f348d14d) } +func init() { proto.RegisterFile("lib/db/structs.proto", fileDescriptor_5465d80e8cba02e3) } -var fileDescriptor_e774e8f5f348d14d = []byte{ - // 863 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x54, 0x4f, 0x8f, 0xdb, 0x54, - 0x10, 0x8f, 0x9b, 0xff, 0xe3, 0x64, 0xdb, 0xbe, 0x76, 0x57, 0x66, 0x25, 0x1c, 0x2b, 0x08, 0x61, - 0x71, 0x48, 0x60, 0x7b, 0xa3, 0x12, 0x42, 0x61, 0x55, 0x11, 0x09, 0x51, 0xf4, 0xb6, 0xf4, 0x80, - 0x2a, 0x45, 0xb6, 0xf3, 0x92, 0x3c, 0xd5, 0xf1, 0x0b, 0x7e, 0xce, 0xae, 0xd2, 0x4f, 0xc1, 0x05, - 0x89, 0x03, 0x87, 0x5e, 0xf8, 0x2e, 0x7b, 0xec, 0x11, 0x71, 0x88, 0x20, 0x7b, 0x01, 0x3e, 0x05, - 0x7a, 0xf3, 0x9e, 0x1d, 0x6f, 0x38, 0xd0, 0xde, 0x66, 0x7e, 0x33, 0xcf, 0x33, 0xf3, 0x9b, 0x9f, - 0x07, 0xba, 0x32, 0x4b, 0xd7, 0x51, 0x26, 0x07, 0xab, 0x54, 0x64, 0x82, 0xdc, 0x99, 0x86, 0xa7, - 0x1f, 0xa4, 0x6c, 0x25, 0xe4, 0x10, 0x81, 0x70, 0x3d, 0x1b, 0xce, 0xc5, 0x5c, 0xa0, 0x83, 0x96, - 0x4e, 0x3c, 0x3d, 0x89, 0x79, 0xa8, 0x53, 0x22, 0x11, 0x0f, 0x43, 0xb6, 0xd2, 0x78, 0xff, 0x17, - 0x0b, 0xec, 0x27, 0x3c, 0x66, 0xcf, 0x59, 0x2a, 0xb9, 0x48, 0xc8, 0x27, 0xd0, 0xbc, 0xd4, 0xa6, - 0x63, 0x79, 0x96, 0x6f, 0x9f, 0xdd, 0x1b, 0xe4, 0xaf, 0x06, 0xcf, 0x59, 0x94, 0x89, 0x74, 0x54, - 0xbb, 0xde, 0xf6, 0x2a, 0x34, 0x4f, 0x23, 0x0e, 0x34, 0xa7, 0x2c, 0x66, 0x19, 0x9b, 0x3a, 0x77, - 0x3c, 0xcb, 0x6f, 0xd1, 0xdc, 0xd5, 0x91, 0x4b, 0x1e, 0x31, 0xe9, 0x54, 0xbd, 0xaa, 0xdf, 0xa1, - 0xb9, 0x4b, 0x3e, 0x82, 0xbb, 0x3c, 0xb9, 0x0c, 0x62, 0x3e, 0x9d, 0xe4, 0x19, 0x35, 0xcc, 0x38, - 0x32, 0xf0, 0xb9, 0x46, 0xfb, 0xdf, 0x81, 0x6d, 0x3a, 0xfb, 0x9a, 0xcb, 0x8c, 0x7c, 0x01, 0x2d, - 0x53, 0x56, 0x3a, 0x96, 0x57, 0xf5, 0xed, 0xb3, 0xbb, 0x83, 0x69, 0x38, 0x28, 0x0d, 0x30, 0x7a, - 0xa0, 0xba, 0xdb, 0x6d, 0x7b, 0x36, 0x0d, 0xae, 0x0c, 0x26, 0x69, 0xf1, 0xea, 0xb3, 0xda, 0xcf, - 0xaf, 0x7b, 0x95, 0xfe, 0xaf, 0x75, 0xb8, 0xaf, 0x1e, 0x8d, 0x93, 0x99, 0x78, 0x96, 0xae, 0x93, - 0x28, 0x50, 0xfd, 0x12, 0xa8, 0x25, 0xc1, 0x92, 0xe1, 0xe0, 0x6d, 0x8a, 0xb6, 0xc2, 0x24, 0x7f, - 0xc5, 0x9c, 0xaa, 0x67, 0xf9, 0x55, 0x8a, 0x36, 0x79, 0x1f, 0x60, 0x29, 0xa6, 0x7c, 0xc6, 0xd9, - 0x74, 0x22, 0x9d, 0x3a, 0x46, 0xda, 0x39, 0x72, 0x41, 0x5e, 0x80, 0x5d, 0x84, 0xc3, 0x8d, 0xd3, - 0xf1, 0x2c, 0xbf, 0x36, 0x7a, 0xac, 0xda, 0xfa, 0x7d, 0xdb, 0x7b, 0x34, 0xe7, 0xd9, 0x62, 0x1d, - 0x0e, 0x22, 0xb1, 0x1c, 0xca, 0x4d, 0x12, 0x65, 0x0b, 0x9e, 0xcc, 0x4b, 0x56, 0x79, 0x4d, 0x83, - 0x8b, 0x85, 0x48, 0xb3, 0xf1, 0x39, 0x2d, 0xca, 0x8d, 0x36, 0xe5, 0x05, 0xb5, 0xdf, 0x6e, 0x41, - 0xa7, 0xd0, 0x92, 0xec, 0x87, 0x35, 0x4b, 0x22, 0xe6, 0x00, 0x36, 0x5b, 0xf8, 0xe4, 0x43, 0x38, - 0x92, 0x9b, 0x65, 0xcc, 0x93, 0x97, 0x93, 0x2c, 0x48, 0xe7, 0x2c, 0x73, 0xee, 0xe3, 0xf0, 0x5d, - 0x83, 0x3e, 0x43, 0x90, 0xf4, 0xc0, 0x0e, 0x63, 0x11, 0xbd, 0x94, 0x93, 0x45, 0x20, 0x17, 0x0e, - 0xf1, 0x2c, 0xbf, 0x43, 0x41, 0x43, 0x5f, 0x05, 0x72, 0x41, 0x3e, 0x86, 0x5a, 0xb6, 0x59, 0x31, - 0x54, 0xc0, 0xd1, 0xd9, 0xc9, 0xbe, 0xa5, 0x82, 0xe5, 0xcd, 0x8a, 0x51, 0xcc, 0x21, 0x1e, 0xd8, - 0x2b, 0x96, 0x2e, 0xb9, 0xd4, 0x7b, 0xac, 0x79, 0x96, 0xdf, 0xa5, 0x65, 0x48, 0x95, 0x2b, 0x18, - 0x4c, 0xa4, 0x63, 0x7b, 0x96, 0x5f, 0xdf, 0x93, 0xf0, 0x8d, 0x24, 0x43, 0xd0, 0xc5, 0x27, 0xb8, - 0x9b, 0xae, 0x8a, 0x8f, 0xee, 0xed, 0xb6, 0xbd, 0x0e, 0x0d, 0xae, 0x46, 0x2a, 0x70, 0xc1, 0x5f, - 0x31, 0xda, 0x0e, 0x73, 0x53, 0xd5, 0x8c, 0x45, 0x14, 0xc4, 0x93, 0x59, 0x1c, 0xcc, 0xa5, 0xf3, - 0x57, 0x13, 0x8b, 0x02, 0x62, 0x4f, 0x14, 0x44, 0xfa, 0xd0, 0x31, 0x84, 0xe9, 0x19, 0xff, 0x6e, - 0xe2, 0x90, 0xb6, 0x01, 0x71, 0xca, 0x92, 0xd4, 0x1b, 0xb7, 0xa5, 0xee, 0x43, 0xd3, 0x28, 0xd7, - 0x51, 0xef, 0x5a, 0xa3, 0xa3, 0xdd, 0xb6, 0x07, 0x34, 0xb8, 0x1a, 0x6b, 0x94, 0xe6, 0x61, 0xc5, - 0x78, 0x22, 0x26, 0x65, 0x02, 0x5a, 0xf8, 0xa9, 0x6e, 0x22, 0xbe, 0xdd, 0x83, 0x46, 0xa7, 0x9f, - 0x43, 0x1b, 0xc7, 0x41, 0xf1, 0x7f, 0x0a, 0x0d, 0x74, 0x72, 0xe9, 0x3f, 0xd8, 0xb3, 0x8c, 0xb8, - 0xa2, 0xd9, 0xec, 0xde, 0x24, 0xf6, 0x5f, 0xc0, 0xf1, 0x38, 0x99, 0xf2, 0x94, 0x45, 0x99, 0x99, - 0x81, 0xc9, 0xa7, 0x49, 0xbc, 0xf9, 0xff, 0x85, 0xbe, 0x05, 0x1d, 0xfd, 0x7f, 0x2c, 0x68, 0x7c, - 0x29, 0xd6, 0x49, 0x26, 0xc9, 0x43, 0xa8, 0xcf, 0x78, 0xcc, 0x24, 0xfe, 0x3b, 0x75, 0xaa, 0x1d, - 0xc5, 0xba, 0x2e, 0x2e, 0x52, 0xce, 0x24, 0x8a, 0xa3, 0x4e, 0xcb, 0x10, 0x6a, 0x53, 0x2b, 0x4d, - 0xe2, 0x2f, 0x56, 0xa7, 0x85, 0x5f, 0x66, 0xbb, 0x86, 0xa1, 0x82, 0xed, 0x87, 0x50, 0x0f, 0x37, - 0x19, 0xcb, 0xff, 0x3d, 0xed, 0xdc, 0xd2, 0x79, 0xe3, 0x40, 0xe7, 0xa7, 0xd0, 0xd2, 0x87, 0x66, - 0x7c, 0x8e, 0x0a, 0xef, 0xd0, 0xc2, 0x27, 0x2e, 0x94, 0x74, 0x80, 0x54, 0xdc, 0x52, 0x86, 0x59, - 0xc5, 0x53, 0x68, 0xeb, 0x59, 0x2f, 0x58, 0x46, 0x7c, 0x68, 0x44, 0xe8, 0x98, 0x55, 0x80, 0xba, - 0x42, 0x3a, 0x9c, 0x6f, 0x40, 0xc7, 0xd5, 0x10, 0x51, 0xca, 0x82, 0xfc, 0x3a, 0x56, 0x69, 0xee, - 0xf6, 0x7f, 0xb2, 0xe0, 0xb8, 0x74, 0xb8, 0xce, 0xd9, 0x2a, 0x65, 0xfa, 0x0e, 0xbd, 0xfb, 0x0d, - 0x3e, 0x81, 0x86, 0x1e, 0x07, 0x8b, 0x74, 0xa8, 0xf1, 0x54, 0xf5, 0x5c, 0x96, 0x55, 0x2d, 0xd8, - 0x5c, 0x86, 0x07, 0xe4, 0xee, 0xa5, 0xdc, 0xff, 0x1e, 0x8e, 0x4b, 0x27, 0xb7, 0xd4, 0xd6, 0xe3, - 0xff, 0x1c, 0xdf, 0xf7, 0x0e, 0x8e, 0xef, 0x3e, 0xd9, 0x34, 0x78, 0x70, 0x77, 0x47, 0xde, 0xf5, - 0x9f, 0x6e, 0xe5, 0x7a, 0xe7, 0x5a, 0x6f, 0x76, 0xae, 0xf5, 0xc7, 0xce, 0xad, 0xfc, 0x78, 0xe3, - 0x56, 0x5e, 0xdf, 0xb8, 0xd6, 0x9b, 0x1b, 0xb7, 0xf2, 0xdb, 0x8d, 0x5b, 0x09, 0x1b, 0x38, 0xe9, - 0xa3, 0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0x47, 0xe4, 0x5e, 0xea, 0xe8, 0x06, 0x00, 0x00, +var fileDescriptor_5465d80e8cba02e3 = []byte{ + // 1267 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x56, 0xcf, 0x6f, 0x13, 0xc7, + 0x17, 0xf7, 0xc6, 0x3f, 0x62, 0x8f, 0x9d, 0x40, 0x96, 0x2f, 0x68, 0xbf, 0xb4, 0xf5, 0xb8, 0x43, + 0x90, 0xdc, 0x56, 0x72, 0xa4, 0x20, 0x50, 0x85, 0x54, 0x21, 0x96, 0x08, 0x08, 0xa2, 0x50, 0x4d, + 0x10, 0xad, 0x7a, 0xb1, 0xbc, 0xeb, 0x49, 0xb2, 0x62, 0xb3, 0xeb, 0xee, 0x6c, 0x08, 0xe6, 0xd6, + 0x4b, 0xa5, 0xde, 0x2a, 0xd4, 0x43, 0x55, 0x55, 0x15, 0xa7, 0xfe, 0x09, 0x55, 0xff, 0x04, 0x8e, + 0x39, 0x56, 0x3d, 0xac, 0x84, 0x73, 0x69, 0x7d, 0xf4, 0xb1, 0xa7, 0x6a, 0xde, 0xcc, 0xce, 0x8e, + 0x89, 0xa8, 0x80, 0x72, 0xdb, 0xf7, 0x79, 0x9f, 0xf7, 0xbc, 0xfb, 0xde, 0xe7, 0x3d, 0x3f, 0xf4, + 0xbf, 0x30, 0xf0, 0xd6, 0x86, 0xde, 0x1a, 0x4f, 0x93, 0x7d, 0x3f, 0xe5, 0xbd, 0x51, 0x12, 0xa7, + 0xb1, 0xbd, 0x30, 0xf4, 0xce, 0x9e, 0x4b, 0xd8, 0x28, 0xe6, 0x6b, 0x00, 0x78, 0xfb, 0xdb, 0x6b, + 0x3b, 0xf1, 0x4e, 0x0c, 0x06, 0x3c, 0x49, 0xe2, 0xd9, 0x33, 0x22, 0x1c, 0x1e, 0xfd, 0x38, 0x5c, + 0xf3, 0xd8, 0x48, 0xe1, 0x0d, 0xf6, 0x28, 0x95, 0x8f, 0xe4, 0xe7, 0x05, 0xd4, 0xbc, 0x1e, 0x84, + 0xec, 0x3e, 0x4b, 0x78, 0x10, 0x47, 0xf6, 0x6d, 0xb4, 0xf8, 0x50, 0x3e, 0x3a, 0x56, 0xc7, 0xea, + 0x36, 0xd7, 0x4f, 0xf6, 0xf2, 0x04, 0xbd, 0xfb, 0xcc, 0x4f, 0xe3, 0xc4, 0xed, 0x3c, 0xcb, 0x70, + 0x69, 0x9a, 0xe1, 0x9c, 0x38, 0xcb, 0xf0, 0xd2, 0xa3, 0xbd, 0xf0, 0x32, 0x51, 0x36, 0xa1, 0xb9, + 0xc7, 0xbe, 0x84, 0x16, 0x87, 0x2c, 0x64, 0x29, 0x1b, 0x3a, 0x0b, 0x1d, 0xab, 0x5b, 0x77, 0xdf, + 0x15, 0x71, 0x0a, 0xd2, 0x71, 0xca, 0x26, 0x34, 0xf7, 0xd8, 0x17, 0x45, 0xdc, 0xc3, 0xc0, 0x67, + 0xdc, 0x29, 0x77, 0xca, 0xdd, 0x96, 0xfb, 0x8e, 0x8c, 0x03, 0x68, 0x96, 0xe1, 0x96, 0x8a, 0x13, + 0x36, 0x84, 0x81, 0xc3, 0xa6, 0xe8, 0x44, 0x10, 0x3d, 0x1c, 0x84, 0xc1, 0xb0, 0x9f, 0x87, 0x57, + 0x20, 0xfc, 0x83, 0x69, 0x86, 0x97, 0x95, 0x6b, 0x43, 0x67, 0x39, 0x05, 0x59, 0xe6, 0x60, 0x42, + 0x5f, 0xa0, 0x91, 0xaf, 0x2d, 0xd4, 0x54, 0xc5, 0xb9, 0x1d, 0xf0, 0xd4, 0x0e, 0x51, 0x5d, 0x7d, + 0x1d, 0x77, 0xac, 0x4e, 0xb9, 0xdb, 0x5c, 0x3f, 0xd1, 0x1b, 0x7a, 0x3d, 0xa3, 0x86, 0xee, 0x15, + 0x51, 0xa0, 0x49, 0x86, 0x9b, 0x74, 0x70, 0xa0, 0x30, 0x3e, 0xcd, 0xb0, 0x8e, 0x3b, 0x56, 0xb0, + 0x27, 0x87, 0xab, 0x26, 0x97, 0x6a, 0xe6, 0xe5, 0xca, 0x0f, 0x4f, 0x71, 0x89, 0xfc, 0x86, 0xd0, + 0x8a, 0xf8, 0x81, 0xcd, 0x68, 0x3b, 0xbe, 0x97, 0xec, 0x47, 0xfe, 0x40, 0x14, 0xe9, 0x43, 0x54, + 0x89, 0x06, 0x7b, 0x0c, 0xfa, 0xd4, 0x70, 0xcf, 0x4c, 0x33, 0x0c, 0xf6, 0x2c, 0xc3, 0x08, 0xb2, + 0x0b, 0x83, 0x50, 0xc0, 0x04, 0x97, 0x07, 0x8f, 0x99, 0x53, 0xee, 0x58, 0xdd, 0xb2, 0xe4, 0x0a, + 0x5b, 0x73, 0x85, 0x41, 0x28, 0x60, 0xf6, 0x15, 0x84, 0xf6, 0xe2, 0x61, 0xb0, 0x1d, 0xb0, 0x61, + 0x9f, 0x3b, 0x55, 0x88, 0xe8, 0x4c, 0x33, 0xdc, 0xc8, 0xd1, 0xad, 0x59, 0x86, 0x4f, 0x40, 0x98, + 0x46, 0x08, 0x2d, 0xbc, 0xf6, 0xaf, 0x16, 0x6a, 0xea, 0x0c, 0xde, 0xd8, 0x69, 0x75, 0xac, 0x6e, + 0xc5, 0xfd, 0xde, 0x12, 0x65, 0xf9, 0x23, 0xc3, 0x17, 0x76, 0x82, 0x74, 0x77, 0xdf, 0xeb, 0xf9, + 0xf1, 0xde, 0x1a, 0x1f, 0x47, 0x7e, 0xba, 0x1b, 0x44, 0x3b, 0xc6, 0x93, 0x29, 0xda, 0xde, 0xd6, + 0x6e, 0x9c, 0xa4, 0x9b, 0x1b, 0xd3, 0x0c, 0xeb, 0x97, 0x72, 0xc7, 0xb3, 0x0c, 0x9f, 0x9c, 0xfb, + 0x7d, 0x77, 0x4c, 0x7e, 0x3c, 0x5c, 0x7d, 0x93, 0xc4, 0xd4, 0x48, 0x6b, 0x8a, 0xbf, 0xf1, 0xdf, + 0xc5, 0x7f, 0x19, 0xd5, 0x39, 0xfb, 0x6a, 0x9f, 0x45, 0x3e, 0x73, 0x10, 0x54, 0xb1, 0x2d, 0x54, + 0x90, 0x63, 0xb3, 0x0c, 0x2f, 0xcb, 0xda, 0x2b, 0x80, 0x50, 0xed, 0xb3, 0xef, 0xa2, 0x65, 0x3e, + 0xde, 0x0b, 0x83, 0xe8, 0x41, 0x3f, 0x1d, 0x24, 0x3b, 0x2c, 0x75, 0x56, 0xa0, 0xcb, 0xdd, 0x69, + 0x86, 0x97, 0x94, 0xe7, 0x1e, 0x38, 0xb4, 0x8e, 0xe7, 0x50, 0x42, 0xe7, 0x59, 0xf6, 0x35, 0xd4, + 0xf4, 0xc2, 0xd8, 0x7f, 0xc0, 0xfb, 0xbb, 0x03, 0xbe, 0xeb, 0xd8, 0x1d, 0xab, 0xdb, 0x72, 0x89, + 0x28, 0xab, 0x84, 0x6f, 0x0e, 0xf8, 0xae, 0x2e, 0x6b, 0x01, 0x11, 0x6a, 0xf8, 0x6d, 0x17, 0x55, + 0xd2, 0xf1, 0x88, 0xc1, 0x2c, 0x2f, 0xaf, 0x9f, 0x29, 0x8a, 0xa3, 0xc5, 0x39, 0x1e, 0x31, 0xa9, + 0x2e, 0xc1, 0xd3, 0xea, 0x12, 0x06, 0xa1, 0x80, 0xd9, 0xd7, 0x51, 0x73, 0xc4, 0x92, 0xbd, 0x80, + 0xcb, 0x11, 0xaa, 0x74, 0xac, 0xee, 0x92, 0xbb, 0x3a, 0xcd, 0xb0, 0x09, 0xcf, 0x32, 0xbc, 0x02, + 0x91, 0x06, 0x46, 0xa8, 0xc9, 0xb0, 0x6f, 0x19, 0x1a, 0x8b, 0xb8, 0xd3, 0xec, 0x58, 0xdd, 0x2a, + 0xcc, 0xb9, 0x6e, 0xe8, 0x1d, 0x7e, 0x4c, 0x27, 0x77, 0x38, 0xf9, 0x3b, 0xc3, 0xe5, 0x20, 0x4a, + 0xa9, 0x41, 0xb3, 0xb7, 0x91, 0xfc, 0xca, 0x3e, 0xcc, 0xc8, 0x12, 0xa4, 0xba, 0x31, 0xc9, 0x70, + 0x8b, 0x0e, 0x0e, 0x5c, 0xe1, 0xd8, 0x0a, 0x1e, 0x33, 0x31, 0x01, 0x5e, 0x6e, 0xe8, 0x09, 0xd0, + 0x48, 0x9e, 0xf8, 0xc9, 0xe1, 0xea, 0x5c, 0x18, 0x2d, 0x82, 0xec, 0x0d, 0xd4, 0x0c, 0x63, 0x7f, + 0x10, 0xf6, 0xb7, 0xc3, 0xc1, 0x0e, 0x77, 0xfe, 0x5c, 0x84, 0x8f, 0x87, 0x2e, 0x00, 0x7e, 0x5d, + 0xc0, 0xfa, 0xa5, 0x0b, 0x88, 0x50, 0xc3, 0x6f, 0xdf, 0x44, 0x2d, 0x25, 0x31, 0xd9, 0xcb, 0xbf, + 0x16, 0xa1, 0x99, 0x50, 0x43, 0xe5, 0x50, 0xdd, 0x5c, 0x31, 0x95, 0x29, 0xdb, 0x69, 0x32, 0xcc, + 0xf5, 0x5c, 0x7b, 0x9d, 0xf5, 0x4c, 0xd1, 0xa2, 0xda, 0x92, 0xce, 0x22, 0xc4, 0x7d, 0x3c, 0xc9, + 0x30, 0xa2, 0x83, 0x83, 0x4d, 0x89, 0x8a, 0x2c, 0x8a, 0xa0, 0xb3, 0x28, 0x5b, 0xec, 0x3a, 0x83, + 0x49, 0x73, 0x9e, 0x50, 0x7c, 0x14, 0xf7, 0x4d, 0x69, 0xd4, 0x21, 0x35, 0x28, 0x3e, 0x8a, 0x3f, + 0x9b, 0x13, 0x87, 0x54, 0xfc, 0x1c, 0x4a, 0xe8, 0x3c, 0x4b, 0xad, 0xce, 0xcf, 0x51, 0x03, 0x5a, + 0x01, 0xbb, 0xfb, 0x16, 0xaa, 0x49, 0x35, 0xab, 0xcd, 0x7d, 0xaa, 0x50, 0x30, 0x90, 0x84, 0x84, + 0xdd, 0xf7, 0xd4, 0x84, 0x2b, 0xea, 0x2c, 0xc3, 0xcd, 0xa2, 0xd3, 0x84, 0x2a, 0x98, 0xfc, 0x62, + 0xa1, 0xd3, 0x9b, 0xd1, 0x30, 0x48, 0x98, 0x9f, 0xaa, 0x7a, 0x32, 0x7e, 0x37, 0x0a, 0xc7, 0x6f, + 0x67, 0xd4, 0xde, 0x5a, 0x93, 0xc9, 0x4f, 0x15, 0x54, 0xbb, 0x16, 0xef, 0x47, 0x29, 0xb7, 0x2f, + 0xa2, 0xea, 0x76, 0x10, 0x32, 0x0e, 0x7f, 0x19, 0x55, 0x17, 0x4f, 0x33, 0x2c, 0x01, 0xfd, 0x91, + 0x60, 0xe9, 0x19, 0x91, 0x4e, 0xfb, 0x53, 0xd4, 0x94, 0xdf, 0x19, 0x27, 0x01, 0xe3, 0x30, 0xfd, + 0x55, 0xf7, 0x23, 0xf1, 0x26, 0x06, 0xac, 0xdf, 0xc4, 0xc0, 0x74, 0x22, 0x93, 0x68, 0x5f, 0x45, + 0x75, 0xb5, 0x9b, 0x38, 0xfc, 0x1f, 0x55, 0xdd, 0xf3, 0xb0, 0x17, 0x15, 0x56, 0xec, 0x45, 0x05, + 0xe8, 0x2c, 0x9a, 0x62, 0x7f, 0x52, 0x08, 0xb7, 0x02, 0x19, 0xce, 0xfd, 0x9b, 0x70, 0xf3, 0x78, + 0xad, 0xdf, 0x1e, 0xaa, 0x7a, 0xe3, 0x94, 0xe5, 0x7f, 0x6e, 0x8e, 0xa8, 0x03, 0x00, 0x45, 0xb3, + 0x85, 0x45, 0xa8, 0x44, 0xe7, 0x36, 0x79, 0xed, 0x35, 0x37, 0xf9, 0x16, 0x6a, 0xc8, 0x5b, 0xa4, + 0x1f, 0x0c, 0x61, 0x89, 0xb7, 0xdc, 0x4b, 0x93, 0x0c, 0xd7, 0xe5, 0x7d, 0x01, 0xff, 0x6c, 0x75, + 0x49, 0xd8, 0x1c, 0xea, 0x44, 0x39, 0x20, 0xa6, 0x45, 0x33, 0xa9, 0xe6, 0x09, 0x89, 0x99, 0x8b, + 0xc4, 0x7e, 0x93, 0x3d, 0xa2, 0x06, 0xe4, 0x1b, 0x0b, 0x35, 0xa4, 0x3c, 0xb6, 0x58, 0x6a, 0x5f, + 0x45, 0x35, 0x1f, 0x0c, 0x35, 0x21, 0x48, 0xdc, 0x36, 0xd2, 0x5d, 0x0c, 0x86, 0x64, 0xe8, 0x5a, + 0x81, 0x49, 0xa8, 0x82, 0xc5, 0x52, 0xf1, 0x13, 0x36, 0xc8, 0x6f, 0xbe, 0xb2, 0x5c, 0x2a, 0x0a, + 0xd2, 0xbd, 0x51, 0x36, 0xa1, 0xb9, 0x87, 0x7c, 0xbb, 0x80, 0x4e, 0x1b, 0x57, 0xd4, 0x06, 0x1b, + 0x25, 0x4c, 0x1e, 0x3a, 0x6f, 0xf7, 0x26, 0x5d, 0x47, 0x35, 0x59, 0x47, 0x78, 0xbd, 0x96, 0x7b, + 0x56, 0x7c, 0x92, 0x44, 0x8e, 0x5d, 0x96, 0x0a, 0x17, 0xdf, 0x94, 0x2f, 0xbc, 0x72, 0xb1, 0x28, + 0x5f, 0xb6, 0xe2, 0x8a, 0xa5, 0x76, 0x69, 0x5e, 0xa7, 0xaf, 0xba, 0x60, 0xc9, 0x01, 0x3a, 0x6d, + 0xdc, 0x9c, 0x46, 0x29, 0xbe, 0x38, 0x76, 0x7d, 0xfe, 0xff, 0x85, 0xeb, 0xb3, 0x20, 0xbb, 0xef, + 0xab, 0xa2, 0xbc, 0xfc, 0xf0, 0x7c, 0xf1, 0xd2, 0x74, 0x6f, 0x3c, 0x7b, 0xde, 0x2e, 0x1d, 0x3e, + 0x6f, 0x97, 0x9e, 0x4d, 0xda, 0xd6, 0xe1, 0xa4, 0x6d, 0x7d, 0x77, 0xd4, 0x2e, 0x3d, 0x3d, 0x6a, + 0x5b, 0x87, 0x47, 0xed, 0xd2, 0xef, 0x47, 0xed, 0xd2, 0x97, 0xe7, 0x5f, 0xe1, 0xc8, 0x1a, 0x7a, + 0x5e, 0x0d, 0x3a, 0x74, 0xe1, 0x9f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x62, 0x5e, 0x6e, 0xcc, 0xc2, + 0x0c, 0x00, 0x00, } func (m *FileVersion) Marshal() (dAtA []byte, err error) { @@ -1754,7 +1781,7 @@ func (m *FileInfoTruncated) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.ModifiedNs |= int32(b&0x7F) << shift + m.ModifiedNs |= int(b&0x7F) << shift if b < 0x80 { break } @@ -1792,7 +1819,7 @@ func (m *FileInfoTruncated) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.RawBlockSize |= int32(b&0x7F) << shift + m.RawBlockSize |= int(b&0x7F) << shift if b < 0x80 { break } @@ -2191,7 +2218,7 @@ func (m *Counts) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Files |= int32(b&0x7F) << shift + m.Files |= int(b&0x7F) << shift if b < 0x80 { break } @@ -2210,7 +2237,7 @@ func (m *Counts) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Directories |= int32(b&0x7F) << shift + m.Directories |= int(b&0x7F) << shift if b < 0x80 { break } @@ -2229,7 +2256,7 @@ func (m *Counts) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Symlinks |= int32(b&0x7F) << shift + m.Symlinks |= int(b&0x7F) << shift if b < 0x80 { break } @@ -2248,7 +2275,7 @@ func (m *Counts) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Deleted |= int32(b&0x7F) << shift + m.Deleted |= int(b&0x7F) << shift if b < 0x80 { break } diff --git a/lib/fs/copyrangemethod.pb.go b/lib/fs/copyrangemethod.pb.go index 1f72abbd9..f35b4e7e8 100644 --- a/lib/fs/copyrangemethod.pb.go +++ b/lib/fs/copyrangemethod.pb.go @@ -5,6 +5,7 @@ package fs import ( fmt "fmt" + _ "github.com/gogo/protobuf/gogoproto" proto "github.com/gogo/protobuf/proto" math "math" ) @@ -60,28 +61,30 @@ func init() { func init() { proto.RegisterFile("lib/fs/copyrangemethod.proto", fileDescriptor_78e1061c3022e87e) } var fileDescriptor_78e1061c3022e87e = []byte{ - // 357 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x92, 0xbf, 0x4e, 0xc2, 0x40, - 0x00, 0xc6, 0x0b, 0xa8, 0x43, 0x17, 0x9b, 0xc6, 0x04, 0x53, 0xc8, 0x59, 0x25, 0x2e, 0x0e, 0x30, - 0x18, 0x27, 0x5d, 0x8e, 0xf6, 0x0a, 0x0d, 0x47, 0x21, 0x50, 0x83, 0xba, 0x34, 0xfd, 0x07, 0x6d, - 0x3c, 0xda, 0x86, 0x1e, 0x89, 0xbc, 0x42, 0x27, 0x5f, 0xa0, 0x89, 0x9b, 0xaf, 0xe2, 0xc8, 0xe8, - 0x8a, 0x5d, 0x7c, 0x0c, 0x43, 0x59, 0x4c, 0x61, 0xbb, 0xfb, 0xbe, 0xfc, 0x7e, 0xf9, 0x92, 0x3b, - 0xb6, 0x4e, 0x7c, 0xab, 0x35, 0x8d, 0x5b, 0x76, 0x18, 0xad, 0x16, 0x66, 0x30, 0x73, 0xe7, 0x2e, - 0xf5, 0x42, 0xa7, 0x19, 0x2d, 0x42, 0x1a, 0xf2, 0xe5, 0x69, 0x7c, 0xf3, 0x59, 0x61, 0x4f, 0xa5, - 0x30, 0x5a, 0x8d, 0xb6, 0x6d, 0x3f, 0x6f, 0xf9, 0x7b, 0x56, 0x90, 0x06, 0xc3, 0x67, 0x63, 0x04, - 0xb5, 0x0e, 0x32, 0xfa, 0x48, 0xef, 0x0e, 0x64, 0x63, 0xac, 0x43, 0x4d, 0x86, 0x23, 0x99, 0x63, - 0x84, 0x5a, 0x92, 0x8a, 0xd5, 0x02, 0x34, 0xa6, 0x66, 0xe0, 0x98, 0x0b, 0x87, 0xbf, 0x63, 0xab, - 0xfb, 0xb0, 0x3a, 0x90, 0x74, 0xcc, 0x95, 0x84, 0xf3, 0x24, 0x15, 0xcf, 0x0a, 0xa4, 0x1a, 0xda, - 0x94, 0xf0, 0x1d, 0xf6, 0x72, 0x1f, 0xcb, 0x13, 0x45, 0xc5, 0x68, 0x17, 0x73, 0x65, 0x41, 0x4c, - 0x52, 0xb1, 0x5e, 0x10, 0x6c, 0xaf, 0x8a, 0x4f, 0xdc, 0x3c, 0xe2, 0x1f, 0xd8, 0xda, 0x81, 0xf1, - 0x48, 0x93, 0x73, 0x11, 0x57, 0x39, 0xbc, 0xde, 0x0d, 0x9c, 0xad, 0x82, 0xc7, 0x6c, 0x63, 0x9f, - 0x96, 0x1f, 0x87, 0x58, 0x95, 0xa0, 0x8e, 0x0c, 0xf4, 0xa4, 0x23, 0x4d, 0x1f, 0x73, 0x47, 0x42, - 0x23, 0x49, 0xc5, 0x8b, 0x82, 0x45, 0x5e, 0x46, 0xc4, 0xb7, 0x4d, 0xea, 0xa2, 0x37, 0xea, 0x06, - 0x34, 0xe6, 0x7b, 0x87, 0x6c, 0x10, 0x63, 0x63, 0xa2, 0xea, 0x5d, 0x43, 0x81, 0x18, 0xb7, 0xa1, - 0xd4, 0xe3, 0x8e, 0x85, 0xab, 0x24, 0x15, 0x41, 0xc1, 0x06, 0x09, 0x99, 0xf8, 0xd4, 0x53, 0x4c, - 0x42, 0x2c, 0xd3, 0x7e, 0x6d, 0x4b, 0x5f, 0x1b, 0xc0, 0xac, 0x37, 0x80, 0xf9, 0xfd, 0x01, 0xcc, - 0x7b, 0x06, 0x98, 0x8f, 0x0c, 0x94, 0xd6, 0x19, 0x60, 0xbe, 0x33, 0xc0, 0xbc, 0x5c, 0xcf, 0x7c, - 0xea, 0x2d, 0xad, 0xa6, 0x1d, 0xce, 0x5b, 0xf1, 0x2a, 0xb0, 0xa9, 0xe7, 0x07, 0xb3, 0x7f, 0xa7, - 0xdd, 0x47, 0xb0, 0x4e, 0xf2, 0x97, 0xbf, 0xfd, 0x0b, 0x00, 0x00, 0xff, 0xff, 0x06, 0xa6, 0xad, - 0xd0, 0x19, 0x02, 0x00, 0x00, + // 391 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x92, 0xbd, 0x8e, 0xd3, 0x40, + 0x14, 0x85, 0xed, 0xdd, 0x85, 0xc2, 0x0d, 0x96, 0x85, 0xb4, 0x68, 0x76, 0x35, 0x18, 0x22, 0x1a, + 0x8a, 0x75, 0x81, 0xa8, 0xa0, 0x99, 0xb5, 0xc7, 0x59, 0x6b, 0x27, 0x4e, 0x94, 0x18, 0x05, 0x68, + 0x2c, 0xff, 0xc5, 0xb6, 0x98, 0x78, 0x2c, 0x7b, 0x22, 0x91, 0x57, 0x70, 0xc5, 0x0b, 0x58, 0xa2, + 0xa0, 0xa0, 0xe1, 0x3d, 0x52, 0xa6, 0xa4, 0x4d, 0xfc, 0x22, 0x28, 0x93, 0x06, 0x39, 0xe9, 0xee, + 0x3d, 0x9a, 0xef, 0xd3, 0x91, 0xe6, 0x2a, 0xb7, 0x34, 0x0f, 0x8d, 0x45, 0x6d, 0x44, 0xac, 0x5c, + 0x57, 0x41, 0x91, 0x26, 0xcb, 0x84, 0x67, 0x2c, 0xbe, 0x2b, 0x2b, 0xc6, 0x99, 0x76, 0xb1, 0xa8, + 0xc1, 0xa0, 0x4a, 0x4a, 0x56, 0x1b, 0x22, 0x08, 0x57, 0x0b, 0x23, 0x65, 0x29, 0x13, 0x8b, 0x98, + 0x8e, 0x0f, 0xdf, 0xfe, 0xb9, 0x54, 0x9e, 0x99, 0xac, 0x5c, 0x4f, 0x0f, 0x8a, 0x91, 0x50, 0x68, + 0x1f, 0x14, 0x60, 0x8e, 0x27, 0x5f, 0xfc, 0x29, 0x72, 0x87, 0xd8, 0x1f, 0x61, 0xef, 0x61, 0x6c, + 0xf9, 0x33, 0x0f, 0xb9, 0x16, 0x9a, 0x5a, 0xaa, 0x04, 0x6e, 0x9a, 0x56, 0xbf, 0xee, 0x41, 0x33, + 0x1e, 0x14, 0x71, 0x50, 0xc5, 0xda, 0x7b, 0xe5, 0xfa, 0x14, 0x76, 0xc6, 0xa6, 0x47, 0x54, 0x19, + 0xbc, 0x68, 0x5a, 0xfd, 0x79, 0x8f, 0x74, 0x58, 0xc4, 0xa9, 0x36, 0x54, 0x5e, 0x9d, 0x62, 0x22, + 0xb1, 0x1d, 0x82, 0x8f, 0xb1, 0x7a, 0x01, 0xf4, 0xa6, 0xd5, 0x6f, 0x7b, 0x82, 0xc3, 0x6a, 0xe7, + 0x34, 0x11, 0x91, 0xf6, 0x51, 0xb9, 0x39, 0x53, 0x1e, 0xbb, 0x96, 0x10, 0xa9, 0x97, 0xe7, 0xdb, + 0x27, 0x45, 0x7c, 0x50, 0x68, 0x44, 0x19, 0x9c, 0xd2, 0xd6, 0xa7, 0x09, 0x71, 0x4c, 0xe4, 0x61, + 0x1f, 0x7f, 0xf6, 0xb0, 0xeb, 0xcd, 0xd4, 0x2b, 0x30, 0x68, 0x5a, 0xfd, 0x65, 0xcf, 0x62, 0xad, + 0x4a, 0x9a, 0x47, 0x01, 0x4f, 0xf0, 0x77, 0x9e, 0x14, 0xbc, 0xd6, 0x1e, 0xcf, 0xd9, 0x10, 0x21, + 0xfe, 0xdc, 0xf1, 0x1e, 0x7c, 0x1b, 0x11, 0x72, 0x8f, 0xcc, 0x47, 0xf5, 0x09, 0x78, 0xdd, 0xb4, + 0x3a, 0xec, 0xd9, 0x10, 0xa5, 0xf3, 0x9c, 0x67, 0x76, 0x40, 0x69, 0x18, 0x44, 0xdf, 0xc0, 0xd5, + 0xef, 0x5f, 0x50, 0xba, 0x1f, 0x6e, 0x76, 0x50, 0xda, 0xee, 0xa0, 0xb4, 0xd9, 0x43, 0x79, 0xbb, + 0x87, 0xf2, 0x8f, 0x0e, 0x4a, 0x3f, 0x3b, 0x28, 0x6f, 0x3b, 0x28, 0xfd, 0xed, 0xa0, 0xf4, 0xf5, + 0x4d, 0x9a, 0xf3, 0x6c, 0x15, 0xde, 0x45, 0x6c, 0x69, 0xd4, 0xeb, 0x22, 0xe2, 0x59, 0x5e, 0xa4, + 0xff, 0x4d, 0xc7, 0xbb, 0x09, 0x9f, 0x8a, 0xff, 0x7f, 0xf7, 0x2f, 0x00, 0x00, 0xff, 0xff, 0xb6, + 0x5d, 0x2e, 0x16, 0x48, 0x02, 0x00, 0x00, } diff --git a/lib/fs/types.pb.go b/lib/fs/types.pb.go index 6e668e67f..fdf705440 100644 --- a/lib/fs/types.pb.go +++ b/lib/fs/types.pb.go @@ -5,6 +5,7 @@ package fs import ( fmt "fmt" + _ "github.com/gogo/protobuf/gogoproto" proto "github.com/gogo/protobuf/proto" math "math" ) @@ -48,18 +49,20 @@ func init() { func init() { proto.RegisterFile("lib/fs/types.proto", fileDescriptor_b556f45c4309ad5d) } var fileDescriptor_b556f45c4309ad5d = []byte{ - // 194 bytes of a gzipped FileDescriptorProto + // 228 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0xca, 0xc9, 0x4c, 0xd2, 0x4f, 0x2b, 0xd6, 0x2f, 0xa9, 0x2c, 0x48, 0x2d, 0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, - 0x4a, 0x2b, 0xd6, 0x2a, 0xe3, 0xe2, 0x73, 0xcb, 0xcc, 0x49, 0x2d, 0xae, 0x2c, 0x2e, 0x49, 0xcd, - 0x0d, 0xa9, 0x2c, 0x48, 0x15, 0x32, 0xe2, 0x12, 0x75, 0xf3, 0xf4, 0x71, 0x0d, 0x8e, 0x0c, 0x0e, - 0x71, 0xf5, 0x8d, 0x0f, 0x89, 0x0c, 0x70, 0x8d, 0x77, 0x72, 0x0c, 0xf6, 0x74, 0x16, 0x60, 0x90, - 0x12, 0xef, 0x9a, 0xab, 0x20, 0x8c, 0xaa, 0xdc, 0x29, 0xb1, 0x38, 0x33, 0x59, 0xc8, 0x80, 0x4b, - 0x04, 0x5d, 0x8f, 0x9b, 0xa3, 0xb7, 0xab, 0x00, 0xa3, 0x94, 0x58, 0xd7, 0x5c, 0x05, 0x21, 0x54, - 0x2d, 0x6e, 0x89, 0xd9, 0xa9, 0x4e, 0xce, 0x27, 0x1e, 0xca, 0x31, 0x5c, 0x78, 0x28, 0xc7, 0xf0, - 0xe2, 0x91, 0x1c, 0xc3, 0x84, 0xc7, 0x72, 0x0c, 0x0b, 0x1e, 0xcb, 0x31, 0x5e, 0x78, 0x2c, 0xc7, - 0x70, 0xe3, 0xb1, 0x1c, 0x43, 0x94, 0x6a, 0x7a, 0x66, 0x49, 0x46, 0x69, 0x92, 0x5e, 0x72, 0x7e, - 0xae, 0x7e, 0x71, 0x65, 0x5e, 0x72, 0x49, 0x46, 0x66, 0x5e, 0x3a, 0x12, 0x0b, 0xe2, 0x99, 0x24, - 0x36, 0xb0, 0x3f, 0x8c, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0x86, 0xe8, 0x6b, 0xac, 0xdd, 0x00, - 0x00, 0x00, + 0x4a, 0x2b, 0x96, 0x52, 0x2e, 0x4a, 0x2d, 0xc8, 0x2f, 0xd6, 0x07, 0x0b, 0x24, 0x95, 0xa6, 0xe9, + 0xa7, 0xe7, 0xa7, 0xe7, 0x83, 0x39, 0x60, 0x16, 0x44, 0xa1, 0x56, 0x0d, 0x17, 0x9f, 0x5b, 0x66, + 0x4e, 0x6a, 0x71, 0x65, 0x71, 0x49, 0x6a, 0x6e, 0x48, 0x65, 0x41, 0xaa, 0x90, 0x11, 0x97, 0xa8, + 0x9b, 0xa7, 0x8f, 0x6b, 0x70, 0x64, 0x70, 0x88, 0xab, 0x6f, 0x7c, 0x48, 0x64, 0x80, 0x6b, 0xbc, + 0x93, 0x63, 0xb0, 0xa7, 0xb3, 0x00, 0x83, 0x94, 0x78, 0xd7, 0x5c, 0x05, 0x61, 0x54, 0xe5, 0x4e, + 0x89, 0xc5, 0x99, 0xc9, 0x42, 0x06, 0x5c, 0x22, 0xe8, 0x7a, 0xdc, 0x1c, 0xbd, 0x5d, 0x05, 0x18, + 0xa5, 0xc4, 0xba, 0xe6, 0x2a, 0x08, 0xa1, 0x6a, 0x71, 0x4b, 0xcc, 0x4e, 0x95, 0x62, 0x59, 0xb1, + 0x44, 0x8e, 0xc1, 0xc9, 0xfd, 0xc4, 0x43, 0x39, 0x86, 0x0b, 0x0f, 0xe5, 0x18, 0x4e, 0x3c, 0x92, + 0x63, 0xbc, 0xf0, 0x48, 0x8e, 0x71, 0xc2, 0x63, 0x39, 0x86, 0x05, 0x8f, 0xe5, 0x18, 0x2f, 0x3c, + 0x96, 0x63, 0xb8, 0xf1, 0x58, 0x8e, 0x21, 0x4a, 0x35, 0x3d, 0xb3, 0x24, 0xa3, 0x34, 0x49, 0x2f, + 0x39, 0x3f, 0x57, 0xbf, 0xb8, 0x32, 0x2f, 0xb9, 0x24, 0x23, 0x33, 0x2f, 0x1d, 0x89, 0x05, 0xf1, + 0x7b, 0x12, 0x1b, 0xd8, 0x37, 0xc6, 0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0x2c, 0x30, 0x9a, 0x86, + 0x0c, 0x01, 0x00, 0x00, } diff --git a/lib/model/devicedownloadstate.go b/lib/model/devicedownloadstate.go index 302c5d137..9fe3a3552 100644 --- a/lib/model/devicedownloadstate.go +++ b/lib/model/devicedownloadstate.go @@ -16,7 +16,7 @@ import ( // FileInfo.Blocks that the remote device already has, and version represents // the version of the file that the remote device is downloading. type deviceFolderFileDownloadState struct { - blockIndexes []int32 + blockIndexes []int version protocol.Vector blockSize int } @@ -30,7 +30,7 @@ type deviceFolderDownloadState struct { // Has returns whether a block at that specific index, and that specific version of the file // is currently available on the remote device for pulling from a temporary file. -func (p *deviceFolderDownloadState) Has(file string, version protocol.Vector, index int32) bool { +func (p *deviceFolderDownloadState) Has(file string, version protocol.Vector, index int) bool { p.mut.RLock() defer p.mut.RUnlock() @@ -56,9 +56,9 @@ func (p *deviceFolderDownloadState) Update(updates []protocol.FileDownloadProgre for _, update := range updates { local, ok := p.files[update.Name] - if update.UpdateType == protocol.UpdateTypeForget && ok && local.version.Equal(update.Version) { + if update.UpdateType == protocol.FileDownloadProgressUpdateTypeForget && ok && local.version.Equal(update.Version) { delete(p.files, update.Name) - } else if update.UpdateType == protocol.UpdateTypeAppend { + } else if update.UpdateType == protocol.FileDownloadProgressUpdateTypeAppend { if !ok { local = deviceFolderFileDownloadState{ blockIndexes: update.BlockIndexes, @@ -137,7 +137,7 @@ func (t *deviceDownloadState) Update(folder string, updates []protocol.FileDownl // Has returns whether block at that specific index, and that specific version of the file // is currently available on the remote device for pulling from a temporary file. -func (t *deviceDownloadState) Has(folder, file string, version protocol.Vector, index int32) bool { +func (t *deviceDownloadState) Has(folder, file string, version protocol.Vector, index int) bool { if t == nil { return false } diff --git a/lib/model/devicedownloadstate_test.go b/lib/model/devicedownloadstate_test.go index 9ae833d7f..489c09bd7 100644 --- a/lib/model/devicedownloadstate_test.go +++ b/lib/model/devicedownloadstate_test.go @@ -17,16 +17,16 @@ func TestDeviceDownloadState(t *testing.T) { v2 := (protocol.Vector{}).Update(1) // file 1 version 1 part 1 - f1v1p1 := protocol.FileDownloadProgressUpdate{UpdateType: protocol.UpdateTypeAppend, Name: "f1", Version: v1, BlockIndexes: []int32{0, 1, 2}} - f1v1p2 := protocol.FileDownloadProgressUpdate{UpdateType: protocol.UpdateTypeAppend, Name: "f1", Version: v1, BlockIndexes: []int32{3, 4, 5}} - f1v1del := protocol.FileDownloadProgressUpdate{UpdateType: protocol.UpdateTypeForget, Name: "f1", Version: v1, BlockIndexes: nil} - f1v2p1 := protocol.FileDownloadProgressUpdate{UpdateType: protocol.UpdateTypeAppend, Name: "f1", Version: v2, BlockIndexes: []int32{10, 11, 12}} - f1v2p2 := protocol.FileDownloadProgressUpdate{UpdateType: protocol.UpdateTypeAppend, Name: "f1", Version: v2, BlockIndexes: []int32{13, 14, 15}} - f1v2del := protocol.FileDownloadProgressUpdate{UpdateType: protocol.UpdateTypeForget, Name: "f1", Version: v2, BlockIndexes: nil} + f1v1p1 := protocol.FileDownloadProgressUpdate{UpdateType: protocol.FileDownloadProgressUpdateTypeAppend, Name: "f1", Version: v1, BlockIndexes: []int{0, 1, 2}} + f1v1p2 := protocol.FileDownloadProgressUpdate{UpdateType: protocol.FileDownloadProgressUpdateTypeAppend, Name: "f1", Version: v1, BlockIndexes: []int{3, 4, 5}} + f1v1del := protocol.FileDownloadProgressUpdate{UpdateType: protocol.FileDownloadProgressUpdateTypeForget, Name: "f1", Version: v1, BlockIndexes: nil} + f1v2p1 := protocol.FileDownloadProgressUpdate{UpdateType: protocol.FileDownloadProgressUpdateTypeAppend, Name: "f1", Version: v2, BlockIndexes: []int{10, 11, 12}} + f1v2p2 := protocol.FileDownloadProgressUpdate{UpdateType: protocol.FileDownloadProgressUpdateTypeAppend, Name: "f1", Version: v2, BlockIndexes: []int{13, 14, 15}} + f1v2del := protocol.FileDownloadProgressUpdate{UpdateType: protocol.FileDownloadProgressUpdateTypeForget, Name: "f1", Version: v2, BlockIndexes: nil} - f2v1p1 := protocol.FileDownloadProgressUpdate{UpdateType: protocol.UpdateTypeAppend, Name: "f2", Version: v1, BlockIndexes: []int32{20, 21, 22}} - f2v1p2 := protocol.FileDownloadProgressUpdate{UpdateType: protocol.UpdateTypeAppend, Name: "f2", Version: v1, BlockIndexes: []int32{23, 24, 25}} - f2v1del := protocol.FileDownloadProgressUpdate{UpdateType: protocol.UpdateTypeForget, Name: "f2", Version: v1, BlockIndexes: nil} + f2v1p1 := protocol.FileDownloadProgressUpdate{UpdateType: protocol.FileDownloadProgressUpdateTypeAppend, Name: "f2", Version: v1, BlockIndexes: []int{20, 21, 22}} + f2v1p2 := protocol.FileDownloadProgressUpdate{UpdateType: protocol.FileDownloadProgressUpdateTypeAppend, Name: "f2", Version: v1, BlockIndexes: []int{23, 24, 25}} + f2v1del := protocol.FileDownloadProgressUpdate{UpdateType: protocol.FileDownloadProgressUpdateTypeForget, Name: "f2", Version: v1, BlockIndexes: nil} tests := []struct { updates []protocol.FileDownloadProgressUpdate diff --git a/lib/model/fakeconns_test.go b/lib/model/fakeconns_test.go index 455d191e2..d3c0077c0 100644 --- a/lib/model/fakeconns_test.go +++ b/lib/model/fakeconns_test.go @@ -129,7 +129,7 @@ func (f *fakeConnection) addFileLocked(name string, flags uint32, ftype protocol Permissions: flags, Version: version, Sequence: time.Now().UnixNano(), - RawBlockSize: int32(blockSize), + RawBlockSize: blockSize, Blocks: blocks, }) } else { diff --git a/lib/model/folder_recvonly_test.go b/lib/model/folder_recvonly_test.go index cc997b1af..ece6e070b 100644 --- a/lib/model/folder_recvonly_test.go +++ b/lib/model/folder_recvonly_test.go @@ -431,7 +431,7 @@ func setupKnownFiles(t *testing.T, ffs fs.Filesystem, data []byte) []protocol.Fi Permissions: 0644, Size: fi.Size(), ModifiedS: fi.ModTime().Unix(), - ModifiedNs: int32(fi.ModTime().UnixNano() % 1e9), + ModifiedNs: int(fi.ModTime().UnixNano() % 1e9), Version: protocol.Vector{Counters: []protocol.Counter{{ID: 42, Value: 42}}}, Sequence: 42, Blocks: blocks, diff --git a/lib/model/folder_sendrecv.go b/lib/model/folder_sendrecv.go index 29433c777..6f396e8ba 100644 --- a/lib/model/folder_sendrecv.go +++ b/lib/model/folder_sendrecv.go @@ -1074,7 +1074,7 @@ func (f *sendReceiveFolder) handleFile(file protocol.FileInfo, snap *db.Snapshot populateOffsets(file.Blocks) blocks := make([]protocol.BlockInfo, 0, len(file.Blocks)) - reused := make([]int32, 0, len(file.Blocks)) + reused := make([]int, 0, len(file.Blocks)) // Check for an old temporary file which might have some blocks we could // reuse. @@ -1103,7 +1103,7 @@ func (f *sendReceiveFolder) handleFile(file protocol.FileInfo, snap *db.Snapshot if !ok { blocks = append(blocks, block) } else { - reused = append(reused, int32(i)) + reused = append(reused, i) } } diff --git a/lib/model/folder_sendrecv_test.go b/lib/model/folder_sendrecv_test.go index 06dc30fba..32a9b4f4d 100644 --- a/lib/model/folder_sendrecv_test.go +++ b/lib/model/folder_sendrecv_test.go @@ -357,7 +357,7 @@ func TestWeakHash(t *testing.T) { Blocks: existing, Size: size, ModifiedS: info.ModTime().Unix(), - ModifiedNs: int32(info.ModTime().Nanosecond()), + ModifiedNs: info.ModTime().Nanosecond(), } desiredFile := protocol.FileInfo{ Name: "weakhash", diff --git a/lib/model/model.go b/lib/model/model.go index 9c51a0a10..002ed6654 100644 --- a/lib/model/model.go +++ b/lib/model/model.go @@ -712,9 +712,9 @@ type FolderCompletion struct { CompletionPct float64 GlobalBytes int64 NeedBytes int64 - GlobalItems int32 - NeedItems int32 - NeedDeletes int32 + GlobalItems int + NeedItems int + NeedDeletes int Sequence int64 } @@ -2430,7 +2430,7 @@ next: } for _, device := range cfg.Devices { - if m.deviceDownloads[device.DeviceID].Has(folder, file.Name, file.Version, int32(block.Offset/int64(file.BlockSize()))) { + if m.deviceDownloads[device.DeviceID].Has(folder, file.Name, file.Version, int(block.Offset/int64(file.BlockSize()))) { availabilities = append(availabilities, Availability{ID: device.DeviceID, FromTemporary: true}) } } @@ -2633,7 +2633,7 @@ func makeForgetUpdate(files []protocol.FileInfo) []protocol.FileDownloadProgress updates = append(updates, protocol.FileDownloadProgressUpdate{ Name: file.Name, Version: file.Version, - UpdateType: protocol.UpdateTypeForget, + UpdateType: protocol.FileDownloadProgressUpdateTypeForget, }) } return updates diff --git a/lib/model/model_test.go b/lib/model/model_test.go index 8b6cf18c0..3214c964a 100644 --- a/lib/model/model_test.go +++ b/lib/model/model_test.go @@ -3331,7 +3331,7 @@ func TestConnCloseOnRestart(t *testing.T) { br := &testutils.BlockingRW{} nw := &testutils.NoopRW{} - m.AddConnection(newFakeProtoConn(protocol.NewConnection(device1, br, nw, m, "testConn", protocol.CompressNever)), protocol.Hello{}) + m.AddConnection(newFakeProtoConn(protocol.NewConnection(device1, br, nw, m, "testConn", protocol.CompressionNever)), protocol.Hello{}) m.pmut.RLock() if len(m.closed) != 1 { t.Fatalf("Expected just one conn (len(m.conn) == %v)", len(m.conn)) diff --git a/lib/model/progressemitter_test.go b/lib/model/progressemitter_test.go index bbe6792f1..ed68d3093 100644 --- a/lib/model/progressemitter_test.go +++ b/lib/model/progressemitter_test.go @@ -128,7 +128,7 @@ func TestSendDownloadProgressMessages(t *testing.T) { p.registry["folder2"] = make(map[string]*sharedPullerState) p.registry["folderXXX"] = make(map[string]*sharedPullerState) - expect := func(updateIdx int, state *sharedPullerState, updateType protocol.FileDownloadProgressUpdateType, version protocol.Vector, blocks []int32, remove bool) { + expect := func(updateIdx int, state *sharedPullerState, updateType protocol.FileDownloadProgressUpdateType, version protocol.Vector, blocks []int, remove bool) { messageIdx := -1 for i, msg := range fc.downloadProgressMessages { if msg.folder == state.folder { @@ -222,10 +222,10 @@ func TestSendDownloadProgressMessages(t *testing.T) { expectEmpty() // Returns update for puller with new extra blocks - state1.available = []int32{1} + state1.available = []int{1} sendMsgs(p) - expect(0, state1, protocol.UpdateTypeAppend, v1, []int32{1}, true) + expect(0, state1, protocol.FileDownloadProgressUpdateTypeAppend, v1, []int{1}, true) expectEmpty() // Does nothing if nothing changes @@ -239,7 +239,7 @@ func TestSendDownloadProgressMessages(t *testing.T) { expectEmpty() // Does not return an update if date blocks change but date does not (should never happen) - state1.available = []int32{1, 2} + state1.available = []int{1, 2} sendMsgs(p) expectEmpty() @@ -249,7 +249,7 @@ func TestSendDownloadProgressMessages(t *testing.T) { sendMsgs(p) - expect(0, state1, protocol.UpdateTypeAppend, v1, []int32{2}, true) + expect(0, state1, protocol.FileDownloadProgressUpdateTypeAppend, v1, []int{2}, true) expectEmpty() // Returns forget and update if puller version has changed @@ -257,20 +257,20 @@ func TestSendDownloadProgressMessages(t *testing.T) { sendMsgs(p) - expect(0, state1, protocol.UpdateTypeForget, v1, nil, false) - expect(1, state1, protocol.UpdateTypeAppend, v2, []int32{1, 2}, true) + expect(0, state1, protocol.FileDownloadProgressUpdateTypeForget, v1, nil, false) + expect(1, state1, protocol.FileDownloadProgressUpdateTypeAppend, v2, []int{1, 2}, true) expectEmpty() // Returns forget and append if sharedPullerState creation timer changes. - state1.available = []int32{1} + state1.available = []int{1} state1.availableUpdated = tick() state1.created = tick() sendMsgs(p) - expect(0, state1, protocol.UpdateTypeForget, v2, nil, false) - expect(1, state1, protocol.UpdateTypeAppend, v2, []int32{1}, true) + expect(0, state1, protocol.FileDownloadProgressUpdateTypeForget, v2, nil, false) + expect(1, state1, protocol.FileDownloadProgressUpdateTypeAppend, v2, []int{1}, true) expectEmpty() // Sends an empty update if new file exists, but does not have any blocks yet. (To indicate that the old blocks are no longer available) @@ -280,12 +280,12 @@ func TestSendDownloadProgressMessages(t *testing.T) { sendMsgs(p) - expect(0, state1, protocol.UpdateTypeForget, v2, nil, false) - expect(1, state1, protocol.UpdateTypeAppend, v1, nil, true) + expect(0, state1, protocol.FileDownloadProgressUpdateTypeForget, v2, nil, false) + expect(1, state1, protocol.FileDownloadProgressUpdateTypeAppend, v1, nil, true) expectEmpty() // Updates for multiple files and folders can be combined - state1.available = []int32{1, 2, 3} + state1.available = []int{1, 2, 3} state1.availableUpdated = tick() state2 := &sharedPullerState{ @@ -296,7 +296,7 @@ func TestSendDownloadProgressMessages(t *testing.T) { Blocks: blocks, }, mut: sync.NewRWMutex(), - available: []int32{1, 2, 3}, + available: []int{1, 2, 3}, availableUpdated: time.Now(), } state3 := &sharedPullerState{ @@ -307,7 +307,7 @@ func TestSendDownloadProgressMessages(t *testing.T) { Blocks: blocks, }, mut: sync.NewRWMutex(), - available: []int32{1, 2, 3}, + available: []int{1, 2, 3}, availableUpdated: time.Now(), } state4 := &sharedPullerState{ @@ -318,7 +318,7 @@ func TestSendDownloadProgressMessages(t *testing.T) { Blocks: blocks, }, mut: sync.NewRWMutex(), - available: []int32{1, 2, 3}, + available: []int{1, 2, 3}, availableUpdated: time.Now(), } p.registry["folder2"]["2"] = state2 @@ -327,16 +327,16 @@ func TestSendDownloadProgressMessages(t *testing.T) { sendMsgs(p) - expect(-1, state1, protocol.UpdateTypeAppend, v1, []int32{1, 2, 3}, false) - expect(-1, state3, protocol.UpdateTypeAppend, v1, []int32{1, 2, 3}, true) - expect(-1, state2, protocol.UpdateTypeAppend, v1, []int32{1, 2, 3}, false) - expect(-1, state4, protocol.UpdateTypeAppend, v1, []int32{1, 2, 3}, true) + expect(-1, state1, protocol.FileDownloadProgressUpdateTypeAppend, v1, []int{1, 2, 3}, false) + expect(-1, state3, protocol.FileDownloadProgressUpdateTypeAppend, v1, []int{1, 2, 3}, true) + expect(-1, state2, protocol.FileDownloadProgressUpdateTypeAppend, v1, []int{1, 2, 3}, false) + expect(-1, state4, protocol.FileDownloadProgressUpdateTypeAppend, v1, []int{1, 2, 3}, true) expectEmpty() // Returns forget if puller no longer exists, as well as updates if it has been updated. - state1.available = []int32{1, 2, 3, 4, 5} + state1.available = []int{1, 2, 3, 4, 5} state1.availableUpdated = tick() - state2.available = []int32{1, 2, 3, 4, 5} + state2.available = []int{1, 2, 3, 4, 5} state2.availableUpdated = tick() delete(p.registry["folder"], "3") @@ -344,10 +344,10 @@ func TestSendDownloadProgressMessages(t *testing.T) { sendMsgs(p) - expect(-1, state1, protocol.UpdateTypeAppend, v1, []int32{4, 5}, false) - expect(-1, state3, protocol.UpdateTypeForget, v1, nil, true) - expect(-1, state2, protocol.UpdateTypeAppend, v1, []int32{4, 5}, false) - expect(-1, state4, protocol.UpdateTypeForget, v1, nil, true) + expect(-1, state1, protocol.FileDownloadProgressUpdateTypeAppend, v1, []int{4, 5}, false) + expect(-1, state3, protocol.FileDownloadProgressUpdateTypeForget, v1, nil, true) + expect(-1, state2, protocol.FileDownloadProgressUpdateTypeAppend, v1, []int{4, 5}, false) + expect(-1, state4, protocol.FileDownloadProgressUpdateTypeForget, v1, nil, true) expectEmpty() // Deletions are sent only once (actual bug I found writing the tests) @@ -366,7 +366,7 @@ func TestSendDownloadProgressMessages(t *testing.T) { Blocks: blocks, }, mut: sync.NewRWMutex(), - available: []int32{1, 2, 3}, + available: []int{1, 2, 3}, availableUpdated: time.Now(), } // Symlink @@ -378,7 +378,7 @@ func TestSendDownloadProgressMessages(t *testing.T) { Type: protocol.FileInfoTypeSymlink, }, mut: sync.NewRWMutex(), - available: []int32{1, 2, 3}, + available: []int{1, 2, 3}, availableUpdated: time.Now(), } // Some other directory @@ -390,7 +390,7 @@ func TestSendDownloadProgressMessages(t *testing.T) { Blocks: blocks, }, mut: sync.NewRWMutex(), - available: []int32{1, 2, 3}, + available: []int{1, 2, 3}, availableUpdated: time.Now(), } // Less than 10 blocks @@ -402,7 +402,7 @@ func TestSendDownloadProgressMessages(t *testing.T) { Blocks: blocks[:3], }, mut: sync.NewRWMutex(), - available: []int32{1, 2, 3}, + available: []int{1, 2, 3}, availableUpdated: time.Now(), } p.registry["folder"]["5"] = state5 @@ -419,8 +419,8 @@ func TestSendDownloadProgressMessages(t *testing.T) { delete(p.registry["folder2"], "2") // Clean up first sendMsgs(p) - expect(-1, state1, protocol.UpdateTypeForget, v1, nil, true) - expect(-1, state2, protocol.UpdateTypeForget, v1, nil, true) + expect(-1, state1, protocol.FileDownloadProgressUpdateTypeForget, v1, nil, true) + expect(-1, state2, protocol.FileDownloadProgressUpdateTypeForget, v1, nil, true) expectEmpty() @@ -431,10 +431,10 @@ func TestSendDownloadProgressMessages(t *testing.T) { sendMsgs(p) - expect(-1, state1, protocol.UpdateTypeAppend, v1, []int32{1, 2, 3, 4, 5}, false) - expect(-1, state3, protocol.UpdateTypeAppend, v1, []int32{1, 2, 3}, true) - expect(-1, state2, protocol.UpdateTypeAppend, v1, []int32{1, 2, 3, 4, 5}, false) - expect(-1, state4, protocol.UpdateTypeAppend, v1, []int32{1, 2, 3}, true) + expect(-1, state1, protocol.FileDownloadProgressUpdateTypeAppend, v1, []int{1, 2, 3, 4, 5}, false) + expect(-1, state3, protocol.FileDownloadProgressUpdateTypeAppend, v1, []int{1, 2, 3}, true) + expect(-1, state2, protocol.FileDownloadProgressUpdateTypeAppend, v1, []int{1, 2, 3, 4, 5}, false) + expect(-1, state4, protocol.FileDownloadProgressUpdateTypeAppend, v1, []int{1, 2, 3}, true) expectEmpty() p.temporaryIndexUnsubscribe(fc) @@ -444,8 +444,8 @@ func TestSendDownloadProgressMessages(t *testing.T) { // See progressemitter.go for explanation why this is commented out. // Search for state.cleanup - //expect(-1, state2, protocol.UpdateTypeForget, v1, nil, false) - //expect(-1, state4, protocol.UpdateTypeForget, v1, nil, true) + //expect(-1, state2, protocol.FileDownloadProgressUpdateTypeForget, v1, nil, false) + //expect(-1, state4, protocol.FileDownloadProgressUpdateTypeForget, v1, nil, true) expectEmpty() diff --git a/lib/model/sentdownloadstate.go b/lib/model/sentdownloadstate.go index 821e395a3..363a27ac1 100644 --- a/lib/model/sentdownloadstate.go +++ b/lib/model/sentdownloadstate.go @@ -15,7 +15,7 @@ import ( // sentFolderFileDownloadState represents a state of what we've announced as available // to some remote device for a specific file. type sentFolderFileDownloadState struct { - blockIndexes []int32 + blockIndexes []int version protocol.Vector updated time.Time created time.Time @@ -44,7 +44,7 @@ func (s *sentFolderDownloadState) update(pullers []*sharedPullerState) []protoco pullerVersion := puller.file.Version pullerBlockIndexesUpdated := puller.AvailableUpdated() pullerCreated := puller.created - pullerBlockSize := int32(puller.file.BlockSize()) + pullerBlockSize := puller.file.BlockSize() localFile, ok := s.files[name] @@ -57,13 +57,13 @@ func (s *sentFolderDownloadState) update(pullers []*sharedPullerState) []protoco updated: pullerBlockIndexesUpdated, version: pullerVersion, created: pullerCreated, - blockSize: int(pullerBlockSize), + blockSize: pullerBlockSize, } updates = append(updates, protocol.FileDownloadProgressUpdate{ Name: name, Version: pullerVersion, - UpdateType: protocol.UpdateTypeAppend, + UpdateType: protocol.FileDownloadProgressUpdateTypeAppend, BlockIndexes: pullerBlockIndexes, BlockSize: pullerBlockSize, }) @@ -83,12 +83,12 @@ func (s *sentFolderDownloadState) update(pullers []*sharedPullerState) []protoco updates = append(updates, protocol.FileDownloadProgressUpdate{ Name: name, Version: localFile.version, - UpdateType: protocol.UpdateTypeForget, + UpdateType: protocol.FileDownloadProgressUpdateTypeForget, }) updates = append(updates, protocol.FileDownloadProgressUpdate{ Name: name, Version: pullerVersion, - UpdateType: protocol.UpdateTypeAppend, + UpdateType: protocol.FileDownloadProgressUpdateTypeAppend, BlockIndexes: pullerBlockIndexes, BlockSize: pullerBlockSize, }) @@ -112,7 +112,7 @@ func (s *sentFolderDownloadState) update(pullers []*sharedPullerState) []protoco updates = append(updates, protocol.FileDownloadProgressUpdate{ Name: name, Version: localFile.version, - UpdateType: protocol.UpdateTypeAppend, + UpdateType: protocol.FileDownloadProgressUpdateTypeAppend, BlockIndexes: newBlocks, BlockSize: pullerBlockSize, }) @@ -127,7 +127,7 @@ func (s *sentFolderDownloadState) update(pullers []*sharedPullerState) []protoco updates = append(updates, protocol.FileDownloadProgressUpdate{ Name: name, Version: info.version, - UpdateType: protocol.UpdateTypeForget, + UpdateType: protocol.FileDownloadProgressUpdateTypeForget, }) delete(s.files, name) } @@ -144,7 +144,7 @@ func (s *sentFolderDownloadState) destroy() []protocol.FileDownloadProgressUpdat updates = append(updates, protocol.FileDownloadProgressUpdate{ Name: name, Version: info.version, - UpdateType: protocol.UpdateTypeForget, + UpdateType: protocol.FileDownloadProgressUpdateTypeForget, }) delete(s.files, name) } diff --git a/lib/model/sharedpullerstate.go b/lib/model/sharedpullerstate.go index e8befeaa3..30ebe2eca 100644 --- a/lib/model/sharedpullerstate.go +++ b/lib/model/sharedpullerstate.go @@ -44,12 +44,12 @@ type sharedPullerState struct { pullNeeded int // Number of block pulls still pending updated time.Time // Time when any of the counters above were last updated closed bool // True if the file has been finalClosed. - available []int32 // Indexes of the blocks that are available in the temporary file + available []int // Indexes of the blocks that are available in the temporary file availableUpdated time.Time // Time when list of available blocks was last updated mut sync.RWMutex // Protects the above } -func newSharedPullerState(file protocol.FileInfo, fs fs.Filesystem, folderID, tempName string, blocks []protocol.BlockInfo, reused []int32, ignorePerms, hasCurFile bool, curFile protocol.FileInfo, sparse bool, fsync bool) *sharedPullerState { +func newSharedPullerState(file protocol.FileInfo, fs fs.Filesystem, folderID, tempName string, blocks []protocol.BlockInfo, reused []int, ignorePerms, hasCurFile bool, curFile protocol.FileInfo, sparse bool, fsync bool) *sharedPullerState { return &sharedPullerState{ file: file, fs: fs, @@ -244,7 +244,7 @@ func (s *sharedPullerState) copyDone(block protocol.BlockInfo) { s.mut.Lock() s.copyNeeded-- s.updated = time.Now() - s.available = append(s.available, int32(block.Offset/int64(s.file.BlockSize()))) + s.available = append(s.available, int(block.Offset/int64(s.file.BlockSize()))) s.availableUpdated = time.Now() l.Debugln("sharedPullerState", s.folder, s.file.Name, "copyNeeded ->", s.copyNeeded) s.mut.Unlock() @@ -280,7 +280,7 @@ func (s *sharedPullerState) pullDone(block protocol.BlockInfo) { s.mut.Lock() s.pullNeeded-- s.updated = time.Now() - s.available = append(s.available, int32(block.Offset/int64(s.file.BlockSize()))) + s.available = append(s.available, int(block.Offset/int64(s.file.BlockSize()))) s.availableUpdated = time.Now() l.Debugln("sharedPullerState", s.folder, s.file.Name, "pullNeeded done ->", s.pullNeeded) s.mut.Unlock() @@ -359,7 +359,7 @@ func (s *sharedPullerState) AvailableUpdated() time.Time { } // Available returns blocks available in the current temporary file -func (s *sharedPullerState) Available() []int32 { +func (s *sharedPullerState) Available() []int { s.mut.RLock() blocks := s.available s.mut.RUnlock() diff --git a/lib/protocol/benchmark_test.go b/lib/protocol/benchmark_test.go index 65fbd29c0..bfa9b0830 100644 --- a/lib/protocol/benchmark_test.go +++ b/lib/protocol/benchmark_test.go @@ -59,9 +59,9 @@ func benchmarkRequestsTLS(b *testing.B, conn0, conn1 net.Conn) { func benchmarkRequestsConnPair(b *testing.B, conn0, conn1 net.Conn) { // Start up Connections on them - c0 := NewConnection(LocalDeviceID, conn0, conn0, new(fakeModel), "c0", CompressMetadata) + c0 := NewConnection(LocalDeviceID, conn0, conn0, new(fakeModel), "c0", CompressionMetadata) c0.Start() - c1 := NewConnection(LocalDeviceID, conn1, conn1, new(fakeModel), "c1", CompressMetadata) + c1 := NewConnection(LocalDeviceID, conn1, conn1, new(fakeModel), "c1", CompressionMetadata) c1.Start() // Satisfy the assertions in the protocol by sending an initial cluster config diff --git a/lib/protocol/bep.pb.go b/lib/protocol/bep.pb.go index 099ab0f9f..8cc5a4699 100644 --- a/lib/protocol/bep.pb.go +++ b/lib/protocol/bep.pb.go @@ -7,6 +7,7 @@ import ( fmt "fmt" _ "github.com/gogo/protobuf/gogoproto" proto "github.com/gogo/protobuf/proto" + _ "github.com/syncthing/syncthing/proto/ext" io "io" math "math" math_bits "math/bits" @@ -26,36 +27,36 @@ const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package type MessageType int32 const ( - messageTypeClusterConfig MessageType = 0 - messageTypeIndex MessageType = 1 - messageTypeIndexUpdate MessageType = 2 - messageTypeRequest MessageType = 3 - messageTypeResponse MessageType = 4 - messageTypeDownloadProgress MessageType = 5 - messageTypePing MessageType = 6 - messageTypeClose MessageType = 7 + MessageTypeClusterConfig MessageType = 0 + MessageTypeIndex MessageType = 1 + MessageTypeIndexUpdate MessageType = 2 + MessageTypeRequest MessageType = 3 + MessageTypeResponse MessageType = 4 + MessageTypeDownloadProgress MessageType = 5 + MessageTypePing MessageType = 6 + MessageTypeClose MessageType = 7 ) var MessageType_name = map[int32]string{ - 0: "CLUSTER_CONFIG", - 1: "INDEX", - 2: "INDEX_UPDATE", - 3: "REQUEST", - 4: "RESPONSE", - 5: "DOWNLOAD_PROGRESS", - 6: "PING", - 7: "CLOSE", + 0: "MESSAGE_TYPE_CLUSTER_CONFIG", + 1: "MESSAGE_TYPE_INDEX", + 2: "MESSAGE_TYPE_INDEX_UPDATE", + 3: "MESSAGE_TYPE_REQUEST", + 4: "MESSAGE_TYPE_RESPONSE", + 5: "MESSAGE_TYPE_DOWNLOAD_PROGRESS", + 6: "MESSAGE_TYPE_PING", + 7: "MESSAGE_TYPE_CLOSE", } var MessageType_value = map[string]int32{ - "CLUSTER_CONFIG": 0, - "INDEX": 1, - "INDEX_UPDATE": 2, - "REQUEST": 3, - "RESPONSE": 4, - "DOWNLOAD_PROGRESS": 5, - "PING": 6, - "CLOSE": 7, + "MESSAGE_TYPE_CLUSTER_CONFIG": 0, + "MESSAGE_TYPE_INDEX": 1, + "MESSAGE_TYPE_INDEX_UPDATE": 2, + "MESSAGE_TYPE_REQUEST": 3, + "MESSAGE_TYPE_RESPONSE": 4, + "MESSAGE_TYPE_DOWNLOAD_PROGRESS": 5, + "MESSAGE_TYPE_PING": 6, + "MESSAGE_TYPE_CLOSE": 7, } func (x MessageType) String() string { @@ -74,13 +75,13 @@ const ( ) var MessageCompression_name = map[int32]string{ - 0: "NONE", - 1: "LZ4", + 0: "MESSAGE_COMPRESSION_NONE", + 1: "MESSAGE_COMPRESSION_LZ4", } var MessageCompression_value = map[string]int32{ - "NONE": 0, - "LZ4": 1, + "MESSAGE_COMPRESSION_NONE": 0, + "MESSAGE_COMPRESSION_LZ4": 1, } func (x MessageCompression) String() string { @@ -94,21 +95,21 @@ func (MessageCompression) EnumDescriptor() ([]byte, []int) { type Compression int32 const ( - CompressMetadata Compression = 0 - CompressNever Compression = 1 - CompressAlways Compression = 2 + CompressionMetadata Compression = 0 + CompressionNever Compression = 1 + CompressionAlways Compression = 2 ) var Compression_name = map[int32]string{ - 0: "METADATA", - 1: "NEVER", - 2: "ALWAYS", + 0: "COMPRESSION_METADATA", + 1: "COMPRESSION_NEVER", + 2: "COMPRESSION_ALWAYS", } var Compression_value = map[string]int32{ - "METADATA": 0, - "NEVER": 1, - "ALWAYS": 2, + "COMPRESSION_METADATA": 0, + "COMPRESSION_NEVER": 1, + "COMPRESSION_ALWAYS": 2, } func (x Compression) String() string { @@ -122,27 +123,27 @@ func (Compression) EnumDescriptor() ([]byte, []int) { type FileInfoType int32 const ( - FileInfoTypeFile FileInfoType = 0 - FileInfoTypeDirectory FileInfoType = 1 - FileInfoTypeDeprecatedSymlinkFile FileInfoType = 2 // Deprecated: Do not use. - FileInfoTypeDeprecatedSymlinkDirectory FileInfoType = 3 // Deprecated: Do not use. - FileInfoTypeSymlink FileInfoType = 4 + FileInfoTypeFile FileInfoType = 0 + FileInfoTypeDirectory FileInfoType = 1 + FileInfoTypeSymlinkFile FileInfoType = 2 // Deprecated: Do not use. + FileInfoTypeSymlinkDirectory FileInfoType = 3 // Deprecated: Do not use. + FileInfoTypeSymlink FileInfoType = 4 ) var FileInfoType_name = map[int32]string{ - 0: "FILE", - 1: "DIRECTORY", - 2: "SYMLINK_FILE", - 3: "SYMLINK_DIRECTORY", - 4: "SYMLINK", + 0: "FILE_INFO_TYPE_FILE", + 1: "FILE_INFO_TYPE_DIRECTORY", + 2: "FILE_INFO_TYPE_SYMLINK_FILE", + 3: "FILE_INFO_TYPE_SYMLINK_DIRECTORY", + 4: "FILE_INFO_TYPE_SYMLINK", } var FileInfoType_value = map[string]int32{ - "FILE": 0, - "DIRECTORY": 1, - "SYMLINK_FILE": 2, - "SYMLINK_DIRECTORY": 3, - "SYMLINK": 4, + "FILE_INFO_TYPE_FILE": 0, + "FILE_INFO_TYPE_DIRECTORY": 1, + "FILE_INFO_TYPE_SYMLINK_FILE": 2, + "FILE_INFO_TYPE_SYMLINK_DIRECTORY": 3, + "FILE_INFO_TYPE_SYMLINK": 4, } func (x FileInfoType) String() string { @@ -163,17 +164,17 @@ const ( ) var ErrorCode_name = map[int32]string{ - 0: "NO_ERROR", - 1: "GENERIC", - 2: "NO_SUCH_FILE", - 3: "INVALID_FILE", + 0: "ERROR_CODE_NO_ERROR", + 1: "ERROR_CODE_GENERIC", + 2: "ERROR_CODE_NO_SUCH_FILE", + 3: "ERROR_CODE_INVALID_FILE", } var ErrorCode_value = map[string]int32{ - "NO_ERROR": 0, - "GENERIC": 1, - "NO_SUCH_FILE": 2, - "INVALID_FILE": 3, + "ERROR_CODE_NO_ERROR": 0, + "ERROR_CODE_GENERIC": 1, + "ERROR_CODE_NO_SUCH_FILE": 2, + "ERROR_CODE_INVALID_FILE": 3, } func (x ErrorCode) String() string { @@ -187,18 +188,18 @@ func (ErrorCode) EnumDescriptor() ([]byte, []int) { type FileDownloadProgressUpdateType int32 const ( - UpdateTypeAppend FileDownloadProgressUpdateType = 0 - UpdateTypeForget FileDownloadProgressUpdateType = 1 + FileDownloadProgressUpdateTypeAppend FileDownloadProgressUpdateType = 0 + FileDownloadProgressUpdateTypeForget FileDownloadProgressUpdateType = 1 ) var FileDownloadProgressUpdateType_name = map[int32]string{ - 0: "APPEND", - 1: "FORGET", + 0: "FILE_DOWNLOAD_PROGRESS_UPDATE_TYPE_APPEND", + 1: "FILE_DOWNLOAD_PROGRESS_UPDATE_TYPE_FORGET", } var FileDownloadProgressUpdateType_value = map[string]int32{ - "APPEND": 0, - "FORGET": 1, + "FILE_DOWNLOAD_PROGRESS_UPDATE_TYPE_APPEND": 0, + "FILE_DOWNLOAD_PROGRESS_UPDATE_TYPE_FORGET": 1, } func (x FileDownloadProgressUpdateType) String() string { @@ -210,9 +211,9 @@ func (FileDownloadProgressUpdateType) EnumDescriptor() ([]byte, []int) { } type Hello struct { - DeviceName string `protobuf:"bytes,1,opt,name=device_name,json=deviceName,proto3" json:"device_name,omitempty"` - ClientName string `protobuf:"bytes,2,opt,name=client_name,json=clientName,proto3" json:"client_name,omitempty"` - ClientVersion string `protobuf:"bytes,3,opt,name=client_version,json=clientVersion,proto3" json:"client_version,omitempty"` + DeviceName string `protobuf:"bytes,1,opt,name=device_name,json=deviceName,proto3" json:"deviceName" xml:"deviceName"` + ClientName string `protobuf:"bytes,2,opt,name=client_name,json=clientName,proto3" json:"clientName" xml:"clientName"` + ClientVersion string `protobuf:"bytes,3,opt,name=client_version,json=clientVersion,proto3" json:"clientVersion" xml:"clientVersion"` } func (m *Hello) Reset() { *m = Hello{} } @@ -249,8 +250,8 @@ func (m *Hello) XXX_DiscardUnknown() { var xxx_messageInfo_Hello proto.InternalMessageInfo type Header struct { - Type MessageType `protobuf:"varint,1,opt,name=type,proto3,enum=protocol.MessageType" json:"type,omitempty"` - Compression MessageCompression `protobuf:"varint,2,opt,name=compression,proto3,enum=protocol.MessageCompression" json:"compression,omitempty"` + Type MessageType `protobuf:"varint,1,opt,name=type,proto3,enum=protocol.MessageType" json:"type" xml:"type"` + Compression MessageCompression `protobuf:"varint,2,opt,name=compression,proto3,enum=protocol.MessageCompression" json:"compression" xml:"compression"` } func (m *Header) Reset() { *m = Header{} } @@ -287,7 +288,7 @@ func (m *Header) XXX_DiscardUnknown() { var xxx_messageInfo_Header proto.InternalMessageInfo type ClusterConfig struct { - Folders []Folder `protobuf:"bytes,1,rep,name=folders,proto3" json:"folders"` + Folders []Folder `protobuf:"bytes,1,rep,name=folders,proto3" json:"folders" xml:"folder"` } func (m *ClusterConfig) Reset() { *m = ClusterConfig{} } @@ -324,14 +325,14 @@ func (m *ClusterConfig) XXX_DiscardUnknown() { var xxx_messageInfo_ClusterConfig proto.InternalMessageInfo type Folder struct { - ID string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - Label string `protobuf:"bytes,2,opt,name=label,proto3" json:"label,omitempty"` - ReadOnly bool `protobuf:"varint,3,opt,name=read_only,json=readOnly,proto3" json:"read_only,omitempty"` - IgnorePermissions bool `protobuf:"varint,4,opt,name=ignore_permissions,json=ignorePermissions,proto3" json:"ignore_permissions,omitempty"` - IgnoreDelete bool `protobuf:"varint,5,opt,name=ignore_delete,json=ignoreDelete,proto3" json:"ignore_delete,omitempty"` - DisableTempIndexes bool `protobuf:"varint,6,opt,name=disable_temp_indexes,json=disableTempIndexes,proto3" json:"disable_temp_indexes,omitempty"` - Paused bool `protobuf:"varint,7,opt,name=paused,proto3" json:"paused,omitempty"` - Devices []Device `protobuf:"bytes,16,rep,name=devices,proto3" json:"devices"` + ID string `protobuf:"bytes,1,opt,name=id,proto3" json:"id" xml:"id"` + Label string `protobuf:"bytes,2,opt,name=label,proto3" json:"label" xml:"label"` + ReadOnly bool `protobuf:"varint,3,opt,name=read_only,json=readOnly,proto3" json:"readOnly" xml:"readOnly"` + IgnorePermissions bool `protobuf:"varint,4,opt,name=ignore_permissions,json=ignorePermissions,proto3" json:"ignorePermissions" xml:"ignorePermissions"` + IgnoreDelete bool `protobuf:"varint,5,opt,name=ignore_delete,json=ignoreDelete,proto3" json:"ignoreDelete" xml:"ignoreDelete"` + DisableTempIndexes bool `protobuf:"varint,6,opt,name=disable_temp_indexes,json=disableTempIndexes,proto3" json:"disableTempIndexes" xml:"disableTempIndexes"` + Paused bool `protobuf:"varint,7,opt,name=paused,proto3" json:"paused" xml:"paused"` + Devices []Device `protobuf:"bytes,16,rep,name=devices,proto3" json:"devices" xml:"device"` } func (m *Folder) Reset() { *m = Folder{} } @@ -368,15 +369,15 @@ func (m *Folder) XXX_DiscardUnknown() { var xxx_messageInfo_Folder proto.InternalMessageInfo type Device struct { - ID DeviceID `protobuf:"bytes,1,opt,name=id,proto3,customtype=DeviceID" json:"id"` - Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` - Addresses []string `protobuf:"bytes,3,rep,name=addresses,proto3" json:"addresses,omitempty"` - Compression Compression `protobuf:"varint,4,opt,name=compression,proto3,enum=protocol.Compression" json:"compression,omitempty"` - CertName string `protobuf:"bytes,5,opt,name=cert_name,json=certName,proto3" json:"cert_name,omitempty"` - MaxSequence int64 `protobuf:"varint,6,opt,name=max_sequence,json=maxSequence,proto3" json:"max_sequence,omitempty"` - Introducer bool `protobuf:"varint,7,opt,name=introducer,proto3" json:"introducer,omitempty"` - IndexID IndexID `protobuf:"varint,8,opt,name=index_id,json=indexId,proto3,customtype=IndexID" json:"index_id"` - SkipIntroductionRemovals bool `protobuf:"varint,9,opt,name=skip_introduction_removals,json=skipIntroductionRemovals,proto3" json:"skip_introduction_removals,omitempty"` + ID DeviceID `protobuf:"bytes,1,opt,name=id,proto3,customtype=DeviceID" json:"id" xml:"id"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name" xml:"name"` + Addresses []string `protobuf:"bytes,3,rep,name=addresses,proto3" json:"addresses" xml:"address"` + Compression Compression `protobuf:"varint,4,opt,name=compression,proto3,enum=protocol.Compression" json:"compression" xml:"compression"` + CertName string `protobuf:"bytes,5,opt,name=cert_name,json=certName,proto3" json:"certName" xml:"certName"` + MaxSequence int64 `protobuf:"varint,6,opt,name=max_sequence,json=maxSequence,proto3" json:"maxSequence" xml:"maxSequence"` + Introducer bool `protobuf:"varint,7,opt,name=introducer,proto3" json:"introducer" xml:"introducer"` + IndexID IndexID `protobuf:"varint,8,opt,name=index_id,json=indexId,proto3,customtype=IndexID" json:"indexId" xml:"indexId"` + SkipIntroductionRemovals bool `protobuf:"varint,9,opt,name=skip_introduction_removals,json=skipIntroductionRemovals,proto3" json:"skipIntroductionRemovals" xml:"skipIntroductionRemovals"` } func (m *Device) Reset() { *m = Device{} } @@ -413,8 +414,8 @@ func (m *Device) XXX_DiscardUnknown() { var xxx_messageInfo_Device proto.InternalMessageInfo type Index struct { - Folder string `protobuf:"bytes,1,opt,name=folder,proto3" json:"folder,omitempty"` - Files []FileInfo `protobuf:"bytes,2,rep,name=files,proto3" json:"files"` + Folder string `protobuf:"bytes,1,opt,name=folder,proto3" json:"folder" xml:"folder"` + Files []FileInfo `protobuf:"bytes,2,rep,name=files,proto3" json:"files" xml:"file"` } func (m *Index) Reset() { *m = Index{} } @@ -451,8 +452,8 @@ func (m *Index) XXX_DiscardUnknown() { var xxx_messageInfo_Index proto.InternalMessageInfo type IndexUpdate struct { - Folder string `protobuf:"bytes,1,opt,name=folder,proto3" json:"folder,omitempty"` - Files []FileInfo `protobuf:"bytes,2,rep,name=files,proto3" json:"files"` + Folder string `protobuf:"bytes,1,opt,name=folder,proto3" json:"folder" xml:"folder"` + Files []FileInfo `protobuf:"bytes,2,rep,name=files,proto3" json:"files" xml:"file"` } func (m *IndexUpdate) Reset() { *m = IndexUpdate{} } @@ -489,30 +490,30 @@ func (m *IndexUpdate) XXX_DiscardUnknown() { var xxx_messageInfo_IndexUpdate proto.InternalMessageInfo type FileInfo struct { - Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` - Size int64 `protobuf:"varint,3,opt,name=size,proto3" json:"size,omitempty"` - ModifiedS int64 `protobuf:"varint,5,opt,name=modified_s,json=modifiedS,proto3" json:"modified_s,omitempty"` - ModifiedBy ShortID `protobuf:"varint,12,opt,name=modified_by,json=modifiedBy,proto3,customtype=ShortID" json:"modified_by"` - Version Vector `protobuf:"bytes,9,opt,name=version,proto3" json:"version"` - Sequence int64 `protobuf:"varint,10,opt,name=sequence,proto3" json:"sequence,omitempty"` - Blocks []BlockInfo `protobuf:"bytes,16,rep,name=blocks,proto3" json:"blocks"` - SymlinkTarget string `protobuf:"bytes,17,opt,name=symlink_target,json=symlinkTarget,proto3" json:"symlink_target,omitempty"` - BlocksHash []byte `protobuf:"bytes,18,opt,name=blocks_hash,json=blocksHash,proto3" json:"blocks_hash,omitempty"` - Type FileInfoType `protobuf:"varint,2,opt,name=type,proto3,enum=protocol.FileInfoType" json:"type,omitempty"` - Permissions uint32 `protobuf:"varint,4,opt,name=permissions,proto3" json:"permissions,omitempty"` - ModifiedNs int32 `protobuf:"varint,11,opt,name=modified_ns,json=modifiedNs,proto3" json:"modified_ns,omitempty"` - RawBlockSize int32 `protobuf:"varint,13,opt,name=block_size,json=blockSize,proto3" json:"block_size,omitempty"` + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name" xml:"name"` + Size int64 `protobuf:"varint,3,opt,name=size,proto3" json:"size" xml:"size"` + ModifiedS int64 `protobuf:"varint,5,opt,name=modified_s,json=modifiedS,proto3" json:"modifiedS" xml:"modifiedS"` + ModifiedBy ShortID `protobuf:"varint,12,opt,name=modified_by,json=modifiedBy,proto3,customtype=ShortID" json:"modifiedBy" xml:"modifiedBy"` + Version Vector `protobuf:"bytes,9,opt,name=version,proto3" json:"version" xml:"version"` + Sequence int64 `protobuf:"varint,10,opt,name=sequence,proto3" json:"sequence" xml:"sequence"` + Blocks []BlockInfo `protobuf:"bytes,16,rep,name=blocks,proto3" json:"blocks" xml:"block"` + SymlinkTarget string `protobuf:"bytes,17,opt,name=symlink_target,json=symlinkTarget,proto3" json:"symlinkTarget" xml:"symlinkTarget"` + BlocksHash []byte `protobuf:"bytes,18,opt,name=blocks_hash,json=blocksHash,proto3" json:"blocksHash" xml:"blocksHash"` + Type FileInfoType `protobuf:"varint,2,opt,name=type,proto3,enum=protocol.FileInfoType" json:"type" xml:"type"` + Permissions uint32 `protobuf:"varint,4,opt,name=permissions,proto3" json:"permissions" xml:"permissions"` + ModifiedNs int `protobuf:"varint,11,opt,name=modified_ns,json=modifiedNs,proto3,casttype=int" json:"modifiedNs" xml:"modifiedNs"` + RawBlockSize int `protobuf:"varint,13,opt,name=block_size,json=blockSize,proto3,casttype=int" json:"blockSize" xml:"blockSize"` // The local_flags fields stores flags that are relevant to the local // host only. It is not part of the protocol, doesn't get sent or // received (we make sure to zero it), nonetheless we need it on our // struct and to be able to serialize it to/from the database. - LocalFlags uint32 `protobuf:"varint,1000,opt,name=local_flags,json=localFlags,proto3" json:"local_flags,omitempty"` + LocalFlags uint32 `protobuf:"varint,1000,opt,name=local_flags,json=localFlags,proto3" json:"localFlags" xml:"localFlags"` // The version_hash is an implementation detail and not part of the wire // format. - VersionHash []byte `protobuf:"bytes,1001,opt,name=version_hash,json=versionHash,proto3" json:"version_hash,omitempty"` - Deleted bool `protobuf:"varint,6,opt,name=deleted,proto3" json:"deleted,omitempty"` - RawInvalid bool `protobuf:"varint,7,opt,name=invalid,proto3" json:"invalid,omitempty"` - NoPermissions bool `protobuf:"varint,8,opt,name=no_permissions,json=noPermissions,proto3" json:"no_permissions,omitempty"` + VersionHash []byte `protobuf:"bytes,1001,opt,name=version_hash,json=versionHash,proto3" json:"versionHash" xml:"versionHash"` + Deleted bool `protobuf:"varint,6,opt,name=deleted,proto3" json:"deleted" xml:"deleted"` + RawInvalid bool `protobuf:"varint,7,opt,name=invalid,proto3" json:"invalid" xml:"invalid"` + NoPermissions bool `protobuf:"varint,8,opt,name=no_permissions,json=noPermissions,proto3" json:"noPermissions" xml:"noPermissions"` } func (m *FileInfo) Reset() { *m = FileInfo{} } @@ -548,10 +549,10 @@ func (m *FileInfo) XXX_DiscardUnknown() { var xxx_messageInfo_FileInfo proto.InternalMessageInfo type BlockInfo struct { - Hash []byte `protobuf:"bytes,3,opt,name=hash,proto3" json:"hash,omitempty"` - Offset int64 `protobuf:"varint,1,opt,name=offset,proto3" json:"offset,omitempty"` - Size int32 `protobuf:"varint,2,opt,name=size,proto3" json:"size,omitempty"` - WeakHash uint32 `protobuf:"varint,4,opt,name=weak_hash,json=weakHash,proto3" json:"weak_hash,omitempty"` + Hash []byte `protobuf:"bytes,3,opt,name=hash,proto3" json:"hash" xml:"hash"` + Offset int64 `protobuf:"varint,1,opt,name=offset,proto3" json:"offset" xml:"offset"` + Size int `protobuf:"varint,2,opt,name=size,proto3,casttype=int" json:"size" xml:"size"` + WeakHash uint32 `protobuf:"varint,4,opt,name=weak_hash,json=weakHash,proto3" json:"weakHash" xml:"weakHash"` } func (m *BlockInfo) Reset() { *m = BlockInfo{} } @@ -587,7 +588,7 @@ func (m *BlockInfo) XXX_DiscardUnknown() { var xxx_messageInfo_BlockInfo proto.InternalMessageInfo type Vector struct { - Counters []Counter `protobuf:"bytes,1,rep,name=counters,proto3" json:"counters"` + Counters []Counter `protobuf:"bytes,1,rep,name=counters,proto3" json:"counters" xml:"counter"` } func (m *Vector) Reset() { *m = Vector{} } @@ -624,8 +625,8 @@ func (m *Vector) XXX_DiscardUnknown() { var xxx_messageInfo_Vector proto.InternalMessageInfo type Counter struct { - ID ShortID `protobuf:"varint,1,opt,name=id,proto3,customtype=ShortID" json:"id"` - Value uint64 `protobuf:"varint,2,opt,name=value,proto3" json:"value,omitempty"` + ID ShortID `protobuf:"varint,1,opt,name=id,proto3,customtype=ShortID" json:"id" xml:"id"` + Value uint64 `protobuf:"varint,2,opt,name=value,proto3" json:"value" xml:"value"` } func (m *Counter) Reset() { *m = Counter{} } @@ -662,14 +663,14 @@ func (m *Counter) XXX_DiscardUnknown() { var xxx_messageInfo_Counter proto.InternalMessageInfo type Request struct { - ID int32 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` - Folder string `protobuf:"bytes,2,opt,name=folder,proto3" json:"folder,omitempty"` - Name string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"` - Offset int64 `protobuf:"varint,4,opt,name=offset,proto3" json:"offset,omitempty"` - Size int32 `protobuf:"varint,5,opt,name=size,proto3" json:"size,omitempty"` - Hash []byte `protobuf:"bytes,6,opt,name=hash,proto3" json:"hash,omitempty"` - FromTemporary bool `protobuf:"varint,7,opt,name=from_temporary,json=fromTemporary,proto3" json:"from_temporary,omitempty"` - WeakHash uint32 `protobuf:"varint,8,opt,name=weak_hash,json=weakHash,proto3" json:"weak_hash,omitempty"` + ID int `protobuf:"varint,1,opt,name=id,proto3,casttype=int" json:"id" xml:"id"` + Folder string `protobuf:"bytes,2,opt,name=folder,proto3" json:"folder" xml:"folder"` + Name string `protobuf:"bytes,3,opt,name=name,proto3" json:"name" xml:"name"` + Offset int64 `protobuf:"varint,4,opt,name=offset,proto3" json:"offset" xml:"offset"` + Size int `protobuf:"varint,5,opt,name=size,proto3,casttype=int" json:"size" xml:"size"` + Hash []byte `protobuf:"bytes,6,opt,name=hash,proto3" json:"hash" xml:"hash"` + FromTemporary bool `protobuf:"varint,7,opt,name=from_temporary,json=fromTemporary,proto3" json:"fromTemporary" xml:"fromTemporary"` + WeakHash uint32 `protobuf:"varint,8,opt,name=weak_hash,json=weakHash,proto3" json:"weakHash" xml:"weakHash"` } func (m *Request) Reset() { *m = Request{} } @@ -706,9 +707,9 @@ func (m *Request) XXX_DiscardUnknown() { var xxx_messageInfo_Request proto.InternalMessageInfo type Response struct { - ID int32 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` - Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"` - Code ErrorCode `protobuf:"varint,3,opt,name=code,proto3,enum=protocol.ErrorCode" json:"code,omitempty"` + ID int `protobuf:"varint,1,opt,name=id,proto3,casttype=int" json:"id" xml:"id"` + Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data" xml:"data"` + Code ErrorCode `protobuf:"varint,3,opt,name=code,proto3,enum=protocol.ErrorCode" json:"code" xml:"code"` } func (m *Response) Reset() { *m = Response{} } @@ -745,8 +746,8 @@ func (m *Response) XXX_DiscardUnknown() { var xxx_messageInfo_Response proto.InternalMessageInfo type DownloadProgress struct { - Folder string `protobuf:"bytes,1,opt,name=folder,proto3" json:"folder,omitempty"` - Updates []FileDownloadProgressUpdate `protobuf:"bytes,2,rep,name=updates,proto3" json:"updates"` + Folder string `protobuf:"bytes,1,opt,name=folder,proto3" json:"folder" xml:"folder"` + Updates []FileDownloadProgressUpdate `protobuf:"bytes,2,rep,name=updates,proto3" json:"updates" xml:"update"` } func (m *DownloadProgress) Reset() { *m = DownloadProgress{} } @@ -783,11 +784,11 @@ func (m *DownloadProgress) XXX_DiscardUnknown() { var xxx_messageInfo_DownloadProgress proto.InternalMessageInfo type FileDownloadProgressUpdate struct { - UpdateType FileDownloadProgressUpdateType `protobuf:"varint,1,opt,name=update_type,json=updateType,proto3,enum=protocol.FileDownloadProgressUpdateType" json:"update_type,omitempty"` - Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` - Version Vector `protobuf:"bytes,3,opt,name=version,proto3" json:"version"` - BlockIndexes []int32 `protobuf:"varint,4,rep,name=block_indexes,json=blockIndexes,proto3" json:"block_indexes,omitempty"` - BlockSize int32 `protobuf:"varint,5,opt,name=block_size,json=blockSize,proto3" json:"block_size,omitempty"` + UpdateType FileDownloadProgressUpdateType `protobuf:"varint,1,opt,name=update_type,json=updateType,proto3,enum=protocol.FileDownloadProgressUpdateType" json:"updateType" xml:"updateType"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name" xml:"name"` + Version Vector `protobuf:"bytes,3,opt,name=version,proto3" json:"version" xml:"version"` + BlockIndexes []int `protobuf:"varint,4,rep,name=block_indexes,json=blockIndexes,proto3,casttype=int" json:"blockIndexes" xml:"blockIndexe"` + BlockSize int `protobuf:"varint,5,opt,name=block_size,json=blockSize,proto3,casttype=int" json:"blockSize" xml:"blockSize"` } func (m *FileDownloadProgressUpdate) Reset() { *m = FileDownloadProgressUpdate{} } @@ -860,7 +861,7 @@ func (m *Ping) XXX_DiscardUnknown() { var xxx_messageInfo_Ping proto.InternalMessageInfo type Close struct { - Reason string `protobuf:"bytes,1,opt,name=reason,proto3" json:"reason,omitempty"` + Reason string `protobuf:"bytes,1,opt,name=reason,proto3" json:"reason" xml:"reason"` } func (m *Close) Reset() { *m = Close{} } @@ -925,123 +926,169 @@ func init() { func init() { proto.RegisterFile("lib/protocol/bep.proto", fileDescriptor_311ef540e10d9705) } var fileDescriptor_311ef540e10d9705 = []byte{ - // 1846 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x56, 0xcf, 0x73, 0xdb, 0xc6, - 0xf5, 0x27, 0x48, 0xf0, 0xd7, 0x23, 0xa5, 0x40, 0x6b, 0x5b, 0x5f, 0x7c, 0x61, 0x9b, 0x84, 0x69, - 0x3b, 0x66, 0x34, 0xa9, 0xed, 0x26, 0x69, 0x3b, 0xed, 0xb4, 0x9d, 0xe1, 0x0f, 0x48, 0xe6, 0x54, - 0x26, 0xd5, 0x25, 0xe5, 0xd4, 0x39, 0x14, 0x03, 0x12, 0x4b, 0x09, 0x63, 0x10, 0xcb, 0x02, 0xa0, - 0x64, 0xe6, 0x4f, 0xe0, 0xa9, 0xc7, 0x5e, 0x38, 0x93, 0x99, 0x9c, 0xfa, 0x9f, 0xf8, 0xe8, 0xf6, - 0xd4, 0xe9, 0x41, 0xd3, 0xc8, 0x97, 0xf4, 0xd6, 0x4b, 0xaf, 0x9d, 0xce, 0xee, 0x02, 0x24, 0x28, - 0xc5, 0x99, 0x1c, 0x7a, 0xdb, 0x7d, 0xef, 0xb3, 0x6f, 0xf7, 0x7d, 0xf6, 0xbd, 0xcf, 0x2e, 0xec, - 0xba, 0xce, 0xf0, 0xc9, 0xd4, 0xa7, 0x21, 0x1d, 0x51, 0xf7, 0xc9, 0x90, 0x4c, 0x1f, 0xf3, 0x09, - 0x2a, 0xc4, 0x36, 0xed, 0xbe, 0x4f, 0xa6, 0x34, 0x10, 0x98, 0xe1, 0x6c, 0xfc, 0xe4, 0x84, 0x9e, - 0x50, 0x3e, 0xe1, 0x23, 0x01, 0xaf, 0x4d, 0x21, 0xfb, 0x8c, 0xb8, 0x2e, 0x45, 0x55, 0x28, 0xd9, - 0xe4, 0xcc, 0x19, 0x11, 0xd3, 0xb3, 0x26, 0x44, 0x95, 0x74, 0xa9, 0x5e, 0xc4, 0x20, 0x4c, 0x5d, - 0x6b, 0x42, 0x18, 0x60, 0xe4, 0x3a, 0xc4, 0x0b, 0x05, 0x20, 0x2d, 0x00, 0xc2, 0xc4, 0x01, 0x0f, - 0x61, 0x3b, 0x02, 0x9c, 0x11, 0x3f, 0x70, 0xa8, 0xa7, 0x66, 0x38, 0x66, 0x4b, 0x58, 0x5f, 0x08, - 0x63, 0x2d, 0x80, 0xdc, 0x33, 0x62, 0xd9, 0xc4, 0x47, 0x1f, 0x81, 0x1c, 0xce, 0xa7, 0x62, 0xaf, - 0xed, 0x4f, 0x6e, 0x3d, 0x8e, 0x4f, 0xfe, 0xf8, 0x39, 0x09, 0x02, 0xeb, 0x84, 0x0c, 0xe6, 0x53, - 0x82, 0x39, 0x04, 0xfd, 0x1a, 0x4a, 0x23, 0x3a, 0x99, 0xfa, 0x24, 0xe0, 0x81, 0xd3, 0x7c, 0xc5, - 0x9d, 0x6b, 0x2b, 0x5a, 0x6b, 0x0c, 0x4e, 0x2e, 0xa8, 0x35, 0x60, 0xab, 0xe5, 0xce, 0x82, 0x90, - 0xf8, 0x2d, 0xea, 0x8d, 0x9d, 0x13, 0xf4, 0x14, 0xf2, 0x63, 0xea, 0xda, 0xc4, 0x0f, 0x54, 0x49, - 0xcf, 0xd4, 0x4b, 0x9f, 0x28, 0xeb, 0x60, 0xfb, 0xdc, 0xd1, 0x94, 0xdf, 0x5c, 0x54, 0x53, 0x38, - 0x86, 0xd5, 0xbe, 0x4e, 0x43, 0x4e, 0x78, 0xd0, 0x2e, 0xa4, 0x1d, 0x5b, 0x50, 0xd4, 0xcc, 0x5d, - 0x5e, 0x54, 0xd3, 0x9d, 0x36, 0x4e, 0x3b, 0x36, 0xba, 0x09, 0x59, 0xd7, 0x1a, 0x12, 0x37, 0x22, - 0x47, 0x4c, 0xd0, 0x6d, 0x28, 0xfa, 0xc4, 0xb2, 0x4d, 0xea, 0xb9, 0x73, 0x4e, 0x49, 0x01, 0x17, - 0x98, 0xa1, 0xe7, 0xb9, 0x73, 0xf4, 0x23, 0x40, 0xce, 0x89, 0x47, 0x7d, 0x62, 0x4e, 0x89, 0x3f, - 0x71, 0xf8, 0x69, 0x03, 0x55, 0xe6, 0xa8, 0x1d, 0xe1, 0x39, 0x5a, 0x3b, 0xd0, 0x7d, 0xd8, 0x8a, - 0xe0, 0x36, 0x71, 0x49, 0x48, 0xd4, 0x2c, 0x47, 0x96, 0x85, 0xb1, 0xcd, 0x6d, 0xe8, 0x29, 0xdc, - 0xb4, 0x9d, 0xc0, 0x1a, 0xba, 0xc4, 0x0c, 0xc9, 0x64, 0x6a, 0x3a, 0x9e, 0x4d, 0x5e, 0x93, 0x40, - 0xcd, 0x71, 0x2c, 0x8a, 0x7c, 0x03, 0x32, 0x99, 0x76, 0x84, 0x07, 0xed, 0x42, 0x6e, 0x6a, 0xcd, - 0x02, 0x62, 0xab, 0x79, 0x8e, 0x89, 0x66, 0x8c, 0x25, 0x51, 0x01, 0x81, 0xaa, 0x5c, 0x65, 0xa9, - 0xcd, 0x1d, 0x31, 0x4b, 0x11, 0xac, 0xf6, 0xaf, 0x34, 0xe4, 0x84, 0x07, 0x7d, 0xb8, 0x62, 0xa9, - 0xdc, 0xdc, 0x65, 0xa8, 0xbf, 0x5f, 0x54, 0x0b, 0xc2, 0xd7, 0x69, 0x27, 0x58, 0x43, 0x20, 0x27, - 0x2a, 0x8a, 0x8f, 0xd1, 0x1d, 0x28, 0x5a, 0xb6, 0xcd, 0x6e, 0x8f, 0x04, 0x6a, 0x46, 0xcf, 0xd4, - 0x8b, 0x78, 0x6d, 0x40, 0x3f, 0xdb, 0xac, 0x06, 0xf9, 0x6a, 0xfd, 0xbc, 0xaf, 0x0c, 0xd8, 0x55, - 0x8c, 0x88, 0x1f, 0x55, 0x70, 0x96, 0xef, 0x57, 0x60, 0x06, 0x5e, 0xbf, 0xf7, 0xa0, 0x3c, 0xb1, - 0x5e, 0x9b, 0x01, 0xf9, 0xc3, 0x8c, 0x78, 0x23, 0xc2, 0xe9, 0xca, 0xe0, 0xd2, 0xc4, 0x7a, 0xdd, - 0x8f, 0x4c, 0xa8, 0x02, 0xe0, 0x78, 0xa1, 0x4f, 0xed, 0xd9, 0x88, 0xf8, 0x11, 0x57, 0x09, 0x0b, - 0xfa, 0x09, 0x14, 0x38, 0xd9, 0xa6, 0x63, 0xab, 0x05, 0x5d, 0xaa, 0xcb, 0x4d, 0x2d, 0x4a, 0x3c, - 0xcf, 0xa9, 0xe6, 0x79, 0xc7, 0x43, 0x9c, 0xe7, 0xd8, 0x8e, 0x8d, 0x7e, 0x09, 0x5a, 0xf0, 0xca, - 0x61, 0x17, 0x25, 0x22, 0x85, 0x0e, 0xf5, 0x4c, 0x9f, 0x4c, 0xe8, 0x99, 0xe5, 0x06, 0x6a, 0x91, - 0x6f, 0xa3, 0x32, 0x44, 0x27, 0x01, 0xc0, 0x91, 0xbf, 0xd6, 0x83, 0x2c, 0x8f, 0xc8, 0x6e, 0x51, - 0x14, 0x6b, 0xd4, 0xbd, 0xd1, 0x0c, 0x3d, 0x86, 0xec, 0xd8, 0x71, 0x49, 0xa0, 0xa6, 0xf9, 0x1d, - 0xa2, 0x44, 0xa5, 0x3b, 0x2e, 0xe9, 0x78, 0x63, 0x1a, 0xdd, 0xa2, 0x80, 0xd5, 0x8e, 0xa1, 0xc4, - 0x03, 0x1e, 0x4f, 0x6d, 0x2b, 0x24, 0xff, 0xb3, 0xb0, 0x5f, 0x67, 0xa1, 0x10, 0x7b, 0x56, 0x97, - 0x2e, 0x25, 0x2e, 0x1d, 0x81, 0x1c, 0x38, 0x5f, 0x12, 0xde, 0x23, 0x19, 0xcc, 0xc7, 0xe8, 0x2e, - 0xc0, 0x84, 0xda, 0xce, 0xd8, 0x21, 0xb6, 0x19, 0xf0, 0x2b, 0xcb, 0xe0, 0x62, 0x6c, 0xe9, 0xa3, - 0xa7, 0x50, 0x5a, 0xb9, 0x87, 0x73, 0xb5, 0xcc, 0x39, 0xff, 0x20, 0xe6, 0xbc, 0x7f, 0x4a, 0xfd, - 0xb0, 0xd3, 0xc6, 0xab, 0x10, 0xcd, 0x39, 0x2b, 0xe9, 0x58, 0x9e, 0x18, 0xb1, 0x1b, 0x25, 0xfd, - 0x82, 0x8c, 0x42, 0xba, 0x6a, 0xfc, 0x08, 0x86, 0x34, 0x28, 0xac, 0x6a, 0x02, 0xf8, 0x01, 0x56, - 0x73, 0xf4, 0x63, 0xc8, 0x0d, 0x5d, 0x3a, 0x7a, 0x15, 0xf7, 0xc7, 0x8d, 0x75, 0xb0, 0x26, 0xb3, - 0x27, 0x58, 0x88, 0x80, 0x4c, 0x26, 0x83, 0xf9, 0xc4, 0x75, 0xbc, 0x57, 0x66, 0x68, 0xf9, 0x27, - 0x24, 0x54, 0x77, 0x84, 0x4c, 0x46, 0xd6, 0x01, 0x37, 0x32, 0xb9, 0x15, 0x0b, 0xcc, 0x53, 0x2b, - 0x38, 0x55, 0x11, 0x6b, 0x23, 0x0c, 0xc2, 0xf4, 0xcc, 0x0a, 0x4e, 0xd1, 0x5e, 0xa4, 0x9e, 0x42, - 0x0b, 0x77, 0xaf, 0xb3, 0x9f, 0x90, 0x4f, 0x1d, 0x4a, 0x57, 0xe5, 0x65, 0x0b, 0x27, 0x4d, 0x6c, - 0xbb, 0x15, 0x91, 0x5e, 0xa0, 0x96, 0x74, 0xa9, 0x9e, 0x5d, 0xf3, 0xd6, 0x0d, 0xd0, 0x13, 0x10, - 0x9b, 0x9b, 0xfc, 0x8a, 0xb6, 0x98, 0xbf, 0xa9, 0x5c, 0x5e, 0x54, 0xcb, 0xd8, 0x3a, 0xe7, 0xa9, - 0xf6, 0x9d, 0x2f, 0x09, 0x2e, 0x0e, 0xe3, 0x21, 0xdb, 0xd3, 0xa5, 0x23, 0xcb, 0x35, 0xc7, 0xae, - 0x75, 0x12, 0xa8, 0xdf, 0xe6, 0xf9, 0xa6, 0xc0, 0x6d, 0xfb, 0xcc, 0x84, 0x6a, 0x50, 0x8e, 0x38, - 0x16, 0x39, 0xfe, 0x33, 0xcf, 0x93, 0x2c, 0x45, 0x46, 0x9e, 0xa5, 0xca, 0x14, 0x88, 0xa9, 0x9a, - 0x1d, 0xc9, 0x57, 0x3c, 0x45, 0x75, 0xc8, 0x3b, 0xde, 0x99, 0xe5, 0x3a, 0x91, 0x68, 0x35, 0xb7, - 0x2f, 0x2f, 0xaa, 0x80, 0xad, 0xf3, 0x8e, 0xb0, 0xe2, 0xd8, 0xcd, 0x18, 0xf7, 0xe8, 0x86, 0xbe, - 0x16, 0x78, 0xa8, 0x2d, 0x8f, 0x26, 0xb4, 0xf5, 0x17, 0xf2, 0x9f, 0xbe, 0xaa, 0xa6, 0x6a, 0x1e, - 0x14, 0x57, 0x37, 0xc7, 0x2a, 0x92, 0x9f, 0x2c, 0xc3, 0x0f, 0xc6, 0xc7, 0xac, 0x1d, 0xe8, 0x78, - 0x1c, 0x90, 0x90, 0xd7, 0x6e, 0x06, 0x47, 0xb3, 0x55, 0xf5, 0xa6, 0x39, 0x75, 0xa2, 0x7a, 0x6f, - 0x43, 0xf1, 0x9c, 0x58, 0xaf, 0x44, 0x7a, 0x82, 0xf5, 0x02, 0x33, 0xb0, 0xd4, 0xa2, 0xfd, 0x7e, - 0x05, 0x39, 0x51, 0x76, 0xe8, 0x53, 0x28, 0x8c, 0xe8, 0xcc, 0x0b, 0xd7, 0x6f, 0xd2, 0x4e, 0x52, - 0xd2, 0xb8, 0x27, 0xaa, 0xa5, 0x15, 0xb0, 0xb6, 0x0f, 0xf9, 0xc8, 0x85, 0x1e, 0xae, 0xf4, 0x56, - 0x6e, 0xde, 0xba, 0xd2, 0x02, 0x9b, 0x8f, 0xd4, 0x99, 0xe5, 0xce, 0xc4, 0x41, 0x65, 0x2c, 0x26, - 0xb5, 0xbf, 0x48, 0x90, 0xc7, 0xac, 0xaa, 0x83, 0x30, 0xf1, 0xbc, 0x65, 0x37, 0x9e, 0xb7, 0xb5, - 0x10, 0xa4, 0x37, 0x84, 0x20, 0xee, 0xe5, 0x4c, 0xa2, 0x97, 0xd7, 0x2c, 0xc9, 0xdf, 0xc9, 0x52, - 0x36, 0xc1, 0x52, 0xcc, 0x72, 0x2e, 0xc1, 0xf2, 0x43, 0xd8, 0x1e, 0xfb, 0x74, 0xc2, 0x1f, 0x30, - 0xea, 0x5b, 0xfe, 0x3c, 0x52, 0xdb, 0x2d, 0x66, 0x1d, 0xc4, 0xc6, 0x4d, 0x82, 0x0b, 0x9b, 0x04, - 0xd7, 0x4c, 0x28, 0x60, 0x12, 0x4c, 0xa9, 0x17, 0x90, 0xf7, 0xe6, 0x84, 0x40, 0xb6, 0xad, 0xd0, - 0xe2, 0x19, 0x95, 0x31, 0x1f, 0xa3, 0x47, 0x20, 0x8f, 0xa8, 0x2d, 0xf2, 0xd9, 0x4e, 0xb6, 0xb4, - 0xe1, 0xfb, 0xd4, 0x6f, 0x51, 0x9b, 0x60, 0x0e, 0xa8, 0x4d, 0x41, 0x69, 0xd3, 0x73, 0xcf, 0xa5, - 0x96, 0x7d, 0xe4, 0xd3, 0x13, 0xf6, 0xca, 0xbc, 0x57, 0x2d, 0xdb, 0x90, 0x9f, 0x71, 0x3d, 0x8d, - 0xf5, 0xf2, 0xc1, 0x66, 0xc7, 0x5e, 0x0d, 0x24, 0xc4, 0x37, 0xd6, 0xa2, 0x68, 0x69, 0xed, 0xdf, - 0x12, 0x68, 0xef, 0x47, 0xa3, 0x0e, 0x94, 0x04, 0xd2, 0x4c, 0x7c, 0xac, 0xea, 0x3f, 0x64, 0x23, - 0x2e, 0x16, 0x30, 0x5b, 0x8d, 0xbf, 0xf3, 0x55, 0x4e, 0x68, 0x67, 0xe6, 0x87, 0x69, 0xe7, 0x23, - 0xd8, 0x12, 0xaa, 0x11, 0xff, 0x41, 0x64, 0x3d, 0x53, 0xcf, 0x36, 0xd3, 0x4a, 0x0a, 0x97, 0x87, - 0xa2, 0xcd, 0xc4, 0x0f, 0xe4, 0xee, 0x86, 0xbc, 0x88, 0xea, 0x58, 0x8b, 0x49, 0x2d, 0x07, 0xf2, - 0x91, 0xe3, 0x9d, 0xd4, 0xaa, 0x90, 0x6d, 0xb9, 0x94, 0xdf, 0x67, 0xce, 0x27, 0x56, 0x40, 0xbd, - 0x98, 0x66, 0x31, 0xdb, 0xfb, 0x6b, 0x1a, 0x4a, 0x89, 0xef, 0x23, 0x7a, 0x0a, 0xdb, 0xad, 0xc3, - 0xe3, 0xfe, 0xc0, 0xc0, 0x66, 0xab, 0xd7, 0xdd, 0xef, 0x1c, 0x28, 0x29, 0xed, 0xce, 0x62, 0xa9, - 0xab, 0x93, 0x35, 0x68, 0xf3, 0x67, 0x58, 0x85, 0x6c, 0xa7, 0xdb, 0x36, 0x7e, 0xa7, 0x48, 0xda, - 0xcd, 0xc5, 0x52, 0x57, 0x12, 0x40, 0xf1, 0xcc, 0x7e, 0x0c, 0x65, 0x0e, 0x30, 0x8f, 0x8f, 0xda, - 0x8d, 0x81, 0xa1, 0xa4, 0x35, 0x6d, 0xb1, 0xd4, 0x77, 0xaf, 0xe2, 0xa2, 0x2b, 0xb9, 0x0f, 0x79, - 0x6c, 0xfc, 0xf6, 0xd8, 0xe8, 0x0f, 0x94, 0x8c, 0xb6, 0xbb, 0x58, 0xea, 0x28, 0x01, 0x8c, 0x3b, - 0xee, 0x21, 0x14, 0xb0, 0xd1, 0x3f, 0xea, 0x75, 0xfb, 0x86, 0x22, 0x6b, 0xff, 0xb7, 0x58, 0xea, - 0x37, 0x36, 0x50, 0x51, 0x11, 0xff, 0x14, 0x76, 0xda, 0xbd, 0xcf, 0xbb, 0x87, 0xbd, 0x46, 0xdb, - 0x3c, 0xc2, 0xbd, 0x03, 0x6c, 0xf4, 0xfb, 0x4a, 0x56, 0xab, 0x2e, 0x96, 0xfa, 0xed, 0x04, 0xfe, - 0x5a, 0x4d, 0xde, 0x05, 0xf9, 0xa8, 0xd3, 0x3d, 0x50, 0x72, 0xda, 0x8d, 0xc5, 0x52, 0xff, 0x20, - 0x01, 0x65, 0xa4, 0xb2, 0x8c, 0x5b, 0x87, 0xbd, 0xbe, 0xa1, 0xe4, 0xaf, 0x65, 0xcc, 0xc9, 0xde, - 0xfb, 0x3d, 0xa0, 0xeb, 0x1f, 0x6c, 0xf4, 0x00, 0xe4, 0x6e, 0xaf, 0x6b, 0x28, 0x29, 0x91, 0xff, - 0x75, 0x44, 0x97, 0x7a, 0x04, 0xd5, 0x20, 0x73, 0xf8, 0xc5, 0x67, 0x8a, 0xa4, 0xfd, 0xff, 0x62, - 0xa9, 0xdf, 0xba, 0x0e, 0x3a, 0xfc, 0xe2, 0xb3, 0x3d, 0x0a, 0xa5, 0x64, 0xe0, 0x1a, 0x14, 0x9e, - 0x1b, 0x83, 0x46, 0xbb, 0x31, 0x68, 0x28, 0x29, 0x71, 0xa4, 0xd8, 0xfd, 0x9c, 0x84, 0x16, 0xef, - 0xd1, 0x3b, 0x90, 0xed, 0x1a, 0x2f, 0x0c, 0xac, 0x48, 0xda, 0xce, 0x62, 0xa9, 0x6f, 0xc5, 0x80, - 0x2e, 0x39, 0x23, 0x3e, 0xaa, 0x40, 0xae, 0x71, 0xf8, 0x79, 0xe3, 0x65, 0x5f, 0x49, 0x6b, 0x68, - 0xb1, 0xd4, 0xb7, 0x63, 0x77, 0xc3, 0x3d, 0xb7, 0xe6, 0xc1, 0xde, 0x7f, 0x24, 0x28, 0x27, 0x9f, - 0x49, 0x54, 0x01, 0x79, 0xbf, 0x73, 0x68, 0xc4, 0xdb, 0x25, 0x7d, 0x6c, 0x8c, 0xea, 0x50, 0x6c, - 0x77, 0xb0, 0xd1, 0x1a, 0xf4, 0xf0, 0xcb, 0x38, 0x97, 0x24, 0xa8, 0xed, 0xf8, 0xbc, 0xfe, 0xe7, - 0xe8, 0xe7, 0x50, 0xee, 0xbf, 0x7c, 0x7e, 0xd8, 0xe9, 0xfe, 0xc6, 0xe4, 0x11, 0xd3, 0xda, 0xa3, - 0xc5, 0x52, 0xbf, 0xb7, 0x01, 0x26, 0x53, 0x9f, 0x8c, 0xac, 0x90, 0xd8, 0x7d, 0xf1, 0xe4, 0x33, - 0x67, 0x41, 0x42, 0x2d, 0xd8, 0x89, 0x97, 0xae, 0x37, 0xcb, 0x68, 0x1f, 0x2f, 0x96, 0xfa, 0x87, - 0xdf, 0xbb, 0x7e, 0xb5, 0x7b, 0x41, 0x42, 0x0f, 0x20, 0x1f, 0x05, 0x89, 0x2b, 0x29, 0xb9, 0x34, - 0x5a, 0xb0, 0xf7, 0x67, 0x09, 0x8a, 0x2b, 0x35, 0x63, 0x84, 0x77, 0x7b, 0xa6, 0x81, 0x71, 0x0f, - 0xc7, 0x0c, 0xac, 0x9c, 0x5d, 0xca, 0x87, 0xe8, 0x1e, 0xe4, 0x0f, 0x8c, 0xae, 0x81, 0x3b, 0xad, - 0xb8, 0x31, 0x56, 0x90, 0x03, 0xe2, 0x11, 0xdf, 0x19, 0xa1, 0x8f, 0xa0, 0xdc, 0xed, 0x99, 0xfd, - 0xe3, 0xd6, 0xb3, 0x38, 0x75, 0xbe, 0x7f, 0x22, 0x54, 0x7f, 0x36, 0x3a, 0xe5, 0x7c, 0xee, 0xb1, - 0x1e, 0x7a, 0xd1, 0x38, 0xec, 0xb4, 0x05, 0x34, 0xa3, 0xa9, 0x8b, 0xa5, 0x7e, 0x73, 0x05, 0x8d, - 0xde, 0x70, 0x86, 0xdd, 0xb3, 0xa1, 0xf2, 0xfd, 0xba, 0x85, 0x74, 0xc8, 0x35, 0x8e, 0x8e, 0x8c, - 0x6e, 0x3b, 0x3e, 0xfd, 0xda, 0xd7, 0x98, 0x4e, 0x89, 0x67, 0x33, 0xc4, 0x7e, 0x0f, 0x1f, 0x18, - 0x83, 0xf8, 0xf0, 0x6b, 0xc4, 0x3e, 0x65, 0xff, 0xad, 0x66, 0xfd, 0xcd, 0x37, 0x95, 0xd4, 0xdb, - 0x6f, 0x2a, 0xa9, 0x37, 0x97, 0x15, 0xe9, 0xed, 0x65, 0x45, 0xfa, 0xc7, 0x65, 0x25, 0xf5, 0xed, - 0x65, 0x45, 0xfa, 0xe3, 0xbb, 0x4a, 0xea, 0xab, 0x77, 0x15, 0xe9, 0xed, 0xbb, 0x4a, 0xea, 0x6f, - 0xef, 0x2a, 0xa9, 0x61, 0x8e, 0x6b, 0xde, 0xa7, 0xff, 0x0d, 0x00, 0x00, 0xff, 0xff, 0xc7, 0x7a, - 0xfc, 0x00, 0x82, 0x0f, 0x00, 0x00, + // 2584 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x59, 0x4d, 0x6c, 0xe3, 0xc6, + 0xf5, 0x17, 0xf5, 0x61, 0xcb, 0x63, 0x7b, 0x23, 0xcf, 0x7e, 0x29, 0xda, 0x8d, 0xa8, 0xff, 0xfc, + 0x37, 0xad, 0xe3, 0x34, 0xde, 0xc4, 0x49, 0xda, 0x34, 0x49, 0x13, 0xe8, 0x83, 0xb6, 0x95, 0xd8, + 0x92, 0x3b, 0xf2, 0x6e, 0xba, 0x8b, 0x16, 0x04, 0x2d, 0x8e, 0x6d, 0x62, 0x29, 0x52, 0x25, 0x65, + 0xef, 0x3a, 0xe8, 0xa9, 0xbd, 0x04, 0x3a, 0x14, 0x45, 0x4e, 0x45, 0x51, 0xa1, 0x69, 0x2f, 0xbd, + 0x15, 0xe8, 0xa1, 0x97, 0xdc, 0x7a, 0x29, 0x72, 0x5c, 0x04, 0x28, 0x50, 0xf4, 0x40, 0x20, 0xbb, + 0x97, 0x56, 0x47, 0x1d, 0x7b, 0x2a, 0xe6, 0x83, 0xe4, 0xd0, 0xb2, 0x03, 0x27, 0x39, 0xf4, 0xc6, + 0xf7, 0x7b, 0x1f, 0x1c, 0xce, 0xfb, 0xbd, 0x37, 0x6f, 0x24, 0x70, 0xcd, 0xb6, 0xf6, 0x6e, 0xf7, + 0x3d, 0x77, 0xe0, 0x76, 0x5d, 0xfb, 0xf6, 0x1e, 0xe9, 0xaf, 0x32, 0x01, 0xe6, 0x43, 0xac, 0x34, + 0x47, 0x1e, 0x0d, 0x38, 0x58, 0xfa, 0x7f, 0x8f, 0xf4, 0x5d, 0x9f, 0x9b, 0xef, 0x1d, 0xed, 0xdf, + 0x3e, 0x70, 0x0f, 0x5c, 0x26, 0xb0, 0x27, 0x6e, 0x84, 0x9e, 0x28, 0x20, 0xb7, 0x49, 0x6c, 0xdb, + 0x85, 0x75, 0x30, 0x6f, 0x92, 0x63, 0xab, 0x4b, 0x74, 0xc7, 0xe8, 0x91, 0xa2, 0x52, 0x51, 0x96, + 0xe7, 0x6a, 0x68, 0x1c, 0xa8, 0x80, 0xc3, 0x2d, 0xa3, 0x47, 0x26, 0x81, 0x5a, 0x78, 0xd4, 0xb3, + 0xdf, 0x44, 0x31, 0x84, 0xb0, 0xa4, 0xa7, 0x41, 0xba, 0xb6, 0x45, 0x9c, 0x01, 0x0f, 0x92, 0x8e, + 0x83, 0x70, 0x38, 0x11, 0x24, 0x86, 0x10, 0x96, 0xf4, 0xb0, 0x0d, 0x2e, 0x89, 0x20, 0xc7, 0xc4, + 0xf3, 0x2d, 0xd7, 0x29, 0x66, 0x58, 0x9c, 0xe5, 0x71, 0xa0, 0x2e, 0x72, 0xcd, 0x5d, 0xae, 0x98, + 0x04, 0xea, 0x65, 0x29, 0x94, 0x40, 0x11, 0x4e, 0x5a, 0xa1, 0x3f, 0x2b, 0x60, 0x66, 0x93, 0x18, + 0x26, 0xf1, 0x60, 0x15, 0x64, 0x07, 0x27, 0x7d, 0xfe, 0x79, 0x97, 0xd6, 0xae, 0xae, 0x86, 0x1b, + 0xb7, 0xba, 0x4d, 0x7c, 0xdf, 0x38, 0x20, 0xbb, 0x27, 0x7d, 0x52, 0xbb, 0x36, 0x0e, 0x54, 0x66, + 0x36, 0x09, 0x54, 0xc0, 0xe2, 0x53, 0x01, 0x61, 0x86, 0x41, 0x13, 0xcc, 0x77, 0xdd, 0x5e, 0xdf, + 0x23, 0x3e, 0x5b, 0x5b, 0x9a, 0x45, 0xba, 0x39, 0x15, 0xa9, 0x1e, 0xdb, 0xd4, 0x6e, 0x8d, 0x03, + 0x55, 0x76, 0x9a, 0x04, 0xea, 0x12, 0x5f, 0x77, 0x8c, 0x21, 0x2c, 0x5b, 0xa0, 0x1f, 0x83, 0xc5, + 0xba, 0x7d, 0xe4, 0x0f, 0x88, 0x57, 0x77, 0x9d, 0x7d, 0xeb, 0x00, 0xbe, 0x0f, 0x66, 0xf7, 0x5d, + 0xdb, 0x24, 0x9e, 0x5f, 0x54, 0x2a, 0x99, 0xe5, 0xf9, 0xb5, 0x42, 0xfc, 0xca, 0x75, 0xa6, 0xa8, + 0xa9, 0x9f, 0x05, 0x6a, 0x6a, 0x1c, 0xa8, 0xa1, 0xe1, 0x24, 0x50, 0x17, 0xd8, 0x6b, 0xb8, 0x8c, + 0x70, 0xa8, 0x40, 0x9f, 0x66, 0xc1, 0x0c, 0x77, 0x82, 0xab, 0x20, 0x6d, 0x99, 0x22, 0xdd, 0xe5, + 0x27, 0x81, 0x9a, 0x6e, 0x36, 0xc6, 0x81, 0x9a, 0xb6, 0xcc, 0x49, 0xa0, 0xe6, 0x99, 0xb7, 0x65, + 0xa2, 0x8f, 0x1f, 0xdf, 0x4a, 0x37, 0x1b, 0x38, 0x6d, 0x99, 0x70, 0x15, 0xe4, 0x6c, 0x63, 0x8f, + 0xd8, 0x22, 0xb9, 0xc5, 0x71, 0xa0, 0x72, 0x60, 0x12, 0xa8, 0xf3, 0xcc, 0x9e, 0x49, 0x08, 0x73, + 0x14, 0xbe, 0x05, 0xe6, 0x3c, 0x62, 0x98, 0xba, 0xeb, 0xd8, 0x27, 0x2c, 0x91, 0xf9, 0x5a, 0x79, + 0x1c, 0xa8, 0x79, 0x0a, 0xb6, 0x1d, 0xfb, 0x64, 0x12, 0xa8, 0x97, 0x98, 0x5b, 0x08, 0x20, 0x1c, + 0xe9, 0xa0, 0x0e, 0xa0, 0x75, 0xe0, 0xb8, 0x1e, 0xd1, 0xfb, 0xc4, 0xeb, 0x59, 0x6c, 0x6b, 0xfc, + 0x62, 0x96, 0x45, 0x79, 0x79, 0x1c, 0xa8, 0x4b, 0x5c, 0xbb, 0x13, 0x2b, 0x27, 0x81, 0x7a, 0x9d, + 0xaf, 0xfa, 0xb4, 0x06, 0xe1, 0x69, 0x6b, 0xf8, 0x3e, 0x58, 0x14, 0x2f, 0x30, 0x89, 0x4d, 0x06, + 0xa4, 0x98, 0x63, 0xb1, 0xbf, 0x35, 0x0e, 0xd4, 0x05, 0xae, 0x68, 0x30, 0x7c, 0x12, 0xa8, 0x50, + 0x0a, 0xcb, 0x41, 0x84, 0x13, 0x36, 0xd0, 0x04, 0x57, 0x4c, 0xcb, 0x37, 0xf6, 0x6c, 0xa2, 0x0f, + 0x48, 0xaf, 0xaf, 0x5b, 0x8e, 0x49, 0x1e, 0x11, 0xbf, 0x38, 0xc3, 0x62, 0xae, 0x8d, 0x03, 0x15, + 0x0a, 0xfd, 0x2e, 0xe9, 0xf5, 0x9b, 0x5c, 0x3b, 0x09, 0xd4, 0x22, 0xaf, 0xa9, 0x29, 0x15, 0xc2, + 0x67, 0xd8, 0xc3, 0x35, 0x30, 0xd3, 0x37, 0x8e, 0x7c, 0x62, 0x16, 0x67, 0x59, 0xdc, 0xd2, 0x38, + 0x50, 0x05, 0x12, 0x25, 0x9c, 0x8b, 0x08, 0x0b, 0x9c, 0x92, 0x87, 0x57, 0xa9, 0x5f, 0x2c, 0x9c, + 0x26, 0x4f, 0x83, 0x29, 0x62, 0xf2, 0x08, 0xc3, 0x28, 0x16, 0x97, 0x11, 0x0e, 0x15, 0xe8, 0x6f, + 0x39, 0x30, 0xc3, 0x9d, 0x60, 0x2d, 0x22, 0xcf, 0x42, 0x6d, 0x8d, 0x06, 0xf8, 0x67, 0xa0, 0xe6, + 0xb9, 0xae, 0xd9, 0x38, 0x8f, 0x4c, 0x1f, 0x3d, 0xbe, 0xa5, 0x48, 0x84, 0x5a, 0x01, 0x59, 0xa9, + 0x59, 0xb0, 0xda, 0x73, 0x78, 0x9b, 0xe0, 0xb5, 0xe7, 0xb0, 0x06, 0xc1, 0x30, 0xf8, 0x36, 0x98, + 0x33, 0x4c, 0x93, 0xd6, 0x08, 0xf1, 0x8b, 0x99, 0x4a, 0x86, 0x72, 0x76, 0x1c, 0xa8, 0x31, 0x38, + 0x09, 0xd4, 0x45, 0xe6, 0x25, 0x10, 0x84, 0x63, 0x1d, 0xfc, 0x49, 0xb2, 0x72, 0xb3, 0xa7, 0x7b, + 0xc0, 0x37, 0x2b, 0x59, 0xca, 0xf4, 0x2e, 0xf1, 0x44, 0xeb, 0xcb, 0xf1, 0x82, 0xa2, 0x4c, 0xa7, + 0xa0, 0x68, 0x7c, 0x9c, 0xe9, 0x21, 0x80, 0x70, 0xa4, 0x83, 0x1b, 0x60, 0xa1, 0x67, 0x3c, 0xd2, + 0x7d, 0xf2, 0xd3, 0x23, 0xe2, 0x74, 0x09, 0xe3, 0x4c, 0x86, 0xaf, 0xa2, 0x67, 0x3c, 0xea, 0x08, + 0x38, 0x5a, 0x85, 0x84, 0x21, 0x2c, 0x5b, 0xc0, 0x1a, 0x00, 0x96, 0x33, 0xf0, 0x5c, 0xf3, 0xa8, + 0x4b, 0x3c, 0x41, 0x11, 0xd6, 0x81, 0x63, 0x34, 0xea, 0xc0, 0x31, 0x84, 0xb0, 0xa4, 0x87, 0x07, + 0x20, 0xcf, 0xb8, 0xab, 0x5b, 0x66, 0x31, 0x5f, 0x51, 0x96, 0xb3, 0xb5, 0x2d, 0x91, 0xdc, 0x59, + 0xc6, 0x42, 0x96, 0xdb, 0xf0, 0x91, 0x72, 0x86, 0x59, 0x37, 0xcd, 0x68, 0xf7, 0x85, 0x4c, 0xfb, + 0x46, 0x68, 0xf6, 0x9b, 0xf8, 0x11, 0x87, 0xf6, 0xf0, 0x67, 0xa0, 0xe4, 0x3f, 0xb0, 0x68, 0xa5, + 0xf0, 0x77, 0x0f, 0x2c, 0xd7, 0xd1, 0x3d, 0xd2, 0x73, 0x8f, 0x0d, 0xdb, 0x2f, 0xce, 0xb1, 0xc5, + 0xbf, 0x33, 0x0e, 0xd4, 0x22, 0xb5, 0x6a, 0x4a, 0x46, 0x58, 0xd8, 0x4c, 0x02, 0xb5, 0xcc, 0xde, + 0x78, 0x9e, 0x01, 0xc2, 0xe7, 0xfa, 0xa2, 0x9f, 0x2b, 0x20, 0xc7, 0x96, 0x44, 0x6b, 0x8a, 0xb7, + 0x46, 0xd1, 0x08, 0x59, 0x4d, 0x71, 0x64, 0xaa, 0x89, 0x0a, 0x1c, 0x6a, 0x20, 0xb7, 0x6f, 0xd9, + 0xc4, 0x2f, 0xa6, 0x59, 0x45, 0x41, 0xa9, 0x1d, 0x5b, 0x36, 0x69, 0x3a, 0xfb, 0x6e, 0xed, 0x86, + 0xa8, 0x29, 0x6e, 0x18, 0x31, 0x9a, 0x4a, 0x08, 0x73, 0x10, 0x7d, 0xa4, 0x80, 0x79, 0xb6, 0x88, + 0x3b, 0x7d, 0xd3, 0x18, 0x90, 0xff, 0xe5, 0x52, 0x7e, 0x0f, 0x40, 0x3e, 0x74, 0x88, 0xca, 0x52, + 0xb9, 0x40, 0x59, 0xae, 0x80, 0xac, 0x6f, 0x7d, 0x48, 0x58, 0x7b, 0xcf, 0x70, 0x5b, 0x2a, 0x47, + 0xb6, 0x54, 0x40, 0x98, 0x61, 0xf0, 0x5d, 0x00, 0x7a, 0xae, 0x69, 0xed, 0x5b, 0xc4, 0xd4, 0x7d, + 0x56, 0x26, 0x99, 0x5a, 0x85, 0xd6, 0x70, 0x88, 0x76, 0x26, 0x81, 0xfa, 0x0c, 0x27, 0x79, 0x88, + 0x20, 0x1c, 0x6b, 0x69, 0x15, 0x47, 0x01, 0xf6, 0x4e, 0x8a, 0x0b, 0x8c, 0x9f, 0x6f, 0x87, 0xfc, + 0xec, 0x1c, 0xba, 0xde, 0x80, 0x91, 0x32, 0x7a, 0x4d, 0xed, 0x24, 0x22, 0x7c, 0x0c, 0x21, 0xca, + 0x47, 0x61, 0x8c, 0x25, 0x53, 0xb8, 0x05, 0x66, 0xc3, 0xb1, 0x83, 0xf2, 0x2f, 0xd1, 0x2a, 0xef, + 0x92, 0xee, 0xc0, 0xf5, 0x6a, 0x95, 0xb0, 0x55, 0x1e, 0x47, 0x63, 0x08, 0xa7, 0xfd, 0x71, 0x38, + 0x80, 0x84, 0x1a, 0xf8, 0x26, 0xc8, 0x47, 0x25, 0x0d, 0xd8, 0xb7, 0xb2, 0x96, 0xe0, 0xc7, 0xf5, + 0xcc, 0x5b, 0x82, 0x1f, 0x15, 0x73, 0xa4, 0x83, 0xef, 0x81, 0x99, 0x3d, 0xdb, 0xed, 0x3e, 0x08, + 0x7b, 0xf6, 0xe5, 0x78, 0x21, 0x35, 0x8a, 0xb3, 0xbc, 0x3e, 0x27, 0xd6, 0x22, 0x4c, 0xa3, 0x43, + 0x98, 0x89, 0x08, 0x0b, 0x98, 0xce, 0x54, 0xfe, 0x49, 0xcf, 0xb6, 0x9c, 0x07, 0xfa, 0xc0, 0xf0, + 0x0e, 0xc8, 0xa0, 0xb8, 0x14, 0xcf, 0x54, 0x42, 0xb3, 0xcb, 0x14, 0xd1, 0x4c, 0x95, 0x40, 0x11, + 0x4e, 0x5a, 0xd1, 0x49, 0x8f, 0x87, 0xd6, 0x0f, 0x0d, 0xff, 0xb0, 0x08, 0xd9, 0x11, 0xc0, 0xfa, + 0x0c, 0x87, 0x37, 0x0d, 0xff, 0x30, 0xda, 0xf6, 0x18, 0x42, 0x58, 0xd2, 0xc3, 0x9a, 0x98, 0xc6, + 0xf8, 0x0c, 0x75, 0x6d, 0x9a, 0xb6, 0x17, 0x18, 0xc7, 0xd6, 0xc1, 0xfc, 0xe9, 0xd9, 0x60, 0x91, + 0xf7, 0xcd, 0x7e, 0x62, 0x2a, 0xe0, 0x7d, 0xb3, 0x2f, 0xcf, 0x03, 0xb2, 0x05, 0x7c, 0x4f, 0xa2, + 0x95, 0xe3, 0x17, 0xe7, 0x2b, 0xca, 0x72, 0xae, 0xf6, 0x82, 0xcc, 0xa3, 0x96, 0x3f, 0xc5, 0xa3, + 0x96, 0x8f, 0xfe, 0x13, 0xa8, 0x19, 0xcb, 0x19, 0x60, 0xc9, 0x0c, 0xee, 0x03, 0xfe, 0x95, 0x3a, + 0xab, 0x8a, 0x45, 0x16, 0x6a, 0xe3, 0x49, 0xa0, 0x2e, 0x60, 0xe3, 0x21, 0x4b, 0x5d, 0xc7, 0xfa, + 0x90, 0x50, 0xce, 0xef, 0x85, 0x42, 0xc4, 0xf9, 0x08, 0x09, 0x03, 0x7f, 0xfc, 0xf8, 0x56, 0xc2, + 0x0d, 0xc7, 0x4e, 0xb0, 0x01, 0xe6, 0x6d, 0xb7, 0x6b, 0xd8, 0xfa, 0xbe, 0x6d, 0x1c, 0xf8, 0xc5, + 0x7f, 0xcd, 0xb2, 0x8f, 0x67, 0x59, 0x60, 0xf8, 0x3a, 0x85, 0xa3, 0x45, 0xc7, 0x10, 0xc2, 0x92, + 0x1e, 0x6e, 0x82, 0x05, 0x41, 0x57, 0x9e, 0xcb, 0x7f, 0xcf, 0xb2, 0x64, 0xb2, 0x3d, 0x14, 0x0a, + 0x91, 0xcd, 0x25, 0x99, 0xe5, 0x3c, 0x9d, 0xb2, 0x05, 0xfc, 0x2e, 0x1d, 0x33, 0xe8, 0x28, 0x64, + 0x8a, 0x99, 0xe7, 0x26, 0x1f, 0x28, 0x18, 0x14, 0x55, 0x89, 0x90, 0xd9, 0x44, 0xc1, 0x9e, 0x20, + 0x06, 0xb3, 0x96, 0x73, 0x6c, 0xd8, 0x56, 0x38, 0xd3, 0xbc, 0xf1, 0x24, 0x50, 0x01, 0x36, 0x1e, + 0x36, 0x39, 0xca, 0x8f, 0x18, 0xf6, 0x28, 0x1d, 0x31, 0x4c, 0xa6, 0x47, 0x8c, 0x64, 0x89, 0x43, + 0x3b, 0xca, 0x78, 0xc7, 0x4d, 0x8c, 0x8d, 0x79, 0x16, 0x9a, 0x31, 0xde, 0x71, 0x93, 0x23, 0x23, + 0x67, 0x7c, 0x02, 0x45, 0x38, 0x69, 0xf5, 0x66, 0xf6, 0xd7, 0x9f, 0xa8, 0x29, 0xf4, 0x85, 0x02, + 0xe6, 0xa2, 0xea, 0xa3, 0x8d, 0x8f, 0x6d, 0x59, 0x86, 0xed, 0x18, 0x23, 0xea, 0x21, 0xdf, 0x2a, + 0x4e, 0xd4, 0x43, 0xb6, 0x47, 0x0c, 0xa3, 0x8d, 0xdd, 0xdd, 0xdf, 0xf7, 0xc9, 0x80, 0xb5, 0xd4, + 0x0c, 0x6f, 0xec, 0x1c, 0x89, 0x1a, 0x3b, 0x17, 0x11, 0x16, 0x38, 0x7c, 0x45, 0x34, 0xd6, 0x34, + 0xa3, 0xd0, 0x73, 0x67, 0x37, 0xd6, 0x90, 0x81, 0xbc, 0xbf, 0xbe, 0x05, 0xe6, 0x1e, 0x12, 0xe3, + 0x01, 0x4f, 0x25, 0xaf, 0x06, 0xd6, 0x72, 0x28, 0x28, 0xd2, 0xc8, 0x5b, 0x4e, 0x08, 0x20, 0x1c, + 0xe9, 0xc4, 0x37, 0xde, 0x07, 0x33, 0xbc, 0xd3, 0xc1, 0x1d, 0x90, 0xef, 0xba, 0x47, 0xce, 0x20, + 0xbe, 0x75, 0x2c, 0xc9, 0xe3, 0x12, 0xd3, 0xd4, 0xfe, 0x4f, 0xb4, 0xa0, 0xc8, 0x34, 0xca, 0x91, + 0x00, 0xe8, 0x9c, 0x23, 0x54, 0xe8, 0x17, 0x0a, 0x98, 0x15, 0x8e, 0x70, 0x33, 0x9a, 0x1e, 0xb3, + 0xb5, 0x37, 0x4e, 0x35, 0xf0, 0x2f, 0xbf, 0x89, 0xc8, 0xcd, 0x5b, 0x5c, 0x4a, 0x8e, 0x0d, 0xfb, + 0x88, 0x6f, 0x54, 0x96, 0x5f, 0x4a, 0x18, 0x10, 0xf5, 0x43, 0x26, 0x21, 0xcc, 0x51, 0xf4, 0xd7, + 0x0c, 0x98, 0xc5, 0xb4, 0xcf, 0xfa, 0x03, 0xf8, 0x7a, 0xb4, 0x8a, 0x5c, 0xed, 0xf9, 0xf3, 0x5e, + 0x1b, 0x17, 0x63, 0x38, 0xb6, 0xc6, 0xe7, 0x74, 0xfa, 0xc2, 0xe7, 0x74, 0x78, 0xa6, 0x66, 0x2e, + 0x70, 0xa6, 0xc6, 0x74, 0xc9, 0x7e, 0x65, 0xba, 0xe4, 0x2e, 0x4e, 0x97, 0x90, 0xc1, 0x33, 0x17, + 0x60, 0x70, 0x1b, 0x5c, 0xda, 0xf7, 0xdc, 0x1e, 0xbb, 0xdc, 0xb8, 0x9e, 0xe1, 0x9d, 0x88, 0x6a, + 0x65, 0x25, 0x45, 0x35, 0xbb, 0xa1, 0x22, 0x2a, 0xa9, 0x04, 0x8a, 0x70, 0xd2, 0x2a, 0xc9, 0xd5, + 0xfc, 0x57, 0xe3, 0x2a, 0xfa, 0x93, 0x02, 0xf2, 0x98, 0xf8, 0x7d, 0xd7, 0xf1, 0xc9, 0xd7, 0x4d, + 0xe2, 0x0a, 0xc8, 0x9a, 0xc6, 0xc0, 0x60, 0x29, 0x14, 0x5f, 0x4f, 0xe5, 0xe8, 0xeb, 0xa9, 0x80, + 0x30, 0xc3, 0xe0, 0xbb, 0x20, 0xdb, 0x75, 0x4d, 0x9e, 0xbc, 0x4b, 0xf2, 0x61, 0xac, 0x79, 0x9e, + 0xeb, 0xd5, 0x5d, 0x53, 0x9c, 0x54, 0xd4, 0x28, 0x0a, 0x40, 0x05, 0x84, 0x19, 0x86, 0xfe, 0xa8, + 0x80, 0x42, 0xc3, 0x7d, 0xe8, 0xd8, 0xae, 0x61, 0xee, 0x78, 0xee, 0x01, 0xbd, 0x37, 0x7c, 0xad, + 0x71, 0x4f, 0x07, 0xb3, 0x47, 0x6c, 0x58, 0x0c, 0x07, 0xbe, 0x5b, 0xc9, 0x93, 0xf3, 0xf4, 0x4b, + 0xf8, 0x64, 0x19, 0xdf, 0xf0, 0x84, 0x73, 0x14, 0x9f, 0xcb, 0x08, 0x87, 0x0a, 0xf4, 0x87, 0x0c, + 0x28, 0x9d, 0x1f, 0x08, 0xf6, 0xc0, 0x3c, 0xb7, 0xd4, 0xa5, 0xdf, 0x52, 0x96, 0x2f, 0xb2, 0x06, + 0x76, 0x9e, 0xb3, 0xf3, 0xe9, 0x28, 0x92, 0xa3, 0xf3, 0x29, 0x86, 0x10, 0x96, 0xf4, 0x5f, 0xe9, + 0x82, 0x28, 0x4d, 0x6f, 0x99, 0x6f, 0x3e, 0xbd, 0x75, 0xc0, 0x22, 0x3f, 0xc7, 0xc3, 0x9b, 0x7c, + 0xb6, 0x92, 0x59, 0xce, 0xd5, 0x56, 0xc7, 0x81, 0xba, 0xb0, 0xc7, 0x0f, 0x81, 0xf0, 0x0e, 0xbf, + 0x14, 0x9f, 0xde, 0x1c, 0x0c, 0xd9, 0x56, 0x48, 0xe1, 0x84, 0x2d, 0x5c, 0x4f, 0x0c, 0x07, 0xbc, + 0x54, 0xbf, 0x7d, 0xc1, 0x61, 0x40, 0x3a, 0xfc, 0xd1, 0x0c, 0xc8, 0xee, 0x58, 0xce, 0x01, 0x7a, + 0x0b, 0xe4, 0xea, 0xb6, 0xeb, 0xb3, 0x8e, 0xe1, 0x11, 0xc3, 0x77, 0x1d, 0x99, 0x4a, 0x1c, 0x89, + 0x52, 0xcd, 0x45, 0x84, 0x05, 0xbe, 0xf2, 0x69, 0x06, 0xcc, 0x4b, 0x3f, 0x7d, 0xc1, 0x1f, 0x80, + 0x1b, 0xdb, 0x5a, 0xa7, 0x53, 0xdd, 0xd0, 0xf4, 0xdd, 0x7b, 0x3b, 0x9a, 0x5e, 0xdf, 0xba, 0xd3, + 0xd9, 0xd5, 0xb0, 0x5e, 0x6f, 0xb7, 0xd6, 0x9b, 0x1b, 0x85, 0x54, 0xe9, 0xe6, 0x70, 0x54, 0x29, + 0x4a, 0x1e, 0xc9, 0x1f, 0xa9, 0xbe, 0x03, 0x60, 0xc2, 0xbd, 0xd9, 0x6a, 0x68, 0x3f, 0x2a, 0x28, + 0xa5, 0x2b, 0xc3, 0x51, 0xa5, 0x20, 0x79, 0xf1, 0x5b, 0xd7, 0xf7, 0xc1, 0xb3, 0xd3, 0xd6, 0xfa, + 0x9d, 0x9d, 0x46, 0x75, 0x57, 0x2b, 0xa4, 0x4b, 0xa5, 0xe1, 0xa8, 0x72, 0xed, 0xb4, 0x93, 0xa0, + 0xe0, 0xcb, 0xe0, 0x4a, 0xc2, 0x15, 0x6b, 0x3f, 0xbc, 0xa3, 0x75, 0x76, 0x0b, 0x99, 0xd2, 0xb5, + 0xe1, 0xa8, 0x02, 0x25, 0xaf, 0xb0, 0xcd, 0xaf, 0x81, 0xab, 0xa7, 0x3c, 0x3a, 0x3b, 0xed, 0x56, + 0x47, 0x2b, 0x64, 0x4b, 0xd7, 0x87, 0xa3, 0xca, 0xe5, 0x84, 0x8b, 0xe8, 0x2a, 0x75, 0x50, 0x4e, + 0xf8, 0x34, 0xda, 0x1f, 0xb4, 0xb6, 0xda, 0xd5, 0x86, 0xbe, 0x83, 0xdb, 0x1b, 0x58, 0xeb, 0x74, + 0x0a, 0xb9, 0x92, 0x3a, 0x1c, 0x55, 0x6e, 0x48, 0xce, 0x53, 0x15, 0xbe, 0x02, 0x96, 0x12, 0x41, + 0x76, 0x9a, 0xad, 0x8d, 0xc2, 0x4c, 0xe9, 0xf2, 0x70, 0x54, 0x79, 0x46, 0xf2, 0xa3, 0xb9, 0x9c, + 0xda, 0xbf, 0xfa, 0x56, 0xbb, 0xa3, 0x15, 0x66, 0xa7, 0xf6, 0x8f, 0x25, 0x7c, 0xe5, 0x77, 0x0a, + 0x80, 0xd3, 0xbf, 0x36, 0xc2, 0x37, 0x40, 0x31, 0x0c, 0x52, 0x6f, 0x6f, 0xef, 0xd0, 0x75, 0x36, + 0xdb, 0x2d, 0xbd, 0xd5, 0x6e, 0x69, 0x85, 0x54, 0x62, 0x57, 0x25, 0xaf, 0x96, 0xeb, 0x10, 0xd8, + 0x06, 0xd7, 0xcf, 0xf2, 0xdc, 0xba, 0xff, 0x5a, 0x41, 0x29, 0xad, 0x0d, 0x47, 0x95, 0xab, 0xd3, + 0x8e, 0x5b, 0xf7, 0x5f, 0xfb, 0xfc, 0x97, 0xcf, 0x9f, 0xad, 0x58, 0xf9, 0xad, 0x02, 0xe6, 0xe5, + 0xa5, 0xbd, 0x02, 0xae, 0xc8, 0x81, 0xb7, 0xb5, 0xdd, 0x6a, 0xa3, 0xba, 0x5b, 0x2d, 0xa4, 0x78, + 0x0e, 0x24, 0xd3, 0x6d, 0x32, 0x30, 0x58, 0xdb, 0x7d, 0x11, 0x2c, 0x25, 0xbe, 0x42, 0xbb, 0xab, + 0xe1, 0x90, 0x51, 0xf2, 0xfa, 0xc9, 0x31, 0xf1, 0xe0, 0x4b, 0x00, 0xca, 0xc6, 0xd5, 0xad, 0x0f, + 0xaa, 0xf7, 0x3a, 0x85, 0x74, 0xe9, 0xea, 0x70, 0x54, 0x59, 0x92, 0xac, 0xab, 0xf6, 0x43, 0xe3, + 0xc4, 0x5f, 0xf9, 0x4b, 0x1a, 0x2c, 0xc8, 0x57, 0x0d, 0xf8, 0x12, 0xb8, 0xbc, 0xde, 0xdc, 0xa2, + 0x4c, 0x5c, 0x6f, 0xf3, 0x0c, 0x50, 0xb1, 0x90, 0xe2, 0xaf, 0x93, 0x4d, 0xe9, 0x33, 0xfc, 0x1e, + 0x28, 0x9e, 0x32, 0x6f, 0x34, 0xb1, 0x56, 0xdf, 0x6d, 0xe3, 0x7b, 0x05, 0xa5, 0xf4, 0x2c, 0xdd, + 0x30, 0xd9, 0xa7, 0x61, 0x79, 0xac, 0x05, 0x9d, 0xc0, 0x77, 0xc0, 0x8d, 0x53, 0x8e, 0x9d, 0x7b, + 0xdb, 0x5b, 0xcd, 0xd6, 0xfb, 0xfc, 0x7d, 0xe9, 0xd2, 0x73, 0xc3, 0x51, 0xe5, 0xba, 0xec, 0xdb, + 0xe1, 0xb7, 0x2f, 0x0a, 0xe5, 0x15, 0xb8, 0x09, 0x2a, 0xe7, 0xf8, 0xc7, 0x0b, 0xc8, 0x94, 0xd0, + 0x70, 0x54, 0xb9, 0x79, 0x46, 0x90, 0x68, 0x1d, 0x79, 0x05, 0xbe, 0x0a, 0xae, 0x9d, 0x1d, 0x29, + 0xac, 0x8b, 0x33, 0xfc, 0x57, 0xfe, 0xae, 0x80, 0xb9, 0xe8, 0xd4, 0xa3, 0x9b, 0xa6, 0x61, 0xdc, + 0xa6, 0x4d, 0xa2, 0xa1, 0xe9, 0xad, 0xb6, 0xce, 0xa4, 0x70, 0xd3, 0x22, 0xbb, 0x96, 0xcb, 0x1e, + 0x29, 0xc7, 0x25, 0xf3, 0x0d, 0xad, 0xa5, 0xe1, 0x66, 0x3d, 0xcc, 0x68, 0x64, 0xbd, 0x41, 0x1c, + 0xe2, 0x59, 0x5d, 0xf8, 0x1a, 0xb8, 0x9e, 0x0c, 0xde, 0xb9, 0x53, 0xdf, 0x0c, 0x77, 0x89, 0x2d, + 0x50, 0x7a, 0x41, 0xe7, 0xa8, 0x7b, 0xc8, 0x12, 0xf3, 0x7a, 0xc2, 0xab, 0xd9, 0xba, 0x5b, 0xdd, + 0x6a, 0x36, 0xb8, 0x57, 0xa6, 0x54, 0x1c, 0x8e, 0x2a, 0x57, 0x22, 0x2f, 0x71, 0x71, 0xa0, 0x6e, + 0x2b, 0x9f, 0x2b, 0xa0, 0xfc, 0xe5, 0x87, 0x17, 0xfc, 0x00, 0xbc, 0xc0, 0xf6, 0x6b, 0xaa, 0x15, + 0x88, 0xbe, 0xc5, 0xf7, 0xb0, 0xba, 0xb3, 0xa3, 0xb5, 0x1a, 0x85, 0x54, 0x69, 0x79, 0x38, 0xaa, + 0xdc, 0xfa, 0xf2, 0x90, 0xd5, 0x7e, 0x9f, 0x38, 0xe6, 0x05, 0x03, 0xaf, 0xb7, 0xf1, 0x86, 0xb6, + 0x5b, 0x50, 0x2e, 0x12, 0x78, 0xdd, 0xa5, 0x37, 0xf5, 0xda, 0xf6, 0x67, 0x5f, 0x94, 0x53, 0x8f, + 0xbf, 0x28, 0xa7, 0x3e, 0x7b, 0x52, 0x56, 0x1e, 0x3f, 0x29, 0x2b, 0xbf, 0x7a, 0x5a, 0x4e, 0x7d, + 0xf2, 0xb4, 0xac, 0x3c, 0x7e, 0x5a, 0x4e, 0xfd, 0xe3, 0x69, 0x39, 0x75, 0xff, 0xc5, 0x03, 0x6b, + 0x70, 0x78, 0xb4, 0xb7, 0xda, 0x75, 0x7b, 0xb7, 0xfd, 0x13, 0xa7, 0x3b, 0x38, 0xb4, 0x9c, 0x03, + 0xe9, 0x49, 0xfe, 0xd7, 0x69, 0x6f, 0x86, 0x3d, 0xbd, 0xfa, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xf3, 0xce, 0x28, 0x00, 0x8c, 0x1a, 0x00, 0x00, } func (m *Hello) Marshal() (dAtA []byte, err error) { @@ -3768,7 +3815,7 @@ func (m *FileInfo) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.ModifiedNs |= int32(b&0x7F) << shift + m.ModifiedNs |= int(b&0x7F) << shift if b < 0x80 { break } @@ -3806,7 +3853,7 @@ func (m *FileInfo) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.RawBlockSize |= int32(b&0x7F) << shift + m.RawBlockSize |= int(b&0x7F) << shift if b < 0x80 { break } @@ -4050,7 +4097,7 @@ func (m *BlockInfo) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Size |= int32(b&0x7F) << shift + m.Size |= int(b&0x7F) << shift if b < 0x80 { break } @@ -4353,7 +4400,7 @@ func (m *Request) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.ID |= int32(b&0x7F) << shift + m.ID |= int(b&0x7F) << shift if b < 0x80 { break } @@ -4455,7 +4502,7 @@ func (m *Request) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Size |= int32(b&0x7F) << shift + m.Size |= int(b&0x7F) << shift if b < 0x80 { break } @@ -4600,7 +4647,7 @@ func (m *Response) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.ID |= int32(b&0x7F) << shift + m.ID |= int(b&0x7F) << shift if b < 0x80 { break } @@ -4916,7 +4963,7 @@ func (m *FileDownloadProgressUpdate) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 4: if wireType == 0 { - var v int32 + var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBep @@ -4926,7 +4973,7 @@ func (m *FileDownloadProgressUpdate) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - v |= int32(b&0x7F) << shift + v |= int(b&0x7F) << shift if b < 0x80 { break } @@ -4967,10 +5014,10 @@ func (m *FileDownloadProgressUpdate) Unmarshal(dAtA []byte) error { } elementCount = count if elementCount != 0 && len(m.BlockIndexes) == 0 { - m.BlockIndexes = make([]int32, 0, elementCount) + m.BlockIndexes = make([]int, 0, elementCount) } for iNdEx < postIndex { - var v int32 + var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBep @@ -4980,7 +5027,7 @@ func (m *FileDownloadProgressUpdate) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - v |= int32(b&0x7F) << shift + v |= int(b&0x7F) << shift if b < 0x80 { break } @@ -5004,7 +5051,7 @@ func (m *FileDownloadProgressUpdate) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.BlockSize |= int32(b&0x7F) << shift + m.BlockSize |= int(b&0x7F) << shift if b < 0x80 { break } diff --git a/lib/protocol/bep_extensions.go b/lib/protocol/bep_extensions.go index f5914d164..88b7f29c5 100644 --- a/lib/protocol/bep_extensions.go +++ b/lib/protocol/bep_extensions.go @@ -57,7 +57,7 @@ func (f FileInfo) String() string { case FileInfoTypeFile: return fmt.Sprintf("File{Name:%q, Sequence:%d, Permissions:0%o, ModTime:%v, Version:%v, VersionHash:%x, Length:%d, Deleted:%v, Invalid:%v, LocalFlags:0x%x, NoPermissions:%v, BlockSize:%d, Blocks:%v, BlocksHash:%x}", f.Name, f.Sequence, f.Permissions, f.ModTime(), f.Version, f.VersionHash, f.Size, f.Deleted, f.RawInvalid, f.LocalFlags, f.NoPermissions, f.RawBlockSize, f.Blocks, f.BlocksHash) - case FileInfoTypeSymlink, FileInfoTypeDeprecatedSymlinkDirectory, FileInfoTypeDeprecatedSymlinkFile: + case FileInfoTypeSymlink, FileInfoTypeSymlinkDirectory, FileInfoTypeSymlinkFile: return fmt.Sprintf("Symlink{Name:%q, Type:%v, Sequence:%d, Version:%v, VersionHash:%x, Deleted:%v, Invalid:%v, LocalFlags:0x%x, NoPermissions:%v, SymlinkTarget:%q}", f.Name, f.Type, f.Sequence, f.Version, f.VersionHash, f.Deleted, f.RawInvalid, f.LocalFlags, f.NoPermissions, f.SymlinkTarget) default: @@ -99,7 +99,7 @@ func (f FileInfo) ShouldConflict() bool { func (f FileInfo) IsSymlink() bool { switch f.Type { - case FileInfoTypeSymlink, FileInfoTypeDeprecatedSymlinkDirectory, FileInfoTypeDeprecatedSymlinkFile: + case FileInfoTypeSymlink, FileInfoTypeSymlinkDirectory, FileInfoTypeSymlinkFile: return true default: return false diff --git a/lib/protocol/compression.go b/lib/protocol/compression.go index 56e6969a0..428cb180c 100644 --- a/lib/protocol/compression.go +++ b/lib/protocol/compression.go @@ -9,20 +9,20 @@ const ( ) var compressionMarshal = map[Compression]string{ - CompressNever: "never", - CompressMetadata: "metadata", - CompressAlways: "always", + CompressionNever: "never", + CompressionMetadata: "metadata", + CompressionAlways: "always", } var compressionUnmarshal = map[string]Compression{ // Legacy - "false": CompressNever, - "true": CompressMetadata, + "false": CompressionNever, + "true": CompressionMetadata, // Current - "never": CompressNever, - "metadata": CompressMetadata, - "always": CompressAlways, + "never": CompressionNever, + "metadata": CompressionMetadata, + "always": CompressionAlways, } func (c Compression) GoString() string { diff --git a/lib/protocol/compression_test.go b/lib/protocol/compression_test.go index 90312344c..9edb85319 100644 --- a/lib/protocol/compression_test.go +++ b/lib/protocol/compression_test.go @@ -9,21 +9,21 @@ func TestCompressionMarshal(t *testing.T) { s string c Compression }{ - {"true", CompressMetadata}, - {"false", CompressNever}, - {"never", CompressNever}, - {"metadata", CompressMetadata}, - {"always", CompressAlways}, - {"whatever", CompressMetadata}, + {"true", CompressionMetadata}, + {"false", CompressionNever}, + {"never", CompressionNever}, + {"metadata", CompressionMetadata}, + {"always", CompressionAlways}, + {"whatever", CompressionMetadata}, } mTestcases := []struct { s string c Compression }{ - {"never", CompressNever}, - {"metadata", CompressMetadata}, - {"always", CompressAlways}, + {"never", CompressionNever}, + {"metadata", CompressionMetadata}, + {"always", CompressionAlways}, } var c Compression diff --git a/lib/protocol/protocol.go b/lib/protocol/protocol.go index 4811f315e..6c1420b0f 100644 --- a/lib/protocol/protocol.go +++ b/lib/protocol/protocol.go @@ -153,12 +153,12 @@ type rawConnection struct { cr *countingReader cw *countingWriter - awaiting map[int32]chan asyncResult + awaiting map[int]chan asyncResult awaitingMut sync.Mutex idxMut sync.Mutex // ensures serialization of Index calls - nextID int32 + nextID int nextIDMut sync.Mutex inbox chan message @@ -213,7 +213,7 @@ func NewConnection(deviceID DeviceID, reader io.Reader, writer io.Writer, receiv receiver: nativeModel{receiver}, cr: cr, cw: cw, - awaiting: make(map[int32]chan asyncResult), + awaiting: make(map[int]chan asyncResult), inbox: make(chan message), outbox: make(chan asyncMessage), closeBox: make(chan asyncMessage), @@ -301,7 +301,7 @@ func (c *rawConnection) Request(ctx context.Context, folder string, name string, Folder: folder, Name: name, Offset: offset, - Size: int32(size), + Size: size, Hash: hash, WeakHash: weakHash, FromTemporary: fromTemporary, @@ -625,7 +625,7 @@ func checkFilename(name string) error { } func (c *rawConnection) handleRequest(req Request) { - res, err := c.receiver.Request(c.id, req.Folder, req.Name, req.Size, req.Offset, req.Hash, req.WeakHash, req.FromTemporary) + res, err := c.receiver.Request(c.id, req.Folder, req.Name, int32(req.Size), req.Offset, req.Hash, req.WeakHash, req.FromTemporary) if err != nil { c.send(context.Background(), &Response{ ID: req.ID, @@ -797,21 +797,21 @@ func (c *rawConnection) writeUncompressedMessage(msg message) error { func (c *rawConnection) typeOf(msg message) MessageType { switch msg.(type) { case *ClusterConfig: - return messageTypeClusterConfig + return MessageTypeClusterConfig case *Index: - return messageTypeIndex + return MessageTypeIndex case *IndexUpdate: - return messageTypeIndexUpdate + return MessageTypeIndexUpdate case *Request: - return messageTypeRequest + return MessageTypeRequest case *Response: - return messageTypeResponse + return MessageTypeResponse case *DownloadProgress: - return messageTypeDownloadProgress + return MessageTypeDownloadProgress case *Ping: - return messageTypePing + return MessageTypePing case *Close: - return messageTypeClose + return MessageTypeClose default: panic("bug: unknown message type") } @@ -819,21 +819,21 @@ func (c *rawConnection) typeOf(msg message) MessageType { func (c *rawConnection) newMessage(t MessageType) (message, error) { switch t { - case messageTypeClusterConfig: + case MessageTypeClusterConfig: return new(ClusterConfig), nil - case messageTypeIndex: + case MessageTypeIndex: return new(Index), nil - case messageTypeIndexUpdate: + case MessageTypeIndexUpdate: return new(IndexUpdate), nil - case messageTypeRequest: + case MessageTypeRequest: return new(Request), nil - case messageTypeResponse: + case MessageTypeResponse: return new(Response), nil - case messageTypeDownloadProgress: + case MessageTypeDownloadProgress: return new(DownloadProgress), nil - case messageTypePing: + case MessageTypePing: return new(Ping), nil - case messageTypeClose: + case MessageTypeClose: return new(Close), nil default: return nil, errUnknownMessage @@ -842,14 +842,14 @@ func (c *rawConnection) newMessage(t MessageType) (message, error) { func (c *rawConnection) shouldCompressMessage(msg message) bool { switch c.compression { - case CompressNever: + case CompressionNever: return false - case CompressAlways: + case CompressionAlways: // Use compression for large enough messages return msg.ProtoSize() >= compressionThreshold - case CompressMetadata: + case CompressionMetadata: _, isResponse := msg.(*Response) // Compress if it's large enough and not a response message return !isResponse && msg.ProtoSize() >= compressionThreshold diff --git a/lib/protocol/protocol_test.go b/lib/protocol/protocol_test.go index 8d7ca4ad5..bac610ac0 100644 --- a/lib/protocol/protocol_test.go +++ b/lib/protocol/protocol_test.go @@ -31,9 +31,9 @@ func TestPing(t *testing.T) { ar, aw := io.Pipe() br, bw := io.Pipe() - c0 := NewConnection(c0ID, ar, bw, newTestModel(), "name", CompressAlways).(wireFormatConnection).Connection.(*rawConnection) + c0 := NewConnection(c0ID, ar, bw, newTestModel(), "name", CompressionAlways).(wireFormatConnection).Connection.(*rawConnection) c0.Start() - c1 := NewConnection(c1ID, br, aw, newTestModel(), "name", CompressAlways).(wireFormatConnection).Connection.(*rawConnection) + c1 := NewConnection(c1ID, br, aw, newTestModel(), "name", CompressionAlways).(wireFormatConnection).Connection.(*rawConnection) c1.Start() c0.ClusterConfig(ClusterConfig{}) c1.ClusterConfig(ClusterConfig{}) @@ -55,9 +55,9 @@ func TestClose(t *testing.T) { ar, aw := io.Pipe() br, bw := io.Pipe() - c0 := NewConnection(c0ID, ar, bw, m0, "name", CompressAlways).(wireFormatConnection).Connection.(*rawConnection) + c0 := NewConnection(c0ID, ar, bw, m0, "name", CompressionAlways).(wireFormatConnection).Connection.(*rawConnection) c0.Start() - c1 := NewConnection(c1ID, br, aw, m1, "name", CompressAlways) + c1 := NewConnection(c1ID, br, aw, m1, "name", CompressionAlways) c1.Start() c0.ClusterConfig(ClusterConfig{}) c1.ClusterConfig(ClusterConfig{}) @@ -97,7 +97,7 @@ func TestCloseOnBlockingSend(t *testing.T) { m := newTestModel() - c := NewConnection(c0ID, &testutils.BlockingRW{}, &testutils.BlockingRW{}, m, "name", CompressAlways).(wireFormatConnection).Connection.(*rawConnection) + c := NewConnection(c0ID, &testutils.BlockingRW{}, &testutils.BlockingRW{}, m, "name", CompressionAlways).(wireFormatConnection).Connection.(*rawConnection) c.Start() wg := sync.WaitGroup{} @@ -147,9 +147,9 @@ func TestCloseRace(t *testing.T) { ar, aw := io.Pipe() br, bw := io.Pipe() - c0 := NewConnection(c0ID, ar, bw, m0, "c0", CompressNever).(wireFormatConnection).Connection.(*rawConnection) + c0 := NewConnection(c0ID, ar, bw, m0, "c0", CompressionNever).(wireFormatConnection).Connection.(*rawConnection) c0.Start() - c1 := NewConnection(c1ID, br, aw, m1, "c1", CompressNever) + c1 := NewConnection(c1ID, br, aw, m1, "c1", CompressionNever) c1.Start() c0.ClusterConfig(ClusterConfig{}) c1.ClusterConfig(ClusterConfig{}) @@ -184,7 +184,7 @@ func TestCloseRace(t *testing.T) { func TestClusterConfigFirst(t *testing.T) { m := newTestModel() - c := NewConnection(c0ID, &testutils.BlockingRW{}, &testutils.NoopRW{}, m, "name", CompressAlways).(wireFormatConnection).Connection.(*rawConnection) + c := NewConnection(c0ID, &testutils.BlockingRW{}, &testutils.NoopRW{}, m, "name", CompressionAlways).(wireFormatConnection).Connection.(*rawConnection) c.Start() select { @@ -234,7 +234,7 @@ func TestCloseTimeout(t *testing.T) { m := newTestModel() - c := NewConnection(c0ID, &testutils.BlockingRW{}, &testutils.BlockingRW{}, m, "name", CompressAlways).(wireFormatConnection).Connection.(*rawConnection) + c := NewConnection(c0ID, &testutils.BlockingRW{}, &testutils.BlockingRW{}, m, "name", CompressionAlways).(wireFormatConnection).Connection.(*rawConnection) c.Start() done := make(chan struct{}) @@ -260,6 +260,12 @@ func TestMarshalIndexMessage(t *testing.T) { m1.Files = nil } for i, f := range m1.Files { + if len(f.BlocksHash) == 0 { + m1.Files[i].BlocksHash = nil + } + if len(f.VersionHash) == 0 { + m1.Files[i].VersionHash = nil + } if len(f.Blocks) == 0 { m1.Files[i].Blocks = nil } else { @@ -330,7 +336,13 @@ func TestMarshalClusterConfigMessage(t *testing.T) { if len(m1.Folders[i].Devices) == 0 { m1.Folders[i].Devices = nil } + for j := range m1.Folders[i].Devices { + if len(m1.Folders[i].Devices[j].Addresses) == 0 { + m1.Folders[i].Devices[j].Addresses = nil + } + } } + return testMarshal(t, "clusterconfig", &m1, &ClusterConfig{}) } @@ -362,7 +374,10 @@ func TestMarshalFDPU(t *testing.T) { if len(m1.Version.Counters) == 0 { m1.Version.Counters = nil } - return testMarshal(t, "close", &m1, &FileDownloadProgressUpdate{}) + if len(m1.BlockIndexes) == 0 { + m1.BlockIndexes = nil + } + return testMarshal(t, "fdpu", &m1, &FileDownloadProgressUpdate{}) } if err := quick.Check(f, quickCfg); err != nil { @@ -831,7 +846,7 @@ func TestSha256OfEmptyBlock(t *testing.T) { func TestClusterConfigAfterClose(t *testing.T) { m := newTestModel() - c := NewConnection(c0ID, &testutils.BlockingRW{}, &testutils.BlockingRW{}, m, "name", CompressAlways).(wireFormatConnection).Connection.(*rawConnection) + c := NewConnection(c0ID, &testutils.BlockingRW{}, &testutils.BlockingRW{}, m, "name", CompressionAlways).(wireFormatConnection).Connection.(*rawConnection) c.Start() c.internalClose(errManual) @@ -853,7 +868,7 @@ func TestDispatcherToCloseDeadlock(t *testing.T) { // Verify that we don't deadlock when calling Close() from within one of // the model callbacks (ClusterConfig). m := newTestModel() - c := NewConnection(c0ID, &testutils.BlockingRW{}, &testutils.NoopRW{}, m, "name", CompressAlways).(wireFormatConnection).Connection.(*rawConnection) + c := NewConnection(c0ID, &testutils.BlockingRW{}, &testutils.NoopRW{}, m, "name", CompressionAlways).(wireFormatConnection).Connection.(*rawConnection) m.ccFn = func(devID DeviceID, cc ClusterConfig) { c.Close(errManual) } diff --git a/lib/scanner/blocks.go b/lib/scanner/blocks.go index 372af08b7..f343b8ee2 100644 --- a/lib/scanner/blocks.go +++ b/lib/scanner/blocks.go @@ -83,7 +83,7 @@ func Blocks(ctx context.Context, r io.Reader, blocksize int, sizehint int64, cou thisHash, hashes = hashes[:hashLength], hashes[hashLength:] b := protocol.BlockInfo{ - Size: int32(n), + Size: int(n), Offset: offset, Hash: thisHash, WeakHash: weakHf.Sum32(), diff --git a/lib/scanner/walk.go b/lib/scanner/walk.go index c546ff54c..b5d94410a 100644 --- a/lib/scanner/walk.go +++ b/lib/scanner/walk.go @@ -350,7 +350,7 @@ func (w *walker) walkRegular(ctx context.Context, relPath string, info fs.FileIn f, _ := CreateFileInfo(info, relPath, nil) f = w.updateFileInfo(f, curFile) f.NoPermissions = w.IgnorePerms - f.RawBlockSize = int32(blockSize) + f.RawBlockSize = blockSize if hasCurFile { if curFile.IsEquivalentOptional(f, w.ModTimeWindow, w.IgnorePerms, true, w.LocalFlags) { @@ -611,7 +611,7 @@ func CreateFileInfo(fi fs.FileInfo, name string, filesystem fs.Filesystem) (prot } f.Permissions = uint32(fi.Mode() & fs.ModePerm) f.ModifiedS = fi.ModTime().Unix() - f.ModifiedNs = int32(fi.ModTime().Nanosecond()) + f.ModifiedNs = fi.ModTime().Nanosecond() if fi.IsDir() { f.Type = protocol.FileInfoTypeDirectory return f, nil diff --git a/lib/ur/contract/contract.go b/lib/ur/contract/contract.go index 441c68f54..bdc9dac16 100644 --- a/lib/ur/contract/contract.go +++ b/lib/ur/contract/contract.go @@ -289,9 +289,9 @@ func (r *Report) FieldNames() []string { "FolderAutoNormalize", "DeviceIntroducer", "DeviceCustomCertName", - "DeviceCompressAlways", - "DeviceCompressMetadata", - "DeviceCompressNever", + "DeviceCompressionAlways", + "DeviceCompressionMetadata", + "DeviceCompressionNever", "DeviceDynamicAddr", "DeviceStaticAddr", "AnnounceGlobalEnabled", diff --git a/lib/ur/usage_report.go b/lib/ur/usage_report.go index 30be1189c..6b3d5f490 100644 --- a/lib/ur/usage_report.go +++ b/lib/ur/usage_report.go @@ -164,11 +164,11 @@ func (s *Service) reportData(ctx context.Context, urVersion int, preview bool) ( report.DeviceUses.CustomCertName++ } switch cfg.Compression { - case protocol.CompressAlways: + case protocol.CompressionAlways: report.DeviceUses.CompressAlways++ - case protocol.CompressMetadata: + case protocol.CompressionMetadata: report.DeviceUses.CompressMetadata++ - case protocol.CompressNever: + case protocol.CompressionNever: report.DeviceUses.CompressNever++ default: l.Warnf("Unhandled versioning type for usage reports: %s", cfg.Compression) diff --git a/proto/ext.proto b/proto/ext.proto index 1b3da600b..73b4ba730 100644 --- a/proto/ext.proto +++ b/proto/ext.proto @@ -17,6 +17,7 @@ extend google.protobuf.FieldOptions { optional bool restart = 75008; optional bool device_id = 75009; optional string goname = 75010; + optional string gotype = 75011; } extend google.protobuf.EnumValueOptions { diff --git a/proto/ext/ext.pb.go b/proto/ext/ext.pb.go index 82a6747c6..2e9f4aecc 100644 --- a/proto/ext/ext.pb.go +++ b/proto/ext/ext.pb.go @@ -84,6 +84,15 @@ var E_Goname = &proto.ExtensionDesc{ Filename: "ext.proto", } +var E_Gotype = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.FieldOptions)(nil), + ExtensionType: (*string)(nil), + Field: 75011, + Name: "ext.gotype", + Tag: "bytes,75011,opt,name=gotype", + Filename: "ext.proto", +} + var E_Enumgoname = &proto.ExtensionDesc{ ExtendedType: (*descriptor.EnumValueOptions)(nil), ExtensionType: (*string)(nil), @@ -101,31 +110,32 @@ func init() { proto.RegisterExtension(E_Restart) proto.RegisterExtension(E_DeviceId) proto.RegisterExtension(E_Goname) + proto.RegisterExtension(E_Gotype) proto.RegisterExtension(E_Enumgoname) } func init() { proto.RegisterFile("ext.proto", fileDescriptor_95fe6908ffcf64d3) } var fileDescriptor_95fe6908ffcf64d3 = []byte{ - // 305 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0xd1, 0x3d, 0x4b, 0x03, 0x31, - 0x18, 0xc0, 0x71, 0x8e, 0x16, 0xdb, 0x66, 0xec, 0x24, 0x82, 0xb5, 0x6e, 0x9d, 0xee, 0x10, 0x41, - 0x31, 0x74, 0x52, 0x14, 0x1c, 0x44, 0x28, 0xe2, 0xe0, 0x52, 0xd2, 0xcb, 0xd3, 0x34, 0x92, 0x97, - 0x72, 0x49, 0x24, 0x6e, 0xea, 0x37, 0xf0, 0x2b, 0x39, 0x69, 0x27, 0xfd, 0x06, 0xd2, 0xd1, 0xef, - 0xe0, 0x0b, 0x77, 0x97, 0x93, 0x42, 0x87, 0xdb, 0x42, 0xf8, 0xff, 0x1e, 0x12, 0x1e, 0xd4, 0x01, - 0x6f, 0xe3, 0x79, 0xa6, 0xad, 0xee, 0x36, 0xc0, 0xdb, 0xad, 0x3e, 0xd3, 0x9a, 0x09, 0x48, 0x8a, - 0xab, 0x89, 0x9b, 0x26, 0x14, 0x4c, 0x9a, 0xf1, 0xb9, 0xd5, 0x59, 0x99, 0xe1, 0x21, 0x6a, 0x7b, - 0x29, 0xc6, 0x96, 0x30, 0xd3, 0xdd, 0x89, 0xcb, 0x3c, 0xae, 0xf2, 0xf8, 0x02, 0x8c, 0x21, 0x0c, - 0x2e, 0xe7, 0x96, 0x6b, 0x65, 0x36, 0x9f, 0x5f, 0x9a, 0xfd, 0x68, 0xd0, 0x1e, 0xb5, 0xbc, 0x14, - 0x57, 0x84, 0x19, 0xbc, 0x87, 0x1a, 0x5e, 0x8a, 0xee, 0xf6, 0x1a, 0x3c, 0xe3, 0x20, 0x68, 0xc5, - 0xbe, 0xdf, 0x72, 0xd6, 0x19, 0xe5, 0x2d, 0xde, 0x47, 0xcd, 0x5b, 0xa3, 0x55, 0x9d, 0xf9, 0x09, - 0xa6, 0x88, 0xf1, 0x11, 0x6a, 0x51, 0x98, 0x12, 0x27, 0x6c, 0x9d, 0xfb, 0x0d, 0xae, 0xea, 0x73, - 0x9a, 0x81, 0xb1, 0x24, 0xab, 0xa5, 0x0f, 0x8b, 0xf0, 0xbb, 0xd0, 0xe3, 0x21, 0xea, 0x50, 0xb8, - 0xe3, 0x29, 0x8c, 0x39, 0xad, 0xc3, 0x8f, 0x01, 0xb7, 0x4b, 0x71, 0x4e, 0xf1, 0x21, 0xda, 0x60, - 0x5a, 0x11, 0x09, 0x75, 0xf4, 0x69, 0x51, 0x3e, 0x39, 0xe4, 0xf8, 0x04, 0x21, 0x50, 0x4e, 0x06, - 0xbc, 0xbb, 0x86, 0x4f, 0x95, 0x93, 0xd7, 0x44, 0xb8, 0xff, 0xb5, 0x7c, 0x7d, 0x94, 0x03, 0x56, - 0xd8, 0xf1, 0xc1, 0xeb, 0xb2, 0x17, 0xbd, 0x2f, 0x7b, 0xd1, 0xe7, 0xb2, 0x17, 0xdd, 0x0c, 0x18, - 0xb7, 0x33, 0x37, 0x89, 0x53, 0x2d, 0x13, 0x73, 0xaf, 0x52, 0x3b, 0xe3, 0x8a, 0xad, 0x9c, 0x8a, - 0xd9, 0x09, 0x78, 0xfb, 0x17, 0x00, 0x00, 0xff, 0xff, 0xcd, 0x40, 0x4c, 0x73, 0x42, 0x02, 0x00, - 0x00, + // 318 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0xd1, 0xcb, 0x4a, 0x33, 0x31, + 0x14, 0xc0, 0x71, 0x86, 0x96, 0xaf, 0x6d, 0x96, 0x5d, 0x7d, 0x08, 0xd6, 0xba, 0xeb, 0x6a, 0x06, + 0x11, 0x14, 0x43, 0x57, 0x8a, 0x82, 0x0b, 0x11, 0x8a, 0xb8, 0x70, 0x53, 0xd2, 0x99, 0xd3, 0x34, + 0x92, 0xcb, 0x30, 0x39, 0x23, 0xd3, 0x9d, 0x97, 0x27, 0xf0, 0x95, 0x5c, 0x69, 0x57, 0xfa, 0x06, + 0xd2, 0xa5, 0xef, 0xe0, 0x85, 0xe9, 0xa4, 0x5a, 0xe8, 0x22, 0xbb, 0x10, 0xfe, 0xbf, 0x93, 0x84, + 0x90, 0x16, 0x14, 0x18, 0xa6, 0x99, 0x41, 0xd3, 0xae, 0x41, 0x81, 0x1b, 0x5d, 0x6e, 0x0c, 0x97, + 0x10, 0x2d, 0xb6, 0x46, 0xf9, 0x38, 0x4a, 0xc0, 0xc6, 0x99, 0x48, 0xd1, 0x64, 0x55, 0x46, 0xfb, + 0xa4, 0x59, 0x28, 0x39, 0x44, 0xc6, 0x6d, 0x7b, 0x2b, 0xac, 0xf2, 0x70, 0x99, 0x87, 0x67, 0x60, + 0x2d, 0xe3, 0x70, 0x9e, 0xa2, 0x30, 0xda, 0xfe, 0x7f, 0x7c, 0xaa, 0x77, 0x83, 0x5e, 0x73, 0xd0, + 0x28, 0x94, 0xbc, 0x60, 0xdc, 0xd2, 0x1d, 0x52, 0x2b, 0x94, 0x6c, 0x6f, 0xae, 0xc1, 0x13, 0x01, + 0x32, 0x59, 0xb2, 0xcf, 0x97, 0x92, 0xb5, 0x06, 0x65, 0x4b, 0x77, 0x49, 0xfd, 0xda, 0x1a, 0xed, + 0x33, 0x5f, 0xce, 0x2c, 0x62, 0x7a, 0x40, 0x1a, 0x09, 0x8c, 0x59, 0x2e, 0xd1, 0xe7, 0xbe, 0x9d, + 0x5b, 0xf6, 0x25, 0xcd, 0xc0, 0x22, 0xcb, 0xbc, 0xf4, 0x76, 0xe6, 0x5e, 0xe7, 0x7a, 0xda, 0x27, + 0xad, 0x04, 0x6e, 0x44, 0x0c, 0x43, 0x91, 0xf8, 0xf0, 0x9d, 0xc3, 0xcd, 0x4a, 0x9c, 0x26, 0x74, + 0x9f, 0xfc, 0xe3, 0x46, 0x33, 0x05, 0x3e, 0x7a, 0x3f, 0xab, 0xae, 0xec, 0xf2, 0x0a, 0xe2, 0x34, + 0xf5, 0xc2, 0x87, 0x3f, 0x58, 0xe6, 0xf4, 0x88, 0x10, 0xd0, 0xb9, 0x72, 0xa7, 0x6e, 0xaf, 0xe1, + 0x63, 0x9d, 0xab, 0x4b, 0x26, 0xf3, 0xdf, 0xff, 0xfc, 0x78, 0xab, 0x06, 0xac, 0xb0, 0xc3, 0xbd, + 0xe7, 0x79, 0x27, 0x78, 0x9d, 0x77, 0x82, 0xf7, 0x79, 0x27, 0xb8, 0xea, 0x71, 0x81, 0x93, 0x7c, + 0x14, 0xc6, 0x46, 0x45, 0x76, 0xaa, 0x63, 0x9c, 0x08, 0xcd, 0x57, 0x56, 0x8b, 0xd9, 0x11, 0x14, + 0xf8, 0x13, 0x00, 0x00, 0xff, 0xff, 0x5a, 0xa4, 0x49, 0x7c, 0x7b, 0x02, 0x00, 0x00, } diff --git a/proto/generate.go b/proto/generate.go index 4cf477dca..6a0e5e1e9 100644 --- a/proto/generate.go +++ b/proto/generate.go @@ -25,10 +25,7 @@ import ( // Inception, go generate calls the script itself that then deals with generation. // This is only done because go:generate does not support wildcards in paths. -//go:generate go run generate.go lib/config lib/fs - -// Use the standard compiler here. We can revisit this later, but we don't plan on exposing this via any APIs. -//go:generate protoc -I ../ -I . --gogofast_out=paths=source_relative:.. lib/protocol/bep.proto +//go:generate go run generate.go lib/protocol lib/config lib/fs lib/db func main() { for _, path := range os.Args[1:] { diff --git a/proto/lib/config/blockpullorder.proto b/proto/lib/config/blockpullorder.proto index 124b54844..a80cb6b4a 100644 --- a/proto/lib/config/blockpullorder.proto +++ b/proto/lib/config/blockpullorder.proto @@ -2,7 +2,11 @@ syntax = "proto3"; package config; +import "repos/protobuf/gogoproto/gogo.proto"; + enum BlockPullOrder { + option (gogoproto.goproto_enum_stringer) = false; + BLOCK_PULL_ORDER_STANDARD = 0; BLOCK_PULL_ORDER_RANDOM = 1; BLOCK_PULL_ORDER_IN_ORDER = 2; diff --git a/proto/lib/config/foldertype.proto b/proto/lib/config/foldertype.proto index 5ab498c31..69ff2a432 100644 --- a/proto/lib/config/foldertype.proto +++ b/proto/lib/config/foldertype.proto @@ -2,7 +2,11 @@ syntax = "proto3"; package config; +import "repos/protobuf/gogoproto/gogo.proto"; + enum FolderType { + option (gogoproto.goproto_enum_stringer) = false; + FOLDER_TYPE_SEND_RECEIVE = 0; FOLDER_TYPE_SEND_ONLY = 1; FOLDER_TYPE_RECEIVE_ONLY = 2; diff --git a/lib/db/structs.proto b/proto/lib/db/structs.proto similarity index 61% rename from lib/db/structs.proto rename to proto/lib/db/structs.proto index f9eeb7367..c197d20c9 100644 --- a/lib/db/structs.proto +++ b/proto/lib/db/structs.proto @@ -4,16 +4,10 @@ package db; import "repos/protobuf/gogoproto/gogo.proto"; import "lib/protocol/bep.proto"; - -option (gogoproto.goproto_getters_all) = false; -option (gogoproto.sizer_all) = false; -option (gogoproto.protosizer_all) = true; -option (gogoproto.goproto_unkeyed_all) = false; -option (gogoproto.goproto_unrecognized_all) = false; -option (gogoproto.goproto_sizecache_all) = false; +import "ext.proto"; message FileVersion { - protocol.Vector version = 1 [(gogoproto.nullable) = false]; + protocol.Vector version = 1; bool deleted = 2; repeated bytes devices = 3; repeated bytes invalid_devices = 4; @@ -21,7 +15,7 @@ message FileVersion { message VersionList { option (gogoproto.goproto_stringer) = false; - repeated FileVersion versions = 1 [(gogoproto.customname) = "RawVersions", (gogoproto.nullable) = false]; + repeated FileVersion versions = 1 [(ext.goname) = "RawVersions"]; } // Must be the same as FileInfo but without the blocks field @@ -30,8 +24,8 @@ message FileInfoTruncated { string name = 1; int64 size = 3; int64 modified_s = 5; - uint64 modified_by = 12 [(gogoproto.customtype) = "github.com/syncthing/syncthing/lib/protocol.ShortID", (gogoproto.nullable) = false]; - protocol.Vector version = 9 [(gogoproto.nullable) = false]; + uint64 modified_by = 12 [(ext.gotype) = "github.com/syncthing/syncthing/lib/protocol.ShortID"]; + protocol.Vector version = 9; int64 sequence = 10; // repeated BlockInfo Blocks = 16 string symlink_target = 17; @@ -39,20 +33,20 @@ message FileInfoTruncated { protocol.FileInfoType type = 2; uint32 permissions = 4; int32 modified_ns = 11; - int32 block_size = 13 [(gogoproto.customname) = "RawBlockSize"]; + int32 block_size = 13 [(ext.goname) = "RawBlockSize"]; // see bep.proto uint32 local_flags = 1000; bytes version_hash = 1001; bool deleted = 6; - bool invalid = 7 [(gogoproto.customname) = "RawInvalid"]; + bool invalid = 7 [(ext.goname) = "RawInvalid"]; bool no_permissions = 8; } // BlockList is the structure used to store block lists message BlockList { - repeated protocol.BlockInfo Blocks = 1 [(gogoproto.nullable) = false]; + repeated protocol.BlockInfo blocks = 1; } // IndirectionHashesOnly is used to only unmarshal the indirection hashes @@ -66,23 +60,24 @@ message IndirectionHashesOnly { // counts and sequence. We also keep one for the global state of the folder. message Counts { option (gogoproto.goproto_stringer) = false; + int32 files = 1; int32 directories = 2; int32 symlinks = 3; int32 deleted = 4; int64 bytes = 5; int64 sequence = 6; // zero for the global state - bytes deviceID = 17; // device ID for remote devices, or special values for local/global - uint32 localFlags = 18; // the local flag for this count bucket + bytes device_id = 17 [(ext.goname) = "DeviceID"]; // device ID for remote devices, or special values for local/global + uint32 local_flags = 18; // the local flag for this count bucket } message CountsSet { - repeated Counts counts = 1 [(gogoproto.nullable) = false]; + repeated Counts counts = 1; int64 created = 2; // unix nanos } message FileVersionDeprecated { - protocol.Vector version = 1 [(gogoproto.nullable) = false]; + protocol.Vector version = 1; bytes device = 2; bool invalid = 3; bool deleted = 4; @@ -90,5 +85,5 @@ message FileVersionDeprecated { message VersionListDeprecated { option (gogoproto.goproto_stringer) = false; - repeated FileVersionDeprecated versions = 1 [(gogoproto.nullable) = false]; + repeated FileVersionDeprecated versions = 1; } diff --git a/proto/lib/fs/copyrangemethod.proto b/proto/lib/fs/copyrangemethod.proto index 5adaed385..a651a1025 100644 --- a/proto/lib/fs/copyrangemethod.proto +++ b/proto/lib/fs/copyrangemethod.proto @@ -2,7 +2,11 @@ syntax = "proto3"; package fs; +import "repos/protobuf/gogoproto/gogo.proto"; + enum CopyRangeMethod { + option (gogoproto.goproto_enum_stringer) = false; + COPY_RANGE_METHOD_STANDARD = 0; COPY_RANGE_METHOD_IOCTL = 1; COPY_RANGE_METHOD_COPY_FILE_RANGE = 2; diff --git a/proto/lib/fs/types.proto b/proto/lib/fs/types.proto index 994ac123f..6f3a5c78d 100644 --- a/proto/lib/fs/types.proto +++ b/proto/lib/fs/types.proto @@ -2,7 +2,11 @@ syntax = "proto3"; package fs; +import "repos/protobuf/gogoproto/gogo.proto"; + enum FilesystemType { + option (gogoproto.goproto_enum_stringer) = false; + FILESYSTEM_TYPE_BASIC = 0; FILESYSTEM_TYPE_FAKE = 1; } diff --git a/proto/lib/protocol/bep.proto b/proto/lib/protocol/bep.proto index f2c222d2c..d470c7d7c 100644 --- a/proto/lib/protocol/bep.proto +++ b/proto/lib/protocol/bep.proto @@ -2,17 +2,9 @@ syntax = "proto3"; package protocol; +import "ext.proto"; import "repos/protobuf/gogoproto/gogo.proto"; -option (gogoproto.goproto_getters_all) = false; -option (gogoproto.sizer_all) = false; -option (gogoproto.protosizer_all) = true; -option (gogoproto.goproto_enum_stringer_all) = true; -option (gogoproto.goproto_enum_prefix_all) = false; -option (gogoproto.goproto_unkeyed_all) = false; -option (gogoproto.goproto_unrecognized_all) = false; -option (gogoproto.goproto_sizecache_all) = false; - // --- Pre-auth --- message Hello { @@ -29,19 +21,19 @@ message Header { } enum MessageType { - CLUSTER_CONFIG = 0 [(gogoproto.enumvalue_customname) = "messageTypeClusterConfig"]; - INDEX = 1 [(gogoproto.enumvalue_customname) = "messageTypeIndex"]; - INDEX_UPDATE = 2 [(gogoproto.enumvalue_customname) = "messageTypeIndexUpdate"]; - REQUEST = 3 [(gogoproto.enumvalue_customname) = "messageTypeRequest"]; - RESPONSE = 4 [(gogoproto.enumvalue_customname) = "messageTypeResponse"]; - DOWNLOAD_PROGRESS = 5 [(gogoproto.enumvalue_customname) = "messageTypeDownloadProgress"]; - PING = 6 [(gogoproto.enumvalue_customname) = "messageTypePing"]; - CLOSE = 7 [(gogoproto.enumvalue_customname) = "messageTypeClose"]; + MESSAGE_TYPE_CLUSTER_CONFIG = 0; + MESSAGE_TYPE_INDEX = 1; + MESSAGE_TYPE_INDEX_UPDATE = 2; + MESSAGE_TYPE_REQUEST = 3; + MESSAGE_TYPE_RESPONSE = 4; + MESSAGE_TYPE_DOWNLOAD_PROGRESS = 5; + MESSAGE_TYPE_PING = 6; + MESSAGE_TYPE_CLOSE = 7; } enum MessageCompression { - NONE = 0 [(gogoproto.enumvalue_customname) = "MessageCompressionNone"]; - LZ4 = 1 [(gogoproto.enumvalue_customname) = "MessageCompressionLZ4"]; + MESSAGE_COMPRESSION_NONE = 0; + MESSAGE_COMPRESSION_LZ4 = 1 [(ext.enumgoname) = "MessageCompressionLZ4"]; } // --- Actual messages --- @@ -49,11 +41,11 @@ enum MessageCompression { // Cluster Config message ClusterConfig { - repeated Folder folders = 1 [(gogoproto.nullable) = false]; + repeated Folder folders = 1; } message Folder { - string id = 1 [(gogoproto.customname) = "ID"]; + string id = 1 [(ext.goname) = "ID"]; string label = 2; bool read_only = 3; bool ignore_permissions = 4; @@ -61,37 +53,37 @@ message Folder { bool disable_temp_indexes = 6; bool paused = 7; - repeated Device devices = 16 [(gogoproto.nullable) = false]; + repeated Device devices = 16; } message Device { - bytes id = 1 [(gogoproto.customname) = "ID", (gogoproto.customtype) = "DeviceID", (gogoproto.nullable) = false]; + bytes id = 1 [(ext.goname) = "ID", (ext.device_id) = true]; string name = 2; repeated string addresses = 3; Compression compression = 4; string cert_name = 5; int64 max_sequence = 6; bool introducer = 7; - uint64 index_id = 8 [(gogoproto.customname) = "IndexID", (gogoproto.customtype) = "IndexID", (gogoproto.nullable) = false]; + uint64 index_id = 8 [(ext.goname) = "IndexID", (ext.gotype) = "IndexID"]; bool skip_introduction_removals = 9; } enum Compression { - METADATA = 0 [(gogoproto.enumvalue_customname) = "CompressMetadata"]; - NEVER = 1 [(gogoproto.enumvalue_customname) = "CompressNever"]; - ALWAYS = 2 [(gogoproto.enumvalue_customname) = "CompressAlways"]; + COMPRESSION_METADATA = 0; + COMPRESSION_NEVER = 1; + COMPRESSION_ALWAYS = 2; } // Index and Index Update message Index { string folder = 1; - repeated FileInfo files = 2 [(gogoproto.nullable) = false]; + repeated FileInfo files = 2; } message IndexUpdate { string folder = 1; - repeated FileInfo files = 2 [(gogoproto.nullable) = false]; + repeated FileInfo files = 2; } message FileInfo { @@ -103,16 +95,16 @@ message FileInfo { string name = 1; int64 size = 3; int64 modified_s = 5; - uint64 modified_by = 12 [(gogoproto.customtype) = "ShortID", (gogoproto.nullable) = false]; - Vector version = 9 [(gogoproto.nullable) = false]; + uint64 modified_by = 12 [(ext.gotype) = "ShortID"]; + Vector version = 9; int64 sequence = 10; - repeated BlockInfo blocks = 16 [(gogoproto.nullable) = false]; + repeated BlockInfo blocks = 16; string symlink_target = 17; bytes blocks_hash = 18; FileInfoType type = 2; uint32 permissions = 4; int32 modified_ns = 11; - int32 block_size = 13 [(gogoproto.customname) = "RawBlockSize"]; + int32 block_size = 13 [(ext.goname) = "RawBlockSize"]; // The local_flags fields stores flags that are relevant to the local // host only. It is not part of the protocol, doesn't get sent or @@ -124,16 +116,16 @@ message FileInfo { bytes version_hash = 1001; bool deleted = 6; - bool invalid = 7 [(gogoproto.customname) = "RawInvalid"]; + bool invalid = 7 [(ext.goname) = "RawInvalid"]; bool no_permissions = 8; } enum FileInfoType { - FILE = 0 [(gogoproto.enumvalue_customname) = "FileInfoTypeFile"]; - DIRECTORY = 1 [(gogoproto.enumvalue_customname) = "FileInfoTypeDirectory"]; - SYMLINK_FILE = 2 [(gogoproto.enumvalue_customname) = "FileInfoTypeDeprecatedSymlinkFile", deprecated = true]; - SYMLINK_DIRECTORY = 3 [(gogoproto.enumvalue_customname) = "FileInfoTypeDeprecatedSymlinkDirectory", deprecated = true]; - SYMLINK = 4 [(gogoproto.enumvalue_customname) = "FileInfoTypeSymlink"]; + FILE_INFO_TYPE_FILE = 0; + FILE_INFO_TYPE_DIRECTORY = 1; + FILE_INFO_TYPE_SYMLINK_FILE = 2 [deprecated = true]; + FILE_INFO_TYPE_SYMLINK_DIRECTORY = 3 [deprecated = true]; + FILE_INFO_TYPE_SYMLINK = 4; } message BlockInfo { @@ -145,18 +137,18 @@ message BlockInfo { } message Vector { - repeated Counter counters = 1 [(gogoproto.nullable) = false]; + repeated Counter counters = 1; } message Counter { - uint64 id = 1 [(gogoproto.customname) = "ID", (gogoproto.customtype) = "ShortID", (gogoproto.nullable) = false]; + uint64 id = 1 [(ext.goname) = "ID", (ext.gotype) = "ShortID"]; uint64 value = 2; } // Request message Request { - int32 id = 1 [(gogoproto.customname) = "ID"]; + int32 id = 1 [(ext.goname) = "ID"]; string folder = 2; string name = 3; int64 offset = 4; @@ -169,36 +161,36 @@ message Request { // Response message Response { - int32 id = 1 [(gogoproto.customname) = "ID"]; + int32 id = 1 [(ext.goname) = "ID"]; bytes data = 2; ErrorCode code = 3; } enum ErrorCode { - NO_ERROR = 0 [(gogoproto.enumvalue_customname) = "ErrorCodeNoError"]; - GENERIC = 1 [(gogoproto.enumvalue_customname) = "ErrorCodeGeneric"]; - NO_SUCH_FILE = 2 [(gogoproto.enumvalue_customname) = "ErrorCodeNoSuchFile"]; - INVALID_FILE = 3 [(gogoproto.enumvalue_customname) = "ErrorCodeInvalidFile"]; + ERROR_CODE_NO_ERROR = 0; + ERROR_CODE_GENERIC = 1; + ERROR_CODE_NO_SUCH_FILE = 2; + ERROR_CODE_INVALID_FILE = 3; } // DownloadProgress message DownloadProgress { string folder = 1; - repeated FileDownloadProgressUpdate updates = 2 [(gogoproto.nullable) = false]; + repeated FileDownloadProgressUpdate updates = 2; } message FileDownloadProgressUpdate { FileDownloadProgressUpdateType update_type = 1; string name = 2; - Vector version = 3 [(gogoproto.nullable) = false]; + Vector version = 3; repeated int32 block_indexes = 4 [packed=false]; int32 block_size = 5; } enum FileDownloadProgressUpdateType { - APPEND = 0 [(gogoproto.enumvalue_customname) = "UpdateTypeAppend"]; - FORGET = 1 [(gogoproto.enumvalue_customname) = "UpdateTypeForget"]; + FILE_DOWNLOAD_PROGRESS_UPDATE_TYPE_APPEND = 0; + FILE_DOWNLOAD_PROGRESS_UPDATE_TYPE_FORGET = 1; } // Ping diff --git a/proto/scripts/protoc_plugin.go b/proto/scripts/protoc_plugin.go index 29565c169..8ede1f24e 100644 --- a/proto/scripts/protoc_plugin.go +++ b/proto/scripts/protoc_plugin.go @@ -34,11 +34,11 @@ func main() { vanity.ForEachFile(files, vanity.TurnOffGoUnrecognizedAll) vanity.ForEachFile(files, vanity.TurnOffGoUnkeyedAll) vanity.ForEachFile(files, vanity.TurnOffGoSizecacheAll) - vanity.ForEachFile(files, vanity.TurnOffGoEnumStringerAll) + vanity.ForEachFile(files, vanity.TurnOnMarshalerAll) + vanity.ForEachFile(files, vanity.TurnOnUnmarshalerAll) vanity.ForEachEnumInFiles(files, HandleCustomEnumExtensions) vanity.ForEachFile(files, SetPackagePrefix("github.com/syncthing/syncthing")) - - vanity.ForEachMessageInFiles(files, HandleCustomExtensions) + vanity.ForEachFile(files, HandleFile) vanity.ForEachFieldInFilesExcludingExtensions(files, TurnOffNullableForMessages) resp := command.Generate(req) @@ -204,88 +204,102 @@ func GetMessageBoolExtension(msg *descriptor.DescriptorProto, extension *proto.E return *val, true } -func HandleCustomExtensions(msg *descriptor.DescriptorProto) { - generateXmlTags := true - if generate, ok := GetMessageBoolExtension(msg, ext.E_XmlTags); ok { - generateXmlTags = generate - } - - vanity.ForEachField([]*descriptor.DescriptorProto{msg}, func(field *descriptor.FieldDescriptorProto) { - if field.Options == nil { - field.Options = &descriptor.FieldOptions{} - } - deprecated := field.Options.Deprecated != nil && *field.Options.Deprecated == true - - if field.Type != nil && *field.Type == descriptor.FieldDescriptorProto_TYPE_INT32 { - SetStringFieldOption(field, gogoproto.E_Casttype, "int") - } - - if field.TypeName != nil && *field.TypeName == ".google.protobuf.Timestamp" { - vanity.SetBoolFieldOption(gogoproto.E_Stdtime, true)(field) - } - - if goName, ok := GetFieldStringExtension(field, ext.E_Goname); ok { - SetStringFieldOption(field, gogoproto.E_Customname, goName) - } else if deprecated { - SetStringFieldOption(field, gogoproto.E_Customname, "Deprecated"+toCamelCase(*field.Name, true)) - } - - if val, ok := GetFieldBooleanExtension(field, ext.E_DeviceId); ok && val { - SetStringFieldOption(field, gogoproto.E_Customtype, "github.com/syncthing/syncthing/lib/protocol.DeviceID") - } - - if jsonValue, ok := GetFieldStringExtension(field, ext.E_Json); ok { - SetStringFieldOption(field, gogoproto.E_Jsontag, jsonValue) - } else if deprecated { - SetStringFieldOption(field, gogoproto.E_Jsontag, "-") - } else { - SetStringFieldOption(field, gogoproto.E_Jsontag, toCamelCase(*field.Name, false)) - } - - current := "" - if v, ok := GetFieldStringExtension(field, gogoproto.E_Moretags); ok { - current = v - } - - if generateXmlTags { - if len(current) > 0 { - current += " " - } - if xmlValue, ok := GetFieldStringExtension(field, ext.E_Xml); ok { - current += fmt.Sprintf(`xml:"%s"`, xmlValue) - } else { - xmlValue = toCamelCase(*field.Name, false) - // XML dictates element name within the collection, not collection name, so trim plural suffix. - if field.IsRepeated() { - if strings.HasSuffix(xmlValue, "ses") { - // addresses -> address - xmlValue = strings.TrimSuffix(xmlValue, "es") - } else { - // devices -> device - xmlValue = strings.TrimSuffix(xmlValue, "s") - } - } - if deprecated { - xmlValue += ",omitempty" - } - current += fmt.Sprintf(`xml:"%s"`, xmlValue) - } - } - - if defaultValue, ok := GetFieldStringExtension(field, ext.E_Default); ok { - if len(current) > 0 { - current += " " - } - current += fmt.Sprintf(`default:"%s"`, defaultValue) - } - - if restartValue, ok := GetFieldBooleanExtension(field, ext.E_Restart); ok { - if len(current) > 0 { - current += " " - } - current += fmt.Sprintf(`restart:"%t"`, restartValue) - } - - SetStringFieldOption(field, gogoproto.E_Moretags, current) - }) +func HandleFile(file *descriptor.FileDescriptorProto) { + vanity.ForEachMessageInFiles([]*descriptor.FileDescriptorProto{file}, HandleCustomExtensions(file)) +} + +func HandleCustomExtensions(file *descriptor.FileDescriptorProto) func(msg *descriptor.DescriptorProto) { + return func(msg *descriptor.DescriptorProto) { + generateXmlTags := true + if generate, ok := GetMessageBoolExtension(msg, ext.E_XmlTags); ok { + generateXmlTags = generate + } + + vanity.ForEachField([]*descriptor.DescriptorProto{msg}, func(field *descriptor.FieldDescriptorProto) { + if field.Options == nil { + field.Options = &descriptor.FieldOptions{} + } + deprecated := field.Options.Deprecated != nil && *field.Options.Deprecated == true + + if field.Type != nil && *field.Type == descriptor.FieldDescriptorProto_TYPE_INT32 { + SetStringFieldOption(field, gogoproto.E_Casttype, "int") + } + + if field.TypeName != nil && *field.TypeName == ".google.protobuf.Timestamp" { + vanity.SetBoolFieldOption(gogoproto.E_Stdtime, true)(field) + } + + if goName, ok := GetFieldStringExtension(field, ext.E_Goname); ok { + SetStringFieldOption(field, gogoproto.E_Customname, goName) + } else if deprecated { + SetStringFieldOption(field, gogoproto.E_Customname, "Deprecated"+toCamelCase(*field.Name, true)) + } + + if goType, ok := GetFieldStringExtension(field, ext.E_Gotype); ok { + SetStringFieldOption(field, gogoproto.E_Customtype, goType) + } + + if val, ok := GetFieldBooleanExtension(field, ext.E_DeviceId); ok && val { + if *file.Options.GoPackage != "github.com/syncthing/syncthing/lib/protocol" { + SetStringFieldOption(field, gogoproto.E_Customtype, "github.com/syncthing/syncthing/lib/protocol.DeviceID") + } else { + SetStringFieldOption(field, gogoproto.E_Customtype, "DeviceID") + } + } + + if jsonValue, ok := GetFieldStringExtension(field, ext.E_Json); ok { + SetStringFieldOption(field, gogoproto.E_Jsontag, jsonValue) + } else if deprecated { + SetStringFieldOption(field, gogoproto.E_Jsontag, "-") + } else { + SetStringFieldOption(field, gogoproto.E_Jsontag, toCamelCase(*field.Name, false)) + } + + current := "" + if v, ok := GetFieldStringExtension(field, gogoproto.E_Moretags); ok { + current = v + } + + if generateXmlTags { + if len(current) > 0 { + current += " " + } + if xmlValue, ok := GetFieldStringExtension(field, ext.E_Xml); ok { + current += fmt.Sprintf(`xml:"%s"`, xmlValue) + } else { + xmlValue = toCamelCase(*field.Name, false) + // XML dictates element name within the collection, not collection name, so trim plural suffix. + if field.IsRepeated() { + if strings.HasSuffix(xmlValue, "ses") { + // addresses -> address + xmlValue = strings.TrimSuffix(xmlValue, "es") + } else { + // devices -> device + xmlValue = strings.TrimSuffix(xmlValue, "s") + } + } + if deprecated { + xmlValue += ",omitempty" + } + current += fmt.Sprintf(`xml:"%s"`, xmlValue) + } + } + + if defaultValue, ok := GetFieldStringExtension(field, ext.E_Default); ok { + if len(current) > 0 { + current += " " + } + current += fmt.Sprintf(`default:"%s"`, defaultValue) + } + + if restartValue, ok := GetFieldBooleanExtension(field, ext.E_Restart); ok { + if len(current) > 0 { + current += " " + } + current += fmt.Sprintf(`restart:"%t"`, restartValue) + } + + SetStringFieldOption(field, gogoproto.E_Moretags, current) + }) + } }