调整项目结构、尝试支持安卓

switch/src/proto/message.rs

@@ -0,0 +1,941 @@
+// This file is generated by rust-protobuf 3.2.0. Do not edit
+// .proto file is parsed by pure
+// @generated
+
+// https://github.com/rust-lang/rust-clippy/issues/702
+#![allow(unknown_lints)]
+#![allow(clippy::all)]
+
+#![allow(unused_attributes)]
+#![cfg_attr(rustfmt, rustfmt::skip)]
+
+#![allow(box_pointers)]
+#![allow(dead_code)]
+#![allow(missing_docs)]
+#![allow(non_camel_case_types)]
+#![allow(non_snake_case)]
+#![allow(non_upper_case_globals)]
+#![allow(trivial_casts)]
+#![allow(unused_results)]
+#![allow(unused_mut)]
+
+//! Generated file from `message.proto`
+
+/// Generated files are compatible only with the same version
+/// of protobuf runtime.
+const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_3_2_0;
+
+#[derive(PartialEq,Clone,Default,Debug)]
+// @@protoc_insertion_point(message:RegistrationRequest)
+pub struct RegistrationRequest {
+    // message fields
+    // @@protoc_insertion_point(field:RegistrationRequest.token)
+    pub token: ::std::string::String,
+    // @@protoc_insertion_point(field:RegistrationRequest.mac_address)
+    pub mac_address: ::std::string::String,
+    // special fields
+    // @@protoc_insertion_point(special_field:RegistrationRequest.special_fields)
+    pub special_fields: ::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a RegistrationRequest {
+    fn default() -> &'a RegistrationRequest {
+        <RegistrationRequest as ::protobuf::Message>::default_instance()
+    }
+}
+
+impl RegistrationRequest {
+    pub fn new() -> RegistrationRequest {
+        ::std::default::Default::default()
+    }
+
+    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
+        let mut fields = ::std::vec::Vec::with_capacity(2);
+        let mut oneofs = ::std::vec::Vec::with_capacity(0);
+        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
+            "token",
+            |m: &RegistrationRequest| { &m.token },
+            |m: &mut RegistrationRequest| { &mut m.token },
+        ));
+        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
+            "mac_address",
+            |m: &RegistrationRequest| { &m.mac_address },
+            |m: &mut RegistrationRequest| { &mut m.mac_address },
+        ));
+        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<RegistrationRequest>(
+            "RegistrationRequest",
+            fields,
+            oneofs,
+        )
+    }
+}
+
+impl ::protobuf::Message for RegistrationRequest {
+    const NAME: &'static str = "RegistrationRequest";
+
+    fn is_initialized(&self) -> bool {
+        true
+    }
+
+    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
+        while let Some(tag) = is.read_raw_tag_or_eof()? {
+            match tag {
+                10 => {
+                    self.token = is.read_string()?;
+                },
+                18 => {
+                    self.mac_address = is.read_string()?;
+                },
+                tag => {
+                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
+                },
+            };
+        }
+        ::std::result::Result::Ok(())
+    }
+
+    // Compute sizes of nested messages
+    #[allow(unused_variables)]
+    fn compute_size(&self) -> u64 {
+        let mut my_size = 0;
+        if !self.token.is_empty() {
+            my_size += ::protobuf::rt::string_size(1, &self.token);
+        }
+        if !self.mac_address.is_empty() {
+            my_size += ::protobuf::rt::string_size(2, &self.mac_address);
+        }
+        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
+        self.special_fields.cached_size().set(my_size as u32);
+        my_size
+    }
+
+    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
+        if !self.token.is_empty() {
+            os.write_string(1, &self.token)?;
+        }
+        if !self.mac_address.is_empty() {
+            os.write_string(2, &self.mac_address)?;
+        }
+        os.write_unknown_fields(self.special_fields.unknown_fields())?;
+        ::std::result::Result::Ok(())
+    }
+
+    fn special_fields(&self) -> &::protobuf::SpecialFields {
+        &self.special_fields
+    }
+
+    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
+        &mut self.special_fields
+    }
+
+    fn new() -> RegistrationRequest {
+        RegistrationRequest::new()
+    }
+
+    fn clear(&mut self) {
+        self.token.clear();
+        self.mac_address.clear();
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static RegistrationRequest {
+        static instance: RegistrationRequest = RegistrationRequest {
+            token: ::std::string::String::new(),
+            mac_address: ::std::string::String::new(),
+            special_fields: ::protobuf::SpecialFields::new(),
+        };
+        &instance
+    }
+}
+
+impl ::protobuf::MessageFull for RegistrationRequest {
+    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
+        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
+        descriptor.get(|| file_descriptor().message_by_package_relative_name("RegistrationRequest").unwrap()).clone()
+    }
+}
+
+impl ::std::fmt::Display for RegistrationRequest {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        ::protobuf::text_format::fmt(self, f)
+    }
+}
+
+impl ::protobuf::reflect::ProtobufValue for RegistrationRequest {
+    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
+}
+
+#[derive(PartialEq,Clone,Default,Debug)]
+// @@protoc_insertion_point(message:RegistrationResponse)
+pub struct RegistrationResponse {
+    // message fields
+    // @@protoc_insertion_point(field:RegistrationResponse.virtual_ip)
+    pub virtual_ip: u32,
+    // @@protoc_insertion_point(field:RegistrationResponse.virtual_gateway)
+    pub virtual_gateway: u32,
+    // @@protoc_insertion_point(field:RegistrationResponse.virtual_netmask)
+    pub virtual_netmask: u32,
+    // @@protoc_insertion_point(field:RegistrationResponse.epoch)
+    pub epoch: u32,
+    // @@protoc_insertion_point(field:RegistrationResponse.virtual_ip_list)
+    pub virtual_ip_list: ::std::vec::Vec<u32>,
+    // @@protoc_insertion_point(field:RegistrationResponse.public_ip)
+    pub public_ip: u32,
+    // @@protoc_insertion_point(field:RegistrationResponse.public_port)
+    pub public_port: u32,
+    // special fields
+    // @@protoc_insertion_point(special_field:RegistrationResponse.special_fields)
+    pub special_fields: ::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a RegistrationResponse {
+    fn default() -> &'a RegistrationResponse {
+        <RegistrationResponse as ::protobuf::Message>::default_instance()
+    }
+}
+
+impl RegistrationResponse {
+    pub fn new() -> RegistrationResponse {
+        ::std::default::Default::default()
+    }
+
+    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
+        let mut fields = ::std::vec::Vec::with_capacity(7);
+        let mut oneofs = ::std::vec::Vec::with_capacity(0);
+        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
+            "virtual_ip",
+            |m: &RegistrationResponse| { &m.virtual_ip },
+            |m: &mut RegistrationResponse| { &mut m.virtual_ip },
+        ));
+        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
+            "virtual_gateway",
+            |m: &RegistrationResponse| { &m.virtual_gateway },
+            |m: &mut RegistrationResponse| { &mut m.virtual_gateway },
+        ));
+        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
+            "virtual_netmask",
+            |m: &RegistrationResponse| { &m.virtual_netmask },
+            |m: &mut RegistrationResponse| { &mut m.virtual_netmask },
+        ));
+        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
+            "epoch",
+            |m: &RegistrationResponse| { &m.epoch },
+            |m: &mut RegistrationResponse| { &mut m.epoch },
+        ));
+        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
+            "virtual_ip_list",
+            |m: &RegistrationResponse| { &m.virtual_ip_list },
+            |m: &mut RegistrationResponse| { &mut m.virtual_ip_list },
+        ));
+        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
+            "public_ip",
+            |m: &RegistrationResponse| { &m.public_ip },
+            |m: &mut RegistrationResponse| { &mut m.public_ip },
+        ));
+        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
+            "public_port",
+            |m: &RegistrationResponse| { &m.public_port },
+            |m: &mut RegistrationResponse| { &mut m.public_port },
+        ));
+        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<RegistrationResponse>(
+            "RegistrationResponse",
+            fields,
+            oneofs,
+        )
+    }
+}
+
+impl ::protobuf::Message for RegistrationResponse {
+    const NAME: &'static str = "RegistrationResponse";
+
+    fn is_initialized(&self) -> bool {
+        true
+    }
+
+    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
+        while let Some(tag) = is.read_raw_tag_or_eof()? {
+            match tag {
+                13 => {
+                    self.virtual_ip = is.read_fixed32()?;
+                },
+                21 => {
+                    self.virtual_gateway = is.read_fixed32()?;
+                },
+                29 => {
+                    self.virtual_netmask = is.read_fixed32()?;
+                },
+                32 => {
+                    self.epoch = is.read_uint32()?;
+                },
+                42 => {
+                    is.read_repeated_packed_fixed32_into(&mut self.virtual_ip_list)?;
+                },
+                45 => {
+                    self.virtual_ip_list.push(is.read_fixed32()?);
+                },
+                53 => {
+                    self.public_ip = is.read_fixed32()?;
+                },
+                56 => {
+                    self.public_port = is.read_uint32()?;
+                },
+                tag => {
+                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
+                },
+            };
+        }
+        ::std::result::Result::Ok(())
+    }
+
+    // Compute sizes of nested messages
+    #[allow(unused_variables)]
+    fn compute_size(&self) -> u64 {
+        let mut my_size = 0;
+        if self.virtual_ip != 0 {
+            my_size += 1 + 4;
+        }
+        if self.virtual_gateway != 0 {
+            my_size += 1 + 4;
+        }
+        if self.virtual_netmask != 0 {
+            my_size += 1 + 4;
+        }
+        if self.epoch != 0 {
+            my_size += ::protobuf::rt::uint32_size(4, self.epoch);
+        }
+        my_size += 5 * self.virtual_ip_list.len() as u64;
+        if self.public_ip != 0 {
+            my_size += 1 + 4;
+        }
+        if self.public_port != 0 {
+            my_size += ::protobuf::rt::uint32_size(7, self.public_port);
+        }
+        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
+        self.special_fields.cached_size().set(my_size as u32);
+        my_size
+    }
+
+    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
+        if self.virtual_ip != 0 {
+            os.write_fixed32(1, self.virtual_ip)?;
+        }
+        if self.virtual_gateway != 0 {
+            os.write_fixed32(2, self.virtual_gateway)?;
+        }
+        if self.virtual_netmask != 0 {
+            os.write_fixed32(3, self.virtual_netmask)?;
+        }
+        if self.epoch != 0 {
+            os.write_uint32(4, self.epoch)?;
+        }
+        for v in &self.virtual_ip_list {
+            os.write_fixed32(5, *v)?;
+        };
+        if self.public_ip != 0 {
+            os.write_fixed32(6, self.public_ip)?;
+        }
+        if self.public_port != 0 {
+            os.write_uint32(7, self.public_port)?;
+        }
+        os.write_unknown_fields(self.special_fields.unknown_fields())?;
+        ::std::result::Result::Ok(())
+    }
+
+    fn special_fields(&self) -> &::protobuf::SpecialFields {
+        &self.special_fields
+    }
+
+    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
+        &mut self.special_fields
+    }
+
+    fn new() -> RegistrationResponse {
+        RegistrationResponse::new()
+    }
+
+    fn clear(&mut self) {
+        self.virtual_ip = 0;
+        self.virtual_gateway = 0;
+        self.virtual_netmask = 0;
+        self.epoch = 0;
+        self.virtual_ip_list.clear();
+        self.public_ip = 0;
+        self.public_port = 0;
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static RegistrationResponse {
+        static instance: RegistrationResponse = RegistrationResponse {
+            virtual_ip: 0,
+            virtual_gateway: 0,
+            virtual_netmask: 0,
+            epoch: 0,
+            virtual_ip_list: ::std::vec::Vec::new(),
+            public_ip: 0,
+            public_port: 0,
+            special_fields: ::protobuf::SpecialFields::new(),
+        };
+        &instance
+    }
+}
+
+impl ::protobuf::MessageFull for RegistrationResponse {
+    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
+        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
+        descriptor.get(|| file_descriptor().message_by_package_relative_name("RegistrationResponse").unwrap()).clone()
+    }
+}
+
+impl ::std::fmt::Display for RegistrationResponse {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        ::protobuf::text_format::fmt(self, f)
+    }
+}
+
+impl ::protobuf::reflect::ProtobufValue for RegistrationResponse {
+    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
+}
+
+#[derive(PartialEq,Clone,Default,Debug)]
+// @@protoc_insertion_point(message:DeviceList)
+pub struct DeviceList {
+    // message fields
+    // @@protoc_insertion_point(field:DeviceList.epoch)
+    pub epoch: u32,
+    // @@protoc_insertion_point(field:DeviceList.virtual_ip_list)
+    pub virtual_ip_list: ::std::vec::Vec<u32>,
+    // special fields
+    // @@protoc_insertion_point(special_field:DeviceList.special_fields)
+    pub special_fields: ::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a DeviceList {
+    fn default() -> &'a DeviceList {
+        <DeviceList as ::protobuf::Message>::default_instance()
+    }
+}
+
+impl DeviceList {
+    pub fn new() -> DeviceList {
+        ::std::default::Default::default()
+    }
+
+    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
+        let mut fields = ::std::vec::Vec::with_capacity(2);
+        let mut oneofs = ::std::vec::Vec::with_capacity(0);
+        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
+            "epoch",
+            |m: &DeviceList| { &m.epoch },
+            |m: &mut DeviceList| { &mut m.epoch },
+        ));
+        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
+            "virtual_ip_list",
+            |m: &DeviceList| { &m.virtual_ip_list },
+            |m: &mut DeviceList| { &mut m.virtual_ip_list },
+        ));
+        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<DeviceList>(
+            "DeviceList",
+            fields,
+            oneofs,
+        )
+    }
+}
+
+impl ::protobuf::Message for DeviceList {
+    const NAME: &'static str = "DeviceList";
+
+    fn is_initialized(&self) -> bool {
+        true
+    }
+
+    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
+        while let Some(tag) = is.read_raw_tag_or_eof()? {
+            match tag {
+                8 => {
+                    self.epoch = is.read_uint32()?;
+                },
+                18 => {
+                    is.read_repeated_packed_fixed32_into(&mut self.virtual_ip_list)?;
+                },
+                21 => {
+                    self.virtual_ip_list.push(is.read_fixed32()?);
+                },
+                tag => {
+                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
+                },
+            };
+        }
+        ::std::result::Result::Ok(())
+    }
+
+    // Compute sizes of nested messages
+    #[allow(unused_variables)]
+    fn compute_size(&self) -> u64 {
+        let mut my_size = 0;
+        if self.epoch != 0 {
+            my_size += ::protobuf::rt::uint32_size(1, self.epoch);
+        }
+        my_size += 5 * self.virtual_ip_list.len() as u64;
+        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
+        self.special_fields.cached_size().set(my_size as u32);
+        my_size
+    }
+
+    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
+        if self.epoch != 0 {
+            os.write_uint32(1, self.epoch)?;
+        }
+        for v in &self.virtual_ip_list {
+            os.write_fixed32(2, *v)?;
+        };
+        os.write_unknown_fields(self.special_fields.unknown_fields())?;
+        ::std::result::Result::Ok(())
+    }
+
+    fn special_fields(&self) -> &::protobuf::SpecialFields {
+        &self.special_fields
+    }
+
+    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
+        &mut self.special_fields
+    }
+
+    fn new() -> DeviceList {
+        DeviceList::new()
+    }
+
+    fn clear(&mut self) {
+        self.epoch = 0;
+        self.virtual_ip_list.clear();
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static DeviceList {
+        static instance: DeviceList = DeviceList {
+            epoch: 0,
+            virtual_ip_list: ::std::vec::Vec::new(),
+            special_fields: ::protobuf::SpecialFields::new(),
+        };
+        &instance
+    }
+}
+
+impl ::protobuf::MessageFull for DeviceList {
+    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
+        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
+        descriptor.get(|| file_descriptor().message_by_package_relative_name("DeviceList").unwrap()).clone()
+    }
+}
+
+impl ::std::fmt::Display for DeviceList {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        ::protobuf::text_format::fmt(self, f)
+    }
+}
+
+impl ::protobuf::reflect::ProtobufValue for DeviceList {
+    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
+}
+
+#[derive(PartialEq,Clone,Default,Debug)]
+// @@protoc_insertion_point(message:Punch)
+pub struct Punch {
+    // message fields
+    // @@protoc_insertion_point(field:Punch.virtual_ip)
+    pub virtual_ip: u32,
+    // @@protoc_insertion_point(field:Punch.public_ip_list)
+    pub public_ip_list: ::std::vec::Vec<u32>,
+    // @@protoc_insertion_point(field:Punch.public_port)
+    pub public_port: u32,
+    // @@protoc_insertion_point(field:Punch.public_port_range)
+    pub public_port_range: u32,
+    // @@protoc_insertion_point(field:Punch.nat_type)
+    pub nat_type: ::protobuf::EnumOrUnknown<NatType>,
+    // @@protoc_insertion_point(field:Punch.reply)
+    pub reply: bool,
+    // @@protoc_insertion_point(field:Punch.step)
+    pub step: ::protobuf::EnumOrUnknown<Step>,
+    // special fields
+    // @@protoc_insertion_point(special_field:Punch.special_fields)
+    pub special_fields: ::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a Punch {
+    fn default() -> &'a Punch {
+        <Punch as ::protobuf::Message>::default_instance()
+    }
+}
+
+impl Punch {
+    pub fn new() -> Punch {
+        ::std::default::Default::default()
+    }
+
+    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
+        let mut fields = ::std::vec::Vec::with_capacity(7);
+        let mut oneofs = ::std::vec::Vec::with_capacity(0);
+        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
+            "virtual_ip",
+            |m: &Punch| { &m.virtual_ip },
+            |m: &mut Punch| { &mut m.virtual_ip },
+        ));
+        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
+            "public_ip_list",
+            |m: &Punch| { &m.public_ip_list },
+            |m: &mut Punch| { &mut m.public_ip_list },
+        ));
+        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
+            "public_port",
+            |m: &Punch| { &m.public_port },
+            |m: &mut Punch| { &mut m.public_port },
+        ));
+        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
+            "public_port_range",
+            |m: &Punch| { &m.public_port_range },
+            |m: &mut Punch| { &mut m.public_port_range },
+        ));
+        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
+            "nat_type",
+            |m: &Punch| { &m.nat_type },
+            |m: &mut Punch| { &mut m.nat_type },
+        ));
+        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
+            "reply",
+            |m: &Punch| { &m.reply },
+            |m: &mut Punch| { &mut m.reply },
+        ));
+        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
+            "step",
+            |m: &Punch| { &m.step },
+            |m: &mut Punch| { &mut m.step },
+        ));
+        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Punch>(
+            "Punch",
+            fields,
+            oneofs,
+        )
+    }
+}
+
+impl ::protobuf::Message for Punch {
+    const NAME: &'static str = "Punch";
+
+    fn is_initialized(&self) -> bool {
+        true
+    }
+
+    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
+        while let Some(tag) = is.read_raw_tag_or_eof()? {
+            match tag {
+                13 => {
+                    self.virtual_ip = is.read_fixed32()?;
+                },
+                18 => {
+                    is.read_repeated_packed_fixed32_into(&mut self.public_ip_list)?;
+                },
+                21 => {
+                    self.public_ip_list.push(is.read_fixed32()?);
+                },
+                24 => {
+                    self.public_port = is.read_uint32()?;
+                },
+                32 => {
+                    self.public_port_range = is.read_uint32()?;
+                },
+                40 => {
+                    self.nat_type = is.read_enum_or_unknown()?;
+                },
+                48 => {
+                    self.reply = is.read_bool()?;
+                },
+                56 => {
+                    self.step = is.read_enum_or_unknown()?;
+                },
+                tag => {
+                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
+                },
+            };
+        }
+        ::std::result::Result::Ok(())
+    }
+
+    // Compute sizes of nested messages
+    #[allow(unused_variables)]
+    fn compute_size(&self) -> u64 {
+        let mut my_size = 0;
+        if self.virtual_ip != 0 {
+            my_size += 1 + 4;
+        }
+        my_size += 5 * self.public_ip_list.len() as u64;
+        if self.public_port != 0 {
+            my_size += ::protobuf::rt::uint32_size(3, self.public_port);
+        }
+        if self.public_port_range != 0 {
+            my_size += ::protobuf::rt::uint32_size(4, self.public_port_range);
+        }
+        if self.nat_type != ::protobuf::EnumOrUnknown::new(NatType::Symmetric) {
+            my_size += ::protobuf::rt::int32_size(5, self.nat_type.value());
+        }
+        if self.reply != false {
+            my_size += 1 + 1;
+        }
+        if self.step != ::protobuf::EnumOrUnknown::new(Step::Step1) {
+            my_size += ::protobuf::rt::int32_size(7, self.step.value());
+        }
+        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
+        self.special_fields.cached_size().set(my_size as u32);
+        my_size
+    }
+
+    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
+        if self.virtual_ip != 0 {
+            os.write_fixed32(1, self.virtual_ip)?;
+        }
+        for v in &self.public_ip_list {
+            os.write_fixed32(2, *v)?;
+        };
+        if self.public_port != 0 {
+            os.write_uint32(3, self.public_port)?;
+        }
+        if self.public_port_range != 0 {
+            os.write_uint32(4, self.public_port_range)?;
+        }
+        if self.nat_type != ::protobuf::EnumOrUnknown::new(NatType::Symmetric) {
+            os.write_enum(5, ::protobuf::EnumOrUnknown::value(&self.nat_type))?;
+        }
+        if self.reply != false {
+            os.write_bool(6, self.reply)?;
+        }
+        if self.step != ::protobuf::EnumOrUnknown::new(Step::Step1) {
+            os.write_enum(7, ::protobuf::EnumOrUnknown::value(&self.step))?;
+        }
+        os.write_unknown_fields(self.special_fields.unknown_fields())?;
+        ::std::result::Result::Ok(())
+    }
+
+    fn special_fields(&self) -> &::protobuf::SpecialFields {
+        &self.special_fields
+    }
+
+    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
+        &mut self.special_fields
+    }
+
+    fn new() -> Punch {
+        Punch::new()
+    }
+
+    fn clear(&mut self) {
+        self.virtual_ip = 0;
+        self.public_ip_list.clear();
+        self.public_port = 0;
+        self.public_port_range = 0;
+        self.nat_type = ::protobuf::EnumOrUnknown::new(NatType::Symmetric);
+        self.reply = false;
+        self.step = ::protobuf::EnumOrUnknown::new(Step::Step1);
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static Punch {
+        static instance: Punch = Punch {
+            virtual_ip: 0,
+            public_ip_list: ::std::vec::Vec::new(),
+            public_port: 0,
+            public_port_range: 0,
+            nat_type: ::protobuf::EnumOrUnknown::from_i32(0),
+            reply: false,
+            step: ::protobuf::EnumOrUnknown::from_i32(0),
+            special_fields: ::protobuf::SpecialFields::new(),
+        };
+        &instance
+    }
+}
+
+impl ::protobuf::MessageFull for Punch {
+    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
+        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
+        descriptor.get(|| file_descriptor().message_by_package_relative_name("Punch").unwrap()).clone()
+    }
+}
+
+impl ::std::fmt::Display for Punch {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        ::protobuf::text_format::fmt(self, f)
+    }
+}
+
+impl ::protobuf::reflect::ProtobufValue for Punch {
+    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
+}
+
+#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
+// @@protoc_insertion_point(enum:NatType)
+pub enum NatType {
+    // @@protoc_insertion_point(enum_value:NatType.Symmetric)
+    Symmetric = 0,
+    // @@protoc_insertion_point(enum_value:NatType.Cone)
+    Cone = 1,
+}
+
+impl ::protobuf::Enum for NatType {
+    const NAME: &'static str = "NatType";
+
+    fn value(&self) -> i32 {
+        *self as i32
+    }
+
+    fn from_i32(value: i32) -> ::std::option::Option<NatType> {
+        match value {
+            0 => ::std::option::Option::Some(NatType::Symmetric),
+            1 => ::std::option::Option::Some(NatType::Cone),
+            _ => ::std::option::Option::None
+        }
+    }
+
+    const VALUES: &'static [NatType] = &[
+        NatType::Symmetric,
+        NatType::Cone,
+    ];
+}
+
+impl ::protobuf::EnumFull for NatType {
+    fn enum_descriptor() -> ::protobuf::reflect::EnumDescriptor {
+        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::Lazy::new();
+        descriptor.get(|| file_descriptor().enum_by_package_relative_name("NatType").unwrap()).clone()
+    }
+
+    fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor {
+        let index = *self as usize;
+        Self::enum_descriptor().value_by_index(index)
+    }
+}
+
+impl ::std::default::Default for NatType {
+    fn default() -> Self {
+        NatType::Symmetric
+    }
+}
+
+impl NatType {
+    fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData {
+        ::protobuf::reflect::GeneratedEnumDescriptorData::new::<NatType>("NatType")
+    }
+}
+
+#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
+// @@protoc_insertion_point(enum:Step)
+pub enum Step {
+    // @@protoc_insertion_point(enum_value:Step.Step1)
+    Step1 = 0,
+    // @@protoc_insertion_point(enum_value:Step.Step2)
+    Step2 = 1,
+    // @@protoc_insertion_point(enum_value:Step.Step3)
+    Step3 = 2,
+    // @@protoc_insertion_point(enum_value:Step.Step4)
+    Step4 = 3,
+}
+
+impl ::protobuf::Enum for Step {
+    const NAME: &'static str = "Step";
+
+    fn value(&self) -> i32 {
+        *self as i32
+    }
+
+    fn from_i32(value: i32) -> ::std::option::Option<Step> {
+        match value {
+            0 => ::std::option::Option::Some(Step::Step1),
+            1 => ::std::option::Option::Some(Step::Step2),
+            2 => ::std::option::Option::Some(Step::Step3),
+            3 => ::std::option::Option::Some(Step::Step4),
+            _ => ::std::option::Option::None
+        }
+    }
+
+    const VALUES: &'static [Step] = &[
+        Step::Step1,
+        Step::Step2,
+        Step::Step3,
+        Step::Step4,
+    ];
+}
+
+impl ::protobuf::EnumFull for Step {
+    fn enum_descriptor() -> ::protobuf::reflect::EnumDescriptor {
+        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::Lazy::new();
+        descriptor.get(|| file_descriptor().enum_by_package_relative_name("Step").unwrap()).clone()
+    }
+
+    fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor {
+        let index = *self as usize;
+        Self::enum_descriptor().value_by_index(index)
+    }
+}
+
+impl ::std::default::Default for Step {
+    fn default() -> Self {
+        Step::Step1
+    }
+}
+
+impl Step {
+    fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData {
+        ::protobuf::reflect::GeneratedEnumDescriptorData::new::<Step>("Step")
+    }
+}
+
+static file_descriptor_proto_data: &'static [u8] = b"\
+    \n\rmessage.proto\"L\n\x13RegistrationRequest\x12\x14\n\x05token\x18\x01\
+    \x20\x01(\tR\x05token\x12\x1f\n\x0bmac_address\x18\x02\x20\x01(\tR\nmacA\
+    ddress\"\x83\x02\n\x14RegistrationResponse\x12\x1d\n\nvirtual_ip\x18\x01\
+    \x20\x01(\x07R\tvirtualIp\x12'\n\x0fvirtual_gateway\x18\x02\x20\x01(\x07\
+    R\x0evirtualGateway\x12'\n\x0fvirtual_netmask\x18\x03\x20\x01(\x07R\x0ev\
+    irtualNetmask\x12\x14\n\x05epoch\x18\x04\x20\x01(\rR\x05epoch\x12&\n\x0f\
+    virtual_ip_list\x18\x05\x20\x03(\x07R\rvirtualIpList\x12\x1b\n\tpublic_i\
+    p\x18\x06\x20\x01(\x07R\x08publicIp\x12\x1f\n\x0bpublic_port\x18\x07\x20\
+    \x01(\rR\npublicPort\"J\n\nDeviceList\x12\x14\n\x05epoch\x18\x01\x20\x01\
+    (\rR\x05epoch\x12&\n\x0fvirtual_ip_list\x18\x02\x20\x03(\x07R\rvirtualIp\
+    List\"\xef\x01\n\x05Punch\x12\x1d\n\nvirtual_ip\x18\x01\x20\x01(\x07R\tv\
+    irtualIp\x12$\n\x0epublic_ip_list\x18\x02\x20\x03(\x07R\x0cpublicIpList\
+    \x12\x1f\n\x0bpublic_port\x18\x03\x20\x01(\rR\npublicPort\x12*\n\x11publ\
+    ic_port_range\x18\x04\x20\x01(\rR\x0fpublicPortRange\x12#\n\x08nat_type\
+    \x18\x05\x20\x01(\x0e2\x08.NatTypeR\x07natType\x12\x14\n\x05reply\x18\
+    \x06\x20\x01(\x08R\x05reply\x12\x19\n\x04step\x18\x07\x20\x01(\x0e2\x05.\
+    StepR\x04step*\"\n\x07NatType\x12\r\n\tSymmetric\x10\0\x12\x08\n\x04Cone\
+    \x10\x01*2\n\x04Step\x12\t\n\x05Step1\x10\0\x12\t\n\x05Step2\x10\x01\x12\
+    \t\n\x05Step3\x10\x02\x12\t\n\x05Step4\x10\x03b\x06proto3\
+";
+
+/// `FileDescriptorProto` object which was a source for this generated file
+fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
+    static file_descriptor_proto_lazy: ::protobuf::rt::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::Lazy::new();
+    file_descriptor_proto_lazy.get(|| {
+        ::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
+    })
+}
+
+/// `FileDescriptor` object which allows dynamic access to files
+pub fn file_descriptor() -> &'static ::protobuf::reflect::FileDescriptor {
+    static generated_file_descriptor_lazy: ::protobuf::rt::Lazy<::protobuf::reflect::GeneratedFileDescriptor> = ::protobuf::rt::Lazy::new();
+    static file_descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::FileDescriptor> = ::protobuf::rt::Lazy::new();
+    file_descriptor.get(|| {
+        let generated_file_descriptor = generated_file_descriptor_lazy.get(|| {
+            let mut deps = ::std::vec::Vec::with_capacity(0);
+            let mut messages = ::std::vec::Vec::with_capacity(4);
+            messages.push(RegistrationRequest::generated_message_descriptor_data());
+            messages.push(RegistrationResponse::generated_message_descriptor_data());
+            messages.push(DeviceList::generated_message_descriptor_data());
+            messages.push(Punch::generated_message_descriptor_data());
+            let mut enums = ::std::vec::Vec::with_capacity(2);
+            enums.push(NatType::generated_enum_descriptor_data());
+            enums.push(Step::generated_enum_descriptor_data());
+            ::protobuf::reflect::GeneratedFileDescriptor::new_generated(
+                file_descriptor_proto(),
+                deps,
+                messages,
+                enums,
+            )
+        });
+        ::protobuf::reflect::FileDescriptor::new_generated_2(generated_file_descriptor)
+    })
+}

switch/src/proto/mod.rs

@@ -0,0 +1,3 @@
+// @generated
+
+pub mod message;