添加Gb28181Config

liuxiaolong

2020-12-29 5adb9117d705cc32a7d205ef8510919883853b9a

添加Gb28181Config

 sysset.pb.go

@@ -514,61 +514,168 @@
    return 0
}

type Gb28181Config struct {
    Id           string `protobuf:"bytes,1,opt,name=Id,proto3" json:"Id,omitempty"`
    ServerIp     string `protobuf:"bytes,2,opt,name=ServerIp,proto3" json:"ServerIp,omitempty"`
    ServerPort   string `protobuf:"bytes,3,opt,name=ServerPort,proto3" json:"ServerPort,omitempty"`
    PublicId     string `protobuf:"bytes,4,opt,name=PublicId,proto3" json:"PublicId,omitempty"`
    GbServerPort string `protobuf:"bytes,5,opt,name=GbServerPort,proto3" json:"GbServerPort,omitempty"`
    IsAuth       bool   `protobuf:"varint,6,opt,name=IsAuth,proto3" json:"IsAuth,omitempty"`
    Password     string `protobuf:"bytes,7,opt,name=Password,proto3" json:"Password,omitempty"`
    UpdateTime   string `protobuf:"bytes,8,opt,name=UpdateTime,proto3" json:"UpdateTime,omitempty"`
}

func (m *Gb28181Config) Reset()         { *m = Gb28181Config{} }
func (m *Gb28181Config) String() string { return proto.CompactTextString(m) }
func (*Gb28181Config) ProtoMessage()    {}
func (*Gb28181Config) Descriptor() ([]byte, []int) {
    return fileDescriptor_5be590c6b2a0d755, []int{5}
}
func (m *Gb28181Config) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
}
func (m *Gb28181Config) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    if deterministic {
        return xxx_messageInfo_Gb28181Config.Marshal(b, m, deterministic)
    } else {
        b = b[:cap(b)]
        n, err := m.MarshalTo(b)
        if err != nil {
            return nil, err
        }
        return b[:n], nil
    }
}
func (m *Gb28181Config) XXX_Merge(src proto.Message) {
    xxx_messageInfo_Gb28181Config.Merge(m, src)
}
func (m *Gb28181Config) XXX_Size() int {
    return m.Size()
}
func (m *Gb28181Config) XXX_DiscardUnknown() {
    xxx_messageInfo_Gb28181Config.DiscardUnknown(m)
}

var xxx_messageInfo_Gb28181Config proto.InternalMessageInfo

func (m *Gb28181Config) GetId() string {
    if m != nil {
        return m.Id
    }
    return ""
}

func (m *Gb28181Config) GetServerIp() string {
    if m != nil {
        return m.ServerIp
    }
    return ""
}

func (m *Gb28181Config) GetServerPort() string {
    if m != nil {
        return m.ServerPort
    }
    return ""
}

func (m *Gb28181Config) GetPublicId() string {
    if m != nil {
        return m.PublicId
    }
    return ""
}

func (m *Gb28181Config) GetGbServerPort() string {
    if m != nil {
        return m.GbServerPort
    }
    return ""
}

func (m *Gb28181Config) GetIsAuth() bool {
    if m != nil {
        return m.IsAuth
    }
    return false
}

func (m *Gb28181Config) GetPassword() string {
    if m != nil {
        return m.Password
    }
    return ""
}

func (m *Gb28181Config) GetUpdateTime() string {
    if m != nil {
        return m.UpdateTime
    }
    return ""
}

func init() {
    proto.RegisterType((*LocalConfig)(nil), "protomsg.LocalConfig")
    proto.RegisterType((*PollConfig)(nil), "protomsg.PollConfig")
    proto.RegisterType((*Cluster)(nil), "protomsg.Cluster")
    proto.RegisterType((*ClusterNode)(nil), "protomsg.ClusterNode")
    proto.RegisterType((*ResourceConfig)(nil), "protomsg.ResourceConfig")
    proto.RegisterType((*Gb28181Config)(nil), "protomsg.Gb28181Config")
}

func init() { proto.RegisterFile("sysset.proto", fileDescriptor_5be590c6b2a0d755) }

var fileDescriptor_5be590c6b2a0d755 = []byte{
    // 680 bytes of a gzipped FileDescriptorProto
    0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x53, 0x4d, 0x6e, 0x13, 0x4d,
    0x10, 0xcd, 0x38, 0x19, 0xdb, 0x53, 0xf6, 0xe7, 0xe4, 0x6b, 0x85, 0x30, 0x84, 0x60, 0x8c, 0x37,
    0x58, 0x20, 0x45, 0x08, 0x6e, 0x80, 0xd9, 0x58, 0x22, 0x91, 0x35, 0x8a, 0xc4, 0xd2, 0x6a, 0xcf,
    0x54, 0x92, 0x56, 0x66, 0xa6, 0x5b, 0xdd, 0xed, 0x38, 0xe6, 0x14, 0x1c, 0x82, 0x1b, 0x70, 0x09,
    0x36, 0x48, 0x59, 0x22, 0xb1, 0x41, 0xc9, 0x45, 0x50, 0xff, 0x8c, 0xed, 0x24, 0x12, 0x62, 0x65,
    0xbf, 0xf7, 0xea, 0xd5, 0x54, 0x75, 0x55, 0x41, 0x5b, 0x2d, 0x94, 0x42, 0x7d, 0x28, 0x24, 0xd7,
    0x9c, 0x34, 0xed, 0x4f, 0xa1, 0xce, 0xfa, 0xbf, 0xb6, 0xa0, 0xf5, 0x91, 0xa7, 0x34, 0x1f, 0xf2,
    0xf2, 0x94, 0x9d, 0x91, 0xa7, 0x10, 0x29, 0x94, 0x97, 0x28, 0x27, 0x2c, 0x8b, 0x83, 0x5e, 0x30,
    0x88, 0x92, 0xa6, 0x23, 0x46, 0x19, 0x79, 0x0e, 0x2d, 0x2f, 0x96, 0xb4, 0xc0, 0xb8, 0x66, 0x65,
    0x70, 0xd4, 0x31, 0x2d, 0x70, 0x2d, 0x40, 0x2f, 0x04, 0xc6, 0x9b, 0xbd, 0x60, 0x10, 0x56, 0x01,
    0x27, 0x0b, 0x81, 0xeb, 0xe9, 0x45, 0xbc, 0x75, 0x27, 0xbd, 0x20, 0x4f, 0xa0, 0x49, 0x73, 0x2a,
    0x0b, 0xa3, 0x85, 0x56, 0x6b, 0x58, 0x3c, 0x12, 0xe4, 0x19, 0x80, 0x93, 0x04, 0x97, 0x3a, 0xae,
    0xdb, 0xbc, 0x91, 0x65, 0xc6, 0x5c, 0x6a, 0x72, 0x00, 0x30, 0xc7, 0xe9, 0x44, 0xb0, 0xd4, 0x78,
    0x1b, 0x2e, 0xef, 0x1c, 0xa7, 0x63, 0x96, 0x8e, 0x04, 0xe9, 0x41, 0xbb, 0x52, 0xad, 0xbd, 0xe9,
    0xca, 0x72, 0xba, 0xf5, 0xef, 0x43, 0x84, 0xaa, 0xb2, 0x47, 0xee, 0xd3, 0xa8, 0x9c, 0xbb, 0x0b,
    0x2d, 0xaf, 0x59, 0x33, 0xb8, 0x6f, 0x5b, 0xd5, 0x7a, 0x07, 0xb0, 0x93, 0xce, 0xf4, 0xa4, 0xa0,
    0x57, 0x93, 0x6c, 0x26, 0xa9, 0x66, 0xbc, 0x8c, 0x5b, 0x36, 0xa8, 0x93, 0xce, 0xf4, 0x11, 0xbd,
    0xfa, 0xe0, 0xd9, 0x65, 0x24, 0x2b, 0x57, 0x91, 0xed, 0x55, 0x24, 0x2b, 0x97, 0x91, 0xfb, 0xd0,
    0x94, 0x68, 0xdf, 0x25, 0x8b, 0xff, 0x73, 0xdd, 0x54, 0xd8, 0xbc, 0xd2, 0x19, 0xd5, 0x38, 0x99,
    0xd3, 0x45, 0xdc, 0x71, 0xa5, 0x1a, 0xfc, 0x89, 0x2e, 0x8c, 0x54, 0xa2, 0x29, 0x45, 0x5d, 0xc4,
    0xdb, 0x4e, 0x2a, 0x51, 0x1f, 0x51, 0x75, 0x61, 0x24, 0x89, 0x34, 0x37, 0x65, 0xc6, 0x3b, 0xf6,
    0x9b, 0x0d, 0x83, 0x8f, 0xe8, 0x15, 0x79, 0x03, 0xbb, 0xee, 0x6d, 0xf5, 0xb9, 0x44, 0x75, 0xce,
    0xf3, 0xcc, 0x4d, 0xef, 0x7f, 0x1b, 0x46, 0xac, 0x76, 0x52, 0x49, 0x76, 0x8a, 0x2f, 0x61, 0xfb,
    0x9e, 0x23, 0x26, 0xae, 0x8f, 0xbb, 0xc1, 0xfd, 0xaf, 0x01, 0xc0, 0x98, 0xe7, 0xff, 0xba, 0x5c,
    0x82, 0xe7, 0xf9, 0x44, 0xa0, 0x64, 0x3c, 0xb3, 0xcb, 0x15, 0x26, 0x60, 0xa8, 0xb1, 0x65, 0xc8,
    0x2e, 0x84, 0x19, 0xe6, 0x74, 0xe1, 0xd7, 0xca, 0x01, 0xb2, 0x07, 0x75, 0x2c, 0xe9, 0x34, 0x47,
    0xbb, 0x4e, 0xcd, 0xc4, 0x23, 0xf2, 0x0a, 0x76, 0x8c, 0x77, 0x78, 0x4e, 0xcb, 0x12, 0xf3, 0x21,
    0x9f, 0x95, 0xda, 0x2e, 0x55, 0x98, 0x3c, 0xe0, 0xfb, 0xdf, 0x02, 0x68, 0x0c, 0xf3, 0x99, 0xd2,
    0x28, 0xcd, 0xa6, 0xa5, 0xee, 0xef, 0xaa, 0xc8, 0xc8, 0x33, 0xa3, 0x8c, 0xbc, 0x80, 0x76, 0x25,
    0xaf, 0xdd, 0x40, 0xcb, 0x73, 0xf6, 0x08, 0xf6, 0xa1, 0x29, 0xa8, 0x52, 0x73, 0x2e, 0x33, 0x5b,
    0x6a, 0x94, 0x2c, 0xb1, 0xc9, 0x7e, 0xc9, 0xa4, 0x9e, 0xd1, 0x7c, 0x75, 0x00, 0x91, 0x67, 0x46,
    0x82, 0xbc, 0x86, 0xb0, 0xe4, 0x19, 0xaa, 0x38, 0xec, 0x6d, 0x0e, 0x5a, 0x6f, 0x1f, 0x1d, 0x56,
    0x77, 0x7a, 0xe8, 0xcb, 0x3b, 0xe6, 0x19, 0x26, 0x2e, 0xa6, 0xff, 0x23, 0x80, 0xd6, 0x1a, 0x4d,
    0x3a, 0x50, 0x5b, 0x56, 0x5c, 0x63, 0xd9, 0xbd, 0x4e, 0x6a, 0xf7, 0x3b, 0xb9, 0x33, 0x8c, 0xcd,
    0xbf, 0x5f, 0xfa, 0xd6, 0x83, 0x4b, 0x7f, 0x0c, 0x0d, 0x53, 0x85, 0xf1, 0xba, 0x53, 0xad, 0x1b,
    0x38, 0xca, 0x56, 0x82, 0xb0, 0x67, 0x5a, 0x09, 0xc2, 0xa4, 0x4c, 0x25, 0x9a, 0xcd, 0xd5, 0xac,
    0x40, 0x7f, 0xa4, 0xe0, 0xa8, 0x13, 0x56, 0x60, 0xff, 0x33, 0x74, 0x12, 0x54, 0x7c, 0x26, 0x53,
    0xf4, 0xfb, 0xb2, 0x07, 0x75, 0x26, 0xcc, 0xc6, 0xd9, 0xae, 0xc2, 0xc4, 0x23, 0x72, 0xe0, 0x4a,
    0x67, 0x29, 0x8e, 0x44, 0xd5, 0xd8, 0x92, 0x30, 0xae, 0x8c, 0x17, 0x94, 0x95, 0xbe, 0x2b, 0x8f,
    0xcc, 0x5c, 0x4e, 0x59, 0x8e, 0xe6, 0x68, 0x6d, 0x43, 0x61, 0xb2, 0xc4, 0xef, 0xe3, 0xef, 0x37,
    0xdd, 0xe0, 0xfa, 0xa6, 0x1b, 0xfc, 0xbe, 0xe9, 0x06, 0x5f, 0x6e, 0xbb, 0x1b, 0xd7, 0xb7, 0xdd,
    0x8d, 0x9f, 0xb7, 0xdd, 0x8d, 0x69, 0xdd, 0x8e, 0xe0, 0xdd, 0x9f, 0x00, 0x00, 0x00, 0xff, 0xff,
    0x79, 0xee, 0xda, 0x54, 0x41, 0x05, 0x00, 0x00,
    // 782 bytes of a gzipped FileDescriptorProto
    0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x54, 0xdd, 0x6e, 0x1b, 0x45,
    0x14, 0xce, 0x3a, 0x59, 0xdb, 0x7b, 0xec, 0xba, 0x61, 0x54, 0xca, 0x12, 0xca, 0x12, 0x7c, 0x43,
    0x04, 0x52, 0x44, 0xcb, 0x4d, 0x6f, 0x21, 0x48, 0xd5, 0x4a, 0xa4, 0xb2, 0x96, 0x20, 0x2e, 0xad,
    0xf1, 0xce, 0x69, 0x32, 0xea, 0xee, 0xce, 0x68, 0x66, 0xb6, 0x89, 0x79, 0x0a, 0x1e, 0x82, 0x37,
    0xe0, 0x25, 0xb8, 0x41, 0xea, 0x25, 0x12, 0x37, 0x28, 0x79, 0x00, 0x5e, 0x01, 0xcd, 0xcf, 0xae,
    0xed, 0x54, 0x42, 0xbd, 0xb2, 0xbf, 0xef, 0x3b, 0xdf, 0x99, 0x73, 0x66, 0xcf, 0x19, 0x98, 0xea,
    0xb5, 0xd6, 0x68, 0x4e, 0xa5, 0x12, 0x46, 0x90, 0xb1, 0xfb, 0xa9, 0xf5, 0xe5, 0xfc, 0xef, 0x03,
    0x98, 0xfc, 0x20, 0x4a, 0x5a, 0x9d, 0x89, 0xe6, 0x15, 0xbf, 0x24, 0x9f, 0x40, 0xa2, 0x51, 0xbd,
    0x41, 0xb5, 0xe4, 0x2c, 0x8d, 0x8e, 0xa3, 0x93, 0xa4, 0x18, 0x7b, 0x22, 0x67, 0xe4, 0x33, 0x98,
    0x04, 0xb1, 0xa1, 0x35, 0xa6, 0x03, 0x27, 0x83, 0xa7, 0x5e, 0xd2, 0x1a, 0xb7, 0x02, 0xcc, 0x5a,
    0x62, 0xba, 0x7f, 0x1c, 0x9d, 0xc4, 0x5d, 0xc0, 0xc5, 0x5a, 0xe2, 0x76, 0x7a, 0x99, 0x1e, 0xec,
    0xa4, 0x97, 0xe4, 0x63, 0x18, 0xd3, 0x8a, 0xaa, 0xda, 0x6a, 0xb1, 0xd3, 0x46, 0x0e, 0xe7, 0x92,
    0x7c, 0x0a, 0xe0, 0x25, 0x29, 0x94, 0x49, 0x87, 0x2e, 0x6f, 0xe2, 0x98, 0x85, 0x50, 0x86, 0x3c,
    0x01, 0xb8, 0xc6, 0xd5, 0x52, 0xf2, 0xd2, 0x7a, 0x47, 0x3e, 0xef, 0x35, 0xae, 0x16, 0xbc, 0xcc,
    0x25, 0x39, 0x86, 0x69, 0xa7, 0x3a, 0xfb, 0xd8, 0x97, 0xe5, 0x75, 0xe7, 0x3f, 0x82, 0x04, 0x75,
    0x67, 0x4f, 0xfc, 0xd1, 0xa8, 0xbd, 0x3b, 0x83, 0x49, 0xd0, 0x9c, 0x19, 0xfc, 0xd9, 0x4e, 0x75,
    0xde, 0x13, 0x38, 0x2c, 0x5b, 0xb3, 0xac, 0xe9, 0xcd, 0x92, 0xb5, 0x8a, 0x1a, 0x2e, 0x9a, 0x74,
    0xe2, 0x82, 0x66, 0x65, 0x6b, 0xce, 0xe9, 0xcd, 0xf7, 0x81, 0xed, 0x23, 0x79, 0xb3, 0x89, 0x9c,
    0x6e, 0x22, 0x79, 0xd3, 0x47, 0x1e, 0xc1, 0x58, 0xa1, 0xbb, 0x17, 0x96, 0x3e, 0xf0, 0xdd, 0x74,
    0xd8, 0xde, 0xd2, 0x25, 0x35, 0xb8, 0xbc, 0xa6, 0xeb, 0x74, 0xe6, 0x4b, 0xb5, 0xf8, 0x67, 0xba,
    0xb6, 0x52, 0x83, 0xb6, 0x14, 0xfd, 0x3a, 0x7d, 0xe8, 0xa5, 0x06, 0xcd, 0x39, 0xd5, 0xaf, 0xad,
    0xa4, 0x90, 0x56, 0xb6, 0xcc, 0xf4, 0xd0, 0x9d, 0x39, 0xb2, 0xf8, 0x9c, 0xde, 0x90, 0xaf, 0xe1,
    0x91, 0xbf, 0x5b, 0x73, 0xa5, 0x50, 0x5f, 0x89, 0x8a, 0xf9, 0xaf, 0xf7, 0x81, 0x0b, 0x23, 0x4e,
    0xbb, 0xe8, 0x24, 0xf7, 0x15, 0xbf, 0x80, 0x87, 0xf7, 0x1c, 0x29, 0xf1, 0x7d, 0xec, 0x06, 0xcf,
    0x7f, 0x8b, 0x00, 0x16, 0xa2, 0x7a, 0xdf, 0xe1, 0x92, 0xa2, 0xaa, 0x96, 0x12, 0x15, 0x17, 0xcc,
    0x0d, 0x57, 0x5c, 0x80, 0xa5, 0x16, 0x8e, 0x21, 0x8f, 0x20, 0x66, 0x58, 0xd1, 0x75, 0x18, 0x2b,
    0x0f, 0xc8, 0x63, 0x18, 0x62, 0x43, 0x57, 0x15, 0xba, 0x71, 0x1a, 0x17, 0x01, 0x91, 0x2f, 0xe1,
    0xd0, 0x7a, 0xcf, 0xae, 0x68, 0xd3, 0x60, 0x75, 0x26, 0xda, 0xc6, 0xb8, 0xa1, 0x8a, 0x8b, 0x77,
    0xf8, 0xf9, 0xef, 0x11, 0x8c, 0xce, 0xaa, 0x56, 0x1b, 0x54, 0x76, 0xd2, 0x4a, 0xff, 0x77, 0x53,
    0x64, 0x12, 0x98, 0x9c, 0x91, 0xcf, 0x61, 0xda, 0xc9, 0x5b, 0x3b, 0x30, 0x09, 0x9c, 0x5b, 0x82,
    0x23, 0x18, 0x4b, 0xaa, 0xf5, 0xb5, 0x50, 0xcc, 0x95, 0x9a, 0x14, 0x3d, 0xb6, 0xd9, 0xdf, 0x70,
    0x65, 0x5a, 0x5a, 0x6d, 0x16, 0x20, 0x09, 0x4c, 0x2e, 0xc9, 0x57, 0x10, 0x37, 0x82, 0xa1, 0x4e,
    0xe3, 0xe3, 0xfd, 0x93, 0xc9, 0xb3, 0x0f, 0x4f, 0xbb, 0x3d, 0x3d, 0x0d, 0xe5, 0xbd, 0x14, 0x0c,
    0x0b, 0x1f, 0x33, 0xff, 0x33, 0x82, 0xc9, 0x16, 0x4d, 0x66, 0x30, 0xe8, 0x2b, 0x1e, 0x70, 0x76,
    0xaf, 0x93, 0xc1, 0xfd, 0x4e, 0x76, 0x3e, 0xc6, 0xfe, 0xff, 0x6f, 0xfa, 0xc1, 0x3b, 0x9b, 0xfe,
    0x11, 0x8c, 0x6c, 0x15, 0xd6, 0xeb, 0x57, 0x75, 0x68, 0x61, 0xce, 0x36, 0x82, 0x74, 0x6b, 0xda,
    0x09, 0xd2, 0xa6, 0x2c, 0x15, 0xda, 0xc9, 0x35, 0xbc, 0xc6, 0xb0, 0xa4, 0xe0, 0xa9, 0x0b, 0x5e,
    0xe3, 0xfc, 0x17, 0x98, 0x15, 0xa8, 0x45, 0xab, 0x4a, 0x0c, 0xf3, 0xf2, 0x18, 0x86, 0x5c, 0xda,
    0x89, 0x73, 0x5d, 0xc5, 0x45, 0x40, 0xe4, 0x89, 0x2f, 0x9d, 0x97, 0x98, 0xcb, 0xae, 0xb1, 0x9e,
    0xb0, 0x2e, 0x26, 0x6a, 0xca, 0x9b, 0xd0, 0x55, 0x40, 0xf6, 0xbb, 0xbc, 0xe2, 0x15, 0xda, 0xa5,
    0x75, 0x0d, 0xc5, 0x45, 0x8f, 0xe7, 0xff, 0x46, 0xf0, 0xe0, 0xc5, 0xea, 0xd9, 0xf3, 0xa7, 0xcf,
    0x9f, 0x86, 0xb3, 0x67, 0x30, 0xc8, 0xfb, 0xdb, 0xcc, 0x99, 0x75, 0xff, 0x18, 0x1e, 0xaa, 0x70,
    0x64, 0x8f, 0x49, 0x06, 0xe0, 0xff, 0xbb, 0xdc, 0xfe, 0xd4, 0x2d, 0xc6, 0x7a, 0x17, 0xed, 0xaa,
    0xe2, 0x65, 0xce, 0xba, 0x47, 0xaf, 0xc3, 0x64, 0x0e, 0xd3, 0x17, 0xab, 0x2d, 0xb7, 0xbf, 0xcd,
    0x1d, 0xce, 0x76, 0x94, 0xeb, 0x6f, 0x5b, 0x73, 0xe5, 0xae, 0x74, 0x5c, 0x04, 0xe4, 0xf2, 0x76,
    0x93, 0x16, 0x1e, 0xbd, 0x0e, 0xdb, 0x9a, 0x7e, 0x92, 0x2c, 0xdc, 0xad, 0x7b, 0xf2, 0x92, 0x62,
    0x8b, 0xf9, 0x2e, 0xfd, 0xe3, 0x36, 0x8b, 0xde, 0xde, 0x66, 0xd1, 0x3f, 0xb7, 0x59, 0xf4, 0xeb,
    0x5d, 0xb6, 0xf7, 0xf6, 0x2e, 0xdb, 0xfb, 0xeb, 0x2e, 0xdb, 0x5b, 0x0d, 0xdd, 0xd0, 0x7d, 0xf3,
    0x5f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xdc, 0xb0, 0x46, 0x16, 0x33, 0x06, 0x00, 0x00,
}

func (m *LocalConfig) Marshal() (dAtA []byte, err error) {
@@ -897,6 +1004,76 @@
    return i, nil
}

func (m *Gb28181Config) Marshal() (dAtA []byte, err error) {
    size := m.Size()
    dAtA = make([]byte, size)
    n, err := m.MarshalTo(dAtA)
    if err != nil {
        return nil, err
    }
    return dAtA[:n], nil
}

func (m *Gb28181Config) MarshalTo(dAtA []byte) (int, error) {
    var i int
    _ = i
    var l int
    _ = l
    if len(m.Id) > 0 {
        dAtA[i] = 0xa
        i++
        i = encodeVarintSysset(dAtA, i, uint64(len(m.Id)))
        i += copy(dAtA[i:], m.Id)
    }
    if len(m.ServerIp) > 0 {
        dAtA[i] = 0x12
        i++
        i = encodeVarintSysset(dAtA, i, uint64(len(m.ServerIp)))
        i += copy(dAtA[i:], m.ServerIp)
    }
    if len(m.ServerPort) > 0 {
        dAtA[i] = 0x1a
        i++
        i = encodeVarintSysset(dAtA, i, uint64(len(m.ServerPort)))
        i += copy(dAtA[i:], m.ServerPort)
    }
    if len(m.PublicId) > 0 {
        dAtA[i] = 0x22
        i++
        i = encodeVarintSysset(dAtA, i, uint64(len(m.PublicId)))
        i += copy(dAtA[i:], m.PublicId)
    }
    if len(m.GbServerPort) > 0 {
        dAtA[i] = 0x2a
        i++
        i = encodeVarintSysset(dAtA, i, uint64(len(m.GbServerPort)))
        i += copy(dAtA[i:], m.GbServerPort)
    }
    if m.IsAuth {
        dAtA[i] = 0x30
        i++
        if m.IsAuth {
            dAtA[i] = 1
        } else {
            dAtA[i] = 0
        }
        i++
    }
    if len(m.Password) > 0 {
        dAtA[i] = 0x3a
        i++
        i = encodeVarintSysset(dAtA, i, uint64(len(m.Password)))
        i += copy(dAtA[i:], m.Password)
    }
    if len(m.UpdateTime) > 0 {
        dAtA[i] = 0x42
        i++
        i = encodeVarintSysset(dAtA, i, uint64(len(m.UpdateTime)))
        i += copy(dAtA[i:], m.UpdateTime)
    }
    return i, nil
}

func encodeVarintSysset(dAtA []byte, offset int, v uint64) int {
    for v >= 1<<7 {
        dAtA[offset] = uint8(v&0x7f | 0x80)
@@ -1090,6 +1267,46 @@
    }
    if m.FilePort != 0 {
        n += 1 + sovSysset(uint64(m.FilePort))
    }
    return n
}

func (m *Gb28181Config) Size() (n int) {
    if m == nil {
        return 0
    }
    var l int
    _ = l
    l = len(m.Id)
    if l > 0 {
        n += 1 + l + sovSysset(uint64(l))
    }
    l = len(m.ServerIp)
    if l > 0 {
        n += 1 + l + sovSysset(uint64(l))
    }
    l = len(m.ServerPort)
    if l > 0 {
        n += 1 + l + sovSysset(uint64(l))
    }
    l = len(m.PublicId)
    if l > 0 {
        n += 1 + l + sovSysset(uint64(l))
    }
    l = len(m.GbServerPort)
    if l > 0 {
        n += 1 + l + sovSysset(uint64(l))
    }
    if m.IsAuth {
        n += 2
    }
    l = len(m.Password)
    if l > 0 {
        n += 1 + l + sovSysset(uint64(l))
    }
    l = len(m.UpdateTime)
    if l > 0 {
        n += 1 + l + sovSysset(uint64(l))
    }
    return n
}
@@ -2421,6 +2638,303 @@
    }
    return nil
}
func (m *Gb28181Config) 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 ErrIntOverflowSysset
            }
            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: Gb28181Config: wiretype end group for non-group")
        }
        if fieldNum <= 0 {
            return fmt.Errorf("proto: Gb28181Config: 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 ErrIntOverflowSysset
                }
                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 ErrInvalidLengthSysset
            }
            postIndex := iNdEx + intStringLen
            if postIndex < 0 {
                return ErrInvalidLengthSysset
            }
            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 ServerIp", wireType)
            }
            var stringLen uint64
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowSysset
                }
                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 ErrInvalidLengthSysset
            }
            postIndex := iNdEx + intStringLen
            if postIndex < 0 {
                return ErrInvalidLengthSysset
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.ServerIp = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        case 3:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field ServerPort", wireType)
            }
            var stringLen uint64
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowSysset
                }
                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 ErrInvalidLengthSysset
            }
            postIndex := iNdEx + intStringLen
            if postIndex < 0 {
                return ErrInvalidLengthSysset
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.ServerPort = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        case 4:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field PublicId", wireType)
            }
            var stringLen uint64
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowSysset
                }
                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 ErrInvalidLengthSysset
            }
            postIndex := iNdEx + intStringLen
            if postIndex < 0 {
                return ErrInvalidLengthSysset
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.PublicId = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        case 5:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field GbServerPort", wireType)
            }
            var stringLen uint64
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowSysset
                }
                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 ErrInvalidLengthSysset
            }
            postIndex := iNdEx + intStringLen
            if postIndex < 0 {
                return ErrInvalidLengthSysset
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.GbServerPort = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        case 6:
            if wireType != 0 {
                return fmt.Errorf("proto: wrong wireType = %d for field IsAuth", wireType)
            }
            var v int
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowSysset
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                v |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            m.IsAuth = bool(v != 0)
        case 7:
            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 ErrIntOverflowSysset
                }
                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 ErrInvalidLengthSysset
            }
            postIndex := iNdEx + intStringLen
            if postIndex < 0 {
                return ErrInvalidLengthSysset
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.Password = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        case 8:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field UpdateTime", wireType)
            }
            var stringLen uint64
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowSysset
                }
                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 ErrInvalidLengthSysset
            }
            postIndex := iNdEx + intStringLen
            if postIndex < 0 {
                return ErrInvalidLengthSysset
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.UpdateTime = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        default:
            iNdEx = preIndex
            skippy, err := skipSysset(dAtA[iNdEx:])
            if err != nil {
                return err
            }
            if skippy < 0 {
                return ErrInvalidLengthSysset
            }
            if (iNdEx + skippy) < 0 {
                return ErrInvalidLengthSysset
            }
            if (iNdEx + skippy) > l {
                return io.ErrUnexpectedEOF
            }
            iNdEx += skippy
        }
    }

    if iNdEx > l {
        return io.ErrUnexpectedEOF
    }
    return nil
}
func skipSysset(dAtA []byte) (n int, err error) {
    l := len(dAtA)
    iNdEx := 0

 sysset.proto

@@ -55,4 +55,15 @@
    string serviceIp = 2;
    string domain = 3;
    int32 filePort = 4;
}

message Gb28181Config {
    string Id = 1;
    string ServerIp = 2;
    string ServerPort = 3;
    string PublicId = 4;
    string GbServerPort = 5;
    bool IsAuth = 6;
    string Password = 7;
    string UpdateTime = 8;
}