fed up with generic stuffs

1 files changed, 235 insertions, 265 deletions

diff --git a/src/session/tcp_session.rs b/src/session/tcp_session.rs
index 238db38..3aecef1 100644
--- a/src/session/tcp_session.rs
+++ b/src/session/tcp_session.rs
@@ -46,8 +46,10 @@ impl SessionState for TimeWait{}
 impl SessionState for Closed{}
 
 enum TcpSessionErr {
-    WrongPacket(String),
+    WrongFlag(String),
     NoWindowSpace,
+    WrongSender(PeerRole),
+    FurtherCheckClosing,
 }
 
 #[derive(Debug)]
@@ -73,6 +75,11 @@ struct Packet {
     segment: TcpSegment,
 }
 
+enum PeerRole {
+    Client,
+    Server,
+}
+
 pub(super) struct Peer {
     state: Box<dyn SessionState>,
     ian: u32, // initial ack number
@@ -147,27 +154,22 @@ enum ClosingBy {
     Closed,
 }
 
-#[derive(Debug)]
-struct TransferringState<'a, SSender: SessionState, SReceiver: SessionState>{
-    client: &'a mut Peer,
-    server: &'a mut Peer,
-    closing_by: ClosingBy,
-    p: PhantomData<SSender>,
-    q: PhantomData<SReceiver>,
+#[derive(Debug, PartialEq, Eq)]
+struct TransferringState<SSender: SessionState, SReceiver: SessionState>{
+    state_sender: SSender,
+    state_receiver: SReceiver,
 }
 
-impl<'a, SSender: SessionState, SReceiver: SessionState> Default for TransferringState<'a, SSender, SReceiver> {
-    fn default() -> Self {
+impl<SSender: SessionState, SReceiver: SessionState> TransferringState<SSender, SReceiver> {
+    fn new(state_sender: SSender, state_receiver: SReceiver) -> Self {
         TransferringState {
-            client: panic!("Default not implemented for client"), // You can't provide a default for a reference
-            server: panic!("Default not implemented for server"), // You can't provide a default for a reference
-            closing_by: ClosingBy::Nil,
-            p: PhantomData,
-            q: PhantomData,
+            state_sender,
+            state_receiver,
         }
     }
 }
 
+
 // wave hand:
 // Peer                                     side
 // Established send fin -> FinWait1*        Established receive fin -> CloseWait        
@@ -180,170 +182,213 @@ impl<'a, SSender: SessionState, SReceiver: SessionState> Default for Transferrin
 // (just wait)                              FinWait1 receive fin -> Closing
 // Closing send ack -> Closing              Closing send ack -> closing
 // Closing receive ack -> timewait          Closing receive ack -> timewait
-enum TransferringStateWrapper<'a> {
-    Closed(TransferringState<'a, Closed, Closed>), // initial and end
-    SynSent(TransferringState<'a, SynSent, Listen>),    // the client start a connection
-    SynReceived(TransferringState<'a, SynReceived, SynSent>), // server ack the syn packet
-    Established(TransferringState<'a, Established, Established>), // 3 way handshake done
-    FinWait1(TransferringState<'a, FinWait1, CloseWait>), // one of(either client or server) peer sends fin|rst and turn to FinWait1
-    FinWait2(TransferringState<'a, FinWait2, CloseWait>), // receive ack
-    LastAck(TransferringState<'a, LastAck, TimeWait>), // the side peer send fin on receiving fin that initiated by the other peer
-    TimeWait(TransferringState<'a, TimeWait, Closed>), // 4-way handshake done
-    Closing1(TransferringState<'a, FinWait1, Closing>), // one of Established state send syn and turn to FinWait1, while its peer, which has already sent syn and were being in FinWait1 state, receive syn and turn to Closing state
-    Closing2(TransferringState<'a, Closing, Closing>), // both peers enter the temporary Closing state
-    BothTimeWait1(TransferringState<'a, Closing, TimeWait>), // closing receive ack and turn to timewait
-    BothTimeWait2(TransferringState<'a, TimeWait, TimeWait>), // closing receive ack and turn to timewait
-}
-
-impl<'a> TransferringStateWrapper<'a> {
-    fn step(&mut self, packet: Packet) -> Result<(), TcpSessionErr> {
+enum TransferringStateWrapper {
+    Closed(TransferringState<Closed, Closed>), // initial and end
+    SynSent(TransferringState<SynSent, Listen>),    // the client start a connection
+    SynReceived(TransferringState<SynReceived, SynSent>), // server ack the syn packet
+    Established(TransferringState<Established, Established>), // 3 way handshake done
+    FinWait1(TransferringState<FinWait1, CloseWait>), // one of(either client or server) peer sends fin|rst and turn to FinWait1
+    FinWait2(TransferringState<FinWait2, CloseWait>), // receive ack
+    LastAck(TransferringState<LastAck, TimeWait>), // the side peer send fin on receiving fin that initiated by the other peer
+    TimeWait(TransferringState<TimeWait, Closed>), // 4-way handshake done
+    Closing1(TransferringState<FinWait1, Closing>), // one of Established state send syn and turn to FinWait1, while its peer, which has already sent syn and were being in FinWait1 state, receive syn and turn to Closing state
+    Closing2(TransferringState<Closing, Closing>), // both peers enter the temporary Closing state
+    BothTimeWait1(TransferringState<Closing, TimeWait>), // closing receive ack and turn to timewait
+    BothTimeWait2(TransferringState<TimeWait, TimeWait>), // closing receive ack and turn to timewait
+}
+
+struct TransferringStateTransition {
+    from: TransferringStateWrapper,
+    to: TransferringStateWrapper,
+    ret_err: Option<TcpSessionErr>,
+}
+
+
+impl TransferringStateWrapper {
+    fn try_step(&self, packet: Packet) -> TransferringStateTransition {
+        let mut ret = TransferringStateTransition {
+            from: *self,
+            to: *self,
+            ret_err: None,
+        };
         match *self {
             /* ---------------------------  3 way handshake --------------------------- */
             TransferringStateWrapper::Closed(state) => {
                 if !packet.tcp_header.flag_syn {
-                    return Err(TcpSessionErr::WrongPacket("Closed server expect syn packet".to_string()));
+                    ret.ret_err = Some(TcpSessionErr::WrongFlag("Closed server expect syn packet".to_string()));
+                } else {
+                    ret.to = TransferringStateWrapper::SynSent(TransferringState{
+                        state_sender: SynSent,
+                        state_receiver: Listen,
+                    })
                 }
-                *self = TransferringStateWrapper::SynSent(TransferringState{
-                    client: state.client,
-                    server: state.server,
-                    ..Default::default()
-                });
+
+                return ret;
             },
             TransferringStateWrapper::SynSent(state) => {
                 if !packet.tcp_header.flag_syn || !packet.tcp_header.flag_ack {
-                    return Err(TcpSessionErr::WrongPacket("Client expects syn + ack packet to establish connection".to_string()));
+                    ret.ret_err = Some(TcpSessionErr::WrongFlag("Client expects syn + ack packet to establish connection".to_string()));
+                } else {
+                    ret.to = TransferringStateWrapper::SynReceived(TransferringState{
+                        state_sender: SynReceived,
+                        state_receiver: SynSent,
+                    })
                 }
-                *self = TransferringStateWrapper::SynReceived(TransferringState{
-                    client: state.client,
-                    server: state.server,
-                    ..Default::default()
-                });
+                return ret;
             },
             TransferringStateWrapper::SynReceived(state) => {
                 if !packet.tcp_header.flag_ack {
-                    return Err(TcpSessionErr::WrongPacket("Server expects ack packet to establish connection".to_string()));
+                    ret.ret_err = Some(TcpSessionErr::WrongFlag("Server expects ack packet to establish connection".to_string()));
+                } else {
+                    ret.to = TransferringStateWrapper::Established(TransferringState{
+                        state_sender: Established,
+                        state_receiver: Established,
+                    })
                 }
-                *self = TransferringStateWrapper::Established(TransferringState{
-                    client: state.client,
-                    server: state.server,
-                    ..Default::default()
-                });
+                return ret;
             },
-
             /* ---------------------------  established & 4 way handshake --------------------------- */
             TransferringStateWrapper::Established(state) => {
                 if !packet.tcp_header.flag_ack && !packet.tcp_header.flag_fin && !packet.tcp_header.flag_rst {
-                    return Err(TcpSessionErr::WrongPacket("During transferring, every packet must carry ack, fin or rst flag.".to_string()));
+                    ret.ret_err = Some(TcpSessionErr::WrongFlag("During transferring, every packet must carry ack, fin or rst flag.".to_string()));
+                    return ret;
                 }
-
                 if packet.tcp_header.flag_fin || packet.tcp_header.flag_rst {
-                    *self = TransferringStateWrapper::FinWait1(TransferringState{
-                        client: state.client,
-                        server: state.server,
-                        ..Default::default()
+                    ret.to = TransferringStateWrapper::FinWait1(TransferringState{
+                        state_sender: FinWait1,
+                        state_receiver: CloseWait,
                     });
                 }
+                return ret;
             },
             TransferringStateWrapper::FinWait1(state) => {
                 if !packet.tcp_header.flag_ack || !packet.tcp_header.flag_fin {
-                    return Err(TcpSessionErr::WrongPacket("During FinWait1, wrong packet flag.".to_string()));
+                    ret.ret_err = Some(TcpSessionErr::WrongFlag("During FinWait1, wrong packet flag.".to_string()));
+                    return ret;
                 }
                 if packet.tcp_header.flag_ack {
-                    *self = TransferringStateWrapper::FinWait2(TransferringState{
-                        client: state.client,
-                        server: state.server,
-                        ..Default::default()
+                    ret.to = TransferringStateWrapper::FinWait2(TransferringState{
+                        state_sender: FinWait2,
+                        state_receiver: CloseWait,
                     });
                 } else {
-                    *self = TransferringStateWrapper::Closing1(TransferringState{
-                        client: state.client,
-                        server: state.server,
-                        ..Default::default()
-                    });
+                    ret.to = TransferringStateWrapper::Closing1(TransferringState{
+                            state_sender: FinWait1,
+                            state_receiver: Closing,
+                        });
                 }
+                return ret;
             }
             TransferringStateWrapper::FinWait2(state) => {
                 if !packet.tcp_header.flag_fin {
-                    return Err(TcpSessionErr::WrongPacket("During FinWait2, wrong packet flag, expecting fin".to_string()));
+                    ret.ret_err = Some(TcpSessionErr::WrongFlag("During FinWait2, wrong packet flag, expecting fin".to_string()));
+                } else {
+                    ret.to = TransferringStateWrapper::TimeWait(TransferringState{
+                        state_sender: TimeWait,
+                        state_receiver: Closed,
+                    });
                 }
-                *self = TransferringStateWrapper::LastAck(TransferringState{
-                    client: state.client,
-                    server: state.server,
-                    ..Default::default()
-                });
+                return ret;
             }
             TransferringStateWrapper::LastAck(state) => {
                 if !packet.tcp_header.flag_ack {
-                    return Err(TcpSessionErr::WrongPacket("During LastAck, wrong packet flag, expecting ack".to_string()));
+                    ret.ret_err = Some(TcpSessionErr::WrongFlag("During LastAck, wrong packet flag, expecting ack".to_string()));
+                } else {
+                    ret.to = TransferringStateWrapper::TimeWait(TransferringState{
+                        state_sender: TimeWait,
+                        state_receiver: Closed,
+                    });
                 }
-
-                *self = TransferringStateWrapper::TimeWait(TransferringState{
-                    client: state.client,
-                    server: state.server,
-                    ..Default::default()
-                });
+                return ret;
             }
             TransferringStateWrapper::TimeWait(state) => {
+                return ret;
                 // do nothing. Just throw away the redundant packets when in TimeWait state
             }
-
             /* --------------------------------- closing -------------------------------- */
             TransferringStateWrapper::Closing1(state) => {
                 if !packet.tcp_header.flag_syn {
-                    return Err(TcpSessionErr::WrongPacket("During Closing1, wrong packet flag, expecting syn".to_string()));
+                    ret.ret_err = Some(TcpSessionErr::WrongFlag("During Closing1, wrong packet flag, expecting syn".to_string()));
+                } else {
+                    ret.to = TransferringStateWrapper::Closing2(TransferringState{
+                        state_sender: Closing,
+                        state_receiver: Closing,
+                    });
                 }
-
-                *self = TransferringStateWrapper::Closing2(TransferringState{
-                    client: state.client,
-                    server: state.server,
-                    ..Default::default()
-                });
+                return ret;
             }
             TransferringStateWrapper::Closing2(state) => {
                 if !packet.tcp_header.flag_ack {
-                    return Err(TcpSessionErr::WrongPacket("A peer in closing state expects ack".to_string()));
+                    ret.ret_err = Some(TcpSessionErr::WrongFlag("During Closing2, wrong packet flag, expecting ack".to_string()));
+                } else {
+                    ret.to = TransferringStateWrapper::BothTimeWait1(TransferringState{
+                        state_sender: Closing,
+                        state_receiver: TimeWait,
+                    });
                 }
-
-                *self = TransferringStateWrapper::BothTimeWait1(TransferringState{
-                    client: state.client,
-                    server: state.server,
-                    ..Default::default()
-                });
+                return ret;
             }
             TransferringStateWrapper::BothTimeWait1(state) => {
                 // todo: 如果是重复发包，也就是主动关闭的那方收到的ack，就直接return, 这个检查放到状态机外面的前面
                 if !packet.tcp_header.flag_ack {
-                    return Err(TcpSessionErr::WrongPacket("A peer in closing state expects ack".to_string()));
+                    ret.ret_err = Some(TcpSessionErr::FurtherCheckClosing);
+                } else {
+                    ret.to = TransferringStateWrapper::BothTimeWait2(TransferringState{
+                        state_sender: TimeWait,
+                        state_receiver: TimeWait,
+                    });
                 }
-
-                *self = TransferringStateWrapper::BothTimeWait2(TransferringState{
-                    client: state.client,
-                    server: state.server,
-                    ..Default::default()
-                });
+                return ret;
             }
             TransferringStateWrapper::BothTimeWait2(_) => {
+                return ret;
                 // do nothing.Just throw away the redundant packets when in TimeWait state
             }
         }
-        Ok(())
     }
 }
 
-impl<'a, T1:SessionState, T2:SessionState> From<(&'a mut Peer, &'a mut Peer)> for TransferringState<'a, T1, T2> {
-    fn from((client,server): (&'a mut Peer, &'a mut Peer)) -> Self {
-        TransferringState {
-            client: client,
-            server: server,
-            closing_by: ClosingBy::Nil,
-            p: PhantomData,
-            q: PhantomData,
+impl TransferringStateTransition {
+    fn run(&self, packet: &Packet, client:&mut Peer, server:&mut Peer) -> Result<(TransferringStateWrapper, Option<Policy>), TcpSessionErr> {
+        match self.from {
+            
+        }
+        if let Some(err) = &self.ret_err {
+            match err {
+                TcpSessionErr::FurtherCheckClosing => {
+                    (sender, receiver) = find_role();
+                    if receiver.
+                },
+                _ => {
+                    return Err(TcpSessionErr::WrongFlag("During transferring, wrong packet flag.".to_string()));
+                }
+            }
+        }
+    }
+}
+
+fn session_add_packet() {
+    let next = session.wrapper.try_step(packet);
+    let sender = {
+        // 比较port和ip，判断是client还是server
+    }
+    if next is FinWait1 {
+        session.closing_by = sender_is;
+    }
+    TransferringState.into_state(packet, client, server);
+    if next is err: FurtherCheckClosing { // 当前的状态应该是BothTimeWait1, 
+        assert(currentState == BothTimeWait1);
+        if closing_by_closingMode == sender_is {
+            return;
+        } else {
+            // 重复发包，直接return
         }
+        return;
     }
 }
 
-trait SessionStateMachine<'a, SSender: SessionState, SReceiver: SessionState> {
-    fn next_state(&'a mut self, packet: & Packet) -> Result<(TransferringState<'a, SSender, SReceiver>, Option<Policy>), TcpSessionErr>;
+trait IntoState<SSender: SessionState, SReceiver: SessionState> {
+    fn into_state(&mut self, packet: & Packet, client: &mut Peer, server: &mut Peer) -> Result<(TransferringState<SSender, SReceiver>, Option<Policy>), TcpSessionErr>;
 }
 
 pub struct Session {
@@ -351,59 +396,36 @@ pub struct Session {
     server: Peer,
 }
 
-impl<'a> SessionStateMachine<'a, SynSent, Listen> for TransferringState<'a, Closed, Closed> {
-    fn next_state(&'a mut self, packet: &Packet) -> Result<(TransferringState<'a, SynSent, Listen>, Option<Policy>), TcpSessionErr> {
-        if !packet.tcp_header.flag_syn {
-            return Err(TcpSessionErr::WrongPacket("Closed server expect syn packet".to_string()));
-        }
-        self.client.state = Box::new(SynSent);
-        self.server.state = Box::new(Listen);
-        self.client.as_sender(packet);
-        self.server.as_receiver(packet);
-        Ok((TransferringState{
-            client: self.client,
-            server: self.server,
-            closing_by: ClosingBy::Nil,
-            p: PhantomData,
-            q: PhantomData,
-        }, None))
+impl IntoState<SynSent, Listen> for TransferringState<Closed, Closed> {
+    fn into_state(&mut self, packet: &Packet, client:&mut Peer, server:&mut Peer) -> Result<Option<Policy>, TcpSessionErr> {
+        client.state = Box::new(SynSent);
+        server.state = Box::new(Listen);
+        client.as_sender(packet);
+        server.as_receiver(packet);
+        Ok(None)
     }
 }
 
-impl<'a> SessionStateMachine<'a, SynReceived, SynSent> for TransferringState<'a, SynSent, Listen> {
-    fn next_state(&'a mut self, packet: &Packet) -> Result<(TransferringState<'a, SynReceived, SynSent>, Option<Policy>), TcpSessionErr> {
-        if !packet.tcp_header.flag_syn || !packet.tcp_header.flag_ack {
-            return Err(TcpSessionErr::WrongPacket("Client expects syn + ack packet to establish connection".to_string()));
-        }
-        self.client.state = Box::new(SynSent);
-        self.server.state = Box::new(SynReceived);
-        self.client.as_receiver(packet);
-        self.server.as_sender(packet);
-        Ok(
-            (TransferringState{
-                client: self.client,
-                server: self.server,
-                closing_by: ClosingBy::Nil,
-                p: PhantomData,
-                q: PhantomData,
-            }, None)
-        )
+impl IntoState<SynReceived, SynSent> for TransferringState<SynSent, Listen> {
+    fn into_state(&mut self, packet: & Packet, client: &mut Peer, server: &mut Peer) -> Result<(TransferringState<SynReceived, SynSent>, Option<Policy>), TcpSessionErr> {
+        client.state = Box::new(SynSent);
+        server.state = Box::new(SynReceived);
+        client.as_receiver(packet);
+        server.as_sender(packet);
+        Ok((TransferringState{
+            state_sender: SynReceived,
+            state_receiver: SynSent,
+        }, None))
     }
 }
 
-impl<'a> SessionStateMachine<'a, Established, Established> for TransferringState<'a, SynReceived, SynSent> {
-    fn next_state(&'a mut self, packet: & Packet) -> Result<(TransferringState<'a, Established, Established>, Option<Policy>), TcpSessionErr> {
-        if !packet.tcp_header.flag_ack {
-            return Err(TcpSessionErr::WrongPacket("Server expects ack packet to establish connection".to_string()));
-        }
-        self.client.state = Box::new(Established);
-        self.server.state = Box::new(Established);
+impl IntoState<Established, Established> for TransferringState<SynReceived, SynSent> {
+    fn into_state(&mut self, packet: & Packet, client: &mut Peer, server: &mut Peer) -> Result<(TransferringState<Established, Established>, Option<Policy>), TcpSessionErr> {
+        client.state = Box::new(Established);
+        server.state = Box::new(Established);
         Ok((TransferringState{
-            client: self.client,
-            server: self.server,
-            closing_by: ClosingBy::Nil,
-            p: PhantomData,
-            q: PhantomData,
+            state_sender: Established,
+            state_receiver: Established,
         }, None))
     }
 }
@@ -433,24 +455,19 @@ fn sender_operation_for_establised(sender: &mut Peer, packet: &Packet) -> Result
     Ok(())
 }
 
-impl<'a> SessionStateMachine<'a, FinWait1, CloseWait> for TransferringState<'a, Established, Established> {
-    fn next_state(&'a mut self, packet: & Packet) -> Result<(TransferringState<'a, FinWait1, CloseWait>, Option<Policy>), TcpSessionErr> {
-        // determine the sender
-        if !packet.tcp_header.flag_ack && !packet.tcp_header.flag_fin && !packet.tcp_header.flag_rst {
-            return Err(TcpSessionErr::WrongPacket("During transferring, every packet must carry ack, fin or rst flag.".to_string()));
-        }
-
-        if packet.tcp_header.source_port == self.client.port && packet.ip_src == self.client.ip {
-            sender_operation_for_establised(&mut self.client, packet)?;
-            self.server.state = Box::new(CloseWait);
+impl IntoState<FinWait1, CloseWait> for TransferringState<Established, Established> {
+    fn into_state(&mut self, packet: & Packet, client: &mut Peer, server: &mut Peer) -> Result<(TransferringState<FinWait1, CloseWait>, Option<Policy>), TcpSessionErr> {
+        if packet.tcp_header.source_port == client.port && packet.ip_src == client.ip {
+            sender_operation_for_establised(client, packet)?;
+            server.state = Box::new(CloseWait);
         } else {
-            sender_operation_for_establised(&mut self.server, packet)?;
-            self.client.state = Box::new(CloseWait);
+            sender_operation_for_establised(server, packet)?;
+            client.state = Box::new(CloseWait);
         }
 
         if packet.tcp_header.flag_fin || packet.tcp_header.flag_rst {
             self.closing_by = {
-                if packet.tcp_header.source_port == self.client.port && packet.ip_src == self.client.ip {
+                if packet.tcp_header.source_port == client.port && packet.ip_src == client.ip {
                     ClosingBy::Client
                 } else {
                     ClosingBy::Server
@@ -458,8 +475,6 @@ impl<'a> SessionStateMachine<'a, FinWait1, CloseWait> for TransferringState<'a,
             };
         }
         Ok((TransferringState{
-            client: self.client,
-            server: self.server,
             closing_by: self.closing_by.clone(),
             p: PhantomData,
             q: PhantomData,
@@ -467,13 +482,51 @@ impl<'a> SessionStateMachine<'a, FinWait1, CloseWait> for TransferringState<'a,
     }
 }
 
-impl<'a> SessionStateMachine<'a, CloseWait, FinWait2> for TransferringState<'a, FinWait1, CloseWait> {
-    fn next_state(&'a mut self, packet: & Packet) -> Result<(TransferringState<'a, CloseWait, FinWait2>, Option<Policy>), TcpSessionErr> {
-        // if !packet.tcp_header.flag_ack {
-        //     return Err(TcpSessionErr::WrongPacket("During closing, wrong packet flag.".to_string()));
-        // }
+impl IntoState<FinWait2, CloseWait> for TransferringState<FinWait1, CloseWait> {
+    fn into_state(&mut self, packet: & Packet, client: &mut Peer, server: &mut Peer) -> Result<(TransferringState<FinWait2, CloseWait>, Option<Policy>), TcpSessionErr> {
+        
+    }
+}
+
+impl IntoState<FinWait1, Closing> for TransferringState<FinWait1, CloseWait> {
+    fn into_state(&mut self, packet: & Packet, client: &mut Peer, server: &mut Peer) -> Result<(TransferringState<FinWait1, Closing>, Option<Policy>), TcpSessionErr> {
+        
+    }
+}
+
+impl IntoState<LastAck, TimeWait> for TransferringState<FinWait2, CloseWait> {
+    fn into_state(&mut self, packet: & Packet, client: &mut Peer, server: &mut Peer) -> Result<(TransferringState<LastAck, TimeWait>, Option<Policy>), TcpSessionErr> {
+        
+    }
+}
+
+impl IntoState<TimeWait, Closed> for TransferringState<LastAck, TimeWait> {
+    fn into_state(&mut self, packet: & Packet, client: &mut Peer, server: &mut Peer) -> Result<(TransferringState<TimeWait, Closed>, Option<Policy>), TcpSessionErr> {
+        
+    }
+}
+
+impl IntoState<Closing, Closing> for TransferringState<FinWait1, Closing> {
+    fn into_state(&mut self, packet: & Packet, client: &mut Peer, server: &mut Peer) -> Result<(TransferringState<Closing, Closing>, Option<Policy>), TcpSessionErr> {
+        
+    }
+}
+
+impl IntoState<Closing, TimeWait> for TransferringState<Closing, Closing> {
+    fn into_state(&mut self, packet: & Packet, client: &mut Peer, server: &mut Peer) -> Result<(TransferringState<Closing, TimeWait>, Option<Policy>), TcpSessionErr> {
+        
+    }
+}
+
+impl IntoState<TimeWait, TimeWait> for TransferringState<Closing, TimeWait> {
+    fn into_state(&mut self, packet: & Packet, client: &mut Peer, server: &mut Peer) -> Result<(TransferringState<TimeWait, TimeWait>, Option<Policy>), TcpSessionErr> {
+        
+    }
+}
 
-        // (sender, receiver) = match self.closing_by {
+impl IntoState<CloseWait, FinWait2> for TransferringState<FinWait1, CloseWait> {
+    fn into_state(&mut self, packet: & Packet, client: &mut Peer, server: &mut Peer) -> Result<(TransferringState<CloseWait, FinWait2>, Option<Policy>), TcpSessionErr> {
+                // (sender, receiver) = match self.closing_by {
         //     ClosingBy::Client: {
         //         (self.server, self.client)
         //     },
@@ -481,97 +534,14 @@ impl<'a> SessionStateMachine<'a, CloseWait, FinWait2> for TransferringState<'a,
         //         (self.client, self.server)
         //     },
         //     _: {
-        //         return Err(TcpSessionErr::WrongPacket("During closing, wrong packet.".to_string()));
+        //         return Err(TcpSessionErr::WrongFlag("During closing, wrong packet.".to_string()));
         //     }
         // }
-        return Err(TcpSessionErr::WrongPacket("try1.".to_string()));
+        return Err(TcpSessionErr::WrongFlag("try1.".to_string()));
     }
 }
 
-impl<'a> SessionStateMachine<'a, LastAck, TimeWait> for TransferringState<'a, FinWait1, CloseWait> {
-    fn next_state(&'a mut self, packet: & Packet) -> Result<(TransferringState<'a, LastAck, TimeWait>, Option<Policy>), TcpSessionErr> {
-        return Err(TcpSessionErr::WrongPacket("try2.".to_string()));
-    }
-}
-
-// impl<'a> SessionStateMachine<'a, FinWait1, CloseWait, callbacks::SendCB> for TransferringState<'a, Established, Established> {
-//     fn next_state(&'a mut self, packet: & Packet) -> Result<(TransferringState<'a, FinWait1, CloseWait>, Vec<callbacks::SendCB>), TcpSessionErr> {
-//         // determine the sender
-//         let (sender, receiver) = {
-//             if packet.tcp_header.source_port == self.client.port && packet.ip_src == self.client.ip {
-//                 (self.client, self.server)
-//             } else {
-//                 (self.server, self.client)
-//             }
-//         };
-//         // todo: window and payload check 
-//         if packet.tcp_header.flag_fin { // todo: reset?
-//             sender.state = Box::new(FinWait1);
-//             receiver.state = Box::new(CloseWait);
-//             self.closing_by = {
-//                 if packet.tcp_header.source_port == self.client.port && packet.ip_src == self.client.ip {
-//                     ClosingBy::Client
-//                 } else {
-//                     ClosingBy::Server
-//                 }
-//             };
-//             // todo: close connection callbacks
-//         } else if packet.tcp_header.flag_ack {
-//             // state remain the same
-//             // packet proc
-//         } else {
-//             return Err(TcpSessionErr::WrongPacket("During transferring, every packet must carry ack flag.".to_string()));
-//         }
-        
-//     }
-// }
 
-// // fn next_peers<'a>(client: &'a mut Peer, server: &'a mut Peer, packet: &'a TcpHeader) -> (&'a Peer, &'a Peer) {
-// //     match (client.state, server.state) {
-// //         (SessionState::Closed, SessionState::Closed) => {
-// //             client.state = SessionState::SynSent;
-// //             server.state = SessionState::Listen;
-// //             (client, server)},
-// //         (SessionState::SynSent, SessionState::Listen) => {
-// //             client.state = SessionState::SynReceived;
-// //             server.state = SessionState::Listen;
-// //             (server, client)},
-// //         (SessionState::SynReceived, SessionState::Listen) => {
-// //             if packet.flags == TcpFlags::FIN {
-// //                 client.state = SessionState::Established;
-// //                 server.state = SessionState::Established;
-// //             } else {
-// //                 client.state = SessionState::SynReceived;
-// //                 server.state = SessionState::SynReceived;
-// //             }
-// //             client.state = SessionState::Established;
-// //             server.state = SessionState::Established;
-// //             (client, server)},
-// //         (SessionState::Established, SessionState::Established) => {
-// //             let (peer:&'a mut Peer, side:&'a mut Peer) = if packet.src_port == client.src_port && packet.tuple.src_ip == client.tuple.src_ip {
-// //                 (client, server)
-// //             } else {
-// //                 (server, client)
-// //             };
-// //             if packet.flags == TcpFlags::FIN {
-// //                 peer.state = SessionState::FinWait1;
-// //                 side.state = SessionState::CloseWait;
-// //             }
-// //             (peer, side)
-// //         },
-// //         (SessionState::FinWait1, SessionState::CloseWait) => {
-// //             if packet.flags == TcpFlags::FIN {
-// //                 client.state = SessionState::FinWait2;
-// //                 server.state = SessionState::Closing;
-// //             } else {
-// //                 client.state = SessionState::FinWait2;
-// //                 server.state = SessionState::LastAck;
-// //             }
-// //             client.state = SessionState::FinWait2;
-// //             server.state = SessionState::LastAck;
-// //             (client, server)},
-// //     }
-// // }
 
 
 #[cfg(test)]