version a0.0.1

src/main.rs

@@ -0,0 +1,180 @@
+mod discovery;
+mod models;
+mod p2p;
+mod tls;
+mod ui;
+
+use axum::{
+    extract::DefaultBodyLimit,
+    routing::{get, post},
+    Router,
+};
+use axum_server::tls_rustls::RustlsConfig;
+use local_ip_address::local_ip;
+use models::{AppState, MAX_PAYLOAD_SIZE, MAX_RAM_TEXTS, MEDIA_DIR};
+use std::{
+    collections::{HashMap, VecDeque},
+    net::SocketAddr,
+    sync::{Arc, RwLock},
+};
+
+#[tokio::main]
+async fn main() {
+    // 0. Регистрация глобального CryptoProvider (ring) для rustls 0.23+
+    let _ = rustls::crypto::ring::default_provider().install_default();
+
+    let args: Vec<String> = std::env::args().collect();
+
+    let mut device_name = "My-Device".to_string();
+    let mut p2p_port: u16 = 8443;
+    let mut ui_port: u16 = 8080;
+    let mut custom_ip: Option<String> = None;
+
+    let mut i = 1;
+    let mut positional_idx = 0;
+    while i < args.len() {
+        match args[i].as_str() {
+            "--ip" => {
+                if i + 1 < args.len() {
+                    custom_ip = Some(args[i + 1].clone());
+                    i += 1;
+                }
+            }
+            "--name" => {
+                if i + 1 < args.len() {
+                    device_name = args[i + 1].clone();
+                    i += 1;
+                }
+            }
+            "--p2p-port" => {
+                if i + 1 < args.len() {
+                    if let Ok(p) = args[i + 1].parse() {
+                        p2p_port = p;
+                    }
+                    i += 1;
+                }
+            }
+            "--ui-port" => {
+                if i + 1 < args.len() {
+                    if let Ok(p) = args[i + 1].parse() {
+                        ui_port = p;
+                    }
+                    i += 1;
+                }
+            }
+            arg if !arg.starts_with("--") => {
+                match positional_idx {
+                    0 => device_name = arg.to_string(),
+                    1 => {
+                        if let Ok(p) = arg.parse() {
+                            p2p_port = p;
+                        }
+                    }
+                    2 => {
+                        if let Ok(p) = arg.parse() {
+                            ui_port = p;
+                        }
+                    }
+                    3 => custom_ip = Some(arg.to_string()),
+                    _ => {}
+                }
+                positional_idx += 1;
+            }
+            _ => {}
+        }
+        i += 1;
+    }
+
+    let (bind_ip, my_ip) = match custom_ip {
+        Some(ip) => {
+            if ip == "0.0.0.0" {
+                let detected = local_ip()
+                    .map(|addr| addr.to_string())
+                    .unwrap_or_else(|_| "127.0.0.1".to_string());
+                ("0.0.0.0".to_string(), detected)
+            } else {
+                (ip.clone(), ip)
+            }
+        }
+        None => {
+            let detected = local_ip().expect("Не удалось определить локальный IP").to_string();
+            ("0.0.0.0".to_string(), detected)
+        }
+    };
+
+    tokio::fs::create_dir_all(MEDIA_DIR)
+        .await
+        .expect("Не удалось создать папку received_media на диске");
+
+    // 1. Генерация сертификата в ОЗУ под выбранный IP и настройка HTTPS-клиентов
+    let (cert_der, key_der, my_fingerprint) = tls::generate_in_memory_cert(&my_ip);
+    let trusted_fingerprints = Arc::new(RwLock::new(HashMap::new()));
+    let http_client = tls::build_pinned_http_client(trusted_fingerprints.clone());
+    let probe_client = tls::build_probe_http_client();
+
+    let state = Arc::new(AppState {
+        device_name: device_name.clone(),
+        my_ip: my_ip.clone(),
+        p2p_port,
+        my_fingerprint: my_fingerprint.clone(),
+        ram_texts: RwLock::new(VecDeque::with_capacity(MAX_RAM_TEXTS)),
+        disk_media: RwLock::new(VecDeque::new()),
+        peers: RwLock::new(HashMap::new()),
+        trusted_fingerprints,
+        http_client,
+        probe_client,
+    });
+
+    // 2. Запуск широковещательного UDP-маяка на порт 5354
+    discovery::start_discovery(state.clone());
+
+    // 3. Запуск внешнего P2P HTTPS-сервера
+    let tls_config = RustlsConfig::from_der(vec![cert_der], key_der)
+        .await
+        .expect("Ошибка конфигурации TLS");
+
+    let p2p_router = Router::new()
+        .route("/p2p/info", get(p2p::p2p_info))
+        .route("/p2p/text", post(p2p::p2p_receive_text))
+        .route("/p2p/media", post(p2p::p2p_receive_media))
+        .layer(DefaultBodyLimit::max(MAX_PAYLOAD_SIZE))
+        .with_state(state.clone());
+
+    let p2p_addr: SocketAddr = format!("{}:{}", bind_ip, p2p_port)
+        .parse()
+        .unwrap_or_else(|_| panic!("Некорректный сокет: {}:{}", bind_ip, p2p_port));
+
+    tokio::spawn(async move {
+        axum_server::bind_rustls(p2p_addr, tls_config)
+            .serve(p2p_router.into_make_service())
+            .await
+            .expect("Ошибка P2P HTTPS-сервера");
+    });
+
+    // 4. Запуск локального UI-сервера (127.0.0.1)
+    let ui_router = Router::new()
+        .route("/", get(ui::ui_index))
+        .route("/ui/state", get(ui::ui_get_state))
+        .route("/ui/manual-peer", post(ui::ui_add_manual_peer))
+        .route("/ui/trust", post(ui::ui_trust_peer))
+        .route("/ui/clear-ram", post(ui::ui_clear_ram))
+        .route("/ui/send-text", post(ui::ui_send_text))
+        .route("/ui/send-media", post(ui::ui_send_media))
+        .route("/ui/files/:filename", get(ui::ui_serve_saved_file))
+        .layer(DefaultBodyLimit::max(MAX_PAYLOAD_SIZE))
+        .with_state(state);
+
+    let ui_addr: SocketAddr = format!("127.0.0.1:{}", ui_port).parse().unwrap();
+    println!("==============================================================");
+    println!(" Устройство:                   {}", device_name);
+    println!(" P2P сокет (HTTPS):            https://{}:{}", bind_ip, p2p_port);
+    println!(" Маяк обнаружения (UDP):       255.255.255.255:5354");
+    println!(" КОД СВЕРКИ СЕРТИФИКАТА (PIN): [ {} ]", &my_fingerprint[..8].to_uppercase());
+    println!(" Хранилище медиа:              ./{}/", MEDIA_DIR);
+    println!("--------------------------------------------------------------");
+    println!(" ОТКРОЙТЕ ИНТЕРФЕЙС В БРАУЗЕРЕ: http://127.0.0.1:{}", ui_port);
+    println!("==============================================================");
+
+    let listener = tokio::net::TcpListener::bind(ui_addr).await.unwrap();
+    axum::serve(listener, ui_router).await.unwrap();
+}