From e8e8655100c2c9fc757ee485325624863d29d987 Mon Sep 17 00:00:00 2001 From: alex Date: Mon, 2 Mar 2026 16:12:19 +0800 Subject: [PATCH] cached login info, and connect info is accessed while connect --- src/bin/punchnet/main.rs | 112 +++++++++++++++++++++++++++++++++------ src/utils/mod.rs | 29 +++++++--- 2 files changed, 118 insertions(+), 23 deletions(-) diff --git a/src/bin/punchnet/main.rs b/src/bin/punchnet/main.rs index fe47384..e01dbfd 100755 --- a/src/bin/punchnet/main.rs +++ b/src/bin/punchnet/main.rs @@ -4,11 +4,14 @@ use std::process; use std::env; use clap::Parser; +use punchnet::CachedLoginInfo; use punchnet::CommandLineInput2; use punchnet::Commands; use punchnet::create_or_load_mac; +use punchnet::get_access_token; use punchnet::get_base_dir; use punchnet::get_edge; +use punchnet::ip_string_to_u32; use punchnet::mod_hostname; use punchnet::restore_dns; use punchnet::run_sdlan; @@ -27,9 +30,12 @@ use tracing::error; use std::net::ToSocketAddrs; use structopt::StructOpt; +use crate::api::ConnectData; +use crate::api::ConnectResponse; use crate::api::LoginData; use crate::api::LoginResponse; use crate::api::TEST_PREFIX; +use crate::api::connect; use crate::api::login_with_token; use crate::api::login_with_user_pass; @@ -38,6 +44,26 @@ const APP_USER_ENV_NAME: &str = "PUNCH_USER"; const APP_PASS_ENV_NAME: &str = "PUNCH_PASS"; const APP_TOKEN_ENV_NAME: &str = "PUNCH_TOKEN"; +fn parse_connect_result(res: Result) -> ConnectData { + match res { + Err(e) => { + eprintln!("failed to connect"); + process::exit(-3); + } + Ok(data) => { + if data.code != 0 { + eprintln!("failed to connect: {}", data.message); + process::exit(-3); + } + if data.data.is_none() { + eprintln!("connect empty response"); + process::exit(-3); + } + data.data.unwrap() + } + } +} + fn parse_login_result(res: Result) -> LoginData { match res { Err(e) => { @@ -54,7 +80,14 @@ fn parse_login_result(res: Result) -> LoginData { process::exit(-1); }; - if let Err(_e) = set_access_token(&data.access_token) { + if let Err(_e) = set_access_token(&CachedLoginInfo { + access_token: data.access_token.clone(), + username: data.username.clone(), + user_type: data.user_type.clone(), + audit: data.audit, + network_id: data.network_id, + network_name: data.network_name.clone(), + }) { eprintln!("failed to save access_token"); } data @@ -80,30 +113,68 @@ async fn main() { let cmd = CommandLineInput2::parse(); // println!("port is {}", cmd.port); + let connect_info: ConnectData; + let remembered: CachedLoginInfo; + match cmd.cmd { Commands::Login(user) => { // TODO: do login with user - let data = parse_login_result( + let _ = parse_login_result( login_with_user_pass(TEST_PREFIX, &client_id, &user.username, &user.password, mac, system, version).await ); + process::exit(0); } Commands::TokenLogin(tk) => { - + let _ = parse_login_result( + login_with_token(TEST_PREFIX, &client_id, &tk.token, mac, system, version).await + ); + process::exit(0); } Commands::AutoRun(tk) => { + let mut remembered_token = get_access_token(); + if remembered_token.is_none() { + let data = parse_login_result( + login_with_token(TEST_PREFIX, &client_id, &tk.token, mac, system, version).await + ); + remembered_token = Some(CachedLoginInfo{ + access_token: data.access_token, + username: data.username, + user_type: data.user_type, + audit: data.audit, + network_id: data.network_id, + network_name: data.network_name, + }); + } + remembered = remembered_token.unwrap(); + + connect_info = parse_connect_result( + connect(TEST_PREFIX, &client_id, &remembered.access_token).await + ); } Commands::Start => { - + let remembered_token = get_access_token(); + if remembered_token.is_none() { + eprintln!("not logged in, should login with user/pass or token first"); + process::exit(-2); + } + + remembered = remembered_token.unwrap(); + + connect_info = parse_connect_result( + connect(TEST_PREFIX, &client_id, &remembered.access_token).await + ); } Commands::Stop => { - + process::exit(-4); } } + let self_host_name = connect_info.hostname; + let (tx, rx) = std::sync::mpsc::channel(); - let hostname = "punchnet.aioe.tech".to_owned(); + let hostname = "118.178.229.213".to_owned(); let host = format!("{}:80", hostname); let mut server = String::new(); if let Ok(addrs) = host.to_socket_addrs() { @@ -141,10 +212,11 @@ async fn main() { client_id, mac, CommandLine { - sn: server.clone()+":1265", - tcp: server.clone()+":18083", - nat_server1: server.clone() +":1265", - nat_server2: "47.98.178.3:1265".to_owned(), + sn: server.clone()+":1365", + tcp: server.clone()+":443", + nat_server1: server.clone() +":1365", + // nat_server2: "47.98.178.3:1265".to_owned(), + nat_server2: server.clone() +":1366", _allow_routing: true, _drop_multicast: true, register_ttl: 1, @@ -159,7 +231,7 @@ async fn main() { tx, &punchnet::get_install_channel(), server, - Some(hostname), + Some(self_host_name), None, ) .await; @@ -191,14 +263,20 @@ async fn main() { // exit(0); } */ + let Ok(ip_net) = ip_string_to_u32(&connect_info.ip) else { + eprintln!("got ip from network is invlid: {}", connect_info.ip); + process::exit(-5); + }; if let Err(e) = edge.start_without_feedback( - String::new(), - 0, + remembered.access_token.clone(), + // String::new(), + remembered.network_id, &"".to_owned(), - 0, - 24, - 0, - Some("".to_owned()) + ip_net, + connect_info.mask_len, + connect_info.identity_id, + // 0, + None, ).await { error!("failed to start: {:?}", e); } diff --git a/src/utils/mod.rs b/src/utils/mod.rs index 624ec9f..bae63f9 100755 --- a/src/utils/mod.rs +++ b/src/utils/mod.rs @@ -1,18 +1,29 @@ mod command; -use std::{fs::OpenOptions, io::Write, path::Path}; +use std::{fs::OpenOptions, io::Write, net::Ipv4Addr, path::Path}; pub use command::*; mod socks; use rand::Rng; use sdlan_sn_rs::utils::{Mac, Result, SDLanError, save_to_file}; +use serde::{Deserialize, Serialize}; pub use socks::*; use crate::get_base_dir; mod pid_recorder; +#[derive(Serialize, Deserialize, Debug)] +pub struct CachedLoginInfo { + pub access_token: String, + pub username: String, + pub user_type: String, + pub audit: u32, + pub network_id: u32, + pub network_name: String, +} + // pub const CRC_HASH: crc::Crc = crc::Crc::::new(&crc::CRC_32_XFER); #[allow(unused)] @@ -21,18 +32,24 @@ pub fn caculate_crc(data: &[u8]) -> u32 { res } -pub fn get_access_token() -> Option { +pub fn ip_string_to_u32(ip: &str) -> Result { + let ip = ip.parse::()?; + Ok(u32::from(ip)) +} + +pub fn get_access_token() -> Option { let path = format!("{}/.access_token", get_base_dir()); if let Ok(content) = std::fs::read(&path) { - let result = String::from_utf8_lossy(&content); - return Some(result.to_string()); + let data = serde_json::from_slice((&content)).unwrap(); + return Some(data); } None } -pub fn set_access_token(tk: &str) -> Result<()> { +pub fn set_access_token(cache_info: &CachedLoginInfo) -> Result<()> { let path = format!("{}/.access_token", get_base_dir()); - std::fs::write(path, tk)?; + let data = serde_json::to_string(cache_info).unwrap(); + std::fs::write(path, &data)?; Ok(()) }