修复域名转换ip的问题

.gitignore

@@ -1,4 +1,4 @@
 target/*
-vnt/src/proto/message.rs
+vnt/src/proto/*
 vnt-cli/src/generated_serial_number.rs
 Cargo.lock

vnt-cli/Cargo.toml

@@ -40,5 +40,5 @@ server_encrypt=["vnt/server_encrypt"]
 ip_proxy=["vnt/ip_proxy"]
 [build-dependencies]
 embed-manifest = "1.4.0"
-rand = "0.9.0-alpha.0"
+rand = "0.8.5"
 chrono = "0.4.23"

vnt-jni/java/top/wherewego/vnt/jni/CallBack.java

@@ -8,6 +8,10 @@ import top.wherewego.vnt.jni.param.*;
  * @author https://github.com/lbl8603/vnt
  */
 public interface CallBack {
+    /**
+     * 连接成功的回调
+     */
+    void success();
     /**
      * 创建虚拟网卡成功的回调方法
      *

vnt-jni/java/top/wherewego/vnt/jni/Config.java

@@ -90,6 +90,18 @@ public class Config {
      * 虚拟网卡fd 仅在android上支持
      */
     private int deviceFd;
+    /**
+     * enum: relay/p2p/all
+     */
+    private String useChannel;
+    /**
+     * 模拟丢包率，取0~1之间的数，为null表示不丢包，1表示全部丢包
+     */
+    private Double packetLossRate;
+    /**
+     * 模拟延迟 单位毫秒(ms)
+     */
+    private Integer packetDelay;
 
     public Config() {
     }
@@ -261,4 +273,28 @@ public class Config {
     public void setDeviceFd(int deviceFd) {
         this.deviceFd = deviceFd;
     }
+
+    public String getUseChannel() {
+        return useChannel;
+    }
+
+    public void setUseChannel(String useChannel) {
+        this.useChannel = useChannel;
+    }
+
+    public Double getPacketLossRate() {
+        return packetLossRate;
+    }
+
+    public void setPacketLossRate(Double packetLossRate) {
+        this.packetLossRate = packetLossRate;
+    }
+
+    public Integer getPacketDelay() {
+        return packetDelay;
+    }
+
+    public void setPacketDelay(Integer packetDelay) {
+        this.packetDelay = packetDelay;
+    }
 }

vnt-jni/java/top/wherewego/vnt/jni/IpUtils.java

@@ -1,8 +1,9 @@
 package top.wherewego.vnt.jni;
 
 /**
- * @author lubeilin
- * @date: 2024/02/27 18:31
+ * ip转换
+ *
+ * @author https://github.com/lbl8603/vnt
  */
 public class IpUtils {
     public static String intToIpAddress(int ipAddress) {

vnt-jni/java/top/wherewego/vnt/jni/Vnt.java

@@ -11,11 +11,8 @@ import java.io.IOException;
 public class Vnt implements Closeable {
     private final long raw;
 
-    public Vnt(Config config, CallBack callBack) {
+    public Vnt(Config config, CallBack callBack) throws Exception{
         this.raw = new0(config, callBack);
-        if(this.raw == 0){
-            throw new RuntimeException();
-        }
     }
 
     public void stop() {
@@ -30,7 +27,7 @@ public class Vnt implements Closeable {
         return list0(raw);
     }
 
-    private native long new0(Config config, CallBack callBack);
+    private native long new0(Config config, CallBack callBack) throws Exception;
 
     private native void stop0(long raw);
 

vnt-jni/src/callback.rs

@@ -26,6 +26,11 @@ impl CallBack {
 }
 
 impl CallBack {
+    fn success0(&self) -> jni::errors::Result<()> {
+        let env = &mut self.jvm.attach_current_thread()? as &mut JNIEnv;
+        env.call_method(&self.this, "success", "()V", &[])?;
+        Ok(())
+    }
     fn create_tun0(&self, info: DeviceInfo) -> jni::errors::Result<()> {
         let env = &mut self.jvm.attach_current_thread()? as &mut JNIEnv;
         let param = env.new_object(
@@ -139,13 +144,16 @@ impl CallBack {
     }
     fn stop0(&self) -> jni::errors::Result<()> {
         let env = &mut self.jvm.attach_current_thread()? as &mut JNIEnv;
-        env.call_method(&self.this, "error", "()V", &[])?;
+        env.call_method(&self.this, "stop", "()V", &[])?;
         Ok(())
     }
 }
 
 impl VntCallback for CallBack {
     fn success(&self) {
+        if let Err(e) = self.success0() {
+            log::warn!("success {:?}", e);
+        }
     }
     fn create_tun(&self, info: DeviceInfo) {
         if let Err(e) = self.create_tun0(info) {

vnt-jni/src/config.rs

@@ -29,6 +29,11 @@ pub fn new_config(env: &mut JNIEnv, config: JObject) -> Result<Config, Error> {
     let use_channel = to_string(env, &config, "useChannel")?;
     let finger = env.get_field(&config, "finger", "Z")?.z()?;
     let first_latency = env.get_field(&config, "firstLatency", "Z")?.z()?;
+    let packet_delay = to_integer(env, &config, "packetDelay")?
+        .map(|v| v as u32)
+        .unwrap_or_default();
+    let packet_loss_rate = to_double(env, &config, "packetLossRate")?;
+
     let in_ips = to_string_array(env, &config, "inIps")?;
     let out_ips = to_string_array(env, &config, "outIps")?;
     let ports =
@@ -132,8 +137,8 @@ pub fn new_config(env: &mut JNIEnv, config: JObject) -> Result<Config, Error> {
         #[cfg(target_os = "android")]
         device_fd,
         UseChannelType::from_str(&use_channel.unwrap_or_default()).unwrap_or_default(),
-        None,
-        0,
+        packet_loss_rate,
+        packet_delay,
     ) {
         Ok(config) => config,
         Err(e) => {

vnt-jni/src/utils.rs

@@ -119,3 +119,13 @@ pub fn to_integer(env: &mut JNIEnv, config: &JObject, name: &str) -> Result<Opti
         env.call_method(value, "intValue", "()I", &[])?.i()? as _
     ));
 }
+pub fn to_double(env: &mut JNIEnv, config: &JObject, name: &str) -> Result<Option<f64>, Error> {
+    let value = env.get_field(config, name, "Ljava/lang/Double;")?.l()?;
+    if value.is_null() {
+        return Ok(None);
+    }
+    // 调用 intValue
+    return Ok(Some(
+        env.call_method(value, "doubleValue", "()D", &[])?.d()? as _,
+    ));
+}

vnt/src/channel/context.rs

@@ -453,14 +453,19 @@ impl RouteTable {
         }
         None
     }
-    pub fn need_punch(&self, id: &Ipv4Addr) -> bool {
+    pub fn no_need_punch(&self, id: &Ipv4Addr) -> bool {
         if let Some((_, v)) = self.route_table.read().get(id) {
-            //存在p2p的通道则不再打洞
-            if v.iter().filter(|(k, _)| k.is_p2p()).count() >= 1 {
-                return false;
-            }
+            //p2p的通道数符合要求
+            return v.iter().filter(|(k, _)| k.is_p2p()).count() >= self.channel_num;
+        }
+        false
+    }
+    pub fn p2p_num(&self, id: &Ipv4Addr) -> usize {
+        if let Some((_, v)) = self.route_table.read().get(id) {
+            v.iter().filter(|(k, _)| k.is_p2p()).count()
+        } else {
+            0
         }
-        true
     }
     /// 返回所有路由
     pub fn route_table(&self) -> Vec<(Ipv4Addr, Vec<Route>)> {

vnt/src/channel/punch.rs

@@ -235,7 +235,7 @@ impl Punch {
         nat_info: NatInfo,
         punch_tcp: bool,
     ) -> io::Result<()> {
-        if !self.context.route_table.need_punch(&id) {
+        if self.context.route_table.no_need_punch(&id) {
             log::info!("已打洞成功,无需打洞:{:?}", id);
             return Ok(());
         }

vnt/src/handle/maintain/idle.rs

@@ -1,7 +1,7 @@
 use std::io;
 use std::net::{SocketAddr, ToSocketAddrs};
 use std::sync::Arc;
-use std::time::{Duration, Instant};
+use std::time::Duration;
 
 use crossbeam_utils::atomic::AtomicCell;
 use mio::net::TcpStream;
@@ -30,30 +30,8 @@ pub fn idle_route<Call: VntCallback>(
         log::info!("定时任务停止");
     }
 }
+
 pub fn idle_gateway<Call: VntCallback>(
-    scheduler: &Scheduler,
-    context: Context,
-    current_device_info: Arc<AtomicCell<CurrentDeviceInfo>>,
-    config: BaseConfigInfo,
-    tcp_socket_sender: AcceptSocketSender<(TcpStream, SocketAddr, Option<Vec<u8>>)>,
-    call: Call,
-    connect_count: usize,
-    handshake: Handshake,
-) {
-    let time = Instant::now();
-    idle_gateway_(
-        scheduler,
-        context,
-        current_device_info,
-        config,
-        tcp_socket_sender,
-        call,
-        connect_count,
-        handshake,
-        time,
-    );
-}
-pub fn idle_gateway_<Call: VntCallback>(
     scheduler: &Scheduler,
     context: Context,
     current_device_info: Arc<AtomicCell<CurrentDeviceInfo>>,
@@ -62,7 +40,6 @@ pub fn idle_gateway_<Call: VntCallback>(
     call: Call,
     mut connect_count: usize,
     handshake: Handshake,
-    mut time: Instant,
 ) {
     idle_gateway0(
         &context,
@@ -72,10 +49,9 @@ pub fn idle_gateway_<Call: VntCallback>(
         &call,
         &mut connect_count,
         &handshake,
-        &mut time,
     );
     let rs = scheduler.timeout(Duration::from_secs(5), move |s| {
-        idle_gateway_(
+        idle_gateway(
             s,
             context,
             current_device_info,
@@ -84,13 +60,13 @@ pub fn idle_gateway_<Call: VntCallback>(
             call,
             connect_count,
             handshake,
-            time,
         )
     });
     if !rs {
         log::info!("定时任务停止");
     }
 }
+
 fn idle_gateway0<Call: VntCallback>(
     context: &Context,
     current_device: &AtomicCell<CurrentDeviceInfo>,
@@ -99,7 +75,6 @@ fn idle_gateway0<Call: VntCallback>(
     call: &Call,
     connect_count: &mut usize,
     handshake: &Handshake,
-    time: &mut Instant,
 ) {
     if let Err(e) = check_gateway_channel(
         context,
@@ -109,7 +84,6 @@ fn idle_gateway0<Call: VntCallback>(
         call,
         connect_count,
         handshake,
-        time,
     ) {
         let cur = current_device.load();
         call.error(ErrorInfo::new_msg(
@@ -118,6 +92,7 @@ fn idle_gateway0<Call: VntCallback>(
         ));
     }
 }
+
 fn idle_route0<Call: VntCallback>(
     idle: &Idle,
     context: &Context,
@@ -149,16 +124,12 @@ fn check_gateway_channel<Call: VntCallback>(
     call: &Call,
     count: &mut usize,
     handshake: &Handshake,
-    time: &mut Instant,
 ) -> io::Result<()> {
     let mut current_device = current_device_info.load();
     if current_device.status.offline() {
         *count += 1;
-        if time.elapsed() < Duration::from_secs(6 * 60) {
-            // 探测服务器地址
-            current_device = domain_request0(current_device_info, config);
-            *time = Instant::now()
-        }
+        // 探测服务器地址
+        current_device = domain_request0(current_device_info, config);
         //需要重连
         call.connect(ConnectInfo::new(*count, current_device.connect_server));
         log::info!("发送握手请求,{:?}", config);
@@ -185,6 +156,7 @@ fn check_gateway_channel<Call: VntCallback>(
     }
     Ok(())
 }
+
 pub fn domain_request0(
     current_device: &AtomicCell<CurrentDeviceInfo>,
     config: &BaseConfigInfo,
@@ -197,13 +169,15 @@ pub fn domain_request0(
                 let mut tmp = current_dev.clone();
                 tmp.connect_server = addr;
                 let rs = current_device.compare_exchange(current_dev, tmp);
-                current_dev.connect_server = addr;
                 log::info!(
                     "服务端地址变化,旧地址:{}，新地址:{},替换结果:{}",
                     current_dev.connect_server,
                     addr,
                     rs.is_ok()
                 );
+                if rs.is_ok() {
+                    current_dev.connect_server = addr;
+                }
             }
         }
     }

vnt/src/handle/maintain/punch.rs

@@ -227,7 +227,9 @@ fn punch0(
     if total_count < 10
         && (nat_info.public_ips.is_empty()
             || nat_info.public_ports.is_empty()
-            || nat_info.public_ports[0] == 0)
+            || nat_info.public_ports[0] == 0
+            || nat_info.public_ports.iter().filter(|&&v| v == 0).count()
+                > nat_info.public_ports.len() / 2)
     {
         log::info!("公网地址为空，暂时放弃打洞,第{}轮", total_count);
         return Ok(());
@@ -242,22 +244,33 @@ fn punch0(
         .collect();
     list.shuffle(&mut rand::thread_rng());
     for info in list {
-        if !context.route_table.need_punch(&info.virtual_ip) {
-            punch_record.lock().remove(&info.virtual_ip);
-            continue;
-        }
-        // 能发起打洞的前提是自己空闲，这里会间隔5秒以上发起一次打洞，所以假定上一轮打洞已结束
         let punch_count = punch_record
             .lock()
             .get(&info.virtual_ip)
             .cloned()
             .unwrap_or(0);
+        let p2p_num = context.route_table.p2p_num(&info.virtual_ip);
+        let mut max_punch_interval = 70;
+        if p2p_num > 0 {
+            if punch_count == 0 {
+                continue;
+            }
+            if p2p_num >= context.channel_num() {
+                //通道数满足要求，不再打洞
+                punch_record.lock().remove(&info.virtual_ip);
+                continue;
+            }
+            //有p2p通道，但是通道数量不够，则继续打洞
+            // 提高等待上限
+            max_punch_interval = 300;
+        }
+        // 能发起打洞的前提是自己空闲，这里会间隔5秒以上发起一次打洞，所以假定上一轮打洞已结束
         let last_punch = last_punch_record
             .get(&info.virtual_ip)
             .cloned()
             .unwrap_or(0);
-        // 梯度减少打洞频率
-        if total_count > last_punch + punch_count.min(35) {
+        // 梯度增加打洞时间间隔
+        if total_count > last_punch + punch_count.min(max_punch_interval) {
             last_punch_record.insert(info.virtual_ip, total_count);
             let packet = punch_packet(
                 client_cipher,

vnt/src/handle/recv_data/server.rs

@@ -267,57 +267,64 @@ impl<Call: VntCallback> ServerPacketHandler<Call> {
                         if old.virtual_ip != Ipv4Addr::UNSPECIFIED {
                             log::info!("ip发生变化,old:{:?},response={:?}", old, response);
                         }
-                        if let Err(e) = self.device.set_ip(virtual_ip, virtual_netmask) {
-                            log::error!("LocalIpExists {:?}", e);
-                            self.callback.error(ErrorInfo::new_msg(
-                                ErrorType::LocalIpExists,
-                                format!("set_ip {:?}", e),
-                            ));
-                            return Ok(());
-                        }
-                        let mut guard = self.route_record.lock();
-                        for (dest, mask) in guard.drain(..) {
-                            if let Err(e) = self.device.delete_route(dest, mask) {
-                                log::warn!("删除路由失败 ={:?}", e);
-                            }
-                        }
-                        if let Err(e) = self.device.add_route(virtual_network, virtual_netmask, 1) {
-                            log::warn!("添加默认路由失败 ={:?}", e);
-                        } else {
-                            guard.push((virtual_network, virtual_netmask));
-                        }
-                        if let Err(e) =
-                            self.device
-                                .add_route(Ipv4Addr::BROADCAST, Ipv4Addr::BROADCAST, 1)
+                        #[cfg(not(target_os = "android"))]
                         {
-                            log::warn!("添加广播路由失败 ={:?}", e);
-                        } else {
-                            guard.push((Ipv4Addr::BROADCAST, Ipv4Addr::BROADCAST));
-                        }
+                            if let Err(e) = self.device.set_ip(virtual_ip, virtual_netmask) {
+                                log::error!("LocalIpExists {:?}", e);
+                                self.callback.error(ErrorInfo::new_msg(
+                                    ErrorType::LocalIpExists,
+                                    format!("set_ip {:?}", e),
+                                ));
+                                return Ok(());
+                            }
+                            let mut guard = self.route_record.lock();
+                            for (dest, mask) in guard.drain(..) {
+                                if let Err(e) = self.device.delete_route(dest, mask) {
+                                    log::warn!("删除路由失败 ={:?}", e);
+                                }
+                            }
+                            if let Err(e) =
+                                self.device.add_route(virtual_network, virtual_netmask, 1)
+                            {
+                                log::warn!("添加默认路由失败 ={:?}", e);
+                            } else {
+                                guard.push((virtual_network, virtual_netmask));
+                            }
+                            if let Err(e) =
+                                self.device
+                                    .add_route(Ipv4Addr::BROADCAST, Ipv4Addr::BROADCAST, 1)
+                            {
+                                log::warn!("添加广播路由失败 ={:?}", e);
+                            } else {
+                                guard.push((Ipv4Addr::BROADCAST, Ipv4Addr::BROADCAST));
+                            }
 
-                        if let Err(e) = self.device.add_route(
-                            Ipv4Addr::from([224, 0, 0, 0]),
-                            Ipv4Addr::from([240, 0, 0, 0]),
-                            1,
-                        ) {
-                            log::warn!("添加组播路由失败 ={:?}", e);
-                        } else {
-                            guard.push((
+                            if let Err(e) = self.device.add_route(
                                 Ipv4Addr::from([224, 0, 0, 0]),
                                 Ipv4Addr::from([240, 0, 0, 0]),
-                            ));
-                        }
-
-                        for (dest, mask) in self.external_route.to_route() {
-                            if let Err(e) = self.device.add_route(dest, mask, 1) {
-                                log::warn!("添加路由失败 ={:?}", e);
+                                1,
+                            ) {
+                                log::warn!("添加组播路由失败 ={:?}", e);
                             } else {
-                                guard.push((dest, mask));
+                                guard.push((
+                                    Ipv4Addr::from([224, 0, 0, 0]),
+                                    Ipv4Addr::from([240, 0, 0, 0]),
+                                ));
+                            }
+
+                            for (dest, mask) in self.external_route.to_route() {
+                                if let Err(e) = self.device.add_route(dest, mask, 1) {
+                                    log::warn!("添加路由失败 ={:?}", e);
+                                } else {
+                                    guard.push((dest, mask));
+                                }
                             }
                         }
-                        self.callback.success();
                     }
                     self.set_device_info_list(response.device_info_list, response.epoch as _);
+                    if old.status.offline() {
+                        self.callback.success();
+                    }
                 }
             }
             service_packet::Protocol::PushDeviceList => {

vnt/src/proto/message.rs

@@ -1,2080 +0,0 @@
-// 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:HandshakeRequest)
-pub struct HandshakeRequest {
-    // message fields
-    // @@protoc_insertion_point(field:HandshakeRequest.version)
-    pub version: ::std::string::String,
-    // @@protoc_insertion_point(field:HandshakeRequest.secret)
-    pub secret: bool,
-    // special fields
-    // @@protoc_insertion_point(special_field:HandshakeRequest.special_fields)
-    pub special_fields: ::protobuf::SpecialFields,
-}
-
-impl<'a> ::std::default::Default for &'a HandshakeRequest {
-    fn default() -> &'a HandshakeRequest {
-        <HandshakeRequest as ::protobuf::Message>::default_instance()
-    }
-}
-
-impl HandshakeRequest {
-    pub fn new() -> HandshakeRequest {
-        ::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::<_, _>(
-            "version",
-            |m: &HandshakeRequest| { &m.version },
-            |m: &mut HandshakeRequest| { &mut m.version },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "secret",
-            |m: &HandshakeRequest| { &m.secret },
-            |m: &mut HandshakeRequest| { &mut m.secret },
-        ));
-        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<HandshakeRequest>(
-            "HandshakeRequest",
-            fields,
-            oneofs,
-        )
-    }
-}
-
-impl ::protobuf::Message for HandshakeRequest {
-    const NAME: &'static str = "HandshakeRequest";
-
-    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.version = is.read_string()?;
-                },
-                16 => {
-                    self.secret = is.read_bool()?;
-                },
-                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.version.is_empty() {
-            my_size += ::protobuf::rt::string_size(1, &self.version);
-        }
-        if self.secret != false {
-            my_size += 1 + 1;
-        }
-        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.version.is_empty() {
-            os.write_string(1, &self.version)?;
-        }
-        if self.secret != false {
-            os.write_bool(2, self.secret)?;
-        }
-        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() -> HandshakeRequest {
-        HandshakeRequest::new()
-    }
-
-    fn clear(&mut self) {
-        self.version.clear();
-        self.secret = false;
-        self.special_fields.clear();
-    }
-
-    fn default_instance() -> &'static HandshakeRequest {
-        static instance: HandshakeRequest = HandshakeRequest {
-            version: ::std::string::String::new(),
-            secret: false,
-            special_fields: ::protobuf::SpecialFields::new(),
-        };
-        &instance
-    }
-}
-
-impl ::protobuf::MessageFull for HandshakeRequest {
-    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("HandshakeRequest").unwrap()).clone()
-    }
-}
-
-impl ::std::fmt::Display for HandshakeRequest {
-    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
-    }
-}
-
-impl ::protobuf::reflect::ProtobufValue for HandshakeRequest {
-    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
-}
-
-#[derive(PartialEq,Clone,Default,Debug)]
-// @@protoc_insertion_point(message:HandshakeResponse)
-pub struct HandshakeResponse {
-    // message fields
-    // @@protoc_insertion_point(field:HandshakeResponse.version)
-    pub version: ::std::string::String,
-    // @@protoc_insertion_point(field:HandshakeResponse.secret)
-    pub secret: bool,
-    // @@protoc_insertion_point(field:HandshakeResponse.public_key)
-    pub public_key: ::std::vec::Vec<u8>,
-    // @@protoc_insertion_point(field:HandshakeResponse.key_finger)
-    pub key_finger: ::std::string::String,
-    // special fields
-    // @@protoc_insertion_point(special_field:HandshakeResponse.special_fields)
-    pub special_fields: ::protobuf::SpecialFields,
-}
-
-impl<'a> ::std::default::Default for &'a HandshakeResponse {
-    fn default() -> &'a HandshakeResponse {
-        <HandshakeResponse as ::protobuf::Message>::default_instance()
-    }
-}
-
-impl HandshakeResponse {
-    pub fn new() -> HandshakeResponse {
-        ::std::default::Default::default()
-    }
-
-    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
-        let mut fields = ::std::vec::Vec::with_capacity(4);
-        let mut oneofs = ::std::vec::Vec::with_capacity(0);
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "version",
-            |m: &HandshakeResponse| { &m.version },
-            |m: &mut HandshakeResponse| { &mut m.version },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "secret",
-            |m: &HandshakeResponse| { &m.secret },
-            |m: &mut HandshakeResponse| { &mut m.secret },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "public_key",
-            |m: &HandshakeResponse| { &m.public_key },
-            |m: &mut HandshakeResponse| { &mut m.public_key },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "key_finger",
-            |m: &HandshakeResponse| { &m.key_finger },
-            |m: &mut HandshakeResponse| { &mut m.key_finger },
-        ));
-        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<HandshakeResponse>(
-            "HandshakeResponse",
-            fields,
-            oneofs,
-        )
-    }
-}
-
-impl ::protobuf::Message for HandshakeResponse {
-    const NAME: &'static str = "HandshakeResponse";
-
-    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.version = is.read_string()?;
-                },
-                16 => {
-                    self.secret = is.read_bool()?;
-                },
-                26 => {
-                    self.public_key = is.read_bytes()?;
-                },
-                34 => {
-                    self.key_finger = 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.version.is_empty() {
-            my_size += ::protobuf::rt::string_size(1, &self.version);
-        }
-        if self.secret != false {
-            my_size += 1 + 1;
-        }
-        if !self.public_key.is_empty() {
-            my_size += ::protobuf::rt::bytes_size(3, &self.public_key);
-        }
-        if !self.key_finger.is_empty() {
-            my_size += ::protobuf::rt::string_size(4, &self.key_finger);
-        }
-        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.version.is_empty() {
-            os.write_string(1, &self.version)?;
-        }
-        if self.secret != false {
-            os.write_bool(2, self.secret)?;
-        }
-        if !self.public_key.is_empty() {
-            os.write_bytes(3, &self.public_key)?;
-        }
-        if !self.key_finger.is_empty() {
-            os.write_string(4, &self.key_finger)?;
-        }
-        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() -> HandshakeResponse {
-        HandshakeResponse::new()
-    }
-
-    fn clear(&mut self) {
-        self.version.clear();
-        self.secret = false;
-        self.public_key.clear();
-        self.key_finger.clear();
-        self.special_fields.clear();
-    }
-
-    fn default_instance() -> &'static HandshakeResponse {
-        static instance: HandshakeResponse = HandshakeResponse {
-            version: ::std::string::String::new(),
-            secret: false,
-            public_key: ::std::vec::Vec::new(),
-            key_finger: ::std::string::String::new(),
-            special_fields: ::protobuf::SpecialFields::new(),
-        };
-        &instance
-    }
-}
-
-impl ::protobuf::MessageFull for HandshakeResponse {
-    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("HandshakeResponse").unwrap()).clone()
-    }
-}
-
-impl ::std::fmt::Display for HandshakeResponse {
-    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
-    }
-}
-
-impl ::protobuf::reflect::ProtobufValue for HandshakeResponse {
-    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
-}
-
-#[derive(PartialEq,Clone,Default,Debug)]
-// @@protoc_insertion_point(message:SecretHandshakeRequest)
-pub struct SecretHandshakeRequest {
-    // message fields
-    // @@protoc_insertion_point(field:SecretHandshakeRequest.token)
-    pub token: ::std::string::String,
-    // @@protoc_insertion_point(field:SecretHandshakeRequest.key)
-    pub key: ::std::vec::Vec<u8>,
-    // special fields
-    // @@protoc_insertion_point(special_field:SecretHandshakeRequest.special_fields)
-    pub special_fields: ::protobuf::SpecialFields,
-}
-
-impl<'a> ::std::default::Default for &'a SecretHandshakeRequest {
-    fn default() -> &'a SecretHandshakeRequest {
-        <SecretHandshakeRequest as ::protobuf::Message>::default_instance()
-    }
-}
-
-impl SecretHandshakeRequest {
-    pub fn new() -> SecretHandshakeRequest {
-        ::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: &SecretHandshakeRequest| { &m.token },
-            |m: &mut SecretHandshakeRequest| { &mut m.token },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "key",
-            |m: &SecretHandshakeRequest| { &m.key },
-            |m: &mut SecretHandshakeRequest| { &mut m.key },
-        ));
-        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<SecretHandshakeRequest>(
-            "SecretHandshakeRequest",
-            fields,
-            oneofs,
-        )
-    }
-}
-
-impl ::protobuf::Message for SecretHandshakeRequest {
-    const NAME: &'static str = "SecretHandshakeRequest";
-
-    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.key = is.read_bytes()?;
-                },
-                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.key.is_empty() {
-            my_size += ::protobuf::rt::bytes_size(2, &self.key);
-        }
-        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.key.is_empty() {
-            os.write_bytes(2, &self.key)?;
-        }
-        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() -> SecretHandshakeRequest {
-        SecretHandshakeRequest::new()
-    }
-
-    fn clear(&mut self) {
-        self.token.clear();
-        self.key.clear();
-        self.special_fields.clear();
-    }
-
-    fn default_instance() -> &'static SecretHandshakeRequest {
-        static instance: SecretHandshakeRequest = SecretHandshakeRequest {
-            token: ::std::string::String::new(),
-            key: ::std::vec::Vec::new(),
-            special_fields: ::protobuf::SpecialFields::new(),
-        };
-        &instance
-    }
-}
-
-impl ::protobuf::MessageFull for SecretHandshakeRequest {
-    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("SecretHandshakeRequest").unwrap()).clone()
-    }
-}
-
-impl ::std::fmt::Display for SecretHandshakeRequest {
-    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
-    }
-}
-
-impl ::protobuf::reflect::ProtobufValue for SecretHandshakeRequest {
-    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
-}
-
-#[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.device_id)
-    pub device_id: ::std::string::String,
-    // @@protoc_insertion_point(field:RegistrationRequest.name)
-    pub name: ::std::string::String,
-    // @@protoc_insertion_point(field:RegistrationRequest.is_fast)
-    pub is_fast: bool,
-    // @@protoc_insertion_point(field:RegistrationRequest.version)
-    pub version: ::std::string::String,
-    // @@protoc_insertion_point(field:RegistrationRequest.virtual_ip)
-    pub virtual_ip: u32,
-    // @@protoc_insertion_point(field:RegistrationRequest.allow_ip_change)
-    pub allow_ip_change: bool,
-    // @@protoc_insertion_point(field:RegistrationRequest.client_secret)
-    pub client_secret: bool,
-    // 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(8);
-        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::<_, _>(
-            "device_id",
-            |m: &RegistrationRequest| { &m.device_id },
-            |m: &mut RegistrationRequest| { &mut m.device_id },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "name",
-            |m: &RegistrationRequest| { &m.name },
-            |m: &mut RegistrationRequest| { &mut m.name },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "is_fast",
-            |m: &RegistrationRequest| { &m.is_fast },
-            |m: &mut RegistrationRequest| { &mut m.is_fast },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "version",
-            |m: &RegistrationRequest| { &m.version },
-            |m: &mut RegistrationRequest| { &mut m.version },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "virtual_ip",
-            |m: &RegistrationRequest| { &m.virtual_ip },
-            |m: &mut RegistrationRequest| { &mut m.virtual_ip },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "allow_ip_change",
-            |m: &RegistrationRequest| { &m.allow_ip_change },
-            |m: &mut RegistrationRequest| { &mut m.allow_ip_change },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "client_secret",
-            |m: &RegistrationRequest| { &m.client_secret },
-            |m: &mut RegistrationRequest| { &mut m.client_secret },
-        ));
-        ::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.device_id = is.read_string()?;
-                },
-                26 => {
-                    self.name = is.read_string()?;
-                },
-                32 => {
-                    self.is_fast = is.read_bool()?;
-                },
-                42 => {
-                    self.version = is.read_string()?;
-                },
-                53 => {
-                    self.virtual_ip = is.read_fixed32()?;
-                },
-                56 => {
-                    self.allow_ip_change = is.read_bool()?;
-                },
-                64 => {
-                    self.client_secret = is.read_bool()?;
-                },
-                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.device_id.is_empty() {
-            my_size += ::protobuf::rt::string_size(2, &self.device_id);
-        }
-        if !self.name.is_empty() {
-            my_size += ::protobuf::rt::string_size(3, &self.name);
-        }
-        if self.is_fast != false {
-            my_size += 1 + 1;
-        }
-        if !self.version.is_empty() {
-            my_size += ::protobuf::rt::string_size(5, &self.version);
-        }
-        if self.virtual_ip != 0 {
-            my_size += 1 + 4;
-        }
-        if self.allow_ip_change != false {
-            my_size += 1 + 1;
-        }
-        if self.client_secret != false {
-            my_size += 1 + 1;
-        }
-        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.device_id.is_empty() {
-            os.write_string(2, &self.device_id)?;
-        }
-        if !self.name.is_empty() {
-            os.write_string(3, &self.name)?;
-        }
-        if self.is_fast != false {
-            os.write_bool(4, self.is_fast)?;
-        }
-        if !self.version.is_empty() {
-            os.write_string(5, &self.version)?;
-        }
-        if self.virtual_ip != 0 {
-            os.write_fixed32(6, self.virtual_ip)?;
-        }
-        if self.allow_ip_change != false {
-            os.write_bool(7, self.allow_ip_change)?;
-        }
-        if self.client_secret != false {
-            os.write_bool(8, self.client_secret)?;
-        }
-        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.device_id.clear();
-        self.name.clear();
-        self.is_fast = false;
-        self.version.clear();
-        self.virtual_ip = 0;
-        self.allow_ip_change = false;
-        self.client_secret = false;
-        self.special_fields.clear();
-    }
-
-    fn default_instance() -> &'static RegistrationRequest {
-        static instance: RegistrationRequest = RegistrationRequest {
-            token: ::std::string::String::new(),
-            device_id: ::std::string::String::new(),
-            name: ::std::string::String::new(),
-            is_fast: false,
-            version: ::std::string::String::new(),
-            virtual_ip: 0,
-            allow_ip_change: false,
-            client_secret: false,
-            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.device_info_list)
-    pub device_info_list: ::std::vec::Vec<DeviceInfo>,
-    // @@protoc_insertion_point(field:RegistrationResponse.public_ip)
-    pub public_ip: u32,
-    // @@protoc_insertion_point(field:RegistrationResponse.public_port)
-    pub public_port: u32,
-    // @@protoc_insertion_point(field:RegistrationResponse.public_ipv6)
-    pub public_ipv6: ::std::vec::Vec<u8>,
-    // 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(8);
-        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::<_, _>(
-            "device_info_list",
-            |m: &RegistrationResponse| { &m.device_info_list },
-            |m: &mut RegistrationResponse| { &mut m.device_info_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 },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "public_ipv6",
-            |m: &RegistrationResponse| { &m.public_ipv6 },
-            |m: &mut RegistrationResponse| { &mut m.public_ipv6 },
-        ));
-        ::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 => {
-                    self.device_info_list.push(is.read_message()?);
-                },
-                53 => {
-                    self.public_ip = is.read_fixed32()?;
-                },
-                56 => {
-                    self.public_port = is.read_uint32()?;
-                },
-                66 => {
-                    self.public_ipv6 = is.read_bytes()?;
-                },
-                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);
-        }
-        for value in &self.device_info_list {
-            let len = value.compute_size();
-            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
-        };
-        if self.public_ip != 0 {
-            my_size += 1 + 4;
-        }
-        if self.public_port != 0 {
-            my_size += ::protobuf::rt::uint32_size(7, self.public_port);
-        }
-        if !self.public_ipv6.is_empty() {
-            my_size += ::protobuf::rt::bytes_size(8, &self.public_ipv6);
-        }
-        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.device_info_list {
-            ::protobuf::rt::write_message_field_with_cached_size(5, v, os)?;
-        };
-        if self.public_ip != 0 {
-            os.write_fixed32(6, self.public_ip)?;
-        }
-        if self.public_port != 0 {
-            os.write_uint32(7, self.public_port)?;
-        }
-        if !self.public_ipv6.is_empty() {
-            os.write_bytes(8, &self.public_ipv6)?;
-        }
-        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.device_info_list.clear();
-        self.public_ip = 0;
-        self.public_port = 0;
-        self.public_ipv6.clear();
-        self.special_fields.clear();
-    }
-
-    fn default_instance() -> &'static RegistrationResponse {
-        static instance: RegistrationResponse = RegistrationResponse {
-            virtual_ip: 0,
-            virtual_gateway: 0,
-            virtual_netmask: 0,
-            epoch: 0,
-            device_info_list: ::std::vec::Vec::new(),
-            public_ip: 0,
-            public_port: 0,
-            public_ipv6: ::std::vec::Vec::new(),
-            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:DeviceInfo)
-pub struct DeviceInfo {
-    // message fields
-    // @@protoc_insertion_point(field:DeviceInfo.name)
-    pub name: ::std::string::String,
-    // @@protoc_insertion_point(field:DeviceInfo.virtual_ip)
-    pub virtual_ip: u32,
-    // @@protoc_insertion_point(field:DeviceInfo.device_status)
-    pub device_status: u32,
-    // @@protoc_insertion_point(field:DeviceInfo.client_secret)
-    pub client_secret: bool,
-    // special fields
-    // @@protoc_insertion_point(special_field:DeviceInfo.special_fields)
-    pub special_fields: ::protobuf::SpecialFields,
-}
-
-impl<'a> ::std::default::Default for &'a DeviceInfo {
-    fn default() -> &'a DeviceInfo {
-        <DeviceInfo as ::protobuf::Message>::default_instance()
-    }
-}
-
-impl DeviceInfo {
-    pub fn new() -> DeviceInfo {
-        ::std::default::Default::default()
-    }
-
-    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
-        let mut fields = ::std::vec::Vec::with_capacity(4);
-        let mut oneofs = ::std::vec::Vec::with_capacity(0);
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "name",
-            |m: &DeviceInfo| { &m.name },
-            |m: &mut DeviceInfo| { &mut m.name },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "virtual_ip",
-            |m: &DeviceInfo| { &m.virtual_ip },
-            |m: &mut DeviceInfo| { &mut m.virtual_ip },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "device_status",
-            |m: &DeviceInfo| { &m.device_status },
-            |m: &mut DeviceInfo| { &mut m.device_status },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "client_secret",
-            |m: &DeviceInfo| { &m.client_secret },
-            |m: &mut DeviceInfo| { &mut m.client_secret },
-        ));
-        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<DeviceInfo>(
-            "DeviceInfo",
-            fields,
-            oneofs,
-        )
-    }
-}
-
-impl ::protobuf::Message for DeviceInfo {
-    const NAME: &'static str = "DeviceInfo";
-
-    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.name = is.read_string()?;
-                },
-                21 => {
-                    self.virtual_ip = is.read_fixed32()?;
-                },
-                24 => {
-                    self.device_status = is.read_uint32()?;
-                },
-                32 => {
-                    self.client_secret = is.read_bool()?;
-                },
-                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.name.is_empty() {
-            my_size += ::protobuf::rt::string_size(1, &self.name);
-        }
-        if self.virtual_ip != 0 {
-            my_size += 1 + 4;
-        }
-        if self.device_status != 0 {
-            my_size += ::protobuf::rt::uint32_size(3, self.device_status);
-        }
-        if self.client_secret != false {
-            my_size += 1 + 1;
-        }
-        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.name.is_empty() {
-            os.write_string(1, &self.name)?;
-        }
-        if self.virtual_ip != 0 {
-            os.write_fixed32(2, self.virtual_ip)?;
-        }
-        if self.device_status != 0 {
-            os.write_uint32(3, self.device_status)?;
-        }
-        if self.client_secret != false {
-            os.write_bool(4, self.client_secret)?;
-        }
-        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() -> DeviceInfo {
-        DeviceInfo::new()
-    }
-
-    fn clear(&mut self) {
-        self.name.clear();
-        self.virtual_ip = 0;
-        self.device_status = 0;
-        self.client_secret = false;
-        self.special_fields.clear();
-    }
-
-    fn default_instance() -> &'static DeviceInfo {
-        static instance: DeviceInfo = DeviceInfo {
-            name: ::std::string::String::new(),
-            virtual_ip: 0,
-            device_status: 0,
-            client_secret: false,
-            special_fields: ::protobuf::SpecialFields::new(),
-        };
-        &instance
-    }
-}
-
-impl ::protobuf::MessageFull for DeviceInfo {
-    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("DeviceInfo").unwrap()).clone()
-    }
-}
-
-impl ::std::fmt::Display for DeviceInfo {
-    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
-    }
-}
-
-impl ::protobuf::reflect::ProtobufValue for DeviceInfo {
-    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.device_info_list)
-    pub device_info_list: ::std::vec::Vec<DeviceInfo>,
-    // 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::<_, _>(
-            "device_info_list",
-            |m: &DeviceList| { &m.device_info_list },
-            |m: &mut DeviceList| { &mut m.device_info_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 => {
-                    self.device_info_list.push(is.read_message()?);
-                },
-                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);
-        }
-        for value in &self.device_info_list {
-            let len = value.compute_size();
-            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
-        };
-        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.device_info_list {
-            ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
-        };
-        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.device_info_list.clear();
-        self.special_fields.clear();
-    }
-
-    fn default_instance() -> &'static DeviceList {
-        static instance: DeviceList = DeviceList {
-            epoch: 0,
-            device_info_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:PunchInfo)
-pub struct PunchInfo {
-    // message fields
-    // @@protoc_insertion_point(field:PunchInfo.public_ip_list)
-    pub public_ip_list: ::std::vec::Vec<u32>,
-    // @@protoc_insertion_point(field:PunchInfo.public_port)
-    pub public_port: u32,
-    // @@protoc_insertion_point(field:PunchInfo.public_port_range)
-    pub public_port_range: u32,
-    // @@protoc_insertion_point(field:PunchInfo.nat_type)
-    pub nat_type: ::protobuf::EnumOrUnknown<PunchNatType>,
-    // @@protoc_insertion_point(field:PunchInfo.reply)
-    pub reply: bool,
-    // @@protoc_insertion_point(field:PunchInfo.local_ip)
-    pub local_ip: u32,
-    // @@protoc_insertion_point(field:PunchInfo.local_port)
-    pub local_port: u32,
-    // @@protoc_insertion_point(field:PunchInfo.ipv6)
-    pub ipv6: ::std::vec::Vec<u8>,
-    // @@protoc_insertion_point(field:PunchInfo.ipv6_port)
-    pub ipv6_port: u32,
-    // @@protoc_insertion_point(field:PunchInfo.tcp_port)
-    pub tcp_port: u32,
-    // @@protoc_insertion_point(field:PunchInfo.udp_ports)
-    pub udp_ports: ::std::vec::Vec<u32>,
-    // @@protoc_insertion_point(field:PunchInfo.public_ports)
-    pub public_ports: ::std::vec::Vec<u32>,
-    // special fields
-    // @@protoc_insertion_point(special_field:PunchInfo.special_fields)
-    pub special_fields: ::protobuf::SpecialFields,
-}
-
-impl<'a> ::std::default::Default for &'a PunchInfo {
-    fn default() -> &'a PunchInfo {
-        <PunchInfo as ::protobuf::Message>::default_instance()
-    }
-}
-
-impl PunchInfo {
-    pub fn new() -> PunchInfo {
-        ::std::default::Default::default()
-    }
-
-    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
-        let mut fields = ::std::vec::Vec::with_capacity(12);
-        let mut oneofs = ::std::vec::Vec::with_capacity(0);
-        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
-            "public_ip_list",
-            |m: &PunchInfo| { &m.public_ip_list },
-            |m: &mut PunchInfo| { &mut m.public_ip_list },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "public_port",
-            |m: &PunchInfo| { &m.public_port },
-            |m: &mut PunchInfo| { &mut m.public_port },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "public_port_range",
-            |m: &PunchInfo| { &m.public_port_range },
-            |m: &mut PunchInfo| { &mut m.public_port_range },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "nat_type",
-            |m: &PunchInfo| { &m.nat_type },
-            |m: &mut PunchInfo| { &mut m.nat_type },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "reply",
-            |m: &PunchInfo| { &m.reply },
-            |m: &mut PunchInfo| { &mut m.reply },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "local_ip",
-            |m: &PunchInfo| { &m.local_ip },
-            |m: &mut PunchInfo| { &mut m.local_ip },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "local_port",
-            |m: &PunchInfo| { &m.local_port },
-            |m: &mut PunchInfo| { &mut m.local_port },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "ipv6",
-            |m: &PunchInfo| { &m.ipv6 },
-            |m: &mut PunchInfo| { &mut m.ipv6 },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "ipv6_port",
-            |m: &PunchInfo| { &m.ipv6_port },
-            |m: &mut PunchInfo| { &mut m.ipv6_port },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "tcp_port",
-            |m: &PunchInfo| { &m.tcp_port },
-            |m: &mut PunchInfo| { &mut m.tcp_port },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
-            "udp_ports",
-            |m: &PunchInfo| { &m.udp_ports },
-            |m: &mut PunchInfo| { &mut m.udp_ports },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
-            "public_ports",
-            |m: &PunchInfo| { &m.public_ports },
-            |m: &mut PunchInfo| { &mut m.public_ports },
-        ));
-        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<PunchInfo>(
-            "PunchInfo",
-            fields,
-            oneofs,
-        )
-    }
-}
-
-impl ::protobuf::Message for PunchInfo {
-    const NAME: &'static str = "PunchInfo";
-
-    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 {
-                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()?;
-                },
-                61 => {
-                    self.local_ip = is.read_fixed32()?;
-                },
-                64 => {
-                    self.local_port = is.read_uint32()?;
-                },
-                74 => {
-                    self.ipv6 = is.read_bytes()?;
-                },
-                80 => {
-                    self.ipv6_port = is.read_uint32()?;
-                },
-                88 => {
-                    self.tcp_port = is.read_uint32()?;
-                },
-                98 => {
-                    is.read_repeated_packed_uint32_into(&mut self.udp_ports)?;
-                },
-                96 => {
-                    self.udp_ports.push(is.read_uint32()?);
-                },
-                106 => {
-                    is.read_repeated_packed_uint32_into(&mut self.public_ports)?;
-                },
-                104 => {
-                    self.public_ports.push(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;
-        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(PunchNatType::Symmetric) {
-            my_size += ::protobuf::rt::int32_size(5, self.nat_type.value());
-        }
-        if self.reply != false {
-            my_size += 1 + 1;
-        }
-        if self.local_ip != 0 {
-            my_size += 1 + 4;
-        }
-        if self.local_port != 0 {
-            my_size += ::protobuf::rt::uint32_size(8, self.local_port);
-        }
-        if !self.ipv6.is_empty() {
-            my_size += ::protobuf::rt::bytes_size(9, &self.ipv6);
-        }
-        if self.ipv6_port != 0 {
-            my_size += ::protobuf::rt::uint32_size(10, self.ipv6_port);
-        }
-        if self.tcp_port != 0 {
-            my_size += ::protobuf::rt::uint32_size(11, self.tcp_port);
-        }
-        for value in &self.udp_ports {
-            my_size += ::protobuf::rt::uint32_size(12, *value);
-        };
-        for value in &self.public_ports {
-            my_size += ::protobuf::rt::uint32_size(13, *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<()> {
-        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(PunchNatType::Symmetric) {
-            os.write_enum(5, ::protobuf::EnumOrUnknown::value(&self.nat_type))?;
-        }
-        if self.reply != false {
-            os.write_bool(6, self.reply)?;
-        }
-        if self.local_ip != 0 {
-            os.write_fixed32(7, self.local_ip)?;
-        }
-        if self.local_port != 0 {
-            os.write_uint32(8, self.local_port)?;
-        }
-        if !self.ipv6.is_empty() {
-            os.write_bytes(9, &self.ipv6)?;
-        }
-        if self.ipv6_port != 0 {
-            os.write_uint32(10, self.ipv6_port)?;
-        }
-        if self.tcp_port != 0 {
-            os.write_uint32(11, self.tcp_port)?;
-        }
-        for v in &self.udp_ports {
-            os.write_uint32(12, *v)?;
-        };
-        for v in &self.public_ports {
-            os.write_uint32(13, *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() -> PunchInfo {
-        PunchInfo::new()
-    }
-
-    fn clear(&mut self) {
-        self.public_ip_list.clear();
-        self.public_port = 0;
-        self.public_port_range = 0;
-        self.nat_type = ::protobuf::EnumOrUnknown::new(PunchNatType::Symmetric);
-        self.reply = false;
-        self.local_ip = 0;
-        self.local_port = 0;
-        self.ipv6.clear();
-        self.ipv6_port = 0;
-        self.tcp_port = 0;
-        self.udp_ports.clear();
-        self.public_ports.clear();
-        self.special_fields.clear();
-    }
-
-    fn default_instance() -> &'static PunchInfo {
-        static instance: PunchInfo = PunchInfo {
-            public_ip_list: ::std::vec::Vec::new(),
-            public_port: 0,
-            public_port_range: 0,
-            nat_type: ::protobuf::EnumOrUnknown::from_i32(0),
-            reply: false,
-            local_ip: 0,
-            local_port: 0,
-            ipv6: ::std::vec::Vec::new(),
-            ipv6_port: 0,
-            tcp_port: 0,
-            udp_ports: ::std::vec::Vec::new(),
-            public_ports: ::std::vec::Vec::new(),
-            special_fields: ::protobuf::SpecialFields::new(),
-        };
-        &instance
-    }
-}
-
-impl ::protobuf::MessageFull for PunchInfo {
-    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("PunchInfo").unwrap()).clone()
-    }
-}
-
-impl ::std::fmt::Display for PunchInfo {
-    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
-    }
-}
-
-impl ::protobuf::reflect::ProtobufValue for PunchInfo {
-    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
-}
-
-#[derive(PartialEq,Clone,Default,Debug)]
-// @@protoc_insertion_point(message:ClientStatusInfo)
-pub struct ClientStatusInfo {
-    // message fields
-    // @@protoc_insertion_point(field:ClientStatusInfo.source)
-    pub source: u32,
-    // @@protoc_insertion_point(field:ClientStatusInfo.p2p_list)
-    pub p2p_list: ::std::vec::Vec<RouteItem>,
-    // @@protoc_insertion_point(field:ClientStatusInfo.up_stream)
-    pub up_stream: u64,
-    // @@protoc_insertion_point(field:ClientStatusInfo.down_stream)
-    pub down_stream: u64,
-    // @@protoc_insertion_point(field:ClientStatusInfo.nat_type)
-    pub nat_type: ::protobuf::EnumOrUnknown<PunchNatType>,
-    // special fields
-    // @@protoc_insertion_point(special_field:ClientStatusInfo.special_fields)
-    pub special_fields: ::protobuf::SpecialFields,
-}
-
-impl<'a> ::std::default::Default for &'a ClientStatusInfo {
-    fn default() -> &'a ClientStatusInfo {
-        <ClientStatusInfo as ::protobuf::Message>::default_instance()
-    }
-}
-
-impl ClientStatusInfo {
-    pub fn new() -> ClientStatusInfo {
-        ::std::default::Default::default()
-    }
-
-    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
-        let mut fields = ::std::vec::Vec::with_capacity(5);
-        let mut oneofs = ::std::vec::Vec::with_capacity(0);
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "source",
-            |m: &ClientStatusInfo| { &m.source },
-            |m: &mut ClientStatusInfo| { &mut m.source },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
-            "p2p_list",
-            |m: &ClientStatusInfo| { &m.p2p_list },
-            |m: &mut ClientStatusInfo| { &mut m.p2p_list },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "up_stream",
-            |m: &ClientStatusInfo| { &m.up_stream },
-            |m: &mut ClientStatusInfo| { &mut m.up_stream },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "down_stream",
-            |m: &ClientStatusInfo| { &m.down_stream },
-            |m: &mut ClientStatusInfo| { &mut m.down_stream },
-        ));
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "nat_type",
-            |m: &ClientStatusInfo| { &m.nat_type },
-            |m: &mut ClientStatusInfo| { &mut m.nat_type },
-        ));
-        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<ClientStatusInfo>(
-            "ClientStatusInfo",
-            fields,
-            oneofs,
-        )
-    }
-}
-
-impl ::protobuf::Message for ClientStatusInfo {
-    const NAME: &'static str = "ClientStatusInfo";
-
-    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.source = is.read_fixed32()?;
-                },
-                18 => {
-                    self.p2p_list.push(is.read_message()?);
-                },
-                24 => {
-                    self.up_stream = is.read_uint64()?;
-                },
-                32 => {
-                    self.down_stream = is.read_uint64()?;
-                },
-                40 => {
-                    self.nat_type = 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.source != 0 {
-            my_size += 1 + 4;
-        }
-        for value in &self.p2p_list {
-            let len = value.compute_size();
-            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
-        };
-        if self.up_stream != 0 {
-            my_size += ::protobuf::rt::uint64_size(3, self.up_stream);
-        }
-        if self.down_stream != 0 {
-            my_size += ::protobuf::rt::uint64_size(4, self.down_stream);
-        }
-        if self.nat_type != ::protobuf::EnumOrUnknown::new(PunchNatType::Symmetric) {
-            my_size += ::protobuf::rt::int32_size(5, self.nat_type.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.source != 0 {
-            os.write_fixed32(1, self.source)?;
-        }
-        for v in &self.p2p_list {
-            ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
-        };
-        if self.up_stream != 0 {
-            os.write_uint64(3, self.up_stream)?;
-        }
-        if self.down_stream != 0 {
-            os.write_uint64(4, self.down_stream)?;
-        }
-        if self.nat_type != ::protobuf::EnumOrUnknown::new(PunchNatType::Symmetric) {
-            os.write_enum(5, ::protobuf::EnumOrUnknown::value(&self.nat_type))?;
-        }
-        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() -> ClientStatusInfo {
-        ClientStatusInfo::new()
-    }
-
-    fn clear(&mut self) {
-        self.source = 0;
-        self.p2p_list.clear();
-        self.up_stream = 0;
-        self.down_stream = 0;
-        self.nat_type = ::protobuf::EnumOrUnknown::new(PunchNatType::Symmetric);
-        self.special_fields.clear();
-    }
-
-    fn default_instance() -> &'static ClientStatusInfo {
-        static instance: ClientStatusInfo = ClientStatusInfo {
-            source: 0,
-            p2p_list: ::std::vec::Vec::new(),
-            up_stream: 0,
-            down_stream: 0,
-            nat_type: ::protobuf::EnumOrUnknown::from_i32(0),
-            special_fields: ::protobuf::SpecialFields::new(),
-        };
-        &instance
-    }
-}
-
-impl ::protobuf::MessageFull for ClientStatusInfo {
-    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("ClientStatusInfo").unwrap()).clone()
-    }
-}
-
-impl ::std::fmt::Display for ClientStatusInfo {
-    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
-    }
-}
-
-impl ::protobuf::reflect::ProtobufValue for ClientStatusInfo {
-    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
-}
-
-#[derive(PartialEq,Clone,Default,Debug)]
-// @@protoc_insertion_point(message:RouteItem)
-pub struct RouteItem {
-    // message fields
-    // @@protoc_insertion_point(field:RouteItem.next_ip)
-    pub next_ip: u32,
-    // special fields
-    // @@protoc_insertion_point(special_field:RouteItem.special_fields)
-    pub special_fields: ::protobuf::SpecialFields,
-}
-
-impl<'a> ::std::default::Default for &'a RouteItem {
-    fn default() -> &'a RouteItem {
-        <RouteItem as ::protobuf::Message>::default_instance()
-    }
-}
-
-impl RouteItem {
-    pub fn new() -> RouteItem {
-        ::std::default::Default::default()
-    }
-
-    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
-        let mut fields = ::std::vec::Vec::with_capacity(1);
-        let mut oneofs = ::std::vec::Vec::with_capacity(0);
-        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
-            "next_ip",
-            |m: &RouteItem| { &m.next_ip },
-            |m: &mut RouteItem| { &mut m.next_ip },
-        ));
-        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<RouteItem>(
-            "RouteItem",
-            fields,
-            oneofs,
-        )
-    }
-}
-
-impl ::protobuf::Message for RouteItem {
-    const NAME: &'static str = "RouteItem";
-
-    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.next_ip = 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.next_ip != 0 {
-            my_size += 1 + 4;
-        }
-        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.next_ip != 0 {
-            os.write_fixed32(1, self.next_ip)?;
-        }
-        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() -> RouteItem {
-        RouteItem::new()
-    }
-
-    fn clear(&mut self) {
-        self.next_ip = 0;
-        self.special_fields.clear();
-    }
-
-    fn default_instance() -> &'static RouteItem {
-        static instance: RouteItem = RouteItem {
-            next_ip: 0,
-            special_fields: ::protobuf::SpecialFields::new(),
-        };
-        &instance
-    }
-}
-
-impl ::protobuf::MessageFull for RouteItem {
-    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("RouteItem").unwrap()).clone()
-    }
-}
-
-impl ::std::fmt::Display for RouteItem {
-    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
-    }
-}
-
-impl ::protobuf::reflect::ProtobufValue for RouteItem {
-    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
-}
-
-#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
-// @@protoc_insertion_point(enum:PunchNatType)
-pub enum PunchNatType {
-    // @@protoc_insertion_point(enum_value:PunchNatType.Symmetric)
-    Symmetric = 0,
-    // @@protoc_insertion_point(enum_value:PunchNatType.Cone)
-    Cone = 1,
-}
-
-impl ::protobuf::Enum for PunchNatType {
-    const NAME: &'static str = "PunchNatType";
-
-    fn value(&self) -> i32 {
-        *self as i32
-    }
-
-    fn from_i32(value: i32) -> ::std::option::Option<PunchNatType> {
-        match value {
-            0 => ::std::option::Option::Some(PunchNatType::Symmetric),
-            1 => ::std::option::Option::Some(PunchNatType::Cone),
-            _ => ::std::option::Option::None
-        }
-    }
-
-    const VALUES: &'static [PunchNatType] = &[
-        PunchNatType::Symmetric,
-        PunchNatType::Cone,
-    ];
-}
-
-impl ::protobuf::EnumFull for PunchNatType {
-    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("PunchNatType").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 PunchNatType {
-    fn default() -> Self {
-        PunchNatType::Symmetric
-    }
-}
-
-impl PunchNatType {
-    fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData {
-        ::protobuf::reflect::GeneratedEnumDescriptorData::new::<PunchNatType>("PunchNatType")
-    }
-}
-
-static file_descriptor_proto_data: &'static [u8] = b"\
-    \n\rmessage.proto\"D\n\x10HandshakeRequest\x12\x18\n\x07version\x18\x01\
-    \x20\x01(\tR\x07version\x12\x16\n\x06secret\x18\x02\x20\x01(\x08R\x06sec\
-    ret\"\x83\x01\n\x11HandshakeResponse\x12\x18\n\x07version\x18\x01\x20\
-    \x01(\tR\x07version\x12\x16\n\x06secret\x18\x02\x20\x01(\x08R\x06secret\
-    \x12\x1d\n\npublic_key\x18\x03\x20\x01(\x0cR\tpublicKey\x12\x1d\n\nkey_f\
-    inger\x18\x04\x20\x01(\tR\tkeyFinger\"@\n\x16SecretHandshakeRequest\x12\
-    \x14\n\x05token\x18\x01\x20\x01(\tR\x05token\x12\x10\n\x03key\x18\x02\
-    \x20\x01(\x0cR\x03key\"\xfb\x01\n\x13RegistrationRequest\x12\x14\n\x05to\
-    ken\x18\x01\x20\x01(\tR\x05token\x12\x1b\n\tdevice_id\x18\x02\x20\x01(\t\
-    R\x08deviceId\x12\x12\n\x04name\x18\x03\x20\x01(\tR\x04name\x12\x17\n\
-    \x07is_fast\x18\x04\x20\x01(\x08R\x06isFast\x12\x18\n\x07version\x18\x05\
-    \x20\x01(\tR\x07version\x12\x1d\n\nvirtual_ip\x18\x06\x20\x01(\x07R\tvir\
-    tualIp\x12&\n\x0fallow_ip_change\x18\x07\x20\x01(\x08R\rallowIpChange\
-    \x12#\n\rclient_secret\x18\x08\x20\x01(\x08R\x0cclientSecret\"\xb3\x02\n\
-    \x14RegistrationResponse\x12\x1d\n\nvirtual_ip\x18\x01\x20\x01(\x07R\tvi\
-    rtualIp\x12'\n\x0fvirtual_gateway\x18\x02\x20\x01(\x07R\x0evirtualGatewa\
-    y\x12'\n\x0fvirtual_netmask\x18\x03\x20\x01(\x07R\x0evirtualNetmask\x12\
-    \x14\n\x05epoch\x18\x04\x20\x01(\rR\x05epoch\x125\n\x10device_info_list\
-    \x18\x05\x20\x03(\x0b2\x0b.DeviceInfoR\x0edeviceInfoList\x12\x1b\n\tpubl\
-    ic_ip\x18\x06\x20\x01(\x07R\x08publicIp\x12\x1f\n\x0bpublic_port\x18\x07\
-    \x20\x01(\rR\npublicPort\x12\x1f\n\x0bpublic_ipv6\x18\x08\x20\x01(\x0cR\
-    \npublicIpv6\"\x89\x01\n\nDeviceInfo\x12\x12\n\x04name\x18\x01\x20\x01(\
-    \tR\x04name\x12\x1d\n\nvirtual_ip\x18\x02\x20\x01(\x07R\tvirtualIp\x12#\
-    \n\rdevice_status\x18\x03\x20\x01(\rR\x0cdeviceStatus\x12#\n\rclient_sec\
-    ret\x18\x04\x20\x01(\x08R\x0cclientSecret\"Y\n\nDeviceList\x12\x14\n\x05\
-    epoch\x18\x01\x20\x01(\rR\x05epoch\x125\n\x10device_info_list\x18\x02\
-    \x20\x03(\x0b2\x0b.DeviceInfoR\x0edeviceInfoList\"\x84\x03\n\tPunchInfo\
-    \x12$\n\x0epublic_ip_list\x18\x02\x20\x03(\x07R\x0cpublicIpList\x12\x1f\
-    \n\x0bpublic_port\x18\x03\x20\x01(\rR\npublicPort\x12*\n\x11public_port_\
-    range\x18\x04\x20\x01(\rR\x0fpublicPortRange\x12(\n\x08nat_type\x18\x05\
-    \x20\x01(\x0e2\r.PunchNatTypeR\x07natType\x12\x14\n\x05reply\x18\x06\x20\
-    \x01(\x08R\x05reply\x12\x19\n\x08local_ip\x18\x07\x20\x01(\x07R\x07local\
-    Ip\x12\x1d\n\nlocal_port\x18\x08\x20\x01(\rR\tlocalPort\x12\x12\n\x04ipv\
-    6\x18\t\x20\x01(\x0cR\x04ipv6\x12\x1b\n\tipv6_port\x18\n\x20\x01(\rR\x08\
-    ipv6Port\x12\x19\n\x08tcp_port\x18\x0b\x20\x01(\rR\x07tcpPort\x12\x1b\n\
-    \tudp_ports\x18\x0c\x20\x03(\rR\x08udpPorts\x12!\n\x0cpublic_ports\x18\r\
-    \x20\x03(\rR\x0bpublicPorts\"\xb9\x01\n\x10ClientStatusInfo\x12\x16\n\
-    \x06source\x18\x01\x20\x01(\x07R\x06source\x12%\n\x08p2p_list\x18\x02\
-    \x20\x03(\x0b2\n.RouteItemR\x07p2pList\x12\x1b\n\tup_stream\x18\x03\x20\
-    \x01(\x04R\x08upStream\x12\x1f\n\x0bdown_stream\x18\x04\x20\x01(\x04R\nd\
-    ownStream\x12(\n\x08nat_type\x18\x05\x20\x01(\x0e2\r.PunchNatTypeR\x07na\
-    tType\"$\n\tRouteItem\x12\x17\n\x07next_ip\x18\x01\x20\x01(\x07R\x06next\
-    Ip*'\n\x0cPunchNatType\x12\r\n\tSymmetric\x10\0\x12\x08\n\x04Cone\x10\
-    \x01b\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(10);
-            messages.push(HandshakeRequest::generated_message_descriptor_data());
-            messages.push(HandshakeResponse::generated_message_descriptor_data());
-            messages.push(SecretHandshakeRequest::generated_message_descriptor_data());
-            messages.push(RegistrationRequest::generated_message_descriptor_data());
-            messages.push(RegistrationResponse::generated_message_descriptor_data());
-            messages.push(DeviceInfo::generated_message_descriptor_data());
-            messages.push(DeviceList::generated_message_descriptor_data());
-            messages.push(PunchInfo::generated_message_descriptor_data());
-            messages.push(ClientStatusInfo::generated_message_descriptor_data());
-            messages.push(RouteItem::generated_message_descriptor_data());
-            let mut enums = ::std::vec::Vec::with_capacity(1);
-            enums.push(PunchNatType::generated_enum_descriptor_data());
-            ::protobuf::reflect::GeneratedFileDescriptor::new_generated(
-                file_descriptor_proto(),
-                deps,
-                messages,
-                enums,
-            )
-        });
-        ::protobuf::reflect::FileDescriptor::new_generated_2(generated_file_descriptor)
-    })
-}

vnt/src/proto/mod.rs

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