feat(rustdesk): 完整实现RustDesk协议和P2P连接

重大变更：
- 从prost切换到protobuf 3.4实现完整的RustDesk协议栈
- 新增P2P打洞模块(punch.rs)支持直连和中继回退
- 重构加密系统：临时Curve25519密钥对+Ed25519签名
- 完善HID适配器：支持CapsLock状态同步和修饰键映射
- 添加音频流支持：Opus编码+音频帧适配器
- 优化视频流：改进帧适配器和编码器协商
- 移除pacer.rs简化视频管道

扩展系统：
- 在设置向导中添加扩展步骤(ttyd/rustdesk切换)
- 扩展可用性检测和自动启动
- 新增WebConfig handler用于Web服务器配置

前端改进：
- SetupView增加第4步扩展配置
- 音频设备列表和配置界面
- 新增多语言支持(en-US/zh-CN)
- TypeScript类型生成更新

文档：
- 更新系统架构文档
- 完善config/hid/rustdesk/video/webrtc模块文档

src/otg/configfs.rs

@@ -12,14 +12,14 @@ pub const CONFIGFS_PATH: &str = "/sys/kernel/config/usb_gadget";
 /// Default gadget name
 pub const DEFAULT_GADGET_NAME: &str = "one-kvm";
 
-/// USB Vendor ID (Linux Foundation)
-pub const USB_VENDOR_ID: u16 = 0x1d6b;
+/// USB Vendor ID (Linux Foundation) - default value
+pub const DEFAULT_USB_VENDOR_ID: u16 = 0x1d6b;
 
-/// USB Product ID (Multifunction Composite Gadget)
-pub const USB_PRODUCT_ID: u16 = 0x0104;
+/// USB Product ID (Multifunction Composite Gadget) - default value
+pub const DEFAULT_USB_PRODUCT_ID: u16 = 0x0104;
 
-/// USB device version
-pub const USB_BCD_DEVICE: u16 = 0x0100;
+/// USB device version - default value
+pub const DEFAULT_USB_BCD_DEVICE: u16 = 0x0100;
 
 /// USB spec version (USB 2.0)
 pub const USB_BCD_USB: u16 = 0x0200;

src/otg/manager.rs

@@ -7,7 +7,7 @@ use tracing::{debug, error, info, warn};
 
 use super::configfs::{
     create_dir, find_udc, is_configfs_available, remove_dir, write_file, CONFIGFS_PATH,
-    DEFAULT_GADGET_NAME, USB_BCD_DEVICE, USB_BCD_USB, USB_PRODUCT_ID, USB_VENDOR_ID,
+    DEFAULT_GADGET_NAME, DEFAULT_USB_BCD_DEVICE, USB_BCD_USB, DEFAULT_USB_PRODUCT_ID, DEFAULT_USB_VENDOR_ID,
 };
 use super::endpoint::{EndpointAllocator, DEFAULT_MAX_ENDPOINTS};
 use super::function::{FunctionMeta, GadgetFunction};
@@ -15,6 +15,30 @@ use super::hid::HidFunction;
 use super::msd::MsdFunction;
 use crate::error::{AppError, Result};
 
+/// USB Gadget device descriptor configuration
+#[derive(Debug, Clone)]
+pub struct GadgetDescriptor {
+    pub vendor_id: u16,
+    pub product_id: u16,
+    pub device_version: u16,
+    pub manufacturer: String,
+    pub product: String,
+    pub serial_number: String,
+}
+
+impl Default for GadgetDescriptor {
+    fn default() -> Self {
+        Self {
+            vendor_id: DEFAULT_USB_VENDOR_ID,
+            product_id: DEFAULT_USB_PRODUCT_ID,
+            device_version: DEFAULT_USB_BCD_DEVICE,
+            manufacturer: "One-KVM".to_string(),
+            product: "One-KVM USB Device".to_string(),
+            serial_number: "0123456789".to_string(),
+        }
+    }
+}
+
 /// OTG Gadget Manager - unified management for HID and MSD
 pub struct OtgGadgetManager {
     /// Gadget name
@@ -23,6 +47,8 @@ pub struct OtgGadgetManager {
     gadget_path: PathBuf,
     /// Configuration path
     config_path: PathBuf,
+    /// Device descriptor
+    descriptor: GadgetDescriptor,
     /// Endpoint allocator
     endpoint_allocator: EndpointAllocator,
     /// HID instance counter
@@ -47,6 +73,11 @@ impl OtgGadgetManager {
 
     /// Create a new gadget manager with custom configuration
     pub fn with_config(gadget_name: &str, max_endpoints: u8) -> Self {
+        Self::with_descriptor(gadget_name, max_endpoints, GadgetDescriptor::default())
+    }
+
+    /// Create a new gadget manager with custom descriptor
+    pub fn with_descriptor(gadget_name: &str, max_endpoints: u8, descriptor: GadgetDescriptor) -> Self {
         let gadget_path = PathBuf::from(CONFIGFS_PATH).join(gadget_name);
         let config_path = gadget_path.join("configs/c.1");
 
@@ -54,6 +85,7 @@ impl OtgGadgetManager {
             gadget_name: gadget_name.to_string(),
             gadget_path,
             config_path,
+            descriptor,
             endpoint_allocator: EndpointAllocator::new(max_endpoints),
             hid_instance: 0,
             msd_instance: 0,
@@ -271,9 +303,9 @@ impl OtgGadgetManager {
 
     /// Set USB device descriptors
     fn set_device_descriptors(&self) -> Result<()> {
-        write_file(&self.gadget_path.join("idVendor"), &format!("0x{:04x}", USB_VENDOR_ID))?;
-        write_file(&self.gadget_path.join("idProduct"), &format!("0x{:04x}", USB_PRODUCT_ID))?;
-        write_file(&self.gadget_path.join("bcdDevice"), &format!("0x{:04x}", USB_BCD_DEVICE))?;
+        write_file(&self.gadget_path.join("idVendor"), &format!("0x{:04x}", self.descriptor.vendor_id))?;
+        write_file(&self.gadget_path.join("idProduct"), &format!("0x{:04x}", self.descriptor.product_id))?;
+        write_file(&self.gadget_path.join("bcdDevice"), &format!("0x{:04x}", self.descriptor.device_version))?;
         write_file(&self.gadget_path.join("bcdUSB"), &format!("0x{:04x}", USB_BCD_USB))?;
         write_file(&self.gadget_path.join("bDeviceClass"), "0x00")?; // Composite device
         write_file(&self.gadget_path.join("bDeviceSubClass"), "0x00")?;
@@ -287,9 +319,9 @@ impl OtgGadgetManager {
         let strings_path = self.gadget_path.join("strings/0x409");
         create_dir(&strings_path)?;
 
-        write_file(&strings_path.join("serialnumber"), "0123456789")?;
-        write_file(&strings_path.join("manufacturer"), "One-KVM")?;
-        write_file(&strings_path.join("product"), "One-KVM HID Device")?;
+        write_file(&strings_path.join("serialnumber"), &self.descriptor.serial_number)?;
+        write_file(&strings_path.join("manufacturer"), &self.descriptor.manufacturer)?;
+        write_file(&strings_path.join("product"), &self.descriptor.product)?;
         debug!("Created USB strings");
         Ok(())
     }

src/otg/service.rs

@@ -25,9 +25,10 @@ use std::sync::atomic::{AtomicU8, Ordering};
 use tokio::sync::{Mutex, RwLock};
 use tracing::{debug, info, warn};
 
-use super::manager::{wait_for_hid_devices, OtgGadgetManager};
+use super::manager::{wait_for_hid_devices, GadgetDescriptor, OtgGadgetManager};
 use super::msd::MsdFunction;
 use crate::error::{AppError, Result};
+use crate::config::OtgDescriptorConfig;
 
 /// Bitflags for requested functions (lock-free)
 const FLAG_HID: u8 = 0b01;
@@ -82,6 +83,8 @@ pub struct OtgService {
     msd_function: RwLock<Option<MsdFunction>>,
     /// Requested functions flags (atomic, lock-free read/write)
     requested_flags: AtomicU8,
+    /// Current descriptor configuration
+    current_descriptor: RwLock<GadgetDescriptor>,
 }
 
 impl OtgService {
@@ -92,6 +95,7 @@ impl OtgService {
             state: RwLock::new(OtgServiceState::default()),
             msd_function: RwLock::new(None),
             requested_flags: AtomicU8::new(0),
+            current_descriptor: RwLock::new(GadgetDescriptor::default()),
         }
     }
 
@@ -345,8 +349,13 @@ impl OtgService {
             return Err(AppError::Internal(error));
         }
 
-        // Create new gadget manager
-        let mut manager = OtgGadgetManager::new();
+        // Create new gadget manager with current descriptor
+        let descriptor = self.current_descriptor.read().await.clone();
+        let mut manager = OtgGadgetManager::with_descriptor(
+            super::configfs::DEFAULT_GADGET_NAME,
+            super::endpoint::DEFAULT_MAX_ENDPOINTS,
+            descriptor,
+        );
         let mut hid_paths = None;
 
         // Add HID functions if requested
@@ -445,6 +454,64 @@ impl OtgService {
         Ok(())
     }
 
+    /// Update the descriptor configuration
+    ///
+    /// This updates the stored descriptor and triggers a gadget recreation
+    /// if the gadget is currently active.
+    pub async fn update_descriptor(&self, config: &OtgDescriptorConfig) -> Result<()> {
+        let new_descriptor = GadgetDescriptor {
+            vendor_id: config.vendor_id,
+            product_id: config.product_id,
+            device_version: super::configfs::DEFAULT_USB_BCD_DEVICE,
+            manufacturer: config.manufacturer.clone(),
+            product: config.product.clone(),
+            serial_number: config.serial_number.clone().unwrap_or_else(|| "0123456789".to_string()),
+        };
+
+        // Update stored descriptor
+        *self.current_descriptor.write().await = new_descriptor;
+
+        // If gadget is active, recreate it with new descriptor
+        let state = self.state.read().await;
+        if state.gadget_active {
+            drop(state); // Release read lock before calling recreate
+            info!("Descriptor changed, recreating gadget");
+            self.force_recreate_gadget().await?;
+        }
+
+        Ok(())
+    }
+
+    /// Force recreate the gadget (used when descriptor changes)
+    async fn force_recreate_gadget(&self) -> Result<()> {
+        // Cleanup existing gadget
+        {
+            let mut manager = self.manager.lock().await;
+            if let Some(mut m) = manager.take() {
+                info!("Cleaning up existing gadget for descriptor change");
+                if let Err(e) = m.cleanup() {
+                    warn!("Error cleaning up existing gadget: {}", e);
+                }
+            }
+        }
+
+        // Clear MSD function
+        *self.msd_function.write().await = None;
+
+        // Update state to inactive
+        {
+            let mut state = self.state.write().await;
+            state.gadget_active = false;
+            state.hid_enabled = false;
+            state.msd_enabled = false;
+            state.hid_paths = None;
+            state.error = None;
+        }
+
+        // Recreate with current requested functions
+        self.recreate_gadget().await
+    }
+
     /// Shutdown the OTG service and cleanup all resources
     pub async fn shutdown(&self) -> Result<()> {
         info!("Shutting down OTG service");