handle lcp configure-ack

3 files changed, 50 insertions, 9 deletions

diff --git a/Cargo.lock b/Cargo.lock
index 698379b..f57574e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -619,7 +619,7 @@ checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
 [[package]]
 name = "ppproperly"
 version = "0.1.0"
-source = "git+https://github.com/rsdsl/ppproperly.git#43b138eeec3540660bec582e01f6d235f99a7aab"
+source = "git+https://github.com/rsdsl/ppproperly.git#bdd7501540e9297b38a2cbdd7e05b08b193adf66"
 dependencies = [
  "bitfield",
  "ppproperly_macros",
diff --git a/src/main.rs b/src/main.rs
index 7ef0c0e..051fca1 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -5,7 +5,8 @@ use std::thread;
 use std::time::Duration;
 
 use ppproperly::{
-    Deserialize, LcpOpt, LcpPkt, MacAddr, PppPkt, PppoeData, PppoePkt, PppoeVal, Serialize,
+    Deserialize, LcpData, LcpOpt, LcpPkt, MacAddr, PppData, PppPkt, PppoeData, PppoePkt, PppoeVal,
+    Serialize,
 };
 use rsdsl_netlinkd::link;
 use rsdsl_pppoe2::{Ppp, Pppoe, Result};
@@ -210,7 +211,7 @@ fn session(interface: &str, remote_mac: MacAddr, session_id: u16) -> Result<()>
     let ppp_state = Arc::new(Mutex::new(Ppp::default()));
 
     let ppp_state2 = ppp_state.clone();
-    let recv_sess = thread::spawn(move || match recv_session(ctl, ppp, ppp_state2.clone()) {
+    let recv_lcp = thread::spawn(move || match recv_lcp(ctl, ppp_state2.clone()) {
         Ok(_) => Ok(()),
         Err(e) => {
             *ppp_state2.lock().expect("ppp state mutex is poisoned") = Ppp::Err;
@@ -238,15 +239,32 @@ fn session(interface: &str, remote_mac: MacAddr, session_id: u16) -> Result<()>
                         identifier, mru, magic_number
                     );
                 }
+                Ppp::SyncAck(identifier, mru, magic_number) => {
+                    PppPkt::new_lcp(LcpPkt::new_configure_request(
+                        identifier,
+                        vec![
+                            LcpOpt::Mru(mru).into(),
+                            LcpOpt::MagicNumber(magic_number).into(),
+                        ],
+                    ))
+                    .serialize(&mut ctl_w)?;
+                    ctl_w.flush()?;
+
+                    println!(
+                        " -> lcp configure-req {}, mru: {}, magic number: {}",
+                        identifier, mru, magic_number
+                    );
+                }
+                Ppp::SyncAcked => {} // Packet handler takes care of the rest.
                 Ppp::Auth(_) => {}
                 Ppp::Active => {}
                 Ppp::Terminated => {
                     break;
                 }
                 Ppp::Err => {
-                    return Err(recv_sess
+                    return Err(recv_lcp
                         .join()
-                        .expect("recv_session panic")
+                        .expect("recv_lcp panic")
                         .expect_err("Ppp::Err state entered without an error"));
                 }
             }
@@ -258,7 +276,7 @@ fn session(interface: &str, remote_mac: MacAddr, session_id: u16) -> Result<()>
     Ok(())
 }
 
-fn recv_session(ctl: File, _ppp: File, state: Arc<Mutex<Ppp>>) -> Result<()> {
+fn recv_lcp(ctl: File, state: Arc<Mutex<Ppp>>) -> Result<()> {
     let mut ctl_r = BufReader::with_capacity(1500, ctl);
 
     loop {
@@ -267,10 +285,31 @@ fn recv_session(ctl: File, _ppp: File, state: Arc<Mutex<Ppp>>) -> Result<()> {
             break;
         }
 
-        let mut pkt = PppPkt::default();
-        pkt.deserialize(&mut ctl_r)?;
+        let mut ppp = PppPkt::default();
+        ppp.deserialize(&mut ctl_r)?;
+
+        let lcp = if let PppData::Lcp(lcp) = ppp.data {
+            lcp
+        } else {
+            unreachable!();
+        };
+        match lcp.data {
+            LcpData::ConfigureAck(..) => {
+                let mut state = state.lock().expect("ppp state mutex is poisoned");
+                match *state {
+                    Ppp::Synchronize(identifier, ..) if lcp.identifier == identifier => {
+                        *state = Ppp::SyncAcked
+                    }
+                    Ppp::SyncAck(identifier, ..) if lcp.identifier == identifier => {
+                        *state = Ppp::SyncAcked
+                    }
+                    _ => {} // Ignore invalid identifiers.
+                }
 
-        println!(" <- ppp lcp {:?}", pkt);
+                println!(" <- lcp configure-ack {}", lcp.identifier);
+            }
+            _ => todo!(),
+        }
     }
 
     Ok(())
diff --git a/src/state.rs b/src/state.rs
index bf3d2bd..6fd95a5 100644
--- a/src/state.rs
+++ b/src/state.rs
@@ -17,6 +17,8 @@ impl Default for Pppoe {
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub enum Ppp {
     Synchronize(u8, u16, u32),
+    SyncAck(u8, u16, u32),
+    SyncAcked,
     Auth(AuthProto),
     Active,
     Terminated,