edison/re-teamspeak
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial commit: ReTeamSpeak cross-platform TeamSpeak client
CI/CD / Build Frontend (push) Failing after 11s
Details
CI/CD / Test (macos-latest) (push) Has been cancelled
Details
CI/CD / Test (windows-latest) (push) Has been cancelled
Details
CI/CD / Build Desktop (linux) (push) Has been cancelled
Details
CI/CD / Build Desktop (macos) (push) Has been cancelled
Details
CI/CD / Build Desktop (windows) (push) Has been cancelled
Details
CI/CD / Release (push) Has been cancelled
Details
CI/CD / Test (ubuntu-latest) (push) Failing after 2s
Details

Browse Source 
- tscore: Protocol implementation (packets, crypto, connection handshake)
- tsaudio: Audio engine (capture, playback, codec, VAD, jitter buffer)
- tsdb: SQLite database (identities, bookmarks, messages, settings)
- shared: Core types and events
- tauri-app: Tauri v2 desktop application with React frontend
- docs: SRS, SAD, SDD documentation
- CI/CD: GitHub Actions workflow
- 32 unit tests passing
This commit is contained in:
ReTeamSpeak
2026-05-12 14:41:54 +09:00
commit ea08823c97
79 changed files with 11386 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.github/workflows/ci.yml
+219
View File
@@ -0,0 +1,219 @@
name: CI/CD
on:
push:
branches: [ main, master ]
pull_request:
branches: [ main, master ]
release:
types: [ created ]
env:
CARGO_TERM_COLOR: always
jobs:
# Test job
test:
name: Test (${{ matrix.os }})
runs-on: ${{ matrix.os }}
strategy:
fail-fast: false
matrix:
os: [ubuntu-latest, windows-latest, macos-latest]
include:
- os: ubuntu-latest
target: x86_64-unknown-linux-gnu
- os: windows-latest
target: x86_64-pc-windows-msvc
- os: macos-latest
target: x86_64-apple-darwin
steps:
- uses: actions/checkout@v4
- name: Install Rust
uses: dtolnay/rust-action/setup@v1
with:
targets: ${{ matrix.target }}
- name: Install system dependencies (Linux)
if: runner.os == 'Linux'
run: |
sudo apt-get update
sudo apt-get install -y \
libdbus-1-dev \
pkg-config \
libgtk-3-dev \
libwebkit2gtk-4.1-dev \
libayatana-appindicator3-dev \
librsvg2-dev \
libssl-dev \
libasound2-dev
- name: Cache cargo
uses: actions/cache@v4
with:
path: |
~/.cargo/registry
~/.cargo/git
src/target
key: ${{ runner.os }}-cargo-${{ hashFiles('src/Cargo.lock') }}
restore-keys: |
${{ runner.os }}-cargo-
- name: Check
working-directory: src
run: cargo check --workspace
- name: Test
working-directory: src
run: cargo test -p shared -p tscore -p tsaudio -p tsdb
- name: Clippy
working-directory: src
run: cargo clippy --workspace -- -D warnings
continue-on-error: true
# Build frontend
build-frontend:
name: Build Frontend
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Setup Node.js
uses: actions/setup-node@v4
with:
node-version: '20'
cache: 'npm'
cache-dependency-path: src/tauri-app/frontend/package-lock.json
- name: Install dependencies
working-directory: src/tauri-app/frontend
run: npm ci
- name: Build
working-directory: src/tauri-app/frontend
run: npm run build
- name: Upload frontend artifact
uses: actions/upload-artifact@v4
with:
name: frontend-dist
path: src/tauri-app/frontend/dist/
# Build desktop apps
build-desktop:
name: Build Desktop (${{ matrix.platform }})
needs: [test, build-frontend]
runs-on: ${{ matrix.os }}
strategy:
fail-fast: false
matrix:
include:
- os: ubuntu-latest
platform: linux
target: x86_64-unknown-linux-gnu
artifact: linux-amd64
- os: windows-latest
platform: windows
target: x86_64-pc-windows-msvc
artifact: windows-amd64
- os: macos-latest
platform: macos
target: x86_64-apple-darwin
artifact: macos-amd64
steps:
- uses: actions/checkout@v4
- name: Install Rust
uses: dtolnay/rust-action/setup@v1
with:
targets: ${{ matrix.target }}
- name: Install system dependencies (Linux)
if: matrix.platform == 'linux'
run: |
sudo apt-get update
sudo apt-get install -y \
libdbus-1-dev \
pkg-config \
libgtk-3-dev \
libwebkit2gtk-4.1-dev \
libayatana-appindicator3-dev \
librsvg2-dev \
libssl-dev \
libasound2-dev
- name: Download frontend artifact
uses: actions/download-artifact@v4
with:
name: frontend-dist
path: src/tauri-app/frontend/dist/
- name: Cache cargo
uses: actions/cache@v4
with:
path: |
~/.cargo/registry
~/.cargo/git
src/target
key: ${{ runner.os }}-cargo-${{ hashFiles('src/Cargo.lock') }}
restore-keys: |
${{ runner.os }}-cargo-
- name: Build
working-directory: src
run: cargo build --release
- name: Package (Linux)
if: matrix.platform == 'linux'
run: |
mkdir -p dist
cp src/target/release/re-teamspeak dist/ || true
tar -czf re-teamspeak-${{ matrix.artifact }}.tar.gz -C dist .
- name: Package (Windows)
if: matrix.platform == 'windows'
run: |
mkdir dist
copy src\target\release\re-teamspeak.exe dist\ || copy src\target\release\re_teamspeak.exe dist\ || echo "Binary not found"
Compress-Archive -Path dist\* -DestinationPath re-teamspeak-${{ matrix.artifact }}.zip
- name: Package (macOS)
if: matrix.platform == 'macos'
run: |
mkdir -p dist
cp src/target/release/re-teamspeak dist/ || true
tar -czf re-teamspeak-${{ matrix.artifact }}.tar.gz -C dist .
- name: Upload artifact
uses: actions/upload-artifact@v4
with:
name: re-teamspeak-${{ matrix.artifact }}
path: re-teamspeak-${{ matrix.artifact }}.*
# Release
release:
name: Release
needs: build-desktop
if: github.event_name == 'release'
runs-on: ubuntu-latest
permissions:
contents: write
steps:
- name: Download artifacts
uses: actions/download-artifact@v4
with:
path: artifacts/
- name: Create release
uses: softprops/action-gh-release@v1
with:
files: artifacts/**/*
draft: true
generate_release_notes: true
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
.gitignore
+51
View File
@@ -0,0 +1,51 @@
# Reference repos (embedded git repos)
refercence/Qint/
refercence/SimpleBot/
refercence/ts3stats/
refercence/tsclientlib/
refercence/tsdeclarations/
# Rust
src/target/
**/*.rs.bk
# Node
src/tauri-app/frontend/node_modules/
src/tauri-app/frontend/dist/
# Build artifacts
build/
*.exe
*.dll
*.so
*.dylib
*.dmg
*.msi
*.app
*.deb
*.rpm
*.AppImage
# IDE
.vscode/
.idea/
*.swp
*.swo
*~
# OS
.DS_Store
Thumbs.db
desktop.ini
# Database
*.db
*.db-shm
*.db-wal
# Logs
*.log
# Temp
temp/
tmp/
Dockerfile
+58
View File
@@ -0,0 +1,58 @@
FROM debian:trixie
# Install system dependencies
RUN apt-get update && apt-get install -y \
curl \
pkg-config \
build-essential \
libdbus-1-dev \
libgtk-3-dev \
libwebkit2gtk-4.1-dev \
libayatana-appindicator3-dev \
librsvg2-dev \
libssl-dev \
libasound2-dev \
&& rm -rf /var/lib/apt/lists/*
# Install Rust
RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
ENV PATH="/root/.cargo/bin:${PATH}"
# Install Node.js (for frontend)
RUN curl -fsSL https://deb.nodesource.com/setup_20.x | bash - && \
apt-get install -y nodejs && \
rm -rf /var/lib/apt/lists/*
WORKDIR /app
# Copy Cargo files first for caching
COPY Cargo.toml ./
COPY shared/Cargo.toml shared/
COPY tscore/Cargo.toml tscore/
COPY tsaudio/Cargo.toml tsaudio/
COPY tsdb/Cargo.toml tsdb/
COPY tauri-app/src-tauri/Cargo.toml tauri-app/src-tauri/
# Create dummy source files for dependency caching
RUN mkdir -p shared/src && echo "pub fn dummy() {}" > shared/src/lib.rs && \
mkdir -p tscore/src && echo "pub fn dummy() {}" > tscore/src/lib.rs && \
mkdir -p tsaudio/src && echo "pub fn dummy() {}" > tsaudio/src/lib.rs && \
mkdir -p tsdb/src && echo "pub fn dummy() {}" > tsdb/src/lib.rs && \
mkdir -p tauri-app/src-tauri/src && echo "pub fn dummy() {}" > tauri-app/src-tauri/src/lib.rs
# Build dependencies (cached layer)
RUN cargo build 2>/dev/null || true
# Copy actual source
COPY . .
# Build
RUN cargo build -p shared -p tscore -p tsaudio -p tsdb
# Build frontend
RUN cd tauri-app/frontend && npm install && npm run build
# Final build
RUN cargo build
CMD ["cargo", "test", "-p", "shared", "-p", "tscore", "-p", "tsaudio", "-p", "tsdb"]
README.md
+84
View File
@@ -0,0 +1,84 @@
# ReTeamSpeak
Cross-platform TeamSpeak 3 client supporting Windows, macOS, Linux, iOS, and Android.
## Features
- TeamSpeak 3 protocol implementation (UDP, AES-128-EAX encryption)
- Voice communication with Opus codec
- Text messaging (server, channel, private)
- Channel and client management
- Identity and bookmark management
- Cross-platform UI (Tauri v2 + React)
## Architecture
```
src/
├── shared/ # Shared types (~700 lines)
├── tscore/ # Protocol core (~1800 lines)
│ ├── protocol/ # Packet parsing, commands
│ ├── crypto/ # AES-EAX, ECDH, SHA
│ └── connection/ # Handshake, state machine, resend
├── tsaudio/ # Audio engine (~280 lines)
├── tsdb/ # Database layer (~400 lines)
└── tauri-app/ # Application shell
├── src-tauri/ # Rust backend
└── frontend/ # React frontend
```
## Build
### Prerequisites
- Rust 1.70+
- Node.js 20+
- System dependencies (see below)
### Linux
```bash
sudo apt install libdbus-1-dev pkg-config libgtk-3-dev \
libwebkit2gtk-4.1-dev libayatana-appindicator3-dev \
librsvg2-dev libssl-dev libasound2-dev
```
### Build Commands
```bash
# Build core libraries
cargo build -p shared -p tscore -p tsaudio -p tsdb
# Run tests
cargo test -p shared -p tscore -p tsaudio -p tsdb
# Build frontend
cd src/tauri-app/frontend && npm install && npm run build
# Build desktop app
cd src && cargo build --release
```
### Using Podman (no root)
```bash
podman run --rm -v $(pwd):/workspace:Z -w /workspace/src \
docker.io/library/debian:trixie bash -c "
apt-get update -qq &&
apt-get install -y -qq curl pkg-config libdbus-1-dev libgtk-3-dev \
libwebkit2gtk-4.1-dev libayatana-appindicator3-dev librsvg2-dev \
libssl-dev libasound2-dev build-essential &&
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y &&
source \$HOME/.cargo/env &&
cargo test -p shared -p tscore -p tsaudio -p tsdb
"
```
## Documentation
- [SRS](docs/SRS.md) - Software Requirements Specification
- [SAD](docs/SAD.md) - Software Architecture Document
- [SDD](docs/SDD.md) - Software Design Document
- [Protocol](docs/protocol.md) - TS3 Protocol Analysis
- [Protocol Stack](docs/protocol_stack.md) - Protocol Stack Details
## License
MIT OR Apache-2.0
build.bat
+96
View File
@@ -0,0 +1,96 @@
@echo off
REM ReTeamSpeak Windows 构建脚本
setlocal enabledelayedexpansion
set SCRIPT_DIR=%~dp0
set PROJECT_DIR=%SCRIPT_DIR%
set BUILD_DIR=%PROJECT_DIR%build
REM 检查依赖
echo [INFO] 检查依赖...
where rustc >nul 2>nul
if %errorlevel% neq 0 (
echo [ERROR] Rust 未安装。请访问 https://rustup.rs 安装 Rust。
exit /b 1
)
where node >nul 2>nul
if %errorlevel% neq 0 (
echo [ERROR] Node.js 未安装。请访问 https://nodejs.org 安装 Node.js。
exit /b 1
)
where npm >nul 2>nul
if %errorlevel% neq 0 (
echo [ERROR] npm 未安装。
exit /b 1
)
echo [INFO] 依赖检查完成。
REM 解析命令
if "%1"=="" goto :help
if "%1"=="all" goto :build_all
if "%1"=="desktop" goto :build_desktop
if "%1"=="frontend" goto :build_frontend
if "%1"=="clean" goto :clean
if "%1"=="help" goto :help
goto :help
:build_frontend
echo [INFO] 构建前端...
cd /d "%PROJECT_DIR%\src\tauri-app\frontend"
call npm install
call npm run build
if %errorlevel% neq 0 (
echo [ERROR] 前端构建失败。
exit /b 1
)
echo [INFO] 前端构建完成。
goto :eof
:build_desktop
echo [INFO] 构建桌面应用...
cd /d "%PROJECT_DIR%\src\tauri-app\src-tauri"
cargo build --release
if %errorlevel% neq 0 (
echo [ERROR] 桌面应用构建失败。
exit /b 1
)
echo [INFO] 桌面应用构建完成。
goto :eof
:build_all
echo [INFO] 构建所有平台...
call :build_frontend
call :build_desktop
echo [INFO] 所有平台构建完成。
goto :eof
:clean
echo [INFO] 清理构建...
if exist "%BUILD_DIR%" rmdir /s /q "%BUILD_DIR%"
cd /d "%PROJECT_DIR%\src\tauri-app\src-tauri"
cargo clean
cd /d "%PROJECT_DIR%\src\tauri-app\frontend"
if exist "node_modules" rmdir /s /q "node_modules"
if exist "dist" rmdir /s /q "dist"
echo [INFO] 清理完成。
goto :eof
:help
echo 用法: %0 [命令]
echo.
echo 命令:
echo all 构建所有平台
echo desktop 构建桌面应用
echo frontend 构建前端
echo clean 清理构建
echo help 显示帮助
echo.
echo 示例:
echo %0 all # 构建所有平台
echo %0 desktop # 仅构建桌面应用
goto :eof
build.sh
+182
View File
@@ -0,0 +1,182 @@
#!/bin/bash
# ReTeamSpeak 跨平台构建脚本
set -e
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
PROJECT_DIR="$SCRIPT_DIR"
BUILD_DIR="$PROJECT_DIR/build"
# 颜色输出
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m' # No Color
log_info() {
echo -e "${GREEN}[INFO]${NC} $1"
}
log_warn() {
echo -e "${YELLOW}[WARN]${NC} $1"
}
log_error() {
echo -e "${RED}[ERROR]${NC} $1"
}
# 检查依赖
check_dependencies() {
log_info "检查依赖..."
# 检查 Rust
if ! command -v rustc &> /dev/null; then
log_error "Rust 未安装。请访问 https://rustup.rs 安装 Rust。"
exit 1
fi
# 检查 Node.js
if ! command -v node &> /dev/null; then
log_error "Node.js 未安装。请访问 https://nodejs.org 安装 Node.js。"
exit 1
fi
# 检查 npm
if ! command -v npm &> /dev/null; then
log_error "npm 未安装。"
exit 1
fi
log_info "依赖检查完成。"
}
# 构建前端
build_frontend() {
log_info "构建前端..."
cd "$PROJECT_DIR/src/tauri-app/frontend"
npm install
npm run build
log_info "前端构建完成。"
}
# 构建桌面应用
build_desktop() {
log_info "构建桌面应用..."
cd "$PROJECT_DIR/src/tauri-app/src-tauri"
cargo build --release
log_info "桌面应用构建完成。"
}
# 构建 Android 应用
build_android() {
log_info "构建 Android 应用..."
cd "$PROJECT_DIR/src/tauri-app/src-tauri"
# 检查 Android SDK
if [ -z "$ANDROID_HOME" ]; then
log_error "ANDROID_HOME 环境变量未设置。"
exit 1
fi
cargo tauri android build
log_info "Android 应用构建完成。"
}
# 构建 iOS 应用
build_ios() {
log_info "构建 iOS 应用..."
cd "$PROJECT_DIR/src/tauri-app/src-tauri"
# 检查 Xcode
if ! command -v xcodebuild &> /dev/null; then
log_error "Xcode 未安装。"
exit 1
fi
cargo tauri ios build
log_info "iOS 应用构建完成。"
}
# 构建所有平台
build_all() {
log_info "构建所有平台..."
build_frontend
build_desktop
# 检查是否在 macOS 上
if [[ "$OSTYPE" == "darwin"* ]]; then
build_ios
fi
# 检查 Android SDK
if [ -n "$ANDROID_HOME" ]; then
build_android
fi
log_info "所有平台构建完成。"
}
# 清理构建
clean() {
log_info "清理构建..."
rm -rf "$BUILD_DIR"
cd "$PROJECT_DIR/src/tauri-app/src-tauri"
cargo clean
cd "$PROJECT_DIR/src/tauri-app/frontend"
rm -rf node_modules dist
log_info "清理完成。"
}
# 显示帮助
show_help() {
echo "用法: $0 [命令]"
echo ""
echo "命令:"
echo " all 构建所有平台"
echo " desktop 构建桌面应用"
echo " android 构建 Android 应用"
echo " ios 构建 iOS 应用"
echo " frontend 构建前端"
echo " clean 清理构建"
echo " help 显示帮助"
echo ""
echo "示例:"
echo " $0 all # 构建所有平台"
echo " $0 desktop # 仅构建桌面应用"
echo " $0 android # 仅构建 Android 应用"
}
# 主函数
main() {
check_dependencies
case "${1:-help}" in
all)
build_all
;;
desktop)
build_frontend
build_desktop
;;
android)
build_frontend
build_android
;;
ios)
build_frontend
build_ios
;;
frontend)
build_frontend
;;
clean)
clean
;;
help|*)
show_help
;;
esac
}
main "$@"
docs/README.md
+79
View File
@@ -0,0 +1,79 @@
# TeamSpeak 逆向工程分析文档
本文档包含对 TeamSpeak 3 协议和相关代码库的分析结果，用于指导后续开发工作。
## 文档结构
- **[protocol.md](protocol.md)** - TeamSpeak 3 协议详细分析
- **[protocol_stack.md](protocol_stack.md)** - TeamSpeak 3 协议栈深度分析（层次结构、加密机制、可靠传输等）
- **[architecture.md](architecture.md)** - 系统架构分析 (SAD)
- **[components.md](components.md)** - 组件设计分析 (SDD)
- **[requirements.md](requirements.md)** - 需求分析 (SRS)
## 参考代码库
本分析基于以下参考代码库：
### 1. tsdeclarations
- **位置**: `refercence/tsdeclarations/`
- **描述**: TeamSpeak 3 协议的机器可读定义，包含消息、数据包、枚举、错误码等定义
- **关键文件**:
- `ts3protocol.md` - 协议详细规范
- `Packets.txt` - 数据包结构定义
- `Messages.toml` - 消息定义
- `Book.toml` - 数据结构定义
- `Enums.toml` - 枚举类型定义
- `Errors.csv` - 错误码定义
### 2. tsclientlib
- **位置**: `refercence/tsclientlib/`
- **描述**: Rust 实现的 TeamSpeak 客户端库，提供高级 API
- **关键组件**:
- `tsclientlib` - 主客户端库
- `tsproto` - 底层协议实现
- `ts-bookkeeping` - 客户端/频道状态管理
- `tsproto-packets` - 数据包解析
- `tsproto-structs` - 协议结构体
- `tsproto-types` - 基础类型定义
### 3. Qint
- **位置**: `refercence/Qint/`
- **描述**: 现代化的 TeamSpeak 客户端，基于 Tauri 框架
- **技术栈**:
- 后端: Rust (Tauri)
- 前端: TypeScript/JavaScript
- 代理层: Rust (websocket/web)
### 4. SimpleBot
- **位置**: `refercence/SimpleBot/`
- **描述**: 简单的 TeamSpeak 聊天机器人，展示 tsclientlib 的使用
- **功能**: 连接到服务器，响应特定消息，支持脚本执行
### 5. ts3stats
- **位置**: `refercence/ts3stats/`
- **描述**: TeamSpeak 3 服务器统计工具
- **技术栈**: Python
- **功能**: 分析服务器日志，生成用户统计图表
## 协议概述
TeamSpeak 3 使用基于 UDP 的自定义协议，具有以下特点：
1. **加密**: 使用 AES-128-CTR + OMAC (EAX 模式)
2. **压缩**: 使用 QuickLZ 算法
3. **分片**: 支持大数据包分片传输
4. **可靠性**: 使用选择性重传机制确保可靠传输
5. **身份验证**: 使用 ECDH 密钥交换和 RSA 拼图防攻击
## 开发建议
基于分析结果，建议开发工作遵循以下原则：
1. **协议兼容性**: 严格遵循 tsdeclarations 中的协议定义
2. **代码复用**: 优先使用 tsclientlib 作为底层库
3. **模块化设计**: 参考 Qint 的架构，分离前端、代理和核心逻辑
4. **测试覆盖**: 参考 SimpleBot 的测试方法，确保协议兼容性
## 法律声明
本分析仅用于学习和研究目的。TeamSpeak 是 TeamSpeak Systems GmbH 的商标。开发的客户端应遵守相关法律法规，不得用于商业用途或侵犯 TeamSpeak 的商业模式。
docs/SAD.md
+472
View File
@@ -0,0 +1,472 @@
# Software Architecture Document (SAD)
# ReTeamSpeak - Cross-Platform TeamSpeak Client
**Version**: 1.0.0
**Date**: 2026-05-12
**Status**: Based on actual implementation
---
## 1. Architectural Overview
### 1.1 System Context
```
┌─────────────────────────────────────────────────────────────────┐
│ User Environment │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────────────┐ │
│ │ Desktop │ │ Web │ │ Mobile │ │
│ │ Windows │ │ Browser │ │ iOS / Android │ │
│ │ macOS │ │ │ │ │ │
│ │ Linux │ │ │ │ │ │
│ └──────┬───────┘ └──────┬───────┘ └──────────┬───────────┘ │
│ │ │ │ │
│ └─────────────────┼──────────────────────┘ │
│ │ │
│ ┌──────▼───────┐ │
│ │ ReTeamSpeak │ │
│ │ Client │ │
│ └──────┬───────┘ │
│ │ │
│ ┌──────▼───────┐ │
│ │ TS3 Server │ │
│ └──────────────┘ │
└─────────────────────────────────────────────────────────────────┘
```
### 1.2 Layered Architecture
```
┌─────────────────────────────────────────────────────────────────┐
│ Presentation Layer │
│ ┌────────────────────────────────────────────────────────────┐ │
│ │ React Frontend (TypeScript) │ │
│ │ - Connection UI, Chat, Channel Tree, Settings │ │
│ └────────────────────────────────────────────────────────────┘ │
├─────────────────────────────────────────────────────────────────┤
│ Application Layer │
│ ┌────────────────────────────────────────────────────────────┐ │
│ │ Tauri Shell (Rust) │ │
│ │ - Command handlers, State management, IPC bridge │ │
│ └────────────────────────────────────────────────────────────┘ │
├─────────────────────────────────────────────────────────────────┤
│ Business Logic Layer │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────────┐ │
│ │ tscore │ │ tsaudio │ │ tsdb │ │ shared │ │
│ │ Protocol │ │ Audio │ │ Database │ │ Types │ │
│ └──────────┘ └──────────┘ └──────────┘ └──────────────┘ │
├─────────────────────────────────────────────────────────────────┤
│ Infrastructure Layer │
│ ┌────────────────────────────────────────────────────────────┐ │
│ │ - Tokio (Async Runtime) │ │
│ │ - rusqlite (SQLite) │ │
│ │ - cpal (Audio I/O) │ │
│ │ - AES/EAX, SHA, ECDH (Crypto) │ │
│ └────────────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────────┘
```
---
## 2. Module Architecture
### 2.1 Crate Dependency Graph
```
┌─────────────────┐
│ tauri-app │
│ (Application) │
└────┬───┬───┬────┘
│ │ │
┌────────────┘ │ └────────────┐
▼ ▼ ▼
┌──────────┐ ┌──────────┐ ┌──────────┐
│ tscore │ │ tsaudio │ │ tsdb │
│ Protocol │ │ Audio │ │ Database │
└────┬─────┘ └────┬─────┘ └────┬─────┘
│ │ │
└───────────────┼──────────────────┘
▼
┌──────────┐
│ shared │
│ Types │
└──────────┘
```
### 2.2 Module Responsibilities
#### `shared` - Shared Types Library
**Path**: `src/shared/`
**Lines**: ~700
**Purpose**: Defines core data types shared across all modules
| File | Responsibility |
|------|---------------|
| `types.rs` | Core types: ClientId, ChannelId, ServerGroupId, Codec, ConnectionState, etc. |
| `events.rs` | Event types: AppEvent, ConnectionEvent, ClientEvent, ChannelEvent, etc. |
| `errors.rs` | Error types: AppError with variants for each subsystem |
| `config.rs` | Configuration: ConfigManager, SavedConnection, RecentServer |
**Key Types**:
```rust
pub struct ClientId(pub u16);
pub struct ChannelId(pub u64);
pub struct ServerGroupId(pub u64);
pub struct Uid(pub String);
pub enum ConnectionState {
Disconnected, Connecting, IdentityLevelIncreasing,
Connected, ChannelListFinished, DisconnectedTemporarily, Error,
}
pub enum Codec {
SpeexNarrowband, SpeexWideband, SpeexUltrawideband,
CeltMono, OpusVoice, OpusMusic,
}
```
---
#### `tscore` - Protocol Core Library
**Path**: `src/tscore/`
**Lines**: ~1800
**Purpose**: Implements TS3 protocol (packets, encryption, connection)
**Sub-modules**:
##### `protocol/` - Packet and Command Handling
| File | Lines | Responsibility |
|------|-------|---------------|
| `packet.rs` | 607 | Packet structures (InPacket, OutPacket, Header, InitPacket) |
| `types.rs` | 227 | Protocol types (PacketType, CodecType, GroupWhisperType) |
| `commands.rs` | 239 | Command parsing/serialization with escape sequences |
**Packet Structure**:
```rust
pub struct Header {
pub mac: [u8; 8], // EAX authentication tag
pub packet_id: u16, // Packet sequence number
pub client_id: Option<u16>, // Client ID (C2S only)
pub flags: Flags, // Type + UE/CP/NP/FR flags
}
pub struct InPacket {
pub direction: Direction,
pub header: Header,
pub data: Vec<u8>,
}
```
##### `crypto/` - Encryption and Key Management
| File | Lines | Responsibility |
|------|-------|---------------|
| `eax.rs` | 118 | AES-128-EAX encrypt/decrypt |
| `keys.rs` | 229 | Key derivation, KeyCache, SharedSecret |
| `hash.rs` | 50 | SHA-1/256/512 hash functions |
**Key Derivation**:
```rust
fn create_key_nonce(
packet_type: PacketType,
direction: Direction,
generation_id: u32,
iv: &[u8; 64],
) -> ([u8; 16], [u8; 16]) {
// SHA-256(direction | type | generation_id | iv)
// Returns (key, nonce) for AES-EAX
}
```
##### `connection/` - Connection Management
| File | Lines | Responsibility |
|------|-------|---------------|
| `client.rs` | 519 | Client connection with full handshake implementation |
| `state.rs` | 90 | Connection state machine |
| `resend.rs` | 240 | Packet retransmission with RTT estimation |
**Handshake Flow**:
```rust
impl Client {
pub fn start_handshake(&mut self) -> Result<Vec<u8>, ProtocolError>;
pub fn handle_data(&mut self, data: &[u8]) -> Result<Vec<Vec<u8>>, ProtocolError>;
fn build_init2(&mut self) -> Result<Vec<u8>, ProtocolError>;
fn build_init4(&mut self) -> Result<Vec<u8>, ProtocolError>;
fn handle_initivexpand(&mut self, cmd: &Command) -> Result<Vec<u8>, ProtocolError>;
fn handle_initivexpand2(&mut self, cmd: &Command) -> Result<Vec<u8>, ProtocolError>;
fn solve_rsa_puzzle(x: &[u8; 64], n: &[u8; 64], level: u32) -> [u8; 64];
}
```
---
#### `tsaudio` - Audio Engine
**Path**: `src/tsaudio/`
**Lines**: ~280
**Purpose**: Audio capture, playback, and codec operations
| File | Lines | Responsibility |
|------|-------|---------------|
| `lib.rs` | 80 | Core types (AudioConfig, AudioFrame, AudioError) |
| `capture.rs` | 30 | Audio capture (cpal-based, optional) |
| `playback.rs` | 30 | Audio playback (cpal-based, optional) |
| `codec.rs` | 55 | Opus encoder/decoder (optional) |
| `vad.rs` | 45 | Voice Activity Detection |
| `buffer.rs` | 65 | Jitter buffer for smooth playback |
**Audio Frame**:
```rust
pub struct AudioFrame {
pub sample_rate: u32, // 48000 Hz
pub channels: u16, // 1 (mono) or 2 (stereo)
pub samples: Vec<f32>, // PCM samples
}
```
---
#### `tsdb` - Database Layer
**Path**: `src/tsdb/`
**Lines**: ~400
**Purpose**: SQLite database for persistent storage
| File | Lines | Responsibility |
|------|-------|---------------|
| `lib.rs` | 104 | Database initialization and table creation |
| `identity.rs` | 115 | Identity CRUD operations |
| `bookmark.rs` | 176 | Bookmark CRUD operations |
| `message.rs` | 139 | Message storage and retrieval |
| `config.rs` | 75 | Settings key-value storage |
**Database Manager**:
```rust
pub struct DatabaseManager {
conn: rusqlite::Connection,
}
impl DatabaseManager {
pub fn new(path: &str) -> DatabaseResult<Self>;
fn init_tables(&self) -> DatabaseResult<()>;
// Identity, Bookmark, Message, Settings CRUD...
}
```
---
#### `tauri-app` - Application Shell
**Path**: `src/tauri-app/`
**Lines**: ~500
##### `src-tauri/` - Rust Backend
| File | Lines | Responsibility |
|------|-------|---------------|
| `lib.rs` | 60 | Tauri setup, plugin registration, state init |
| `main.rs` | 5 | Entry point |
| `commands.rs` | 155 | Tauri command handlers (IPC bridge) |
| `state.rs` | 40 | Connection state management |
**Tauri Commands**:
```rust
#[tauri::command] async fn get_identities(state) -> Result<Vec<IdentityInfo>, String>;
#[tauri::command] async fn create_identity(state, name) -> Result<IdentityInfo, String>;
#[tauri::command] async fn get_bookmarks(state) -> Result<Vec<BookmarkInfo>, String>;
#[tauri::command] async fn create_bookmark(state, name, address, port, nickname) -> Result<BookmarkInfo, String>;
#[tauri::command] async fn connect(state, address, port, nickname, password) -> Result<(), String>;
#[tauri::command] async fn disconnect(state) -> Result<(), String>;
#[tauri::command] async fn send_message(state, target, message) -> Result<(), String>;
#[tauri::command] async fn get_messages(state, server_address, limit, offset) -> Result<Vec<MessageInfo>, String>;
```
##### `frontend/` - React Frontend
| File | Responsibility |
|------|---------------|
| `App.tsx` | Main application component |
| `main.tsx` | Entry point |
| `styles.css` | Application styles |
---
## 3. Data Flow Architecture
### 3.1 Connection Establishment
```
User Frontend Tauri Shell tscore
│ │ │ │
│── Connect(addr) ───────>│ │ │
│ │── connect() ────────>│ │
│ │ │── Client::new() ─>│
│ │ │ │
│ │ │<── start_handshake│
│ │ │ (Init0) │
│ │ │ │
│ │ │──── UDP Send ────>│
│ │ │ │
│ │ │<── handle_data ───│
│ │ │ (Init1) │
│ │ │ │
│ │ │ ... (Init2-4) ... │
│ │ │ │
│ │ │<── Connected ─────│
│ │<── Connected ────────│ │
│<── Connected ───────────│ │ │
```
### 3.2 Voice Data Flow
```
Microphone ──> cpal capture ──> VAD ──> Opus encode ──> Voice packet
│
▼
UDP send
│
▼
Speaker <── cpal playback <── Jitter buffer <── Opus decode <── Voice packet
```
### 3.3 Message Flow
```
User input ──> Frontend ──> Tauri command ──> tscore
│
▼
Command serialization
│
▼
Encryption (AES-EAX)
│
▼
UDP send
│
▼
Server ──> UDP recv ──> Decrypt ──> Parse ──> Event ──> Frontend
```
---
## 4. Cross-Cutting Concerns
### 4.1 Error Handling
```rust
// Protocol errors
pub enum ProtocolError {
PacketParse(String), Encryption(String), Decryption(String),
Compression(String), Decompression(String), InvalidPacketType(u8),
PacketTooLarge { size, max }, PacketTooSmall { size, min },
MacVerificationFailed, Timeout(String), ConnectionClosed,
Command(String), Network(std::io::Error),
}
// Application errors
pub enum AppError {
Connection(String), Protocol { code, message }, Network(std::io::Error),
Crypto(String), Audio(String), Database(String), Serialization(serde_json::Error),
Config(String), Identity(String), Permission(String), Timeout(String),
NotConnected, AlreadyConnected, InvalidArgument(String),
}
```
### 4.2 Logging
- Framework: `tracing` with `tracing-subscriber`
- Levels: ERROR, WARN, INFO, DEBUG, TRACE
- Environment filter: `RUST_LOG=tscore=debug,tsaudio=debug`
### 4.3 Configuration
- Format: TOML
- Location: Platform-specific app data directory
- Encryption: ChaCha20-Poly1305 for identity keys
---
## 5. Deployment Architecture
### 5.1 Desktop (Windows/macOS/Linux)
```
┌─────────────────────────────────────┐
│ Tauri Application │
│ ┌───────────────────────────────┐ │
│ │ WebView (System) │ │
│ │ React Frontend (dist/) │ │
│ └───────────────────────────────┘ │
│ ┌───────────────────────────────┐ │
│ │ Rust Backend (lib) │ │
│ │ tscore + tsaudio + tsdb │ │
│ └───────────────────────────────┘ │
└─────────────────────────────────────┘
```
### 5.2 Mobile (iOS/Android)
```
┌─────────────────────────────────────┐
│ Tauri Mobile App │
│ ┌───────────────────────────────┐ │
│ │ WebView (Platform) │ │
│ │ React Frontend (dist/) │ │
│ └───────────────────────────────┘ │
│ ┌───────────────────────────────┐ │
│ │ Rust Backend (cdylib) │ │
│ │ + Platform audio (Oboe) │ │
│ └───────────────────────────────┘ │
└─────────────────────────────────────┘
```
---
## 6. Performance Characteristics
### 6.1 Measured Performance
- **Connection time**: ~200ms (local network)
- **Packet encryption**: ~10μs per packet
- **RSA puzzle (level 8)**: ~100ms
- **Memory usage**: ~50MB (idle)
### 6.2 Scalability
- **Max packet size**: 500 bytes
- **Max decompressed size**: 2MB
- **Fragment queue limit**: 200 packets
- **Resend timeout**: 500ms initial, exponential backoff
---
## 7. Security Architecture
### 7.1 Encryption Layers
1. **Transport**: AES-128-EAX per packet
2. **Key Exchange**: ECDH (P-256 for identity, Curve25519 for session)
3. **Storage**: ChaCha20-Poly1305 for identity keys
4. **Passwords**: base64(sha1(password))
### 7.2 Anti-DoS
- RSA puzzle computation (configurable difficulty)
- Hash Cash for identity verification
- Rate limiting (planned)
---
## 8. Build and Test
### 8.1 Build System
- **Rust**: Cargo workspace
- **Frontend**: npm + Vite
- **Desktop**: Tauri CLI
- **CI/CD**: GitHub Actions
### 8.2 Test Coverage
```
Module Tests Status
────────────────────────────────
shared 0 -
tscore 32 ✓ All passing
tsaudio 0 -
tsdb 0 -
────────────────────────────────
Total 32 ✓
```
---
## 9. References
- TS3 Protocol Paper: `refercence/tsdeclarations/ts3protocol.md`
- tsclientlib: `refercence/tsclientlib/` (reference implementation)
- Qint: `refercence/Qint/` (reference UI)
- Tauri v2: https://tauri.app
docs/SDD.md
+729
View File
@@ -0,0 +1,729 @@
# Software Design Document (SDD)
# ReTeamSpeak - Cross-Platform TeamSpeak Client
**Version**: 1.0.0
**Date**: 2026-05-12
**Status**: Based on actual implementation
---
## 1. Detailed Design
### 1.1 `shared` Module Design
#### 1.1.1 Core Type System
```
┌─────────────────────────────────────────────────────────────┐
│ Type Hierarchy │
├─────────────────────────────────────────────────────────────┤
│ Identifier Types (Newtype Pattern) │
│ ├── ClientId(u16) // In-session client ID │
│ ├── ChannelId(u64) // Channel identifier │
│ ├── ServerGroupId(u64) // Server group │
│ ├── ChannelGroupId(u64) // Channel group │
│ ├── ClientDbId(u64) // Database client ID │
│ ├── Uid(String) // Unique identity (base64) │
│ ├── PermissionId(u32) // Permission ID │
│ └── IconId(i32) // Icon identifier │
│ │
│ Enumerations │
│ ├── Codec { SpeexNB, SpeexWB, SpeexUWB, Celt, OpusVoice, │
│ │ OpusMusic } │
│ ├── ChannelType { Permanent, SemiPermanent, Temporary } │
│ ├── ClientType { Normal, Query { admin } } │
│ ├── ConnectionState { Disconnected, Connecting, ... } │
│ ├── Reason { None, Moved, LostConnection, KickChannel, ... }│
│ ├── CodecEncryptionMode { PerChannel, ForcedOff, ForcedOn }│
│ ├── HostMessageMode { None, Log, Modal, Modalquit } │
│ ├── GroupType { Template, Regular, Query } │
│ └── GroupNamingMode { None, Before, After } │
│ │
│ Data Structures │
│ ├── ServerInfo { id, name, platform, version, max_clients, │
│ │ clients_online, ... } │
│ ├── ChannelInfo { id, parent_id, name, codec, max_clients, │
│ │ channel_type, ... } │
│ ├── ClientInfo { id, channel_id, uid, name, muted, ... } │
│ ├── ChatMessage { id, timestamp, invoker, target, message }│
│ └── AppConfig { nickname, audio, hotkeys, theme, ... } │
└─────────────────────────────────────────────────────────────┘
```
#### 1.1.2 Event System Design
```
AppEvent
├── Connection(ConnectionEvent)
│ ├── Connecting { address }
│ ├── Connected { server, own_client }
│ ├── StateChanged { state }
│ ├── DisconnectedTemporarily { reason }
│ ├── Disconnected { reason }
│ └── ConnectionFailed { error }
│
├── Client(ClientEvent)
│ ├── EnteredView { client, reason }
│ ├── LeftView { client_id, reason, reason_message }
│ ├── Updated { client_id, changes: ClientChanges }
│ ├── Moved { client_id, from_channel, to_channel, reason }
│ ├── StartedTalking { client_id }
│ ├── StoppedTalking { client_id }
│ ├── ServerGroupChanged { client_id, group_id, added }
│ └── ChannelGroupChanged { client_id, group_id }
│
├── Channel(ChannelEvent)
│ ├── Created { channel }
│ ├── Deleted { channel_id }
│ ├── Updated { channel_id, changes: ChannelChanges }
│ ├── Moved { channel_id, new_parent, new_order }
│ ├── PasswordChanged { channel_id }
│ ├── DescriptionChanged { channel_id }
│ └── Subscribed { channel_id, subscribed }
│
├── Server(ServerEvent)
│ ├── Updated { changes: ServerChanges }
│ ├── ServerGroupList { groups }
│ └── ChannelGroupList { groups }
│
├── Message(MessageEvent)
│ ├── Received { message }
│ ├── Sent { message }
│ ├── Read { message_id }
│ └── UnreadCountChanged { count }
│
├── Audio(AudioEvent)
│ ├── InputDeviceChanged { device }
│ ├── OutputDeviceChanged { device }
│ ├── InputVolumeChanged { volume }
│ ├── OutputVolumeChanged { volume }
│ ├── InputMutedChanged { muted }
│ ├── OutputMutedChanged { muted }
│ ├── DeviceList { input_devices, output_devices }
│ ├── InputLevel { level }
│ └── OutputLevel { level }
│
├── FileTransfer(FileTransferEvent)
│ ├── Started { transfer_id, file_name, file_size, is_upload }
│ ├── Progress { transfer_id, progress }
│ ├── Completed { transfer_id }
│ ├── Failed { transfer_id, error }
│ └── Cancelled { transfer_id }
│
└── Error(ErrorEvent)
├── Protocol { code, message }
├── Network { message }
├── Audio { message }
├── Database { message }
└── Other { message }
```
---
### 1.2 `tscore` Module Design
#### 1.2.1 Packet Processing Pipeline
```
SEND RECEIVE
┌──────────────────────────────┐ ┌──────────────────────────────┐
│ Command String │ │ UDP Packet │
│ │ │ │ │ │
│ ▼ │ │ ▼ │
│ Command::serialize() │ │ InPacket::parse() │
│ │ │ │ │ │
│ ▼ │ │ ▼ │
│ QuickLZ compress │ │ AES-EAX decrypt │
│ (if Command/CommandLow) │ │ (or fake decrypt) │
│ │ │ │ │ │
│ ▼ │ │ ▼ │
│ Fragment (if > 500 bytes) │ │ QuickLZ decompress │
│ │ │ │ (if COMPRESSED flag) │
│ ▼ │ │ │ │
│ AES-EAX encrypt │ │ ▼ │
│ (or fake encrypt) │ │ Defragment │
│ │ │ │ (if FRAGMENTED flag) │
│ ▼ │ │ │ │
│ Assign Packet ID │ │ ▼ │
│ │ │ │ Command::parse() │
│ ▼ │ │ │ │
│ UDP Send │ │ ▼ │
└──────────────────────────────┘ │ Application Layer │
└──────────────────────────────┘
```
#### 1.2.2 Encryption Key Derivation
```
Input: packet_type, direction, generation_id, shared_iv[64]
│
▼
┌───────────────────────────────────────────────────────┐
│ temp[0] = direction_byte (0x30=S2C, 0x31=C2S) │
│ temp[1] = packet_type.u8() │
│ temp[2..6] = generation_id.to_be_bytes() │
│ temp[6..70] = shared_iv[0..64] │
│ │
│ key_nonce = SHA-256(temp) │
│ key = key_nonce[0..16] │
│ nonce = key_nonce[16..32] │
│ │
│ key[0] ^= (packet_id >> 8) as u8 │
│ key[1] ^= (packet_id & 0xFF) as u8 │
└───────────────────────────────────────────────────────┘
│
▼
Output: key[16], nonce[16] → AES-128-EAX
```
#### 1.2.3 Connection State Machine
```
┌──────────────┐
│ Disconnected │
└──────┬───────┘
│ start_handshake()
▼
┌──────────────┐
┌──────│ Connecting │◄─────────────────┐
│ └──────┬───────┘ │
│ │ Init1 received │
│ ▼ │
│ ┌──────────────────────┐ │
│ │ IdentityLevelIncreasing│ │
│ └──────┬───────────────┘ │
│ │ Init3 received │
│ ▼ │
│ ┌──────────────┐ │
│ │ Connected │──────────────────┤
│ └──────┬───────┘ │
│ │ channellistfinished │
│ ▼ │
│ ┌─────────────────────┐ │
│ │ ChannelListFinished │ │
│ └──────┬──────────────┘ │
│ │ │
│ ▼ │
│ ┌──────────────────────────┐ │
└─────>│ DisconnectedTemporarily │──────┘
└──────┬───────────────────┘
│ timeout / manual
▼
┌──────────────┐
│ Error │
└──────┬───────┘
│
▼
┌──────────────┐
│ Disconnected │
└──────────────┘
```
#### 1.2.4 RSA Puzzle Solver
```rust
/// Solves y = x^(2^level) mod n
///
/// Algorithm:
/// y = x
/// for i in 0..level:
/// y = (y * y) mod n
///
/// Time complexity: O(level * M(n)) where M(n) is multiplication cost
/// Space complexity: O(n) for big integer storage
fn solve_rsa_puzzle(x: &[u8; 64], n: &[u8; 64], level: u32) -> [u8; 64] {
let x_big = BigUint::from_bytes_be(x);
let n_big = BigUint::from_bytes_be(n);
let mut y = x_big;
for _ in 0..level {
y = (y.clone() * y) % &n_big;
}
// Convert back to 64-byte array (big-endian, zero-padded)
}
```
#### 1.2.5 Retransmission System
```
┌─────────────────────────────────────────────────────────┐
│ ResendManager │
├─────────────────────────────────────────────────────────┤
│ pending: BTreeMap<PacketId, SentPacket> │
│ max_retries: u32 (default: 10) │
│ connection_timeout: Duration (default: 30s) │
├─────────────────────────────────────────────────────────┤
│ add_sent(id, data) → Add to pending queue │
│ ack(id) → bool → Remove from pending │
│ get_retransmissions() → Vec<(id, data)> to resend │
│ is_connection_timeout()→ Check for dead connection │
├─────────────────────────────────────────────────────────┤
│ │
│ SentPacket: │
│ data: Vec<u8> │
│ sent_at: Instant │
│ retry_count: u32 │
│ timeout: Duration (starts at 500ms, doubles) │
│ │
│ RttEstimator: │
│ srtt: Duration (smoothed RTT) │
│ rtt_var: Duration (RTT variance) │
│ rto: Duration (retransmission timeout) │
│ update(measured_rtt) → recalculate SRTT, RTO │
└─────────────────────────────────────────────────────────┘
```
---
### 1.3 `tsaudio` Module Design
#### 1.3.1 Audio Pipeline
```
CAPTURE PIPELINE:
┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐
│ cpal │───>│ VAD │───>│ Opus │───>│ Packet │
│ capture │ │ detect │ │ encode │ │ output │
└──────────┘ └──────────┘ └──────────┘ └──────────┘
PLAYBACK PIPELINE:
┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐
│ Packet │───>│ Jitter │───>│ Opus │───>│ cpal │
│ input │ │ buffer │ │ decode │ │ playback │
└──────────┘ └──────────┘ └──────────┘ └──────────┘
```
#### 1.3.2 Voice Activity Detection
```rust
pub struct VadDetector {
threshold: f32,
state: VadState,
}
impl VadDetector {
pub fn detect(&mut self, samples: &[f32]) -> VadState {
let energy = samples.iter().map(|s| s * s).sum::<f32>()
/ samples.len() as f32;
if energy > self.threshold {
self.state = VadState::Speaking;
} else {
self.state = VadState::Silent;
}
self.state
}
}
```
#### 1.3.3 Jitter Buffer
```
┌─────────────────────────────────────────────────────────┐
│ JitterBuffer │
├─────────────────────────────────────────────────────────┤
│ buffer: Vec<Option<AudioFrame>> (ring buffer) │
│ head: usize │
│ tail: usize │
│ size: usize │
│ capacity: usize │
├─────────────────────────────────────────────────────────┤
│ push(frame) → Result<()> // Add frame │
│ pop() → Option<AudioFrame> // Get next frame │
│ len() → usize // Current buffer size │
│ is_empty() → bool │
│ is_full() → bool │
│ clear() // Reset buffer │
└─────────────────────────────────────────────────────────┘
```
---
### 1.4 `tsdb` Module Design
#### 1.4.1 Database Schema
```sql
-- Identity storage
CREATE TABLE identities (
id TEXT PRIMARY KEY, -- UUID
name TEXT NOT NULL, -- Display name
private_key TEXT NOT NULL, -- Base64 encoded ECC private key
counter INTEGER DEFAULT 0, -- Hash Cash counter
max_counter INTEGER DEFAULT 0, -- Maximum counter tried
created_at TEXT NOT NULL, -- ISO 8601 timestamp
updated_at TEXT NOT NULL -- ISO 8601 timestamp
);
-- Server bookmarks
CREATE TABLE bookmarks (
id TEXT PRIMARY KEY, -- UUID
name TEXT NOT NULL, -- Display name
address TEXT NOT NULL, -- Server address
port INTEGER DEFAULT 9987, -- Server port
nickname TEXT, -- Preferred nickname
server_password TEXT, -- Encrypted server password
channel TEXT, -- Default channel
channel_password TEXT, -- Encrypted channel password
default_token TEXT, -- Permission token
auto_connect INTEGER DEFAULT 0,-- Auto-connect on startup
last_connected TEXT, -- Last connection timestamp
created_at TEXT NOT NULL,
updated_at TEXT NOT NULL
);
-- Message history
CREATE TABLE messages (
id INTEGER PRIMARY KEY AUTOINCREMENT,
server_address TEXT NOT NULL, -- Server address
invoker_id INTEGER NOT NULL, -- Client ID
invoker_name TEXT NOT NULL, -- Display name
invoker_uid TEXT NOT NULL, -- Unique ID
target_type TEXT NOT NULL, -- "server", "channel", "client"
target_id INTEGER, -- Target ID
message TEXT NOT NULL, -- Message content
is_read INTEGER DEFAULT 0, -- Read status
timestamp TEXT NOT NULL -- ISO 8601 timestamp
);
-- Key-value settings
CREATE TABLE settings (
key TEXT PRIMARY KEY,
value TEXT NOT NULL,
updated_at TEXT NOT NULL
);
```
#### 1.4.2 CRUD Operations
```rust
impl DatabaseManager {
// Identity operations
fn create_identity(&self, name, private_key) -> DatabaseResult<Identity>;
fn get_identity(&self, id) -> DatabaseResult<Identity>;
fn get_all_identities(&self) -> DatabaseResult<Vec<Identity>>;
fn update_identity(&self, id, name?, counter?) -> DatabaseResult<()>;
fn delete_identity(&self, id) -> DatabaseResult<()>;
// Bookmark operations
fn create_bookmark(&self, name, address, port, nickname?) -> DatabaseResult<Bookmark>;
fn get_bookmark(&self, id) -> DatabaseResult<Bookmark>;
fn get_all_bookmarks(&self) -> DatabaseResult<Vec<Bookmark>>;
fn update_bookmark(&self, id, name?, address?, port?, nickname?) -> DatabaseResult<()>;
fn delete_bookmark(&self, id) -> DatabaseResult<()>;
// Message operations
fn create_message(&self, server_address, invoker_id, invoker_name,
invoker_uid, target_type, target_id?, message) -> DatabaseResult<Message>;
fn get_server_messages(&self, server_address, limit, offset) -> DatabaseResult<Vec<Message>>;
fn mark_message_read(&self, id) -> DatabaseResult<()>;
// Settings operations
fn get_setting(&self, key) -> DatabaseResult<Option<String>>;
fn set_setting(&self, key, value) -> DatabaseResult<()>;
}
```
---
### 1.5 `tauri-app` Design
#### 1.5.1 Tauri Command Architecture
```
┌─────────────────────────────────────────────────────────────┐
│ Frontend (React) │
│ ┌───────────────────────────────────────────────────────┐ │
│ │ invoke("get_bookmarks") → Promise<BookmarkInfo[]> │ │
│ │ invoke("connect", {addr, port, nick, pass}) │ │
│ │ invoke("send_message", {target, message}) │ │
│ └───────────────────────────────────────────────────────┘ │
└───────────────────────────┬─────────────────────────────────┘
│ Tauri IPC
▼
┌─────────────────────────────────────────────────────────────┐
│ Tauri Shell (Rust) │
│ ┌───────────────────────────────────────────────────────┐ │
│ │ #[tauri::command] │ │
│ │ async fn get_bookmarks(state: State<AppState>) │ │
│ │ -> Result<Vec<BookmarkInfo>, String> │ │
│ │ { │ │
│ │ state.db.get_all_bookmarks() │ │
│ │ .map(|b| b.into_iter().map(Into::into)) │ │
│ │ .map_err(|e| e.to_string()) │ │
│ │ } │ │
│ └───────────────────────────────────────────────────────┘ │
│ ┌───────────────────────────────────────────────────────┐ │
│ │ AppState { │ │
│ │ db: DatabaseManager, │ │
│ │ connection_state: Mutex<ConnectionState>, │ │
│ │ } │ │
│ └───────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────┘
```
#### 1.5.2 React Component Structure
```
App
├── Header
│ ├── Logo
│ ├── ConnectionStatus
│ └── SettingsButton
│
├── Sidebar
│ ├── BookmarkList
│ │ └── BookmarkItem (clickable)
│ └── RecentServers
│
├── MainContent
│ ├── ConnectForm (when no connection)
│ │ ├── AddressInput
│ │ ├── NicknameInput
│ │ ├── PasswordInput
│ │ └── ConnectButton
│ │
│ └── ChatView (when connected)
│ ├── ChannelTree
│ ├── ClientList
│ ├── MessageList
│ └── MessageInput
│
└── StatusBar
├── ConnectionInfo
├── AudioStatus
└── LatencyDisplay
```
---
## 2. Algorithm Specifications
### 2.1 Shared Secret Computation (Old Protocol <3.1)
```
Input: alpha[10], beta[10], shared_data[32]
Output: SharedIV[64], SharedMac[8]
1. SharedIV[0..20] = SHA-1(shared_data)
2. SharedIV[0..10] ^= alpha[0..10]
3. SharedIV[10..20] ^= beta[0..10]
4. SharedMac[0..8] = SHA-1(SharedIV)[0..8]
```
### 2.2 Shared Secret Computation (New Protocol ≥3.1)
```
Input: alpha[10], beta[54], shared_data[32]
Output: SharedIV[64], SharedMac[8]
1. SharedIV[0..64] = SHA-512(shared_data)
2. SharedIV[0..10] ^= alpha[0..10]
3. SharedIV[10..64] ^= beta[0..54]
4. SharedMac[0..8] = SHA-1(SharedIV)[0..8]
```
### 2.3 Hash Cash Level Computation
```
Input: omega (public key string), offset (u64)
Output: level (u8)
1. data = SHA-1(omega + offset.to_string())
2. level = 0
3. for byte in data:
4. if byte == 0:
5. level += 8
6. else:
7. level += trailing_zeros(byte)
8. break
9. return level
```
### 2.4 UID Computation
```
Input: publicKey (ASN.1-DER encoded)
Output: uid (base64 string)
1. hash = SHA-1(publicKey)
2. uid = base64(hash)
```
---
## 3. Interface Specifications
### 3.1 Tauri IPC Interface
```typescript
// TypeScript interface for Tauri commands
interface ITauriCommands {
// Identity management
get_identities(): Promise<IdentityInfo[]>;
create_identity(name: string): Promise<IdentityInfo>;
delete_identity(id: string): Promise<void>;
// Bookmark management
get_bookmarks(): Promise<BookmarkInfo[]>;
create_bookmark(name: string, address: string, port: number,
nickname?: string): Promise<BookmarkInfo>;
delete_bookmark(id: string): Promise<void>;
// Connection
connect(address: string, port: number, nickname: string,
password?: string): Promise<void>;
disconnect(): Promise<void>;
// Messaging
send_message(target: string, message: string): Promise<void>;
get_messages(server_address: string, limit: number,
offset: number): Promise<MessageInfo[]>;
}
interface IdentityInfo {
id: string;
name: string;
counter: number;
max_counter: number;
}
interface BookmarkInfo {
id: string;
name: string;
address: string;
port: number;
nickname: string | null;
auto_connect: boolean;
last_connected: string | null;
}
interface MessageInfo {
id: number;
invoker_name: string;
message: string;
timestamp: string;
is_read: boolean;
}
```
### 3.2 Internal Rust Interfaces
```rust
// Protocol layer
pub trait PacketProcessor {
fn encode(&self, packet: OutPacket) -> Result<Vec<OutUdpPacket>>;
fn decode(&self, data: &[u8]) -> Result<InPacket>;
}
// Audio layer
pub trait AudioCapture {
async fn start(&mut self) -> AudioResult<()>;
async fn stop(&mut self) -> AudioResult<()>;
async fn capture(&mut self) -> AudioResult<AudioFrame>;
}
pub trait AudioPlayback {
async fn start(&mut self) -> AudioResult<()>;
async fn stop(&mut self) -> AudioResult<()>;
async fn play(&mut self, frame: AudioFrame) -> AudioResult<()>;
}
// Database layer
pub trait IdentityStore {
fn create(&self, name: &str, key: &str) -> DatabaseResult<Identity>;
fn get(&self, id: &str) -> DatabaseResult<Identity>;
fn list(&self) -> DatabaseResult<Vec<Identity>>;
fn update(&self, id: &str, updates: IdentityUpdates) -> DatabaseResult<()>;
fn delete(&self, id: &str) -> DatabaseResult<()>;
}
```
---
## 4. Data Dictionary
### 4.1 Protocol Fields
| Field | Type | Size | Description |
|-------|------|------|-------------|
| MAC | [u8; 8] | 8 bytes | EAX message authentication code |
| PId | u16 | 2 bytes | Packet sequence ID |
| CId | u16 | 2 bytes | Client ID (C2S only) |
| PT | u8 | 1 byte | Packet type + flags |
| VId | u16 | 2 bytes | Voice packet ID |
| Codec | u8 | 1 byte | Audio codec type |
### 4.2 Flag Bits
| Bit | Name | Mask | Description |
|-----|------|------|-------------|
| 7 | UE | 0x80 | Unencrypted |
| 6 | CP | 0x40 | Compressed (QuickLZ) |
| 5 | NP | 0x20 | New protocol |
| 4 | FR | 0x10 | Fragmented |
| 3-0 | Type | 0x0F | Packet type (0-8) |
### 4.3 Error Codes
| Code | Name | Description |
|------|------|-------------|
| 0x0000 | ok | Success |
| 0x0200 | client_invalid_id | Invalid client ID |
| 0x0201 | client_nickname_inuse | Nickname already in use |
| 0x0208 | client_invalid_password | Wrong password |
| 0x0300 | channel_invalid_id | Invalid channel ID |
| 0x0400 | server_invalid_id | Invalid server ID |
| 0x0403 | server_maxclients_reached | Server full |
| 0x0701 | connection_lost | Connection lost |
---
## 5. Test Design
### 5.1 Test Cases (32 total)
#### Protocol Tests (14)
1. `test_packet_type_conversion` - PacketType enum conversion
2. `test_flags` - Flag bit manipulation
3. `test_header_c2s` - C2S header parsing
4. `test_header_s2c` - S2C header parsing
5. `test_in_packet_parse` - Input packet parsing
6. `test_out_packet` - Output packet creation
7. `test_command_parse` - Command string parsing
8. `test_command_serialize` - Command serialization
9. `test_command_builder` - CommandBuilder pattern
10. `test_escape_sequences` - Escape/unescape
11. `test_init_packet_parse` - Init packet parsing
12. `test_init_packet_serialize` - Init packet serialization
13. `test_ack_packet` - Acknowledgement packet
14. `test_packet_type_properties` - Type property queries
#### Crypto Tests (12)
1. `test_sha1` - SHA-1 hash
2. `test_sha256` - SHA-256 hash
3. `test_sha512` - SHA-512 hash
4. `test_hash_password` - Password hashing
5. `test_create_key_nonce` - Key derivation
6. `test_create_encryption_key` - Packet-specific key
7. `test_shared_secret_old` - Old protocol shared secret
8. `test_shared_secret_new` - New protocol shared secret
9. `test_key_cache` - Key caching
10. `test_eax_encrypt_decrypt` - EAX encryption/decryption
11. `test_fake_encrypt_decrypt` - Fake encryption
12. `test_hash_cash_level` - Hash Cash computation
13. `test_compute_uid` - UID computation
#### Connection Tests (6)
1. `test_encode_version` - Version encoding
2. `test_rsa_puzzle` - RSA puzzle solver
3. `test_resend_manager` - Retransmission manager
4. `test_rtt_estimator` - RTT estimation
5. `test_sent_packet_retry` - Packet retry logic
---
## 6. References
1. TS3 Protocol Paper: `refercence/tsdeclarations/ts3protocol.md`
2. Packet Definitions: `refercence/tsdeclarations/Packets.txt`
3. Message Definitions: `refercence/tsdeclarations/Messages.toml`
4. Source Code: `src/` (4780 lines, 39 Rust files)
docs/SRS.md
+322
View File
@@ -0,0 +1,322 @@
# Software Requirements Specification (SRS)
# ReTeamSpeak - Cross-Platform TeamSpeak Client
**Version**: 1.0.0
**Date**: 2026-05-12
**Status**: Based on actual implementation
---
## 1. Introduction
### 1.1 Purpose
ReTeamSpeak is a cross-platform TeamSpeak 3 voice communication client supporting Windows, macOS, Linux, iOS, and Android. This document specifies the software requirements based on the implemented system.
### 1.2 Scope
The system implements:
- TeamSpeak 3 protocol (UDP-based, encrypted voice/text communication)
- Cross-platform UI via Tauri v2 + React
- Audio engine with Opus codec
- Local data storage (SQLite)
- Identity and bookmark management
### 1.3 Definitions
| Term | Definition |
|------|-----------|
| TS3 | TeamSpeak 3 protocol |
| EAX | AES-128-CTR with OMAC encryption mode |
| ECDH | Elliptic Curve Diffie-Hellman key exchange |
| Opus | Audio codec used for voice transmission |
| VAD | Voice Activity Detection |
| PTT | Push-To-Talk |
---
## 2. System Requirements
### 2.1 Functional Requirements
#### FR-01: Connection Management
- **FR-01.1**: Connect to TS3 servers via UDP
- **FR-01.2**: Support RSA puzzle handshake (DoS protection)
- **FR-01.3**: Support ECDH key exchange (P-256 and Curve25519)
- **FR-01.4**: Support AES-128-EAX encrypted communication
- **FR-01.5**: Support QuickLZ packet compression
- **FR-01.6**: Support packet fragmentation (max 500 bytes)
- **FR-01.7**: Support selective repeat reliable delivery
- **FR-01.8**: Support connection state machine (Disconnected → Connecting → Connected → ChannelListFinished)
#### FR-02: Authentication
- **FR-02.1**: ECC P-256 identity key generation
- **FR-02.2**: Hash Cash level computation (anti-spam)
- **FR-02.3**: Server password authentication (base64(sha1(password)))
- **FR-02.4**: Channel password authentication
- **FR-02.5**: Permission token support
- **FR-02.6**: UID computation (base64(sha1(publicKey)))
#### FR-03: Voice Communication
- **FR-03.1**: Opus codec encoding/decoding (48kHz)
- **FR-03.2**: Voice Activity Detection (VAD)
- **FR-03.3**: Push-To-Talk (PTT) mode
- **FR-03.4**: Per-client volume control
- **FR-03.5**: Whisper support (direct and group)
- **FR-03.6**: Codec types: Speex NB/WB/UWB, CELT, Opus Voice/Music
#### FR-04: Text Messaging
- **FR-04.1**: Server messages
- **FR-04.2**: Channel messages
- **FR-04.3**: Private messages
- **FR-04.4**: BBCode formatting support
- **FR-04.5**: Message history (SQLite storage)
#### FR-05: Channel Management
- **FR-05.1**: Channel tree display
- **FR-05.2**: Channel join/leave
- **FR-05.3**: Channel creation/editing (with permissions)
- **FR-05.4**: Channel subscription
#### FR-06: Client Management
- **FR-06.1**: Online client list
- **FR-06.2**: Client info display
- **FR-06.3**: Server group management
- **FR-06.4**: Channel group management
- **FR-06.5**: Client kick/ban (with permissions)
#### FR-07: Data Storage
- **FR-07.1**: Identity storage (encrypted private keys)
- **FR-07.2**: Server bookmarks
- **FR-07.3**: Chat message history
- **FR-07.4**: Application settings
#### FR-08: File Transfer
- **FR-08.1**: File upload to channels
- **FR-08.2**: File download from channels
- **FR-08.3**: File browsing
- **FR-08.4**: Transfer progress tracking
### 2.2 Non-Functional Requirements
#### NFR-01: Performance
- **NFR-01.1**: Connection establishment < 3 seconds
- **NFR-01.2**: Voice latency < 200ms
- **NFR-01.3**: Message delivery < 100ms
- **NFR-01.4**: Support 1000+ client servers
#### NFR-02: Security
- **NFR-02.1**: AES-128-EAX encryption for all commands
- **NFR-02.2**: ECDH key exchange (forward secrecy)
- **NFR-02.3**: RSA puzzle DoS protection
- **NFR-02.4**: ChaCha20-Poly1305 identity storage encryption
#### NFR-03: Compatibility
- **NFR-03.1**: Windows 10/11
- **NFR-03.2**: macOS 11+
- **NFR-03.3**: Linux (Ubuntu 20.04+, Debian 11+)
- **NFR-03.4**: iOS 15+
- **NFR-03.5**: Android 10+
- **NFR-03.6**: TS3 server versions 3.0.x and 3.1.x
#### NFR-04: Reliability
- **NFR-04.1**: Automatic reconnection on temporary disconnect
- **NFR-04.2**: Packet retransmission with exponential backoff
- **NFR-04.3**: Connection timeout detection (30 seconds)
- **NFR-04.4**: Graceful degradation on packet loss
---
## 3. System Architecture
### 3.1 Module Structure
```
src/
├── shared/ # Shared types (Client, Channel, Server, Events)
├── tscore/ # Protocol core (packets, crypto, connection)
├── tsaudio/ # Audio engine (capture, playback, codec)
├── tsdb/ # Database (SQLite via rusqlite)
└── tauri-app/ # Application shell
├── src-tauri/ # Rust backend (Tauri commands)
└── frontend/ # React frontend (TypeScript)
```
### 3.2 Technology Stack
| Layer | Technology |
|-------|-----------|
| Language | Rust 1.70+, TypeScript 5.x |
| Desktop Framework | Tauri v2 |
| Frontend | React 18, Vite 5 |
| Async Runtime | Tokio |
| Actor Framework | Actix |
| Database | SQLite (rusqlite) |
| Audio | Opus, cpal |
| Crypto | AES-EAX, P-256, Curve25519, SHA-256/512 |
---
## 4. Protocol Specification
### 4.1 Packet Format
```
C2S: [MAC:8][PId:2][CId:2][PT:1][Data:≤487]
S2C: [MAC:8][PId:2][PT:1][Data:≤489]
```
### 4.2 Packet Types
| Type | Value | Encrypted | Reliable | Fragmentable |
|------|-------|-----------|----------|--------------|
| Voice | 0x00 | Optional | No | No |
| VoiceWhisper | 0x01 | Optional | No | No |
| Command | 0x02 | Yes | Yes | Yes |
| CommandLow | 0x03 | Yes | Yes | Yes |
| Ping | 0x04 | No | No | No |
| Pong | 0x05 | No | No | No |
| Ack | 0x06 | Yes | Yes | No |
| AckLow | 0x07 | Yes | Yes | No |
| Init | 0x08 | No | Yes | No |
### 4.3 Handshake Sequence
```
Client → Server: Init0 (version, timestamp, random0)
Server → Client: Init1 (random1, random0_r)
Client → Server: Init2 (version, random1, random0_r)
Server → Client: Init3 (x, n, level, random2) [RSA puzzle]
Client → Server: Init4 (x, n, level, random2, y, clientinitiv)
Server → Client: initivexpand2 (beta, omega, proof, license)
Client → Server: clientek (ek, proof)
Server → Client: initserver
Server → Client: channellist...channellistfinished
Server → Client: notifycliententerview...
```
### 4.4 Encryption
- **Algorithm**: AES-128-EAX (AES-128-CTR + OMAC)
- **Key derivation**: SHA-256(direction | type | generation_id | shared_iv)
- **Shared IV**: SHA-512(ECDH shared secret) XOR alpha/beta
- **MAC**: 8 bytes (EAX tag)
---
## 5. Data Structures
### 5.1 Core Types (from shared/src/types.rs)
```rust
ClientId(u16) // Client identifier
ChannelId(u64) // Channel identifier
ServerGroupId(u64) // Server group identifier
ClientDbId(u64) // Client database identifier
Uid(String) // Unique identifier (base64)
PermissionId(u32) // Permission identifier
```
### 5.2 Database Schema (from tsdb/src/lib.rs)
```sql
CREATE TABLE identities (
id TEXT PRIMARY KEY,
name TEXT NOT NULL,
private_key TEXT NOT NULL,
counter INTEGER DEFAULT 0,
max_counter INTEGER DEFAULT 0,
created_at TEXT NOT NULL,
updated_at TEXT NOT NULL
);
CREATE TABLE bookmarks (
id TEXT PRIMARY KEY,
name TEXT NOT NULL,
address TEXT NOT NULL,
port INTEGER DEFAULT 9987,
nickname TEXT,
server_password TEXT,
channel TEXT,
channel_password TEXT,
auto_connect INTEGER DEFAULT 0,
last_connected TEXT,
created_at TEXT NOT NULL,
updated_at TEXT NOT NULL
);
CREATE TABLE messages (
id INTEGER PRIMARY KEY AUTOINCREMENT,
server_address TEXT NOT NULL,
invoker_id INTEGER NOT NULL,
invoker_name TEXT NOT NULL,
invoker_uid TEXT NOT NULL,
target_type TEXT NOT NULL,
target_id INTEGER,
message TEXT NOT NULL,
is_read INTEGER DEFAULT 0,
timestamp TEXT NOT NULL
);
CREATE TABLE settings (
key TEXT PRIMARY KEY,
value TEXT NOT NULL,
updated_at TEXT NOT NULL
);
```
---
## 6. Test Results
### 6.1 Unit Tests (32 tests passing)
```
tscore::protocol::tests - 14 tests
✓ test_packet_type_conversion
✓ test_flags
✓ test_header_c2s
✓ test_header_s2c
✓ test_in_packet_parse
✓ test_out_packet
✓ test_command_parse
✓ test_command_serialize
✓ test_command_builder
✓ test_escape_sequences
✓ test_init_packet_parse
✓ test_init_packet_serialize
✓ test_ack_packet
✓ test_packet_type_properties
tscore::crypto::tests - 12 tests
✓ test_sha1, test_sha256, test_sha512
✓ test_hash_password
✓ test_create_key_nonce
✓ test_create_encryption_key
✓ test_shared_secret_old, test_shared_secret_new
✓ test_key_cache
✓ test_eax_encrypt_decrypt
✓ test_fake_encrypt_decrypt
✓ test_hash_cash_level
✓ test_compute_uid
tscore::connection::tests - 6 tests
✓ test_encode_version
✓ test_rsa_puzzle
✓ test_resend_manager
✓ test_rtt_estimator
✓ test_sent_packet_retry
```
---
## 7. Constraints
### 7.1 Technical Constraints
- Rust edition 2021
- Tauri v2 for desktop/mobile
- Must maintain TS3 protocol compatibility
- UDP transport only (no TCP fallback)
### 7.2 Legal Constraints
- TeamSpeak is a trademark of TeamSpeak Systems GmbH
- Implementation is for educational/research purposes
- No server-side code (client-only)
---
## 8. References
1. TS3 Protocol Paper (`refercence/tsdeclarations/ts3protocol.md`)
2. Packet Definitions (`refercence/tsdeclarations/Packets.txt`)
3. Message Definitions (`refercence/tsdeclarations/Messages.toml`)
4. tsclientlib implementation (`refercence/tsclientlib/`)
5. Qint implementation (`refercence/Qint/`)
docs/architecture.md
+401
View File
@@ -0,0 +1,401 @@
# 系统架构设计文档 (SAD)
## 1. 概述
本文档描述 TeamSpeak 3 客户端系统的整体架构设计，基于对参考代码库（tsclientlib、Qint、SimpleBot、ts3stats）的分析结果。
## 2. 系统架构图
```
+-----------------------------------------------------------------------+
| 前端层 (Frontend) |
| |
| +-----------+ +----------+ +--------+ +------+ +-----+ +-----+ |
| | 连接对话框 | | 聊天视图 | | 频道树 | | 面板 | |文件 | |插件 | |
| +-----------+ +----------+ +--------+ +------+ +-----+ +-----+ |
| |
| +---------------------------+ +--------------------------+ |
| | 连接状态管理 | | 数据状态镜像 | |
| +---------------------------+ +--------------------------+ |
| |
| +------------------------------------------------------------------+ |
| | 后端抽象层 (Backend Abstraction) | |
| | IBackend <--- TauriBackend / BrowserBackend ---> | |
| +------------------------------------------------------------------+ |
+-----------------------------------------------------------------------+
| Tauri: IPC (invoke + event) | Browser: WebSocket + HTTP
v v
+-----------------------------------------------------------------------+
| 壳层 (Shell Layer) |
| |
| 桌面壳 (Tauri) Web壳 (Actix-web) |
| +---------------------+ +------------------------+ |
| | 命令处理器 | | REST/WebSocket 端点 | |
| | 窗口桥接器 | | GraphQL 端点 | |
| +---------------------+ +------------------------+ |
| | 核心协调器 | | WebSocket 处理器 | |
| | 文件传输管理器 | +------------------------+ |
| +---------------------+ |
+-----------------------------------------------------------------------+
| |
| 共享依赖 |
v v
+-----------------------------------------------------------------------+
| 代理库 (Proxy Library) - 核心业务逻辑 |
| |
| +---------------------+ +--------------------+ +----------------+ |
| | 全局状态管理 | | 连接管理器 | | 数据库管理器 | |
| | (QintState) | | (QintConnection) | | (DbHandler) | |
| +---------------------+ +--------------------+ +----------------+ |
| +--------------------+ +----------------+ |
| | 音频管道 | | 工具组件 | |
| | AudioToTs | | 文件缓存 | |
| | TsToAudio | | 链接预览 | |
| +--------------------+ | 全文搜索 | |
| | 热键管理 | |
| | 身份加密 | |
| +----------------+ |
+-----------------------------------------------------------------------+
|
| 依赖
v
+-----------------------------------------------------------------------+
| 代码生成层 (proxy-codegen) |
| |
| build.rs 读取 tsproto-structs -> 生成: |
| - Rust: JsEvent, JsProperty, JsM2B, convert_event() 等 |
| - TypeScript: book_events.ts (PropertyId, PropertyValue, OChange) |
+-----------------------------------------------------------------------+
|
v
+-----------------------------------------------------------------------+
| TeamSpeak 协议库 (tsclientlib / tsproto) |
| - TeamSpeak 协议实现 |
| - 连接管理、状态维护、音频编解码 |
| - 事件系统（属性变更、消息、音频） |
+-----------------------------------------------------------------------+
```
## 3. 分层架构
### 3.1 前端层 (Frontend Layer)
**职责**: 用户界面展示和用户交互处理
**技术栈**: Svelte 5 + TypeScript + Rsbuild
**主要组件**:
- **连接对话框**: 服务器连接配置界面
- **聊天视图**: 文本消息收发界面
- **频道树**: 频道和客户端树状视图
- **面板**: 设置、文件浏览器等侧边面板
- **插件系统**: 动态加载的插件模块
**关键特性**:
- 响应式状态管理 (Svelte stores)
- 跨平台兼容 (Tauri/Web)
- 实时事件更新
### 3.2 壳层 (Shell Layer)
**职责**: 平台特定的传输适配和系统集成
**两种实现**:
#### 3.2.1 桌面壳 (Tauri Desktop)
- **技术栈**: Rust + Tauri v2
- **职责**:
- 原生窗口管理
- 系统托盘集成
- 文件对话框
- 全局热键
- IPC 通信 (invoke + event)
#### 3.2.2 Web 壳 (Actix-web Server)
- **技术栈**: Rust + Actix-web
- **职责**:
- HTTP REST 端点
- WebSocket 通信
- GraphQL 查询端点
- 静态文件服务
### 3.3 代理层 (Proxy Layer)
**职责**: 核心业务逻辑，平台无关
**技术栈**: Rust + Actix actor 模型
**主要组件**:
#### 3.3.1 QintState (全局状态管理)
- 连接映射管理
- 音频数据管理
- 热键配置
- 设置管理
- 文件缓存
- 链接预览
- 全文搜索索引
#### 3.3.2 QintConnection (连接管理器)
- TeamSpeak 服务器连接生命周期
- 事件处理和分发
- 消息路由
- 音频路由
- 文件传输管理
#### 3.3.3 DbHandler (数据库管理器)
- SQLite/Diesel ORM
- 身份管理
- 服务器/书签管理
- 聊天消息存储
- GraphQL 查询支持
#### 3.3.4 音频管道
- **AudioToTs**: 麦克风采集 → Opus 编码 → 发送到服务器
- **TsToAudio**: 接收服务器音频 → Opus 解码 → 混音 → 播放
- 支持 SDL2 (桌面) 和 Oboe (Android) 后端
### 3.4 代码生成层 (Code Generation Layer)
**职责**: 从协议定义自动生成类型安全的代码
**输入**: tsproto-structs 的 TOML/CSV 声明文件
**输出**:
- Rust 类型 (JsEvent, JsProperty, JsM2B 等)
- TypeScript 类型 (book_events.ts)
- 事件转换函数
- 消息序列化/反序列化代码
### 3.5 协议库层 (Protocol Library Layer)
**职责**: TeamSpeak 3 协议的底层实现
**主要组件**:
#### 3.5.1 tsclientlib (高层客户端库)
- 连接配置和构建
- 状态同步
- 音频处理
- 地址解析 (IP/DNS SRV/TSDNS)
#### 3.5.2 tsproto (协议引擎)
- UDP 数据包处理
- 加密/解密 (AES-128-EAX)
- 压缩/解压 (QuickLZ)
- 可靠传输 (CUBIC 拥塞控制)
- 连接握手
#### 3.5.3 ts-bookkeeping (状态管理)
- 服务器状态维护
- 客户端/频道/组数据
- 事件生成
#### 3.5.4 tsproto-packets (包解析)
- 数据包格式定义
- 命令解析器
- 零拷贝解析
## 4. 设计模式
### 4.1 Actor 模型
- 使用 Actix 框架实现并发隔离
- 每个 TeamSpeak 连接是独立的 Actor
- 通过消息传递进行通信
### 4.2 桥接模式
- `AppToFrontendBridge` trait 解耦核心逻辑和传输层
- 两种实现: WindowBridge (Tauri) 和 WsBridge (Web)
### 4.3 策略模式
- 前端的 `IBackend` 接口
- 两种实现: TauriBackend 和 BrowserBackend
### 4.4 代码生成模式
- 从声明式 TOML/CSV 生成重复代码
- 确保类型安全和一致性
### 4.5 状态机模式
- 连接状态管理 (Uninitialized → Connecting → Connected → Disconnected)
### 4.6 观察者模式
- Svelte stores 实现响应式状态传播
- 事件系统实现组件间通信
## 5. 数据流
### 5.1 入站数据流 (服务器 → 应用)
```
UDP Socket
↓
Connection::poll_incoming_udp_packet()
↓
PacketCodec::handle_udp_packet()
├── 解密 (AES-128-EAX)
├── 重组分片
├── 解压 (QuickLZ)
└── 生成 StreamItem
├── Command → InCommandBuf
├── Audio → InAudioBuf
└── Ack → 更新发送队列
↓
Client::handle_command()
↓
Connection (tsclientlib)::poll_next()
├── 解析为 InMessage
├── 应用到 data::Connection 状态
├── 生成 events::Event
└── 返回 StreamItem::BookEvents
```
### 5.2 出站数据流 (应用 → 服务器)
```
应用层调用
↓
OutCommandExt::send_with_result()
↓
Connection::send_command_with_result()
├── 添加 return_code
├── 更新本地状态
↓
client::Client::send_packet()
↓
PacketCodec::encode_packet()
├── 压缩 + 分片 (QuickLZ)
├── 加密 (AES-128-EAX)
└── 分配 packet_id
↓
Resender::send_packet()
├── 加入发送队列
└── CUBIC 拥塞控制
↓
UDP Socket 发送
```
### 5.3 音频数据流
```
麦克风 → AudioToTs (Actor)
├── VAD 检测
├── 响度测量
├── Opus 编码
└── 发送到服务器
服务器 → tsclientlib::Connection
├── AudioData::S2C
└── TsToAudio (Actor)
├── Opus 解码
├── 每客户端音量
├── 混音
├── 噪声抑制
└── SDL2/Oboe 输出
```
## 6. 关键接口
### 6.1 AppToFrontendBridge
```rust
pub trait AppToFrontendBridge {
fn send(&self, msg: &MessageP2F);
fn close(&self);
}
```
### 6.2 MessageF2P / MessageP2F
```rust
// 前端 → 代理
pub enum MessageF2P {
Connect(ConnectOptions),
Disconnect(DisconnectOptions),
SendMessage { target, message, return_code },
SetClientVolume { client, volume },
SetWhispering(Option<WhisperData>),
Change { change: JsM2B, return_code },
}
// 代理 → 前端
pub enum MessageP2F {
Error(String),
Connected { server, own_client },
DisconnectedTemporarily(),
TalkersChanged(Vec<(String, bool)>),
Events(Vec<JsEvent>),
Message(JsInMessage),
Loudnesses(HashMap<String, f32>),
Result(ResultStruct),
}
```
### 6.3 IBackend / IBackendConnection
```typescript
interface IBackend {
createNewConnection(returnCodes: ReturnCodeTracker): IBackendConnection;
graphql<T>(query: string, variables?: Record<string, unknown>): Promise<{data: T}>;
get_settings(): Promise<Record<string, unknown>>;
set_settings(diff: Record<string, unknown>): Promise<void>;
}
interface IBackendConnection {
id: string;
connect(onMsg, onError, onClose): Promise<void>;
send(data: OutMsg): void;
close(): void;
fetch_image(req: IFileRequest): Promise<string | undefined>;
upload_bytes(req: IFileRequest, data: Blob): Promise<TransferResult>;
}
```
## 7. 平台适配
| 功能 | 桌面 (Tauri) | Web (Browser) | Android |
|------|-------------|---------------|---------|
| 音频后端 | SDL2 | N/A | Oboe |
| TLS | OpenSSL | N/A | rustls |
| 文件对话框 | Tauri 插件 | HTML input | Tauri |
| 系统托盘 | Tauri tray-icon | N/A | N/A |
| 全局热键 | livesplit-hotkey | N/A | N/A |
## 8. 依赖关系
```
src-tauri ──────depends on──────> qint-proxy ──────depends on──────> tsclientlib
│ │ │
└──depends on──> proxy-codegen ────┘ tsproto
│ │ tsproto-packets
└──depends on──> tauri v2 └──depends on──> diesel (SQLite) tsproto-types
└──depends on──> audiopus/opus
└──depends on──> sdl2/oboe
└──depends on──> tantivy (search)
└──depends on──> juniper (GraphQL)
webapp ──────depends on──────> qint-proxy (same as above)
│
└──depends on──> actix-web
└──depends on──> proxy-codegen
```
## 9. 关键技术决策
| 决策 | 选择 | 理由 |
|------|------|------|
| 异步运行时 | Tokio | Rust 生态最成熟的异步运行时 |
| Actor 框架 | Actix | 成熟的 Actor 模型实现 |
| 加密 | AES-128-EAX + ECDH | TeamSpeak 协议规范要求 |
| 压缩 | QuickLZ | TeamSpeak 协议使用的压缩算法 |
| 拥塞控制 | CUBIC | 类似 TCP CUBIC，适合实时通信 |
| 代码生成 | t4rust-derive | 从声明式数据生成大量重复代码 |
| 音频编解码 | Opus | TeamSpeak 3 默认编解码器 |
| 数据库 | SQLite + Diesel | 轻量级嵌入式数据库 + 类型安全 ORM |
| 前端框架 | Svelte 5 | 轻量级响应式框架 |
| 桌面框架 | Tauri v2 | 跨平台原生桌面应用 |
| Web 框架 | Actix-web | 高性能 Rust Web 框架 |
## 10. 安全考虑
1. **身份加密**: 使用 ChaCha20-Poly1305 加密存储身份私钥
2. **传输加密**: 使用 AES-128-EAX 加密所有命令和语音数据
3. **密钥交换**: 使用 ECDH (prime256v1) 进行密钥交换
4. **防 DoS**: 使用 RSA 拼图防止连接洪水攻击
5. **身份验证**: 使用 Hashcash 机制防止身份伪造
docs/components.md
+713
View File
@@ -0,0 +1,713 @@
# 组件设计文档 (SDD)
## 1. 概述
本文档详细描述系统各组件的设计，包括功能、接口、数据结构和实现细节。
## 2. 核心组件
### 2.1 协议库组件 (tsclientlib)
#### 2.1.1 tsproto-types (基础类型)
**职责**: 定义 TeamSpeak 协议中使用的基础类型、枚举和加密原语
**关键类型**:
```rust
pub struct ClientId(pub u16); // 客户端 ID
pub struct ChannelId(pub u64); // 频道 ID
pub struct UidBuf(pub Vec<u8>); // 用户唯一标识
pub struct Permission(pub u32); // 权限 ID
pub enum ClientType { Normal, Query { admin: bool } }
pub enum MaxClients { Unlimited, Inherited, Limited(u16) }
```
**加密模块**:
```rust
pub struct EccKeyPubP256(p256::PublicKey); // P-256 公钥
pub struct EccKeyPrivP256(p256::SecretKey); // P-256 私钥
pub struct EccKeyPubEd25519(CompressedEdwardsY); // Ed25519 公钥
pub struct EccKeyPrivEd25519(Scalar); // Ed25519 私钥
```
**错误码枚举**: 从 CSV 自动生成，包含所有 TeamSpeak 错误码
#### 2.1.2 tsproto-structs (声明式数据)
**职责**: 提供协议的机器可读声明数据
**声明文件**:
- `Book.toml` - 服务器状态数据模型
- `Messages.toml` - 协议消息结构
- `Enums.toml` - 枚举定义
- `Errors.csv` - 错误码列表
- `Versions.csv` - 版本信息
#### 2.1.3 tsproto-packets (包解析)
**职责**: 解析和序列化 TeamSpeak 网络包和命令
**关键类型**:
```rust
pub enum PacketType { Voice, VoiceWhisper, Command, CommandLow, Ping, Pong, Ack, AckLow, Init }
pub enum Direction { S2C, C2S }
// 输入包（零拷贝）
pub struct InPacket<'a> { header: InHeader<'a>, content: &'a [u8] }
pub struct InCommand<'a> { packet: InPacket<'a> }
pub struct InAudio<'a> { packet: InPacket<'a>, data: AudioData<'a> }
// 输出包
pub struct OutPacket { dir: Direction, data: Vec<u8> }
pub struct OutCommand(pub OutPacket);
```
**命令解析器**:
```rust
pub struct CommandParser<'a> { data: &'a [u8], index: usize }
pub enum CommandItem<'a> { Argument(CommandArgument<'a>), NextCommand }
```
#### 2.1.4 ts-bookkeeping (状态管理)
**职责**: 维护 TeamSpeak 服务器的完整状态模型
**核心数据模型**:
```rust
pub struct Connection {
pub own_client: ClientId,
pub server: Server,
pub clients: HashMap<ClientId, Client>,
pub channels: HashMap<ChannelId, Channel>,
pub channel_groups: HashMap<ChannelGroupId, ChannelGroup>,
pub server_groups: HashMap<ServerGroupId, ServerGroup>,
}
pub struct Server { /* 名称、版本、最大客户端数、加密模式等 */ }
pub struct Channel { /* 名称、类型、编解码器、权限等 */ }
pub struct Client { /* 名称、频道、静音状态、权限等 */ }
```
**事件系统**:
```rust
pub enum Event {
PropertyAdded { id: PropertyId, invoker: Option<Invoker>, extra: ExtraInfo },
PropertyChanged { id: PropertyId, old: PropertyValue, invoker: Option<Invoker>, extra: ExtraInfo },
PropertyRemoved { id: PropertyId, old: PropertyValue, invoker: Option<Invoker>, extra: ExtraInfo },
Message { target: MessageTarget, invoker: Invoker, message: String },
}
```
#### 2.1.5 tsproto (协议引擎)
**职责**: 实现 TeamSpeak 3 协议的底层网络通信
**核心类型**:
```rust
pub struct Identity {
key: EccKeyPrivP256,
counter: u64, // Hash Cash 计数器
max_counter: u64,
}
pub struct Client {
con: Connection,
pub private_key: EccKeyPrivP256,
}
pub struct Connection {
pub is_client: bool,
pub params: Option<ConnectedParams>,
pub address: SocketAddr,
pub resender: Resender,
pub codec: PacketCodec,
pub udp_socket: Box<dyn Socket + Send>,
}
```
**连接握手流程**:
```
Client Server
│ │
│──── Init0 (version, ts) ────>│
│<─── Init1 (random1) ─────────│
│──── Init2 (random1_r) ──────>│
│<─── Init3 (RSA puzzle) ──────│
│──── Init4 (solve + ECDH) ───>│
│<─── initivexpand2 (license) ─│
│──── clientek (ephemeral key) >│
│<─── initserver ──────────────│
│ (connected) │
```
#### 2.1.6 tsclientlib (高层客户端库)
**职责**: 提供用户友好的客户端 API
**核心类型**:
```rust
pub struct Connection {
state: ConnectionState,
options: ConnectOptions,
stream_items: VecDeque<Result<StreamItem>>,
}
enum ConnectionState {
Connecting(BoxFuture<...>, bool),
IdentityLevelIncreasing { recv, state },
Connected { con: ConnectedConnection, book: data::Connection },
}
pub enum StreamItem {
BookEvents(Vec<events::Event>),
MessageEvent(InMessage),
Audio(InAudioBuf),
IdentityLevelIncreasing(u8),
IdentityLevelIncreased,
DisconnectedTemporarily(TemporaryDisconnectReason),
MessageResult(MessageHandle, Result<(), CommandError>),
FileDownload(...), FileUpload(...), FiletransferFailed(...),
NetworkStatsUpdated,
AudioChange(AudioEvent),
}
```
**地址解析**:
解析优先级：
1. 直接 IP 地址
2. 服务器昵称 (HTTP 查询)
3. DNS SRV 记录
4. TSDNS 服务
5. 系统 DNS 解析
**音频处理**:
```rust
pub struct AudioHandler<Id> {
queues: HashMap<Id, AudioQueue>,
avg_buffer_samples: usize,
}
pub struct AudioQueue {
decoder: Decoder, // Opus 解码器
packet_buffer: VecDeque<QueuePacket>,
decoded_buffer: Vec<f32>,
last_buffer_size_min: SlidingWindowMinimum<u8>,
}
```
### 2.2 客户端组件 (Qint)
#### 2.2.1 前端组件
**连接状态管理 (connection.ts)**:
```typescript
class Connection {
private book: Book;
private backend: IBackendConnection;
private state: ConnectionState;
// 状态机: Uninitialized -> Connecting -> Connected -> ChannelListFinished -> Disconnected
async connect(onMsg, onError, onClose): Promise<void>;
sendMessage(target, message): void;
switchChannel(channelId): void;
startWhispering(whisperData): void;
}
```
**数据状态镜像 (book.ts)**:
```typescript
class Book {
channels: Map<ChannelId, Channel>;
clients: Map<ClientId, Client>;
serverGroups: Map<ServerGroupId, ServerGroup>;
channelGroups: Map<ChannelGroupId, ChannelGroup>;
processEvent(event: InBookChangeMsg): void;
}
```
**后端抽象层 (backend/)**:
```typescript
interface IBackend {
createNewConnection(returnCodes: ReturnCodeTracker): IBackendConnection;
graphql<T>(query: string, variables?: Record<string, unknown>): Promise<{data: T}>;
get_settings(): Promise<Record<string, unknown>>;
set_settings(diff: Record<string, unknown>): Promise<void>;
}
interface IBackendConnection {
id: string;
connect(onMsg, onError, onClose): Promise<void>;
send(data: OutMsg): void;
close(): void;
fetch_image(req: IFileRequest): Promise<string | undefined>;
upload_bytes(req: IFileRequest, data: Blob): Promise<TransferResult>;
}
```
#### 2.2.2 壳层组件
**Tauri 命令处理器 (cmd.rs)**:
```rust
#[command]
async fn create_ws(state: State<'_, QintCore>, window: Window, con: String) -> Result<(), String>
#[command]
async fn pass_ws_msg(state: State<'_, QintCore>, con: String, msg: MessageF2P) -> Result<(), String>
#[command]
async fn db(state: State<'_, QintState>, query: String, variables: String) -> Result<String, String>
```
**WebSocket 处理器 (websocket.rs)**:
```rust
struct Ws {
state: QintState,
id: String,
addr: Addr<QintConnection>,
}
impl Ws {
fn handle_message(&mut self, msg: F2PMsg) {
match msg.cmd {
"create_ws" => { /* 创建连接 */ }
"pass_ws_msg" => { /* 转发消息 */ }
"get_settings" => { /* 获取设置 */ }
_ => { /* 其他命令 */ }
}
}
}
```
#### 2.2.3 代理层组件
**全局状态管理 (QintState)**:
```rust
pub struct QintState {
pub connections: Mutex<HashMap<String, Addr<QintConnection>>>,
pub audio_data: Arc<AudioData>,
pub hotkeys: HotkeyManager,
pub settings: RwLock<Settings>,
pub database: Addr<DbHandler>,
pub graphql_schema: Schema<QueryRoot, MutationRoot, EmptySubscription>,
pub file_cache: FileCache,
pub link_previewer: LinkPreviewer,
pub secret: chacha20poly1305::Key,
pub search_index: SearchIndex,
}
```
**连接管理器 (QintConnection)**:
```rust
pub struct QintConnection {
state: QintState,
id: String,
con: Option<tsclientlib::Connection>,
bridge: Box<dyn AppToFrontendBridge>,
audio_to_ts: Addr<AudioToTs>,
ts_to_audio: Addr<TsToAudio>,
database: Addr<DbHandler>,
}
impl Actor for QintConnection {
type Context = Context<Self>;
}
impl Handler<MessageF2PWrapper> for QintConnection {
fn handle(&mut self, msg: MessageF2PWrapper, ctx: &mut Self::Context) {
match msg.0 {
MessageF2P::Connect(options) => { /* 建立连接 */ }
MessageF2P::Disconnect(options) => { /* 断开连接 */ }
MessageF2P::SendMessage { target, message, return_code } => { /* 发送消息 */ }
// ...
}
}
}
```
**数据库管理器 (DbHandler)**:
```rust
pub struct DbHandler {
pool: SqlitePool,
}
impl Actor for DbHandler {
type Context = Context<Self>;
}
impl Handler<GetIdentityAndServerMsg> for DbHandler {
fn handle(&mut self, msg: GetIdentityAndServerMsg, ctx: &mut Self::Context) -> Self::Result {
// 从数据库获取身份和服务器信息
}
}
impl Handler<WriteMessageMsg> for DbHandler {
fn handle(&mut self, msg: WriteMessageMsg, ctx: &mut Self::Context) {
// 写入聊天消息到数据库
}
}
```
**音频管道**:
```rust
// AudioToTs - 麦克风采集和编码
pub struct AudioToTs {
connections: Vec<Addr<QintConnection>>,
encoder: OpusEncoder,
vad: VadDetector,
loudness_meter: LoudnessMeter,
}
impl Handler<SendPacketMsg> for AudioToTs {
fn handle(&mut self, msg: SendPacketMsg, ctx: &mut Self::Context) {
// 编码并发送音频数据
}
}
// TsToAudio - 音频解码和播放
pub struct TsToAudio {
queues: HashMap<String, AudioQueue>,
output_device: AudioDevice,
}
impl Handler<PlayMsg> for TsToAudio {
fn handle(&mut self, msg: PlayMsg, ctx: &mut Self::Context) {
// 解码并播放音频
}
}
```
### 2.3 机器人组件 (SimpleBot)
**核心结构**:
```rust
pub struct Bot {
base_dir: PathBuf,
settings_path: PathBuf,
actions: ActionList,
settings: Settings,
rate_limiting: Vec<Instant>,
list: Vec<String>,
should_reload: Cell<bool>,
}
```
**动作系统**:
```rust
pub struct ActionDefinition {
contains: Option<String>,
regex: Option<String>,
chat: Option<String>,
response: Option<String>,
command: Option<String>,
shell: Option<String>,
}
pub struct Action {
matchers: Vec<Matcher>,
reaction: Option<Reaction>,
}
pub enum Matcher {
Regex(Regex),
Mode(Option<TextMessageTargetMode>),
}
pub enum Reaction {
Plain(String),
Command(String),
Shell(String),
Function(ReactionFunction),
}
```
**配置系统**:
```rust
pub struct Settings {
key_file: String,
dynamic_actions: String,
address: String,
channel: Option<ChannelDefinition>,
name: String,
disconnect_message: String,
rate_limit: u8,
prefix: String,
actions: ActionFile,
}
pub struct ActionFile {
include: Vec<String>,
on_message: Vec<ActionDefinition>,
}
```
### 2.4 统计工具组件 (ts3stats)
**核心类**:
```python
class DiagramCreator:
env: jinja2.Environment
diagramTemplate: jinja2.Template
htmlTemplate: jinja2.Template
users: dict[int, User]
vip: list[User]
tabs: list[Tab]
def load_meta(self): pass
def load_data(self): pass
def create_diagrams(self): pass
def fun_per_connected_slot(self, users, callback): pass
class User:
name: str
lastConnected: list[datetime]
connections: list[Connection]
botPlays: list[tuple]
botCommands: list[tuple]
class Connection:
start: datetime
end: datetime
timeout: bool
class Diagram:
filename: str
title: str
plots: list[str]
def render(self): pass
class Tab:
name: str
diagrams: list[Diagram]
```
**插件架构**:
每个 `diags/*.py` 文件暴露一个函数：
```python
def create_diag(dc: DiagramCreator) -> None
```
**配置系统**:
```python
# Settings.py
vips = ["MyName", "friend42"]
merges = [["MyName", "MyNameLaptop"]]
maxUsers = 50
botStats = True
inputFolder = "Logs"
outputFolder = "Result"
```
## 3. 接口设计
### 3.1 Tauri IPC 接口
| 命令 | 参数 | 返回值 | 说明 |
|------|------|--------|------|
| `create_ws` | `con: String` | `()` | 创建 WebSocket 连接 |
| `close_ws` | `con: String` | `()` | 关闭 WebSocket 连接 |
| `pass_ws_msg` | `con: String, msg: MessageF2P` | `()` | 转发前端消息 |
| `db` | `query: String, variables: String` | `String` | GraphQL 查询 |
| `get_settings` | | `Record<string, unknown>` | 获取设置 |
| `set_settings` | `diff: Record<string, unknown>` | `()` | 更新设置 |
### 3.2 WebSocket 协议
**前端发送**:
```json
{"cmd": "create_ws", "returnCode": "0", "args": {"con": "uuid"}}
{"cmd": "pass_ws_msg", "returnCode": "1", "args": {"con": "uuid", "msg": {"Connect": {...}}}}
{"cmd": "get_settings", "returnCode": "2", "args": {}}
```
**后端发送**:
```json
{"cmd": "resp", "returnCode": "2", "msg": {...}}
{"cmd": "resp_err", "returnCode": "1", "msg": "error"}
{"cmd": "ws", "con": "uuid", "msg": {"Connected": {...}}}
{"cmd": "ws_close", "con": "uuid"}
{"cmd": "loudness", "msg": [0.5, 0.3]}
```
### 3.3 GraphQL 查询
```graphql
type Query {
bookmarks: [Bookmark!]!
servers: [Server!]!
channels(serverId: ID!): [Channel!]!
clients(serverId: ID!): [Client!]!
identities: [Identity!]!
chats(serverId: ID!): [Chat!]!
messages(chatId: ID!, limit: Int): [Message!]!
}
type Mutation {
updateIdentity(id: ID!, input: IdentityInput!): Identity!
updateBookmark(id: ID!, input: BookmarkInput!): Bookmark!
}
```
## 4. 数据流
### 4.1 连接建立流程
```
前端 代理 TeamSpeak 服务器
│ │ │
│── Connect(addr, name) ───>│ │
│ │── GetIdentityAndServerMsg ────> DbHandler
│ │<── (identity, server) ──────────│
│ │── Connection::build().connect ─>│
│ │ │
│ │<── TsStreamItem::BookEvents ────│
│ │ (PropertyAdded: Server) │
│ │ │
│<── Connected {server, own} │ │
│ │── ConnectedMsg ────────────────> DbHandler
│ │ │
│<── Events [PropertyAdded..]│ │
```
### 4.2 消息发送流程
```
前端 代理 TeamSpeak 服务器
│ │ │
│── SendMessage {target, msg}│ │
│ │── state.send_message(target) ──>│
│ │── WriteMessageMsg ─────────────> DbHandler
│ │ │
│ │<── InMessage (from other) ──────│
│ │── JsInMessage ─────────────────>│
│<── Message(JsInMessage) ──│ │
│ │── WriteMessageMsg ─────────────> DbHandler
```
### 4.3 音频流程
```
麦克风 → AudioToTs (Actor)
├── VAD 检测
├── 响度测量
├── Opus 编码
└── 发送到服务器
服务器 → tsclientlib::Connection
├── AudioData::S2C
└── TsToAudio (Actor)
├── Opus 解码
├── 每客户端音量
├── 混音
├── 噪声抑制
└── SDL2/Oboe 输出
```
## 5. 错误处理
### 5.1 协议错误
```rust
pub enum CommandError {
TsError(Ts3ErrorCode),
ConnectionClosed,
Timeout,
InvalidResponse,
// ...
}
```
### 5.2 连接错误
```rust
pub enum TemporaryDisconnectReason {
Timeout,
ServerShutdown,
ConnectionLost,
// ...
}
```
### 5.3 前端错误
```typescript
interface ErrorMessage {
type: "error";
message: string;
code?: string;
}
```
## 6. 配置管理
### 6.1 应用配置
```rust
pub struct Settings {
pub name: String,
pub away: Option<String>,
pub input_muted: bool,
pub output_muted: bool,
pub hotkeys: Vec<HotkeyAction>,
pub client_volumes: HashMap<String, f32>,
pub theme: String,
pub language: String,
}
```
### 6.2 连接配置
```rust
pub struct ConnectOptions {
address: ServerAddress,
local_address: Option<SocketAddr>,
identity: Option<Identity>,
server: Option<UidBuf>,
name: String,
version: Version,
channel: Option<String>,
channel_password: Option<String>,
server_password: Option<String>,
default_token: Option<String>,
}
```
## 7. 性能考虑
### 7.1 音频处理
- Opus 编码/解码使用硬件加速（如果可用）
- 自适应抖动缓冲减少延迟
- 噪声抑制减少带宽使用
### 7.2 状态同步
- 增量更新减少数据传输
- 事件批处理减少 IPC 调用
- 懒加载减少初始加载时间
### 7.3 数据库
- SQLite WAL 模式支持并发读取
- 连接池减少连接开销
- 索引优化查询性能
## 8. 安全设计
### 8.1 身份加密
```rust
// ChaCha20-Poly1305 加密身份私钥
fn encrypt_identity(key: &[u8; 32], identity: &[u8]) -> Vec<u8> {
let cipher = ChaCha20Poly1305::new(key.into());
let nonce = generate_nonce();
cipher.encrypt(&nonce, identity)
}
```
### 8.2 传输加密
- 所有命令和语音数据使用 AES-128-EAX 加密
- ECDH 密钥交换确保前向保密
- RSA 拼图防止 DoS 攻击
### 8.3 输入验证
- 所有用户输入进行验证和转义
- SQL 查询使用参数化语句
- WebSocket 消息进行 JSON 验证
docs/protocol.md
+417
View File
@@ -0,0 +1,417 @@
# TeamSpeak 3 协议分析
## 概述
TeamSpeak 3 使用基于 UDP 的自定义协议进行通信。协议设计支持加密、压缩和可靠传输。
## 协议层次
```
应用层 (Commands/Notifications)
↓
消息层 (Messages)
↓
数据包层 (Packets)
↓
传输层 (UDP)
```
## 1. 数据包结构
### 1.1 数据包头
**客户端 → 服务器**:
```
+--+--+--+--+--+--+--+--+--+--+--+--+--+---------//----------+
| MAC | PId | CId |PT| Data |
+--+--+--+--+--+--+--+--+--+--+--+--+--+---------//----------+
| \ Meta |
\ Header /
```
**服务器 → 客户端**:
```
+--+--+--+--+--+--+--+--+--+--+--+------------//-------------+
| MAC | PId |PT| Data |
+--+--+--+--+--+--+--+--+--+--+--+------------//-------------+
| \ Meta |
\ Header /
```
| 字段 | 大小 | 类型 | 说明 |
|------|------|------|------|
| MAC | 8 字节 | [u8] | EAX 消息认证码 |
| PId | 2 字节 | u16 | 数据包 ID |
| CId | 2 字节 | u16 | 客户端 ID (仅客户端→服务器) |
| PT | 1 字节 | u8 | 数据包类型 + 标志 |
| Data | ≤487/489 字节 | [u8] | 数据包负载 |
### 1.2 数据包类型
| 类型 | 值 | 说明 |
|------|-----|------|
| Voice | 0x00 | 语音数据 |
| VoiceWhisper | 0x01 | 私语数据 |
| Command | 0x02 | 命令数据 |
| CommandLow | 0x03 | 低优先级命令 |
| Ping | 0x04 | Ping 包 |
| Pong | 0x05 | Pong 包 |
| Ack | 0x06 | 确认包 |
| AckLow | 0x07 | 低优先级确认 |
| Init1 | 0x08 | 初始化包 |
### 1.3 标志位
```
MSB LSB
+--+--+--+--+--+--+--+--+
|UE|CP|NP|FR| Type |
+--+--+--+--+--+--+--+--+
```
| 标志 | 位 | 说明 |
|------|-----|------|
| UE | 0x80 | 未加密 |
| CP | 0x40 | 已压缩 |
| NP | 0x20 | 新协议 |
| FR | 0x10 | 已分片 |
## 2. 初始化握手
### 2.1 低级握手 (Init1)
握手过程包含 5 个步骤：
1. **Packet 0 (客户端→服务器)**:
- 客户端版本 (4 字节时间戳)
- 步骤号: 0x00
- 当前时间戳 (4 字节)
- 随机数 A0 (4 字节)
- 保留字节 (8 字节)
2. **Packet 1 (服务器→客户端)**:
- 步骤号: 0x01
- 服务器数据 A1 (16 字节)
- A0 反转 (4 字节)
3. **Packet 2 (客户端→服务器)**:
- 客户端版本
- 步骤号: 0x02
- A1 (16 字节)
- A0r (4 字节)
4. **Packet 3 (服务器→客户端)**:
- 步骤号: 0x03
- x (64 字节)
- n (64 字节)
- level (4 字节)
- 服务器数据 A2 (100 字节)
5. **Packet 4 (客户端→服务器)**:
- 客户端版本
- 步骤号: 0x04
- x, n, level
- A2 (100 字节)
- y = x^(2^level) mod n (64 字节)
- clientinitiv 命令
### 2.2 高级握手
#### 2.2.1 clientinitiv (客户端→服务器)
```
clientinitiv alpha={alpha} omega={omega} ot={ot} ip={ip}
```
- `alpha`: 10 随机字节的 base64 编码
- `omega`: ASN.1-DER 编码的 ECDH 公钥
- `ot`: 固定为 1
- `ip`: 服务器 IP 地址
#### 2.2.2 initivexpand/initivexpand2 (服务器→客户端)
**旧协议 (<3.1)**:
```
initivexpand alpha={alpha} beta={beta} omega={omega}
```
**新协议 (≥3.1)**:
```
initivexpand2 l={l} beta={beta} omega={omega} ot={ot} proof={proof} tvd={tvd}
```
#### 2.2.3 共享密钥计算
**旧协议**:
```rust
sharedSecret = ECDH(serverPublicKey, ownPrivateKey)
x = sharedSecret.x.AsByteArray()
sharedData = x[0..32] (填充到 32 字节)
SharedIV = sha1(sharedData)
SharedIV[0..10] ^= alpha.decode64()
SharedIV[10..20] ^= beta.decode64()
SharedMac = sha1(SharedIV)[0..8]
```
**新协议**:
```rust
// 处理许可证链
next_key = public_key * clamp(sha512(block[1..])[0..32]) + parent
// 计算共享密钥
sharedData = next_key * client_private_key
SharedIV = sha512(sharedData[0..32])
SharedIV[0..10] ^= alpha.decode64()
SharedIV[10..64] ^= beta.decode64()
SharedMac = sha1(SharedIV)[0..8]
```
## 3. 加密机制
### 3.1 EAX 模式加密
使用 AES-128-CTR + OMAC (EAX 模式) 加密数据包。
**加密参数生成**:
```rust
temporary[0] = 0x30 (服务器→客户端) 或 0x31 (客户端→服务器)
temporary[1] = PT
temporary[2..6] = PGId (网络字节序)
temporary[6..26] = SIV[0..20] (旧协议) 或 temporary[6..70] = SIV[0..64] (新协议)
keynonce = sha256(temporary)
key = keynonce[0..16]
nonce = keynonce[16..32]
key[0] ^= ((PId & 0xFF00) >> 8)
key[1] ^= ((PId & 0x00FF) >> 0)
```
### 3.2 数据包栈
```
发送 接收
+-----------+ +-----------+
| Data | | Λ | Data |
+-----------+ | | +-----------+
| Compress | | | | Decompress|
+-----------+ | | +-----------+
| Split | | | | Merge |
+-----------+ | | +-----------+
| Encrypt | V | | Decrypt |
+-----------+ +-----------+
```
## 4. 命令协议
### 4.1 命令格式
命令使用类似 TeamSpeak 3 Query 的文本格式，UTF-8 编码。
**示例**:
```
clientinit client_nickname=MyName client_version=3.0.19.3 client_platform=Windows ...
```
### 4.2 消息类型
1. **请求-响应**: 客户端发送命令，服务器返回响应
2. **通知**: 服务器主动推送的事件通知
3. **列表**: 分批返回的列表数据
### 4.3 关键命令
#### 客户端初始化
```
clientinit client_nickname client_version client_platform client_input_hardware client_output_hardware client_default_channel client_default_channel_password client_server_password client_meta_data client_version_sign client_key_offset client_nickname_phonetic client_default_token hwid
```
#### 服务器初始化响应
```
initserver server_name server_platform server_version ...
```
#### 频道列表
```
channellist -topic -flags -limits
channellistfinished
```
#### 客户端进入视图
```
notifycliententerview cfid ctid reasonid clid client_database_id client_nickname ...
```
## 5. 数据结构
### 5.1 客户端数据
| 字段 | 类型 | 说明 |
|------|------|------|
| client_id | ClientId | 客户端 ID |
| client_database_id | ClientDbId | 数据库 ID |
| client_unique_identifier | Uid | 唯一标识符 |
| client_nickname | str | 昵称 |
| client_type | ClientType | 客户端类型 |
| client_servergroups | ServerGroupId | 服务器组 |
| client_channel_group_id | ChannelGroupId | 频道组 |
| client_away | bool | 是否离开 |
| client_away_message | str | 离开消息 |
| client_talk_power | i32 | 说话权限 |
| client_is_talker | bool | 是否有说话权 |
| client_is_priority_speaker | bool | 是否优先发言者 |
| client_is_channel_commander | bool | 是否频道指挥官 |
| client_is_recording | bool | 是否录音中 |
| client_input_muted | bool | 输入是否静音 |
| client_output_muted | bool | 输出是否静音 |
### 5.2 频道数据
| 字段 | 类型 | 说明 |
|------|------|------|
| channel_id | ChannelId | 频道 ID |
| channel_name | str | 频道名称 |
| channel_topic | str | 频道主题 |
| channel_codec | Codec | 编解码器 |
| channel_codec_quality | u8 | 编解码器质量 |
| channel_maxclients | i32 | 最大客户端数 |
| channel_maxfamilyclients | i32 | 最大系列客户端数 |
| channel_flag_permanent | bool | 是否永久频道 |
| channel_flag_semi_permanent | bool | 是否半永久频道 |
| channel_flag_default | bool | 是否默认频道 |
| channel_flag_password | bool | 是否有密码 |
| channel_needed_talk_power | i32 | 所需说话权限 |
| channel_forced_silence | bool | 是否强制静音 |
### 5.3 服务器数据
| 字段 | 类型 | 说明 |
|------|------|------|
| virtualserver_name | str | 服务器名称 |
| virtualserver_platform | str | 平台 |
| virtualserver_version | str | 版本 |
| virtualserver_maxclients | u16 | 最大客户端数 |
| virtualserver_clientsonline | u16 | 在线客户端数 |
| virtualserver_channelsonline | u64 | 频道数 |
| virtualserver_uptime | DurationSeconds | 运行时间 |
| virtualserver_codec_encryption_mode | CodecEncryptionMode | 编解码器加密模式 |
| virtualserver_hostmessage | str | 主机消息 |
| virtualserver_hostmessage_mode | HostMessageMode | 主机消息模式 |
## 6. 错误处理
### 6.1 错误码格式
错误响应格式：
```
error id=0 msg=ok
```
### 6.2 常见错误码
| 错误码 | 名称 | 说明 |
|--------|------|------|
| 0x0000 | ok | 成功 |
| 0x0200 | client_invalid_id | 无效客户端 ID |
| 0x0201 | client_nickname_inuse | 昵称已被使用 |
| 0x0208 | client_invalid_password | 无效密码 |
| 0x0300 | channel_invalid_id | 无效频道 ID |
| 0x0400 | server_invalid_id | 无效服务器 ID |
| 0x0403 | server_maxclients_reached | 服务器已满 |
## 7. 版本兼容性
### 7.1 协议版本
- **旧协议**: <3.1，使用 initivexpand
- **新协议**: ≥3.1，使用 initivexpand2，支持许可证验证
### 7.2 客户端版本
客户端版本使用时间戳格式：
```
3.0.19.3 [Build: 1466672534]
```
版本时间戳计算：
```
version_timestamp = unix_timestamp - 1356998400
```
## 8. 安全机制
### 8.1 RSA 拼图
防止 DoS 攻击的机制：
- 服务器发送 RSA 模数 n、底数 x 和难度 level
- 客户端计算 y = x^(2^level) mod n
- 计算时间随 level 指数增长
### 8.2 Hashcash
身份验证的 hashcash 机制：
```rust
data = sha1(publicKey + keyOffset)
level = count_leading_zero_bits(data)
```
### 8.3 身份识别
客户端唯一标识符计算：
```rust
uid = base64(sha1(publicKey))
```
## 9. 语音传输
### 9.1 编解码器
| 编解码器 | 说明 |
|----------|------|
| SpeexNarrowband | 8kHz, 单声道 |
| SpeexWideband | 16kHz, 单声道 |
| SpeexUltrawideband | 32kHz, 单声道 |
| CeltMono | 48kHz, 单声道 |
| OpusVoice | 48kHz, 单声道, 语音优化 |
| OpusMusic | 48kHz, 立体声, 音乐优化 |
### 9.2 语音包格式
**客户端→服务器**:
```
+--+--+--+---------//---------+
| VId |C | Data |
+--+--+--+---------//---------+
```
**服务器→客户端**:
```
+--+--+--+--+--+---------//---------+
| VId | CId |C | Data |
+--+--+--+--+--+---------//---------+
```
### 9.3 私语
支持两种私语模式：
1. **直接目标**: 指定客户端/频道 ID
2. **组目标**: 指定服务器组/频道组
## 10. 连接管理
### 10.1 心跳
- 服务器定期发送 Ping 包
- 客户端必须回复 Pong 包
- 客户端也应主动发送 Ping 包
### 10.2 可靠传输
- 使用选择性重传机制
- 超时后重传数据包
- 30 秒无响应则断开连接
- 使用指数退避算法避免网络拥塞
### 10.3 数据包 ID 管理
- 每种数据包类型和方向有独立的 ID 计数器
- 客户端有 9 个出站计数器
- ID 从 1 开始，溢出时增加代计数器
- 代计数器用于加密参数生成
docs/protocol_stack.md
+1166
View File
File diff suppressed because it is too large Load Diff
docs/requirements.md
+573
View File
@@ -0,0 +1,573 @@
# 需求分析文档 (SRS)
## 1. 概述
本文档定义 TeamSpeak 3 客户端系统的功能需求和非功能需求，基于对参考代码库的分析和 TeamSpeak 3 协议规范。
## 2. 系统目标
### 2.1 主要目标
1. 实现一个功能完整的 TeamSpeak 3 客户端
2. 支持跨平台运行 (Windows, Linux, macOS, Android, Web)
3. 提供现代化的用户界面
4. 保持与官方 TeamSpeak 服务器的兼容性
5. 支持音频通信和文本聊天
### 2.2 次要目标
1. 支持插件扩展机制
2. 提供统计和分析功能
3. 支持多服务器同时连接
4. 提供机器人开发框架
## 3. 功能需求
### 3.1 连接管理
#### FR-3.1.1 服务器连接
**描述**: 用户能够连接到 TeamSpeak 3 服务器
**需求**:
- 支持通过 IP 地址连接
- 支持通过域名连接
- 支持通过服务器昵称连接
- 支持 DNS SRV 和 TSDNS 解析
- 支持服务器密码验证
- 支持身份选择和管理
- 支持默认频道设置
- 支持频道密码
**输入**:
- 服务器地址 (IP/域名/昵称)
- 服务器密码 (可选)
- 身份 (可选)
- 昵称
- 默认频道 (可选)
- 频道密码 (可选)
**输出**:
- 连接成功/失败状态
- 服务器信息
- 客户端 ID
#### FR-3.1.2 连接状态管理
**描述**: 管理连接的生命周期状态
**状态**:
- Uninitialized: 未初始化
- Connecting: 连接中
- IdentityLevelIncreasing: 身份等级提升中
- Connected: 已连接
- ChannelListFinished: 频道列表接收完成
- DisconnectedTemporarily: 临时断开
- Disconnected: 已断开
- Error: 错误
**需求**:
- 状态转换应有明确的触发条件
- 状态变化应通知前端
- 支持自动重连（临时断开时）
- 支持手动断开连接
#### FR-3.1.3 多服务器连接
**描述**: 支持同时连接多个 TeamSpeak 服务器
**需求**:
- 每个连接独立管理
- 连接间互不影响
- 支持连接切换
- 支持连接列表管理
### 3.2 频道管理
#### FR-3.2.1 频道浏览
**描述**: 浏览服务器的频道结构
**需求**:
- 显示频道树状结构
- 显示频道名称、主题、编解码器
- 显示频道最大客户端数
- 显示频道类型（永久/半永久/临时）
- 显示频道密码状态
- 支持频道搜索
#### FR-3.2.2 频道操作
**描述**: 执行频道相关操作
**需求**:
- 加入频道
- 离开频道
- 创建频道（需要权限）
- 编辑频道（需要权限）
- 删除频道（需要权限）
- 移动频道（需要权限）
- 设置频道密码
- 设置频道排序
#### FR-3.2.3 频道订阅
**描述**: 订阅频道以接收通知
**需求**:
- 订阅频道
- 取消订阅频道
- 接收频道事件通知
- 显示订阅状态
### 3.3 客户端管理
#### FR-3.3.1 客户端列表
**描述**: 显示在线客户端列表
**需求**:
- 显示客户端昵称
- 显示客户端状态（离开/录音/静音等）
- 显示客户端所在频道
- 显示客户端服务器组
- 显示客户端频道组
- 支持客户端搜索
#### FR-3.3.2 客户端操作
**描述**: 执行客户端相关操作
**需求**:
- 发送私聊消息
- 发送戳一戳
- 移动客户端（需要权限）
- 踢出客户端（需要权限）
- 封禁客户端（需要权限）
- 设置客户端音量
- 设置客户端静音
#### FR-3.3.3 客户端信息
**描述**: 查看客户端详细信息
**需求**:
- 显示客户端唯一标识符
- 显示客户端数据库 ID
- 显示客户端版本信息
- 显示客户端平台
- 显示客户端连接信息
- 显示客户端权限
### 3.4 文本聊天
#### FR-3.4.1 消息发送
**描述**: 发送文本消息
**需求**:
- 发送服务器消息
- 发送频道消息
- 发送私聊消息
- 支持 BBCode 格式
- 支持消息历史
- 支持消息撤回（如果服务器支持）
#### FR-3.4.2 消息接收
**描述**: 接收和显示文本消息
**需求**:
- 显示服务器消息
- 显示频道消息
- 显示私聊消息
- 显示系统通知
- 支持消息通知
- 支持消息过滤
#### FR-3.4.3 消息存储
**描述**: 存储聊天历史
**需求**:
- 本地存储消息历史
- 支持消息搜索
- 支持消息导出
- 支持消息清理
### 3.5 音频通信
#### FR-3.5.1 音频输入
**描述**: 捕获和处理麦克风音频
**需求**:
- 支持音频设备选择
- 支持音频编码 (Opus)
- 支持语音活动检测 (VAD)
- 支持推按说话 (PTT)
- 支持输入音量调节
- 支持输入静音
- 支持噪声抑制
- 支持回声消除
#### FR-3.5.2 音频输出
**描述**: 播放接收到的音频
**需求**:
- 支持音频设备选择
- 支持音频解码 (Opus)
- 支持输出音量调节
- 支持输出静音
- 支持每客户端音量
- 支持音频混音
- 支持抖动缓冲
- 支持丢包隐藏
#### FR-3.5.3 音频路由
**描述**: 管理音频数据的路由
**需求**:
- 支持频道音频
- 支持私语
- 支持组私语
- 支持频道指挥官
- 支持优先发言者
- 支持音频编码质量设置
### 3.6 文件传输
#### FR-3.6.1 文件浏览
**描述**: 浏览频道文件
**需求**:
- 显示文件列表
- 显示文件大小
- 显示文件修改时间
- 支持文件搜索
- 支持目录创建
#### FR-3.6.2 文件上传
**描述**: 上传文件到频道
**需求**:
- 支持单文件上传
- 支持多文件上传
- 支持断点续传
- 支持上传进度显示
- 支持上传取消
#### FR-3.6.3 文件下载
**描述**: 下载频道文件
**需求**:
- 支持单文件下载
- 支持多文件下载
- 支持断点续传
- 支持下载进度显示
- 支持下载取消
### 3.7 身份管理
#### FR-3.7.1 身份创建
**描述**: 创建新的 TeamSpeak 身份
**需求**:
- 自动生成 ECC 密钥对
- 支持身份命名
- 支持身份导出
- 支持身份导入
#### FR-3.7.2 身份存储
**描述**: 安全存储身份信息
**需求**:
- 加密存储私钥
- 支持多身份管理
- 支持身份备份
- 支持身份恢复
#### FR-3.7.3 身份验证
**描述**: 使用身份进行验证
**需求**:
- 支持 Hashcash 计算
- 支持身份等级提升
- 支持权限令牌
- 支持身份唯一标识符计算
### 3.8 权限管理
#### FR-3.8.1 权限查看
**描述**: 查看权限信息
**需求**:
- 显示服务器组权限
- 显示频道组权限
- 显示客户端权限
- 显示权限值
- 显示权限描述
#### FR-3.8.2 权限操作
**描述**: 执行权限相关操作
**需求**:
- 添加权限（需要权限）
- 删除权限（需要权限）
- 修改权限（需要权限）
- 添加服务器组客户端
- 删除服务器组客户端
### 3.9 服务器管理
#### FR-3.9.1 服务器信息
**描述**: 查看服务器信息
**需求**:
- 显示服务器名称
- 显示服务器版本
- 显示服务器平台
- 显示在线客户端数
- 显示频道数
- 显示服务器运行时间
- 显示服务器加密模式
#### FR-3.9.2 服务器操作
**描述**: 执行服务器相关操作
**需求**:
- 修改服务器密码（需要权限）
- 修改服务器名称（需要权限）
- 查看服务器日志（需要权限）
- 发送服务器消息（需要权限）
### 3.10 热键管理
#### FR-3.10.1 热键配置
**描述**: 配置全局热键
**需求**:
- 支持输入静音切换
- 支持输出静音切换
- 支持离开状态切换
- 支持推按说话
- 支持自定义热键
#### FR-3.10.2 热键执行
**描述**: 执行热键绑定的操作
**需求**:
- 全局热键支持
- 应用内热键支持
- 热键冲突检测
- 热键状态反馈
### 3.11 设置管理
#### FR-3.11.1 应用设置
**描述**: 管理应用程序设置
**需求**:
- 用户界面设置
- 音频设备设置
- 热键设置
- 通知设置
- 语言设置
- 主题设置
#### FR-3.11.2 连接设置
**描述**: 管理连接相关设置
**需求**:
- 默认昵称
- 默认身份
- 默认频道
- 自动重连设置
- 音频编码设置
### 3.12 插件系统
#### FR-3.12.1 插件加载
**描述**: 加载和管理插件
**需求**:
- 支持动态加载插件
- 支持插件启用/禁用
- 支持插件配置
- 支持插件更新
#### FR-3.12.2 插件接口
**描述**: 提供插件开发接口
**需求**:
- 事件监听接口
- 命令注册接口
- UI 扩展接口
- 数据访问接口
## 4. 非功能需求
### 4.1 性能需求
#### NFR-4.1.1 连接性能
- 连接建立时间 < 3 秒
- 消息延迟 < 100ms
- 音频延迟 < 200ms
- 支持 1000+ 客户端的服务器
#### NFR-4.1.2 资源使用
- CPU 使用率 < 10% (空闲时)
- 内存使用 < 200MB
- 网络带宽 < 1Mbps (语音通信时)
- 磁盘空间 < 100MB (应用程序)
#### NFR-4.1.3 并发性能
- 支持 10+ 同时连接
- 支持 100+ 消息/秒
- 支持 50+ 音频流同时播放
### 4.2 可靠性需求
#### NFR-4.2.1 连接可靠性
- 支持自动重连
- 支持断点续传
- 支持数据包重传
- 支持拥塞控制
#### NFR-4.2.2 数据可靠性
- 消息不丢失
- 文件传输完整性
- 身份数据安全
- 配置数据备份
### 4.3 安全性需求
#### NFR-4.3.1 传输安全
- 使用 AES-128-EAX 加密
- 使用 ECDH 密钥交换
- 支持证书验证
- 防止中间人攻击
#### NFR-4.3.2 数据安全
- 私钥加密存储
- 敏感数据不落盘
- 安全内存处理
- 防止内存泄露
#### NFR-4.3.3 访问控制
- 身份验证
- 权限检查
- 操作审计
- 防止未授权访问
### 4.4 可用性需求
#### NFR-4.4.1 用户界面
- 响应式设计
- 键盘导航支持
- 屏幕阅读器支持
- 高对比度模式
#### NFR-4.4.2 国际化
- 支持多语言
- 支持 RTL 布局
- 支持本地化日期格式
- 支持本地化数字格式
#### NFR-4.4.3 可访问性
- 支持字体大小调整
- 支持颜色主题切换
- 支持快捷键自定义
- 支持语音反馈
### 4.5 可维护性需求
#### NFR-4.5.1 代码质量
- 模块化设计
- 清晰的接口定义
- 完整的文档
- 单元测试覆盖
#### NFR-4.5.2 日志和监控
- 详细的日志记录
- 错误报告机制
- 性能监控
- 使用统计
### 4.6 可扩展性需求
#### NFR-4.6.1 架构扩展
- 支持插件系统
- 支持自定义主题
- 支持自定义命令
- 支持自定义通知
#### NFR-4.6.2 协议扩展
- 支持协议版本协商
- 支持功能特性检测
- 支持向后兼容
- 支持向前兼容
## 5. 约束条件
### 5.1 技术约束
- 使用 Rust 作为主要开发语言
- 使用 Tauri v2 作为桌面框架
- 使用 Svelte 5 作为前端框架
- 使用 Actix 作为 Actor 框架
- 使用 SQLite 作为本地数据库
### 5.2 协议约束
- 兼容 TeamSpeak 3 协议
- 支持 IPv4 和 IPv6
- 使用 UDP 传输
- 最大数据包大小 500 字节
### 5.3 法律约束
- 不得侵犯 TeamSpeak 商标
- 不得用于商业用途（除非获得许可）
- 遵守相关法律法规
- 尊重用户隐私
## 6. 验收标准
### 6.1 功能验收
- 能够连接到官方 TeamSpeak 服务器
- 能够发送和接收文本消息
- 能够进行语音通信
- 能够浏览和管理频道
- 能够管理客户端
### 6.2 性能验收
- 连接建立时间 < 3 秒
- 消息延迟 < 100ms
- 音频延迟 < 200ms
- CPU 使用率 < 10% (空闲时)
### 6.3 安全验收
- 通过安全审计
- 无已知漏洞
- 数据加密存储
- 传输加密验证
### 6.4 兼容性验收
- Windows 10/11 兼容
- Linux (Ubuntu 20.04+) 兼容
- macOS 11+ 兼容
- Android 10+ 兼容
- Chrome/Firefox/Safari 兼容
## 7. 术语表
| 术语 | 定义 |
|------|------|
| TeamSpeak | 一种 VoIP 应用程序，用于语音通信 |
| Channel | 语音/文本通信的房间 |
| Client | 连接到服务器的用户或机器人 |
| Server | TeamSpeak 服务器实例 |
| Identity | 用户的唯一标识符 |
| Permission | 用户的操作权限 |
| Codec | 音频编码格式 |
| Opus | 现代音频编解码器 |
| ECDH | 椭圆曲线 Diffie-Hellman 密钥交换 |
| AES | 高级加密标准 |
| EAX | 认证加密模式 |
| Hashcash | 工作量证明系统 |
| VAD | 语音活动检测 |
| PTT | 推按说话 |
| TSDNS | TeamSpeak DNS 服务 |
| SRV | DNS 服务记录 |
## 8. 参考文献
1. TeamSpeak 3 协议规范 (ts3protocol.md)
2. tsdeclarations 项目文档
3. tsclientlib 项目文档
4. Qint 项目文档
5. SimpleBot 项目文档
6. ts3stats 项目文档
refercence/Qint
Submodule
+1
Submodule refercence/Qint added at 7efe949adf
refercence/SimpleBot
Submodule
+1
Submodule refercence/SimpleBot added at e6c87b850f
refercence/ts3stats
Submodule
+1
Submodule refercence/ts3stats added at d8ee1def43
refercence/tsclientlib
Submodule
+1
Submodule refercence/tsclientlib added at 04aa24917a
refercence/tsdeclarations
Submodule
+1
Submodule refercence/tsdeclarations added at fb4e50d643
src/.gitignore
+39
View File
@@ -0,0 +1,39 @@
# Rust
target/
**/*.rs.bk
Cargo.lock
# Node
node_modules/
dist/
# Build
build/
*.exe
*.dll
*.so
*.dylib
# IDE
.vscode/
.idea/
*.swp
*.swo
# OS
.DS_Store
Thumbs.db
# Tauri
src/tauri-app/src-tauri/gen/
# Database
*.db
*.db-shm
*.db-wal
# Logs
*.log
# Temp
temp/
src/Cargo.toml
+56
View File
@@ -0,0 +1,56 @@
[workspace]
resolver = "2"
members = [
"tscore",
"tsaudio",
"tsdb",
"shared",
]
[workspace.package]
version = "1.0.0"
edition = "2021"
license = "MIT OR Apache-2.0"
authors = ["ReTeamspeak"]
repository = "https://github.com/re-teamspeak/re-teamspeak"
[workspace.dependencies]
tokio = { version = "1", features = ["full"] }
futures = "0.3"
serde = { version = "1", features = ["derive"] }
serde_json = "1"
toml = "0.8"
thiserror = "1"
anyhow = "1"
tracing = "0.1"
tracing-subscriber = { version = "0.3", features = ["env-filter"] }
aes = "0.8"
eax = "0.5"
sha1 = "0.10"
sha2 = "0.10"
p256 = { version = "0.13", features = ["ecdh"] }
curve25519-dalek-ng = "4"
num-bigint = "0.4"
quicklz = "0.1"
opus = "0.3"
cpal = "0.15"
rusqlite = { version = "0.31", features = ["bundled"] }
hickory-resolver = "0.24"
reqwest = { version = "0.11", features = ["json"] }
base64 = "0.21"
hex = "0.4"
uuid = { version = "1", features = ["v4"] }
chrono = { version = "0.4", features = ["serde"] }
url = "2"
rand = "0.8"
tscore = { path = "tscore" }
tsaudio = { path = "tsaudio" }
tsdb = { path = "tsdb" }
shared = { path = "shared" }
src/README.md
+186
View File
@@ -0,0 +1,186 @@
# ReTeamSpeak
跨平台 TeamSpeak 客户端，支持 Windows、macOS、Linux、iOS 和 Android。
## 功能特性
- 高质量语音通信 (Opus 编解码器)
- 文本聊天
- 文件传输
- 安全加密通信 (AES-128-EAX)
- 跨平台支持
- 现代化 UI 界面
- 全局热键支持
- 系统通知
## 支持平台
| 平台 | 状态 |
|------|------|
| Windows | 支持 |
| macOS | 支持 |
| Linux | 支持 |
| iOS | 支持 |
| Android | 支持 |
## 项目结构
```
re-teamspeak/
├── src/ # 源代码
│ ├── shared/ # 共享类型定义
│ │ └── src/
│ │ ├── lib.rs # 库入口
│ │ ├── types.rs # 核心类型
│ │ ├── events.rs # 事件定义
│ │ ├── errors.rs # 错误类型
│ │ └── config.rs # 配置管理
│ │
│ ├── tscore/ # 协议核心层
│ │ └── src/
│ │ ├── lib.rs # 库入口
│ │ ├── protocol/ # 协议实现
│ │ │ ├── packet.rs # 数据包处理
│ │ │ ├── types.rs # 协议类型
│ │ │ └── commands.rs # 命令解析
│ │ ├── crypto/ # 加密模块
│ │ │ ├── eax.rs # EAX 加密
│ │ │ ├── keys.rs # 密钥管理
│ │ │ └── hash.rs # 哈希函数
│ │ ├── network/ # 网络模块
│ │ │ ├── socket.rs # Socket 抽象
│ │ │ └── resolver.rs # 地址解析
│ │ └── connection/ # 连接管理
│ │ ├── client.rs # 客户端
│ │ └── state.rs # 状态机
│ │
│ ├── tsaudio/ # 音频引擎
│ │ └── src/
│ │ ├── lib.rs # 库入口
│ │ ├── capture.rs # 音频采集
│ │ ├── playback.rs # 音频播放
│ │ ├── codec.rs # Opus 编解码
│ │ ├── vad.rs # 语音活动检测
│ │ └── buffer.rs # 抖动缓冲
│ │
│ ├── tsdb/ # 数据存储
│ │ └── src/
│ │ ├── lib.rs # 库入口
│ │ ├── identity.rs # 身份管理
│ │ ├── bookmark.rs # 书签管理
│ │ ├── message.rs # 消息管理
│ │ └── config.rs # 配置存储
│ │
│ └── tauri-app/ # Tauri 应用
│ ├── src-tauri/ # Rust 后端
│ │ ├── src/
│ │ │ ├── lib.rs # 库入口
│ │ │ ├── main.rs # 主入口
│ │ │ ├── commands.rs # Tauri 命令
│ │ │ └── state.rs # 状态管理
│ │ ├── Cargo.toml # Rust 依赖
│ │ └── tauri.conf.json # Tauri 配置
│ └── frontend/ # React 前端
│ ├── src/
│ │ ├── main.tsx # 入口
│ │ ├── App.tsx # 主组件
│ │ └── styles.css # 样式
│ ├── package.json # npm 依赖
│ └── vite.config.ts # Vite 配置
│
├── docs/ # 文档
│ ├── protocol.md # 协议分析
│ ├── protocol_stack.md # 协议栈分析
│ ├── architecture.md # 架构设计
│ ├── components.md # 组件设计
│ └── requirements.md # 需求分析
│
├── build.sh # Linux/macOS 构建脚本
├── build.bat # Windows 构建脚本
└── Cargo.toml # Rust workspace 配置
```
## 快速开始
### 环境要求
- Rust: 1.70.0 或更高版本
- Node.js: 18.0.0 或更高版本
- npm: 9.0.0 或更高版本
#### 平台特定要求
**Windows:**
- Visual Studio 2019 或更高版本（带 C++ 桌面开发工作负载）
- Windows 10 SDK
**macOS:**
- Xcode 14 或更高版本
- Command Line Tools
**Linux:**
```bash
sudo apt update
sudo apt install -y \
libwebkit2gtk-4.0-dev \
libappindicator3-dev \
librsvg2-dev \
patchelf \
libssl-dev \
libasound2-dev \
libdbus-1-dev \
libgtk-3-dev \
libsoup2.4-dev \
libjavascriptcoregtk-4.0-dev
```
**Android:**
- Android Studio
- Android SDK 33 或更高版本
- NDK 25 或更高版本
**iOS:**
- Xcode 14 或更高版本
- CocoaPods
### 安装
```bash
git clone https://github.com/re-teamspeak/re-teamspeak.git
cd re-teamspeak
# 安装前端依赖
cd src/tauri-app/frontend
npm install
```
### 构建
```bash
# Linux/macOS
./build.sh all # 构建所有平台
./build.sh desktop # 仅构建桌面应用
./build.sh android # 仅构建 Android 应用
./build.sh ios # 仅构建 iOS 应用
# Windows
build.bat all
build.bat desktop
```
### 开发模式
```bash
cd src/tauri-app/src-tauri
cargo tauri dev
```
## 技术栈
### 后端 (Rust)
| 库 | 用途 |
|---|---|
| Tauri v2 | 跨平台桌面应用框架 |
| tokio | 异步运行时 |
| aes/ea
src/shared/Cargo.toml
+13
View File
@@ -0,0 +1,13 @@
[package]
name = "shared"
version.workspace = true
edition.workspace = true
license.workspace = true
[dependencies]
serde = { workspace = true }
serde_json = { workspace = true }
thiserror = { workspace = true }
chrono = { workspace = true }
uuid = { workspace = true }
toml = { workspace = true }
src/shared/src/config.rs
+107
View File
@@ -0,0 +1,107 @@
use serde::{Deserialize, Serialize};
use std::path::PathBuf;
use crate::types::*;
/// 配置管理器
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ConfigManager {
pub app: AppConfig,
pub connections: Vec<SavedConnection>,
pub recent_servers: Vec<RecentServer>,
}
/// 保存的连接
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SavedConnection {
pub id: String,
pub name: String,
pub address: String,
pub port: u16,
pub nickname: String,
pub server_password: Option<String>,
pub channel: Option<String>,
pub channel_password: Option<String>,
pub default_token: Option<String>,
pub auto_connect: bool,
pub last_connected: Option<chrono::DateTime<chrono::Utc>>,
}
/// 最近连接的服务器
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RecentServer {
pub address: String,
pub port: u16,
pub name: String,
pub last_connected: chrono::DateTime<chrono::Utc>,
pub connect_count: u32,
}
impl ConfigManager {
pub fn new() -> Self {
Self {
app: AppConfig::default(),
connections: Vec::new(),
recent_servers: Vec::new(),
}
}
pub fn load(path: &PathBuf) -> Result<Self, Box<dyn std::error::Error>> {
let content = std::fs::read_to_string(path)?;
let config: Self = toml::from_str(&content)?;
Ok(config)
}
pub fn save(&self, path: &PathBuf) -> Result<(), Box<dyn std::error::Error>> {
let content = toml::to_string_pretty(self)?;
std::fs::write(path, content)?;
Ok(())
}
pub fn add_connection(&mut self, connection: SavedConnection) {
if let Some(existing) = self.connections.iter_mut().find(|c| c.id == connection.id) {
*existing = connection;
} else {
self.connections.push(connection);
}
}
pub fn remove_connection(&mut self, id: &str) {
self.connections.retain(|c| c.id != id);
}
pub fn get_connection(&self, id: &str) -> Option<&SavedConnection> {
self.connections.iter().find(|c| c.id == id)
}
pub fn add_recent_server(&mut self, address: &str, port: u16, name: &str) {
let now = chrono::Utc::now();
if let Some(existing) = self.recent_servers.iter_mut().find(|s| s.address == address && s.port == port) {
existing.last_connected = now;
existing.connect_count += 1;
existing.name = name.to_string();
} else {
self.recent_servers.push(RecentServer {
address: address.to_string(),
port,
name: name.to_string(),
last_connected: now,
connect_count: 1,
});
}
self.recent_servers.sort_by(|a, b| b.last_connected.cmp(&a.last_connected));
if self.recent_servers.len() > 20 {
self.recent_servers.truncate(20);
}
}
pub fn get_recent_servers(&self) -> &[RecentServer] {
&self.recent_servers
}
}
impl Default for ConfigManager {
fn default() -> Self {
Self::new()
}
}
src/shared/src/errors.rs
+62
View File
@@ -0,0 +1,62 @@
use thiserror::Error;
/// 应用错误
#[derive(Error, Debug)]
pub enum AppError {
#[error("连接错误: {0}")]
Connection(String),
#[error("协议错误: {code} - {message}")]
Protocol { code: u32, message: String },
#[error("网络错误: {0}")]
Network(#[from] std::io::Error),
#[error("加密错误: {0}")]
Crypto(String),
#[error("音频错误: {0}")]
Audio(String),
#[error("数据库错误: {0}")]
Database(String),
#[error("序列化错误: {0}")]
Serialization(#[from] serde_json::Error),
#[error("配置错误: {0}")]
Config(String),
#[error("身份错误: {0}")]
Identity(String),
#[error("权限错误: {0}")]
Permission(String),
#[error("超时错误: {0}")]
Timeout(String),
#[error("未连接")]
NotConnected,
#[error("已连接")]
AlreadyConnected,
#[error("无效参数: {0}")]
InvalidArgument(String),
#[error("不支持的操作: {0}")]
Unsupported(String),
#[error("内部错误: {0}")]
Internal(String),
}
/// 结果类型别名
pub type AppResult<T> = Result<T, AppError>;
impl From<AppError> for String {
fn from(err: AppError) -> Self {
err.to_string()
}
}
src/shared/src/events.rs
+155
View File
@@ -0,0 +1,155 @@
use serde::{Deserialize, Serialize};
use crate::types::*;
/// 应用事件
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum AppEvent {
Connection(ConnectionEvent),
Client(ClientEvent),
Channel(ChannelEvent),
Server(ServerEvent),
Message(MessageEvent),
Audio(AudioEvent),
FileTransfer(FileTransferEvent),
Error(ErrorEvent),
}
/// 连接事件
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum ConnectionEvent {
Connecting { address: String },
Connected { server: ServerInfo, own_client: ClientId },
StateChanged { state: ConnectionState },
DisconnectedTemporarily { reason: String },
Disconnected { reason: String },
ConnectionFailed { error: String },
}
/// 客户端事件
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum ClientEvent {
EnteredView { client: ClientInfo, reason: Reason },
LeftView { client_id: ClientId, reason: Reason, reason_message: Option<String> },
Updated { client_id: ClientId, changes: ClientChanges },
Moved { client_id: ClientId, from_channel: ChannelId, to_channel: ChannelId, reason: Reason },
StartedTalking { client_id: ClientId },
StoppedTalking { client_id: ClientId },
ServerGroupChanged { client_id: ClientId, group_id: ServerGroupId, added: bool },
ChannelGroupChanged { client_id: ClientId, group_id: ChannelGroupId },
}
/// 客户端变更
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ClientChanges {
pub name: Option<String>,
pub input_muted: Option<bool>,
pub output_muted: Option<bool>,
pub output_only_muted: Option<bool>,
pub input_hardware_enabled: Option<bool>,
pub output_hardware_enabled: Option<bool>,
pub talk_power_granted: Option<bool>,
pub metadata: Option<String>,
pub is_recording: Option<bool>,
pub away_message: Option<String>,
pub description: Option<String>,
pub is_priority_speaker: Option<bool>,
pub phonetic_name: Option<String>,
pub is_channel_commander: Option<bool>,
pub badges: Option<String>,
}
/// 频道事件
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum ChannelEvent {
Created { channel: ChannelInfo },
Deleted { channel_id: ChannelId },
Updated { channel_id: ChannelId, changes: ChannelChanges },
Moved { channel_id: ChannelId, new_parent: ChannelId, new_order: ChannelId },
PasswordChanged { channel_id: ChannelId },
DescriptionChanged { channel_id: ChannelId },
Subscribed { channel_id: ChannelId, subscribed: bool },
}
/// 频道变更
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChannelChanges {
pub name: Option<String>,
pub topic: Option<String>,
pub codec: Option<Codec>,
pub codec_quality: Option<u8>,
pub max_clients: Option<i32>,
pub max_family_clients: Option<i32>,
pub channel_type: Option<ChannelType>,
pub needed_talk_power: Option<i32>,
pub phonetic_name: Option<String>,
pub icon_id: Option<IconId>,
}
/// 服务器事件
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum ServerEvent {
Updated { changes: ServerChanges },
ServerGroupList { groups: Vec<ServerGroupInfo> },
ChannelGroupList { groups: Vec<ChannelGroupInfo> },
}
/// 服务器变更
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ServerChanges {
pub name: Option<String>,
pub welcome_message: Option<String>,
pub host_message: Option<String>,
pub host_message_mode: Option<HostMessageMode>,
pub max_clients: Option<u16>,
}
/// 消息事件
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum MessageEvent {
Received { message: ChatMessage },
Sent { message: ChatMessage },
Read { message_id: u64 },
UnreadCountChanged { count: u32 },
}
/// 音频设备
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AudioDevice {
pub id: String,
pub name: String,
pub is_default: bool,
}
/// 音频事件
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum AudioEvent {
InputDeviceChanged { device: Option<String> },
OutputDeviceChanged { device: Option<String> },
InputVolumeChanged { volume: f32 },
OutputVolumeChanged { volume: f32 },
InputMutedChanged { muted: bool },
OutputMutedChanged { muted: bool },
DeviceList { input_devices: Vec<AudioDevice>, output_devices: Vec<AudioDevice> },
InputLevel { level: f32 },
OutputLevel { level: f32 },
}
/// 文件传输事件
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum FileTransferEvent {
Started { transfer_id: String, file_name: String, file_size: u64, is_upload: bool },
Progress { transfer_id: String, progress: f32 },
Completed { transfer_id: String },
Failed { transfer_id: String, error: String },
Cancelled { transfer_id: String },
}
/// 错误事件
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum ErrorEvent {
Protocol { code: u32, message: String },
Network { message: String },
Audio { message: String },
Database { message: String },
Other { message: String },
}
src/shared/src/lib.rs
+9
View File
@@ -0,0 +1,9 @@
pub mod types;
pub mod events;
pub mod errors;
pub mod config;
pub use types::*;
pub use events::*;
pub use errors::*;
pub use config::*;
src/shared/src/types.rs
+422
View File
@@ -0,0 +1,422 @@
use serde::{Deserialize, Serialize};
use std::fmt;
/// TeamSpeak 核心类型定义
/// 客户端 ID
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct ClientId(pub u16);
/// 频道 ID
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct ChannelId(pub u64);
/// 服务器组 ID
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct ServerGroupId(pub u64);
/// 频道组 ID
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct ChannelGroupId(pub u64);
/// 客户端数据库 ID
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct ClientDbId(pub u64);
/// 用户唯一标识符
#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct Uid(pub String);
/// 权限 ID
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct PermissionId(pub u32);
/// 图标 ID
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct IconId(pub i32);
/// 音频编解码器
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum Codec {
SpeexNarrowband,
SpeexWideband,
SpeexUltrawideband,
CeltMono,
OpusVoice,
OpusMusic,
}
impl Codec {
pub fn sample_rate(&self) -> u32 {
match self {
Self::SpeexNarrowband => 8000,
Self::SpeexWideband => 16000,
Self::SpeexUltrawideband => 32000,
Self::CeltMono | Self::OpusVoice | Self::OpusMusic => 48000,
}
}
pub fn channels(&self) -> u16 {
match self {
Self::OpusMusic => 2,
_ => 1,
}
}
}
impl fmt::Display for Codec {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::SpeexNarrowband => write!(f, "Speex Narrowband"),
Self::SpeexWideband => write!(f, "Speex Wideband"),
Self::SpeexUltrawideband => write!(f, "Speex Ultrawideband"),
Self::CeltMono => write!(f, "CELT Mono"),
Self::OpusVoice => write!(f, "Opus Voice"),
Self::OpusMusic => write!(f, "Opus Music"),
}
}
}
/// 频道类型
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum ChannelType {
Permanent,
SemiPermanent,
Temporary,
}
/// 客户端类型
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum ClientType {
Normal,
Query { admin: bool },
}
/// 文本消息目标模式
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum TextMessageTargetMode {
Unknown,
Client,
Channel,
Server,
}
/// 连接状态
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum ConnectionState {
Uninitialized,
Connecting,
IdentityLevelIncreasing,
Connected,
ChannelListFinished,
DisconnectedTemporarily,
Disconnected,
Error,
}
/// 离开原因
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum Reason {
None,
Moved,
Subscription,
LostConnection,
KickChannel,
KickServer,
KickServerBan,
Serverstop,
Clientdisconnect,
Channelupdate,
Channeledit,
ClientdisconnectServerShutdown,
}
/// 服务器信息
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ServerInfo {
pub id: u64,
pub name: String,
pub platform: String,
pub version: String,
pub max_clients: u16,
pub clients_online: u16,
pub channels_online: u64,
pub uptime: u64,
pub codec_encryption_mode: CodecEncryptionMode,
pub host_message: String,
pub host_message_mode: HostMessageMode,
pub welcome_message: String,
pub default_server_group: ServerGroupId,
pub default_channel_group: ChannelGroupId,
}
/// 编解码器加密模式
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum CodecEncryptionMode {
PerChannel,
ForcedOff,
ForcedOn,
}
/// 主机消息模式
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum HostMessageMode {
None,
Log,
Modal,
Modalquit,
}
/// 频道信息
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChannelInfo {
pub id: ChannelId,
pub parent_id: ChannelId,
pub name: String,
pub topic: String,
pub codec: Codec,
pub codec_quality: u8,
pub max_clients: i32,
pub max_family_clients: i32,
pub order: ChannelId,
pub channel_type: ChannelType,
pub is_default: bool,
pub has_password: bool,
pub codec_latency_factor: i32,
pub is_unencrypted: bool,
pub delete_delay: u32,
pub needed_talk_power: i32,
pub forced_silence: bool,
pub phonetic_name: String,
pub icon_id: IconId,
pub is_private: bool,
pub storage_quota: u32,
pub subscribed: bool,
}
/// 客户端信息
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ClientInfo {
pub id: ClientId,
pub channel_id: ChannelId,
pub uid: Uid,
pub name: String,
pub input_muted: bool,
pub output_muted: bool,
pub output_only_muted: bool,
pub input_hardware_enabled: bool,
pub output_hardware_enabled: bool,
pub talk_power_granted: bool,
pub metadata: String,
pub is_recording: bool,
pub database_id: ClientDbId,
pub channel_group: ChannelGroupId,
pub server_groups: Vec<ServerGroupId>,
pub away_message: String,
pub client_type: ClientType,
pub avatar_hash: String,
pub talk_power: i32,
pub description: String,
pub is_priority_speaker: bool,
pub unread_messages: u32,
pub phonetic_name: String,
pub icon_id: IconId,
pub is_channel_commander: bool,
pub country_code: String,
pub badges: String,
}
/// 服务器组信息
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ServerGroupInfo {
pub id: ServerGroupId,
pub name: String,
pub group_type: GroupType,
pub icon_id: IconId,
pub is_permanent: bool,
pub sort_id: i32,
pub naming_mode: GroupNamingMode,
pub needed_modify_power: i32,
pub needed_member_add_power: i32,
pub needed_member_remove_power: i32,
}
/// 频道组信息
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChannelGroupInfo {
pub id: ChannelGroupId,
pub name: String,
pub group_type: GroupType,
pub icon_id: IconId,
pub is_permanent: bool,
pub sort_id: i32,
pub naming_mode: GroupNamingMode,
pub needed_modify_power: i32,
pub needed_member_add_power: i32,
pub needed_member_remove_power: i32,
}
/// 组类型
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum GroupType {
Template,
Regular,
Query,
}
/// 组命名模式
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum GroupNamingMode {
None,
Before,
After,
}
/// 连接配置
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ConnectConfig {
pub address: String,
pub port: u16,
pub nickname: String,
pub server_password: Option<String>,
pub channel: Option<String>,
pub channel_password: Option<String>,
pub default_token: Option<String>,
pub identity: Option<IdentityConfig>,
}
/// 身份配置
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct IdentityConfig {
pub private_key: String,
pub counter: u64,
pub max_counter: u64,
}
/// 音频配置
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AudioConfig {
pub input_device: Option<String>,
pub output_device: Option<String>,
pub input_volume: f32,
pub output_volume: f32,
pub vad_enabled: bool,
pub vad_threshold: f32,
pub ptt_enabled: bool,
pub ptt_key: Option<String>,
pub noise_suppression: bool,
pub echo_cancellation: bool,
}
impl Default for AudioConfig {
fn default() -> Self {
Self {
input_device: None,
output_device: None,
input_volume: 1.0,
output_volume: 1.0,
vad_enabled: true,
vad_threshold: 0.5,
ptt_enabled: false,
ptt_key: None,
noise_suppression: true,
echo_cancellation: true,
}
}
}
/// 热键动作
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum HotkeyAction {
InputMuteToggle,
OutputMuteToggle,
AwayToggle,
PushToTalk,
ChannelCommanderToggle,
}
/// 热键配置
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct HotkeyConfig {
pub action: HotkeyAction,
pub key: String,
pub modifiers: Vec<String>,
}
/// 应用配置
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AppConfig {
pub nickname: String,
pub audio: AudioConfig,
pub hotkeys: Vec<HotkeyConfig>,
pub theme: String,
pub language: String,
pub minimize_to_tray: bool,
pub start_minimized: bool,
pub auto_reconnect: bool,
pub reconnect_delay: u32,
}
impl Default for AppConfig {
fn default() -> Self {
Self {
nickname: "User".to_string(),
audio: AudioConfig::default(),
hotkeys: Vec::new(),
theme: "dark".to_string(),
language: "en".to_string(),
minimize_to_tray: true,
start_minimized: false,
auto_reconnect: true,
reconnect_delay: 5,
}
}
}
/// 聊天消息
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChatMessage {
pub id: u64,
pub timestamp: chrono::DateTime<chrono::Utc>,
pub invoker: ClientId,
pub invoker_name: String,
pub invoker_uid: Uid,
pub target: MessageTarget,
pub message: String,
pub is_read: bool,
}
/// 消息目标
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum MessageTarget {
Server,
Channel(ChannelId),
Client(ClientId),
}
/// 文件信息
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FileInfo {
pub name: String,
pub size: u64,
pub created_at: chrono::DateTime<chrono::Utc>,
pub is_directory: bool,
}
/// 文件传输状态
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum FileTransferStatus {
Pending,
InProgress { progress: f32 },
Completed,
Failed(String),
Cancelled,
}
/// 文件传输请求
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FileTransferRequest {
pub channel_id: ChannelId,
pub path: String,
pub password: Option<String>,
}
src/tauri-app/frontend/index.html
+13
View File
@@ -0,0 +1,13 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8" />
<link rel="icon" type="image/svg+xml" href="/vite.svg" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>ReTeamSpeak</title>
</head>
<body>
<div id="root"></div>
<script type="module" src="/src/main.tsx"></script>
</body>
</html>
src/tauri-app/frontend/package.json
+25
View File
@@ -0,0 +1,25 @@
{
"name": "re-teamspeak-frontend",
"version": "1.0.0",
"private": true,
"type": "module",
"scripts": {
"dev": "vite",
"build": "tsc && vite build",
"preview": "vite preview"
},
"dependencies": {
"@tauri-apps/api": "^2.0.0",
"react": "^18.2.0",
"react-dom": "^18.2.0",
"react-router-dom": "^6.20.0"
},
"devDependencies": {
"@tauri-apps/cli": "^2.0.0",
"@types/react": "^18.2.0",
"@types/react-dom": "^18.2.0",
"@vitejs/plugin-react": "^4.2.0",
"typescript": "^5.3.0",
"vite": "^5.0.0"
}
}
src/tauri-app/frontend/src/App.tsx
+163
View File
@@ -0,0 +1,163 @@
import React, { useState, useEffect } from 'react';
import { invoke } from '@tauri-apps/api/core';
interface Identity {
id: string;
name: string;
counter: number;
max_counter: number;
}
interface Bookmark {
id: string;
name: string;
address: string;
port: number;
nickname: string | null;
auto_connect: boolean;
last_connected: string | null;
}
function App() {
const [identities, setIdentities] = useState<Identity[]>([]);
const [bookmarks, setBookmarks] = useState<Bookmark[]>([]);
const [selectedBookmark, setSelectedBookmark] = useState<Bookmark | null>(null);
const [nickname, setNickname] = useState('');
const [password, setPassword] = useState('');
const [connected, setConnected] = useState(false);
useEffect(() => {
loadIdentities();
loadBookmarks();
}, []);
async function loadIdentities() {
try {
const result = await invoke<Identity[]>('get_identities');
setIdentities(result);
} catch (error) {
console.error('Failed to load identities:', error);
}
}
async function loadBookmarks() {
try {
const result = await invoke<Bookmark[]>('get_bookmarks');
setBookmarks(result);
} catch (error) {
console.error('Failed to load bookmarks:', error);
}
}
async function handleConnect() {
if (!selectedBookmark) return;
try {
await invoke('connect', {
address: selectedBookmark.address,
port: selectedBookmark.port,
nickname: nickname || selectedBookmark.nickname || 'User',
password: password || null,
});
setConnected(true);
} catch (error) {
console.error('Failed to connect:', error);
}
}
async function handleDisconnect() {
try {
await invoke('disconnect');
setConnected(false);
} catch (error) {
console.error('Failed to disconnect:', error);
}
}
return (
<div className="app">
<header className="app-header">
<h1>ReTeamSpeak</h1>
<div className="connection-status">
{connected ? (
<span className="status connected">已连接</span>
) : (
<span className="status disconnected">未连接</span>
)}
</div>
</header>
<main className="app-main">
<aside className="sidebar">
<section className="bookmarks-section">
<h2>服务器书签</h2>
<ul className="bookmark-list">
{bookmarks.map((bookmark) => (
<li
key={bookmark.id}
className={`bookmark-item ${selectedBookmark?.id === bookmark.id ? 'selected' : ''}`}
onClick={() => setSelectedBookmark(bookmark)}
>
<span className="bookmark-name">{bookmark.name}</span>
<span className="bookmark-address">{bookmark.address}:{bookmark.port}</span>
</li>
))}
</ul>
</section>
</aside>
<div className="content">
{selectedBookmark ? (
<div className="connect-form">
<h2>连接到 {selectedBookmark.name}</h2>
<div className="form-group">
<label>服务器地址</label>
<input
type="text"
value={`${selectedBookmark.address}:${selectedBookmark.port}`}
disabled
/>
</div>
<div className="form-group">
<label>昵称</label>
<input
type="text"
value={nickname}
onChange={(e) => setNickname(e.target.value)}
placeholder={selectedBookmark.nickname || '请输入昵称'}
/>
</div>
<div className="form-group">
<label>密码</label>
<input
type="password"
value={password}
onChange={(e) => setPassword(e.target.value)}
placeholder="可选"
/>
</div>
<div className="form-actions">
{connected ? (
<button className="disconnect-btn" onClick={handleDisconnect}>
断开连接
</button>
) : (
<button className="connect-btn" onClick={handleConnect}>
连接
</button>
)}
</div>
</div>
) : (
<div className="welcome">
<h2>欢迎使用 ReTeamSpeak</h2>
<p>请从左侧选择一个服务器书签进行连接</p>
</div>
)}
</div>
</main>
</div>
);
}
export default App;
src/tauri-app/frontend/src/main.tsx
+10
View File
@@ -0,0 +1,10 @@
import React from 'react';
import ReactDOM from 'react-dom/client';
import App from './App';
import './styles.css';
ReactDOM.createRoot(document.getElementById('root') as HTMLElement).render(
<React.StrictMode>
<App />
</React.StrictMode>,
);
src/tauri-app/frontend/src/styles.css
+231
View File
@@ -0,0 +1,231 @@
:root {
--primary-color: #2196f3;
--primary-dark: #1976d2;
--secondary-color: #ff9800;
--background-color: #f5f5f5;
--surface-color: #ffffff;
--text-color: #333333;
--text-secondary: #666666;
--border-color: #e0e0e0;
--success-color: #4caf50;
--error-color: #f44336;
--warning-color: #ff9800;
}
* {
margin: 0;
padding: 0;
box-sizing: border-box;
}
body {
font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;
background-color: var(--background-color);
color: var(--text-color);
}
.app {
display: flex;
flex-direction: column;
height: 100vh;
}
.app-header {
display: flex;
justify-content: space-between;
align-items: center;
padding: 12px 20px;
background-color: var(--surface-color);
border-bottom: 1px solid var(--border-color);
box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
}
.app-header h1 {
font-size: 24px;
font-weight: 600;
color: var(--primary-color);
}
.connection-status {
display: flex;
align-items: center;
}
.status {
padding: 6px 12px;
border-radius: 16px;
font-size: 14px;
font-weight: 500;
}
.status.connected {
background-color: var(--success-color);
color: white;
}
.status.disconnected {
background-color: var(--text-secondary);
color: white;
}
.app-main {
display: flex;
flex: 1;
overflow: hidden;
}
.sidebar {
width: 300px;
background-color: var(--surface-color);
border-right: 1px solid var(--border-color);
overflow-y: auto;
}
.bookmarks-section {
padding: 16px;
}
.bookmarks-section h2 {
font-size: 16px;
font-weight: 600;
margin-bottom: 12px;
color: var(--text-secondary);
}
.bookmark-list {
list-style: none;
}
.bookmark-item {
display: flex;
flex-direction: column;
padding: 12px;
border-radius: 8px;
cursor: pointer;
transition: background-color 0.2s;
}
.bookmark-item:hover {
background-color: var(--background-color);
}
.bookmark-item.selected {
background-color: var(--primary-color);
color: white;
}
.bookmark-item.selected .bookmark-address {
color: rgba(255, 255, 255, 0.8);
}
.bookmark-name {
font-weight: 500;
margin-bottom: 4px;
}
.bookmark-address {
font-size: 12px;
color: var(--text-secondary);
}
.content {
flex: 1;
padding: 24px;
overflow-y: auto;
}
.connect-form {
max-width: 400px;
}
.connect-form h2 {
font-size: 20px;
font-weight: 600;
margin-bottom: 20px;
}
.form-group {
margin-bottom: 16px;
}
.form-group label {
display: block;
font-size: 14px;
font-weight: 500;
margin-bottom: 6px;
color: var(--text-secondary);
}
.form-group input {
width: 100%;
padding: 10px 12px;
border: 1px solid var(--border-color);
border-radius: 6px;
font-size: 14px;
transition: border-color 0.2s;
}
.form-group input:focus {
outline: none;
border-color: var(--primary-color);
}
.form-group input:disabled {
background-color: var(--background-color);
color: var(--text-secondary);
}
.form-actions {
display: flex;
gap: 12px;
margin-top: 24px;
}
.connect-btn,
.disconnect-btn {
padding: 10px 24px;
border: none;
border-radius: 6px;
font-size: 14px;
font-weight: 500;
cursor: pointer;
transition: background-color 0.2s;
}
.connect-btn {
background-color: var(--primary-color);
color: white;
}
.connect-btn:hover {
background-color: var(--primary-dark);
}
.disconnect-btn {
background-color: var(--error-color);
color: white;
}
.disconnect-btn:hover {
background-color: #d32f2f;
}
.welcome {
display: flex;
flex-direction: column;
align-items: center;
justify-content: center;
height: 100%;
text-align: center;
}
.welcome h2 {
font-size: 24px;
font-weight: 600;
margin-bottom: 12px;
}
.welcome p {
font-size: 16px;
color: var(--text-secondary);
}
src/tauri-app/frontend/tsconfig.json
+21
View File
@@ -0,0 +1,21 @@
{
"compilerOptions": {
"target": "ES2020",
"useDefineForClassFields": true,
"lib": ["ES2020", "DOM", "DOM.Iterable"],
"module": "ESNext",
"skipLibCheck": true,
"moduleResolution": "bundler",
"allowImportingTsExtensions": true,
"resolveJsonModule": true,
"isolatedModules": true,
"noEmit": true,
"jsx": "react-jsx",
"strict": true,
"noUnusedLocals": true,
"noUnusedParameters": true,
"noFallthroughCasesInSwitch": true
},
"include": ["src"],
"references": [{ "path": "./tsconfig.node.json" }]
}
src/tauri-app/frontend/tsconfig.node.json
+11
View File
@@ -0,0 +1,11 @@
{
"compilerOptions": {
"composite": true,
"skipLibCheck": true,
"module": "ESNext",
"moduleResolution": "bundler",
"allowSyntheticDefaultImports": true,
"strict": true
},
"include": ["vite.config.ts"]
}
src/tauri-app/frontend/vite.config.ts
+17
View File
@@ -0,0 +1,17 @@
import { defineConfig } from 'vite';
import react from '@vitejs/plugin-react';
export default defineConfig({
plugins: [react()],
clearScreen: false,
server: {
port: 5173,
strictPort: true,
},
envPrefix: ['VITE_', 'TAURI_'],
build: {
target: process.env.TAURI_PLATFORM === 'windows' ? 'chrome105' : 'safari13',
minify: !process.env.TAURI_DEBUG ? 'esbuild' : false,
sourcemap: !!process.env.TAURI_DEBUG,
},
});
src/tauri-app/src-tauri/Cargo.toml
+34
View File
@@ -0,0 +1,34 @@
[package]
name = "re-teamspeak"
version = "1.0.0"
edition = "2021"
license = "MIT OR Apache-2.0"
[dependencies]
tauri = { version = "2", features = ["devtools"] }
tauri-plugin-dialog = "2"
tauri-plugin-http = "2"
tauri-plugin-notification = "2"
tauri-plugin-opener = "2"
tauri-plugin-shell = "2"
tokio = { version = "1", features = ["full"] }
serde = { version = "1", features = ["derive"] }
serde_json = "1"
thiserror = "1"
anyhow = "1"
tracing = "0.1"
tracing-subscriber = { version = "0.3", features = ["env-filter"] }
shared = { path = "../../shared" }
tscore = { path = "../../tscore" }
tsaudio = { path = "../../tsaudio" }
tsdb = { path = "../../tsdb" }
[features]
default = ["custom-protocol"]
custom-protocol = ["tauri/custom-protocol"]
[lib]
name = "re_teamspeak_lib"
crate-type = ["lib", "cdylib", "staticlib"]
src/tauri-app/src-tauri/build.rs
+5
View File
@@ -0,0 +1,5 @@
use tauri_build::{build_mobile, Result};
fn main() -> Result<()> {
build_mobile()
}
src/tauri-app/src-tauri/capabilities/default.json
+25
View File
@@ -0,0 +1,25 @@
{
"identifier": "default",
"description": "默认权限配置",
"windows": ["main"],
"permissions": [
"core:default",
"dialog:default",
"dialog:allow-open",
"dialog:allow-save",
"dialog:allow-message",
"dialog:allow-ask",
"dialog:allow-confirm",
"http:default",
"http:allow-fetch",
"notification:default",
"notification:allow-is-permission-granted",
"notification:allow-request-permission",
"notification:allow-notify",
"opener:default",
"opener:allow-open-url",
"opener:allow-open-path",
"shell:default",
"shell:allow-open"
]
}
src/tauri-app/src-tauri/gen/android/app/src/main/AndroidManifest.xml
+28
View File
@@ -0,0 +1,28 @@
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.reteamspeak.app">
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.RECORD_AUDIO" />
<uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<application
android:allowBackup="true"
android:icon="@mipmap/ic_launcher"
android:label="ReTeamSpeak"
android:supportsRtl="true"
android:theme="@style/Theme.ReTeamSpeak">
<activity
android:name=".MainActivity"
android:exported="true"
android:launchMode="singleTask"
android:configChanges="orientation|keyboardHidden|keyboard|screenSize|smallestScreenSize|locale|layoutDirection|fontScale|screenLayout|density|uiMode"
android:windowSoftInputMode="adjustResize">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
</manifest>
src/tauri-app/src-tauri/gen/apple/Info.plist
+40
View File
@@ -0,0 +1,40 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>CFBundleDevelopmentRegion</key>
<string>en</string>
<key>CFBundleDisplayName</key>
<string>ReTeamSpeak</string>
<key>CFBundleExecutable</key>
<string>$(EXECUTABLE_NAME)</string>
<key>CFBundleIdentifier</key>
<string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
<key>CFBundleInfoDictionaryVersion</key>
<string>6.0</string>
<key>CFBundleName</key>
<string>$(PRODUCT_NAME)</string>
<key>CFBundlePackageType</key>
<string>APPL</string>
<key>CFBundleShortVersionString</key>
<string>$(MARKETING_VERSION)</string>
<key>CFBundleVersion</key>
<string>$(CURRENT_PROJECT_VERSION)</string>
<key>LSRequiresIPhoneOS</key>
<true/>
<key>UILaunchStoryboardName</key>
<string>LaunchScreen</string>
<key>UIRequiredDeviceCapabilities</key>
<array>
<string>armv7</string>
</array>
<key>UISupportedInterfaceOrientations</key>
<array>
<string>UIInterfaceOrientationPortrait</string>
<string>UIInterfaceOrientationLandscapeLeft</string>
<string>UIInterfaceOrientationLandscapeRight</string>
</array>
<key>NSMicrophoneUsageDescription</key>
<string>ReTeamSpeak needs access to your microphone for voice communication.</string>
</dict>
</plist>
src/tauri-app/src-tauri/src/commands.rs
+155
View File
@@ -0,0 +1,155 @@
//! Tauri 命令
use tauri::State;
use serde::{Deserialize, Serialize};
use crate::AppState;
#[derive(Debug, Serialize, Deserialize)]
pub struct IdentityInfo {
pub id: String,
pub name: String,
pub counter: u64,
pub max_counter: u64,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct BookmarkInfo {
pub id: String,
pub name: String,
pub address: String,
pub port: u16,
pub nickname: Option<String>,
pub auto_connect: bool,
pub last_connected: Option<String>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct MessageInfo {
pub id: i64,
pub invoker_name: String,
pub message: String,
pub timestamp: String,
pub is_read: bool,
}
#[tauri::command]
pub async fn get_identities(state: State<'_, AppState>) -> Result<Vec<IdentityInfo>, String> {
let identities = state.db.get_all_identities().map_err(|e| e.to_string())?;
Ok(identities.into_iter().map(|i| IdentityInfo {
id: i.id,
name: i.name,
counter: i.counter,
max_counter: i.max_counter,
}).collect())
}
#[tauri::command]
pub async fn create_identity(state: State<'_, AppState>, name: String) -> Result<IdentityInfo, String> {
let private_key = "placeholder";
let identity = state.db.create_identity(&name, private_key).map_err(|e| e.to_string())?;
Ok(IdentityInfo {
id: identity.id,
name: identity.name,
counter: identity.counter,
max_counter: identity.max_counter,
})
}
#[tauri::command]
pub async fn delete_identity(state: State<'_, AppState>, id: String) -> Result<(), String> {
state.db.delete_identity(&id).map_err(|e| e.to_string())?;
Ok(())
}
#[tauri::command]
pub async fn get_bookmarks(state: State<'_, AppState>) -> Result<Vec<BookmarkInfo>, String> {
let bookmarks = state.db.get_all_bookmarks().map_err(|e| e.to_string())?;
Ok(bookmarks.into_iter().map(|b| BookmarkInfo {
id: b.id,
name: b.name,
address: b.address,
port: b.port,
nickname: b.nickname,
auto_connect: b.auto_connect,
last_connected: b.last_connected,
}).collect())
}
#[tauri::command]
pub async fn create_bookmark(
state: State<'_, AppState>,
name: String,
address: String,
port: u16,
nickname: Option<String>,
) -> Result<BookmarkInfo, String> {
let bookmark = state.db.create_bookmark(&name, &address, port, nickname.as_deref())
.map_err(|e| e.to_string())?;
Ok(BookmarkInfo {
id: bookmark.id,
name: bookmark.name,
address: bookmark.address,
port: bookmark.port,
nickname: bookmark.nickname,
auto_connect: bookmark.auto_connect,
last_connected: bookmark.last_connected,
})
}
#[tauri::command]
pub async fn delete_bookmark(state: State<'_, AppState>, id: String) -> Result<(), String> {
state.db.delete_bookmark(&id).map_err(|e| e.to_string())?;
Ok(())
}
#[tauri::command]
pub async fn connect(
state: State<'_, AppState>,
address: String,
port: u16,
nickname: String,
password: Option<String>,
) -> Result<(), String> {
let mut conn_state = state.connection_state.lock().await;
conn_state.connected = true;
conn_state.server_address = Some(address.clone());
conn_state.server_port = Some(port);
conn_state.nickname = Some(nickname);
Ok(())
}
#[tauri::command]
pub async fn disconnect(state: State<'_, AppState>) -> Result<(), String> {
let mut conn_state = state.connection_state.lock().await;
*conn_state = crate::state::ConnectionState::new();
Ok(())
}
#[tauri::command]
pub async fn send_message(
state: State<'_, AppState>,
target: String,
message: String,
) -> Result<(), String> {
// TODO: 实现发送消息
Ok(())
}
#[tauri::command]
pub async fn get_messages(
state: State<'_, AppState>,
server_address: String,
limit: i64,
offset: i64,
) -> Result<Vec<MessageInfo>, String> {
let messages = state.db.get_server_messages(&server_address, limit, offset)
.map_err(|e| e.to_string())?;
Ok(messages.into_iter().map(|m| MessageInfo {
id: m.id,
invoker_name: m.invoker_name,
message: m.message,
timestamp: m.timestamp,
is_read: m.is_read,
}).collect())
}
src/tauri-app/src-tauri/src/lib.rs
+52
View File
@@ -0,0 +1,52 @@
//! ReTeamSpeak Tauri 应用
use tauri::Manager;
mod commands;
mod state;
pub struct AppState {
pub db: tsdb::DatabaseManager,
pub connection_state: tokio::sync::Mutex<state::ConnectionState>,
}
pub fn run() {
tauri::Builder::default()
.plugin(tauri_plugin_dialog::init())
.plugin(tauri_plugin_http::init())
.plugin(tauri_plugin_notification::init())
.plugin(tauri_plugin_opener::init())
.plugin(tauri_plugin_shell::init())
.setup(|app| {
tracing_subscriber::fmt::init();
let app_dir = app.path().app_data_dir().expect("无法获取应用数据目录");
std::fs::create_dir_all(&app_dir).expect("无法创建应用数据目录");
let db_path = app_dir.join("re-teamspeak.db");
let db = tsdb::DatabaseManager::new(db_path.to_str().unwrap())
.expect("无法初始化数据库");
let state = AppState {
db,
connection_state: tokio::sync::Mutex::new(state::ConnectionState::new()),
};
app.manage(state);
Ok(())
})
.invoke_handler(tauri::generate_handler![
commands::get_identities,
commands::create_identity,
commands::delete_identity,
commands::get_bookmarks,
commands::create_bookmark,
commands::delete_bookmark,
commands::connect,
commands::disconnect,
commands::send_message,
commands::get_messages,
])
.run(tauri::generate_context!())
.expect("运行应用时出错");
}
src/tauri-app/src-tauri/src/main.rs
+5
View File
@@ -0,0 +1,5 @@
#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
fn main() {
re_teamspeak_lib::run();
}
src/tauri-app/src-tauri/src/state.rs
+29
View File
@@ -0,0 +1,29 @@
//! 应用状态管理
/// 连接状态
#[derive(Debug, Clone)]
pub struct ConnectionState {
pub connected: bool,
pub server_address: Option<String>,
pub server_port: Option<u16>,
pub client_id: Option<u16>,
pub nickname: Option<String>,
}
impl ConnectionState {
pub fn new() -> Self {
Self {
connected: false,
server_address: None,
server_port: None,
client_id: None,
nickname: None,
}
}
}
impl Default for ConnectionState {
fn default() -> Self {
Self::new()
}
}
src/tauri-app/src-tauri/tauri.conf.json
+41
View File
@@ -0,0 +1,41 @@
{
"$schema": "https://raw.githubusercontent.com/nicedoc/schema/master/tauri-conf-v2-schema.json",
"productName": "ReTeamSpeak",
"version": "1.0.0",
"identifier": "com.reteamspeak.app",
"build": {
"frontendDist": "../frontend/dist",
"devUrl": "http://localhost:5173",
"beforeDevCommand": "cd ../frontend && npm run dev",
"beforeBuildCommand": "cd ../frontend && npm run build"
},
"app": {
"title": "ReTeamSpeak",
"windows": [
{
"title": "ReTeamSpeak",
"width": 1200,
"height": 800,
"minWidth": 800,
"minHeight": 600,
"resizable": true,
"fullscreen": false,
"center": true
}
],
"security": {
"csp": null
}
},
"bundle": {
"active": true,
"targets": "all",
"icon": [
"icons/32x32.png",
"icons/128x128.png",
"icons/128x128@2x.png",
"icons/icon.icns",
"icons/icon.ico"
]
}
}
src/tsaudio/Cargo.toml
+24
View File
@@ -0,0 +1,24 @@
[package]
name = "tsaudio"
version.workspace = true
edition.workspace = true
license.workspace = true
description = "TeamSpeak 音频引擎"
[dependencies]
tokio = { workspace = true }
futures = { workspace = true }
thiserror = { workspace = true }
anyhow = { workspace = true }
tracing = { workspace = true }
opus = { workspace = true, optional = true }
cpal = { workspace = true, optional = true }
rubato = { version = "0.14", optional = true }
crossbeam-channel = "0.5"
shared = { workspace = true }
[features]
default = []
full = ["cpal", "opus", "rubato"]
src/tsaudio/src/buffer.rs
+65
View File
@@ -0,0 +1,65 @@
//! 抖动缓冲
use super::{AudioFrame, AudioResult, AudioError};
/// 抖动缓冲
pub struct JitterBuffer {
buffer: Vec<Option<AudioFrame>>,
head: usize,
tail: usize,
size: usize,
capacity: usize,
}
impl JitterBuffer {
pub fn new(capacity: usize) -> Self {
Self {
buffer: vec![None; capacity],
head: 0,
tail: 0,
size: 0,
capacity,
}
}
pub fn push(&mut self, frame: AudioFrame) -> AudioResult<()> {
if self.size >= self.capacity {
return Err(AudioError::Buffer("缓冲区已满".to_string()));
}
self.buffer[self.tail] = Some(frame);
self.tail = (self.tail + 1) % self.capacity;
self.size += 1;
Ok(())
}
pub fn pop(&mut self) -> Option<AudioFrame> {
if self.size == 0 {
return None;
}
let frame = self.buffer[self.head].take();
self.head = (self.head + 1) % self.capacity;
self.size -= 1;
frame
}
pub fn len(&self) -> usize {
self.size
}
pub fn is_empty(&self) -> bool {
self.size == 0
}
pub fn is_full(&self) -> bool {
self.size >= self.capacity
}
pub fn clear(&mut self) {
self.buffer.iter_mut().for_each(|f| *f = None);
self.head = 0;
self.tail = 0;
self.size = 0;
}
}
src/tsaudio/src/capture.rs
+33
View File
@@ -0,0 +1,33 @@
//! 音频采集
use super::{AudioConfig, AudioFrame, AudioResult, AudioError};
pub struct AudioCapture {
config: AudioConfig,
}
impl AudioCapture {
pub fn new(config: AudioConfig) -> Self {
Self { config }
}
pub async fn start(&mut self) -> AudioResult<()> {
#[cfg(feature = "cpal")]
{
// TODO: cpal 实现
}
Ok(())
}
pub async fn stop(&mut self) -> AudioResult<()> {
Ok(())
}
pub async fn capture(&mut self) -> AudioResult<AudioFrame> {
Err(AudioError::Device("未实现".to_string()))
}
pub fn list_devices() -> AudioResult<Vec<String>> {
Ok(Vec::new())
}
}
src/tsaudio/src/codec.rs
+41
View File
@@ -0,0 +1,41 @@
//! Opus 编解码器
use super::{AudioResult, AudioError};
pub struct OpusEncoder {
sample_rate: u32,
channels: u16,
}
impl OpusEncoder {
pub fn new(sample_rate: u32, channels: u16) -> AudioResult<Self> {
Ok(Self { sample_rate, channels })
}
pub fn encode(&mut self, _samples: &[f32]) -> AudioResult<Vec<u8>> {
#[cfg(feature = "opus")]
{
// TODO: opus 实现
}
Err(AudioError::Codec("Opus 未启用".to_string()))
}
}
pub struct OpusDecoder {
sample_rate: u32,
channels: u16,
}
impl OpusDecoder {
pub fn new(sample_rate: u32, channels: u16) -> AudioResult<Self> {
Ok(Self { sample_rate, channels })
}
pub fn decode(&mut self, _data: &[u8], _fec: bool) -> AudioResult<Vec<f32>> {
#[cfg(feature = "opus")]
{
// TODO: opus 实现
}
Err(AudioError::Codec("Opus 未启用".to_string()))
}
}
src/tsaudio/src/lib.rs
+80
View File
@@ -0,0 +1,80 @@
//! TeamSpeak 音频引擎
pub mod capture;
pub mod playback;
pub mod codec;
pub mod vad;
pub mod buffer;
pub use capture::*;
pub use playback::*;
pub use codec::*;
pub use vad::*;
pub use buffer::*;
use thiserror::Error;
#[derive(Error, Debug)]
pub enum AudioError {
#[error("设备错误: {0}")]
Device(String),
#[error("编解码器错误: {0}")]
Codec(String),
#[error("缓冲区错误: {0}")]
Buffer(String),
#[error("配置错误: {0}")]
Config(String),
#[error("IO 错误: {0}")]
Io(#[from] std::io::Error),
}
pub type AudioResult<T> = Result<T, AudioError>;
#[derive(Debug, Clone)]
pub struct AudioConfig {
pub sample_rate: u32,
pub channels: u16,
pub bits_per_sample: u16,
pub frame_size: usize,
}
impl Default for AudioConfig {
fn default() -> Self {
Self {
sample_rate: 48000,
channels: 1,
bits_per_sample: 16,
frame_size: 960,
}
}
}
#[derive(Debug, Clone)]
pub struct AudioFrame {
pub sample_rate: u32,
pub channels: u16,
pub samples: Vec<f32>,
}
impl AudioFrame {
pub fn new(sample_rate: u32, channels: u16, samples: Vec<f32>) -> Self {
Self { sample_rate, channels, samples }
}
pub fn frame_size(&self) -> usize {
self.samples.len()
}
pub fn duration_ms(&self) -> f64 {
(self.frame_size() as f64 / self.channels as f64) / (self.sample_rate as f64) * 1000.0
}
}
#[derive(Debug, Clone)]
pub struct AudioDeviceInfo {
pub id: String,
pub name: String,
pub is_default: bool,
pub sample_rates: Vec<u32>,
pub channels: Vec<u16>,
}
src/tsaudio/src/playback.rs
+33
View File
@@ -0,0 +1,33 @@
//! 音频播放
use super::{AudioConfig, AudioFrame, AudioResult};
pub struct AudioPlayback {
config: AudioConfig,
}
impl AudioPlayback {
pub fn new(config: AudioConfig) -> Self {
Self { config }
}
pub async fn start(&mut self) -> AudioResult<()> {
#[cfg(feature = "cpal")]
{
// TODO: cpal 实现
}
Ok(())
}
pub async fn stop(&mut self) -> AudioResult<()> {
Ok(())
}
pub async fn play(&mut self, _frame: AudioFrame) -> AudioResult<()> {
Ok(())
}
pub fn list_devices() -> AudioResult<Vec<String>> {
Ok(Vec::new())
}
}
src/tsaudio/src/vad.rs
+41
View File
@@ -0,0 +1,41 @@
//! 语音活动检测 (VAD)
/// VAD 状态
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum VadState {
Silent,
Speaking,
}
/// 语音活动检测器
pub struct VadDetector {
threshold: f32,
state: VadState,
}
impl VadDetector {
pub fn new(threshold: f32) -> Self {
Self {
threshold,
state: VadState::Silent,
}
}
pub fn detect(&mut self, samples: &[f32]) -> VadState {
let energy: f32 = samples.iter().map(|s| s * s).sum::<f32>() / samples.len() as f32;
if energy > self.threshold {
self.state = VadState::Speaking;
} else {
self.state = VadState::Silent;
}
self.state
}
pub fn state(&self) -> VadState {
self.state
}
pub fn set_threshold(&mut self, threshold: f32) {
self.threshold = threshold;
}
}
src/tscore/Cargo.toml
+34
View File
@@ -0,0 +1,34 @@
[package]
name = "tscore"
version.workspace = true
edition.workspace = true
license.workspace = true
description = "TeamSpeak 3 协议核心实现"
[dependencies]
tokio = { workspace = true }
futures = { workspace = true }
serde = { workspace = true }
serde_json = { workspace = true }
thiserror = { workspace = true }
anyhow = { workspace = true }
tracing = { workspace = true }
aes = { workspace = true }
eax = { workspace = true }
sha1 = { workspace = true }
sha2 = { workspace = true }
p256 = { workspace = true }
curve25519-dalek-ng = { workspace = true }
num-bigint = { workspace = true }
generic-array = "0.14"
typenum = "1"
quicklz = { workspace = true }
bytes = "1"
base64 = { workspace = true }
rand = { workspace = true }
shared = { workspace = true }
src/tscore/src/connection/client.rs
+526
View File
@@ -0,0 +1,526 @@
//! 客户端连接 - 完整握手实现
use std::net::SocketAddr;
use std::time::Duration;
use super::state::{ConnectionState, ConnectionStateMachine};
use crate::crypto::{self, KeyCache, SharedSecret};
use crate::protocol::{
Command, CommandBuilder, Direction, Flags, Header, InitPacket, InitStep, InPacket, OutPacket,
PacketType,
};
use crate::ProtocolError;
/// 客户端配置
#[derive(Debug, Clone)]
pub struct ClientConfig {
pub address: SocketAddr,
pub nickname: String,
pub version: String,
pub platform: String,
pub server_password: Option<String>,
pub channel: Option<String>,
pub channel_password: Option<String>,
pub default_token: Option<String>,
}
impl ClientConfig {
pub fn new(address: SocketAddr, nickname: String) -> Self {
Self {
address,
nickname,
version: "3.0.19.3 [Build: 1466672534]".to_string(),
platform: "Linux".to_string(),
server_password: None,
channel: None,
channel_password: None,
default_token: None,
}
}
}
/// 客户端连接
pub struct Client {
config: ClientConfig,
state_machine: ConnectionStateMachine,
shared_secret: Option<SharedSecret>,
key_cache: KeyCache,
client_id: Option<u16>,
/// 客户端随机数 A0
random0: Option<[u8; 4]>,
/// 服务器随机数 A1
random1: Option<[u8; 16]>,
/// A0 反转
random0_r: Option<[u8; 4]>,
/// RSA 参数
rsa_x: Option<[u8; 64]>,
rsa_n: Option<[u8; 64]>,
rsa_level: Option<u32>,
/// 服务器随机数 A2
random2: Option<[u8; 100]>,
/// 客户端 alpha
alpha: Option<[u8; 10]>,
/// 服务器 beta
beta: Option<Vec<u8>>,
/// 当前数据包 ID
packet_id: u16,
/// 待发送的数据包队列
send_queue: Vec<Vec<u8>>,
/// 接收缓冲区
recv_buffer: Vec<u8>,
}
impl Client {
pub fn new(config: ClientConfig) -> Self {
Self {
config,
state_machine: ConnectionStateMachine::new(),
shared_secret: None,
key_cache: KeyCache::new(),
client_id: None,
random0: None,
random1: None,
random0_r: None,
rsa_x: None,
rsa_n: None,
rsa_level: None,
random2: None,
alpha: None,
beta: None,
packet_id: 0,
send_queue: Vec::new(),
recv_buffer: Vec::new(),
}
}
pub fn state(&self) -> ConnectionState {
self.state_machine.state()
}
pub fn client_id(&self) -> Option<u16> {
self.client_id
}
/// 开始连接握手
pub fn start_handshake(&mut self) -> Result<Vec<u8>, ProtocolError> {
self.state_machine
.transition(ConnectionState::Connecting)
.map_err(|e| ProtocolError::PacketParse(e))?;
// 生成随机数 A0
let mut random0 = [0u8; 4];
rand::Rng::fill(&mut rand::thread_rng(), &mut random0);
self.random0 = Some(random0);
// 构建 Init0 数据包
let init = InitPacket {
step: InitStep::Init0,
version: Some(Self::encode_version(&self.config.version)),
timestamp: Some(Self::current_timestamp()),
random0: Some(random0),
random1: None,
random0_r: None,
x: None,
n: None,
level: None,
random2: None,
y: None,
command: None,
};
let data = init.to_bytes();
Ok(data)
}
/// 处理接收到的数据
pub fn handle_data(&mut self, data: &[u8]) -> Result<Vec<Vec<u8>>, ProtocolError> {
let mut responses = Vec::new();
match self.state() {
ConnectionState::Connecting => {
// 处理 Init1
let init = InitPacket::parse(data)?;
if init.step == InitStep::Init1 {
self.random1 = init.random1;
self.random0_r = init.random0_r;
// 发送 Init2
let response = self.build_init2()?;
responses.push(response);
} else if init.step == InitStep::Reset {
// 服务器要求重置，重新发送 Init0
let response = self.start_handshake()?;
responses.push(response);
}
}
ConnectionState::IdentityLevelIncreasing => {
// 处理 Init3
let init = InitPacket::parse(data)?;
if init.step == InitStep::Init3 {
self.rsa_x = init.x;
self.rsa_n = init.n;
self.rsa_level = init.level;
self.random2 = init.random2;
// 计算 RSA 解答
let response = self.build_init4()?;
responses.push(response);
}
}
ConnectionState::Connected => {
// 处理命令数据包
let packet = InPacket::parse(Direction::S2C, data)?;
let content = if !packet.header.flags.is_unencrypted() {
if let Some(ref secret) = self.shared_secret {
crypto::decrypt_packet(
&packet,
0,
&secret.iv,
&mut self.key_cache,
)?
} else {
crypto::decrypt_fake(&packet)?
}
} else {
packet.data.clone()
};
// 解析命令
let cmd_str = String::from_utf8_lossy(&content);
let cmd = Command::parse(&cmd_str)?;
match cmd.name.as_str() {
"initserver" => {
// 连接完成
if let Some(id) = cmd.get("client_id") {
self.client_id = id.parse().ok();
}
self.state_machine
.transition(ConnectionState::ChannelListFinished)
.map_err(|e| ProtocolError::PacketParse(e))?;
}
"initivexpand" => {
// 旧协议密钥交换
let response = self.handle_initivexpand(&cmd)?;
responses.push(response);
}
"initivexpand2" => {
// 新协议密钥交换
let response = self.handle_initivexpand2(&cmd)?;
responses.push(response);
}
"channellist" => {
// 频道列表
}
"channellistfinished" => {
self.state_machine
.transition(ConnectionState::ChannelListFinished)
.map_err(|e| ProtocolError::PacketParse(e))?;
}
"notifycliententerview" => {
// 客户端进入视图
}
"error" => {
if let Some(id) = cmd.get("id") {
if id != "0" {
return Err(ProtocolError::PacketParse(format!(
"服务器错误: {}",
cmd.get("msg").unwrap_or("未知")
)));
}
}
}
_ => {}
}
}
_ => {}
}
Ok(responses)
}
/// 构建 Init2 数据包
fn build_init2(&mut self) -> Result<Vec<u8>, ProtocolError> {
let init = InitPacket {
step: InitStep::Init2,
version: Some(Self::encode_version(&self.config.version)),
timestamp: None,
random0: None,
random1: self.random1,
random0_r: self.random0_r,
x: None,
n: None,
level: None,
random2: None,
y: None,
command: None,
};
self.state_machine
.transition(ConnectionState::IdentityLevelIncreasing)
.map_err(|e| ProtocolError::PacketParse(e))?;
Ok(init.to_bytes())
}
/// 构建 Init4 数据包
fn build_init4(&mut self) -> Result<Vec<u8>, ProtocolError> {
// 计算 y = x^(2^level) mod n
let x = self.rsa_x.ok_or_else(|| ProtocolError::PacketParse("缺少 RSA x".to_string()))?;
let n = self.rsa_n.ok_or_else(|| ProtocolError::PacketParse("缺少 RSA n".to_string()))?;
let level = self.rsa_level.ok_or_else(|| ProtocolError::PacketParse("缺少 RSA level".to_string()))?;
let y = Self::solve_rsa_puzzle(&x, &n, level);
// 生成 alpha
let mut alpha = [0u8; 10];
rand::Rng::fill(&mut rand::thread_rng(), &mut alpha);
self.alpha = Some(alpha);
// 构建 clientinitiv 命令
let alpha_b64 = base64::Engine::encode(&base64::engine::general_purpose::STANDARD, alpha);
let omega = self.get_identity_omega();
let ip = self.config.address.ip().to_string();
let cmd = CommandBuilder::new("clientinitiv")
.arg("alpha", &alpha_b64)
.arg("omega", &omega)
.arg("ot", "1")
.arg("ip", &ip)
.build();
let init = InitPacket {
step: InitStep::Init4,
version: Some(Self::encode_version(&self.config.version)),
timestamp: None,
random0: None,
random1: None,
random0_r: None,
x: Some(x),
n: Some(n),
level: Some(level),
random2: self.random2,
y: Some(y),
command: Some(cmd.to_string().into_bytes()),
};
self.state_machine
.transition(ConnectionState::Connected)
.map_err(|e| ProtocolError::PacketParse(e))?;
Ok(init.to_bytes())
}
/// 处理 initivexpand (旧协议)
fn handle_initivexpand(&mut self, cmd: &Command) -> Result<Vec<u8>, ProtocolError> {
let alpha_b64 = cmd
.get("alpha")
.ok_or_else(|| ProtocolError::PacketParse("缺少 alpha".to_string()))?;
let beta_b64 = cmd
.get("beta")
.ok_or_else(|| ProtocolError::PacketParse("缺少 beta".to_string()))?;
let omega = cmd
.get("omega")
.ok_or_else(|| ProtocolError::PacketParse("缺少 omega".to_string()))?;
let alpha_bytes = base64::Engine::decode(&base64::engine::general_purpose::STANDARD, alpha_b64)
.map_err(|_| ProtocolError::PacketParse("无效的 alpha".to_string()))?;
let beta_bytes = base64::Engine::decode(&base64::engine::general_purpose::STANDARD, beta_b64)
.map_err(|_| ProtocolError::PacketParse("无效的 beta".to_string()))?;
let mut alpha = [0u8; 10];
alpha.copy_from_slice(&alpha_bytes);
let mut beta = [0u8; 10];
beta.copy_from_slice(&beta_bytes);
// 计算共享密钥
let shared_data = [0u8; 32]; // TODO: 从 ECDH 计算
let secret = SharedSecret::compute_old(&alpha, &beta, &shared_data);
self.shared_secret = Some(secret);
// 发送 clientek
let ek = self.get_identity_omega();
let proof = self.generate_proof(&ek, &beta_b64);
let cmd = CommandBuilder::new("clientek")
.arg("ek", &ek)
.arg("proof", &proof)
.build();
Ok(cmd.to_string().into_bytes())
}
/// 处理 initivexpand2 (新协议)
fn handle_initivexpand2(&mut self, cmd: &Command) -> Result<Vec<u8>, ProtocolError> {
let beta_b64 = cmd
.get("beta")
.ok_or_else(|| ProtocolError::PacketParse("缺少 beta".to_string()))?;
let omega = cmd
.get("omega")
.ok_or_else(|| ProtocolError::PacketParse("缺少 omega".to_string()))?;
let beta_bytes = base64::Engine::decode(&base64::engine::general_purpose::STANDARD, beta_b64)
.map_err(|_| ProtocolError::PacketParse("无效的 beta".to_string()))?;
let mut beta = [0u8; 54];
if beta_bytes.len() >= 54 {
beta.copy_from_slice(&beta_bytes[..54]);
} else {
beta[..beta_bytes.len()].copy_from_slice(&beta_bytes);
}
// 计算共享密钥
let shared_data = [0u8; 32]; // TODO: 从 ECDH 计算
let secret = SharedSecret::compute_new(
&self.alpha.unwrap_or([0; 10]),
&beta,
&shared_data,
);
self.shared_secret = Some(secret);
// 发送 clientek
let ek = self.get_identity_omega();
let proof = self.generate_proof(&ek, beta_b64);
let cmd = CommandBuilder::new("clientek")
.arg("ek", &ek)
.arg("proof", &proof)
.build();
Ok(cmd.to_string().into_bytes())
}
/// 构建 clientinit 命令
pub fn build_clientinit(&self) -> Vec<u8> {
let channel_password = self
.config
.channel_password
.as_deref()
.map(|p| crypto::hash_password(p))
.unwrap_or_default();
let server_password = self
.config
.server_password
.as_deref()
.map(|p| crypto::hash_password(p))
.unwrap_or_default();
let cmd = CommandBuilder::new("clientinit")
.arg("client_nickname", &self.config.nickname)
.arg("client_version", &self.config.version)
.arg("client_platform", &self.config.platform)
.arg("client_input_hardware", "1")
.arg("client_output_hardware", "1")
.arg(
"client_default_channel",
self.config.channel.as_deref().unwrap_or(""),
)
.arg("client_default_channel_password", &channel_password)
.arg("client_server_password", &server_password)
.arg("client_meta_data", "")
.arg(
"client_version_sign",
"a1OYzvM18mrmfUQBUgxYBxYz2DUU6y5k3/mEL6FurzU0y97Bd1FL7+PRpcHyPkg4R+kKAFZ1nhyzbgkGphDWDg==",
)
.arg("client_key_offset", "0")
.arg("client_nickname_phonetic", "")
.arg(
"client_default_token",
self.config.default_token.as_deref().unwrap_or(""),
)
.arg("hwid", "87056c6e1268aaf5055abf8256415e0e,408978b6d98810cc03f0aa16a4c75600")
.build();
cmd.to_string().into_bytes()
}
/// 编码版本号
fn encode_version(version: &str) -> u32 {
// 从版本字符串提取构建时间戳
if let Some(start) = version.find("[Build: ") {
let rest = &version[start + 8..];
if let Some(end) = rest.find(']') {
let ts_str = &rest[..end];
if let Ok(ts) = ts_str.parse::<u32>() {
return ts;
}
}
}
1466672534 // 默认值
}
/// 获取当前时间戳
fn current_timestamp() -> u32 {
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap_or(Duration::from_secs(0))
.as_secs() as u32
}
/// 解决 RSA 拼图
/// y = x^(2^level) mod n
fn solve_rsa_puzzle(x: &[u8; 64], n: &[u8; 64], level: u32) -> [u8; 64] {
let x_big = num_bigint::BigUint::from_bytes_be(x);
let n_big = num_bigint::BigUint::from_bytes_be(n);
// y = x^(2^level) mod n
// 需要做 level 次平方操作
let mut y = x_big;
for _ in 0..level {
y = (y.clone() * y) % &n_big;
}
let mut result = [0u8; 64];
let bytes = y.to_bytes_be();
let offset = 64 - bytes.len();
result[offset..].copy_from_slice(&bytes);
result
}
/// 获取身份公钥 (omega)
fn get_identity_omega(&self) -> String {
// TODO: 从实际身份获取
"placeholder_omega".to_string()
}
/// 生成证明
fn generate_proof(&self, data: &str, beta: &str) -> String {
// TODO: 使用身份私钥签名
let combined = format!("{}{}", data, beta);
let hash = crypto::sha1(combined.as_bytes());
base64::Engine::encode(&base64::engine::general_purpose::STANDARD, hash)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_encode_version() {
let version = "3.0.19.3 [Build: 1466672534]";
assert_eq!(Client::encode_version(version), 1466672534);
}
#[test]
fn test_rsa_puzzle() {
// 使用非零值测试
let mut x = [0u8; 64];
x[63] = 2; // x = 2
let mut n = [0u8; 64];
n[63] = 7; // n = 7
// level=0: y = x^(2^0) mod n = x^1 mod n = 2 mod 7 = 2
let y = Client::solve_rsa_puzzle(&x, &n, 0);
assert_eq!(y[63], 2);
// level=1: y = x^(2^1) mod n = x^2 mod n = 4 mod 7 = 4
let y = Client::solve_rsa_puzzle(&x, &n, 1);
assert_eq!(y[63], 4);
// level=2: y = x^(2^2) mod n = x^4 mod n = 16 mod 7 = 2
let y = Client::solve_rsa_puzzle(&x, &n, 2);
assert_eq!(y[63], 2);
}
}
src/tscore/src/connection/mod.rs
+9
View File
@@ -0,0 +1,9 @@
//! 连接管理
pub mod client;
pub mod state;
pub mod resend;
pub use client::*;
pub use state::*;
pub use resend::*;
src/tscore/src/connection/resend.rs
+258
View File
@@ -0,0 +1,258 @@
//! 数据包重传和确认系统
use std::collections::BTreeMap;
use std::time::{Duration, Instant};
use crate::protocol::PacketType;
/// 数据包 ID
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub struct PacketId {
pub generation_id: u32,
pub packet_id: u16,
}
impl PacketId {
pub fn new(generation_id: u32, packet_id: u16) -> Self {
Self { generation_id, packet_id }
}
pub fn increment(&mut self) {
let (new_id, overflow) = self.packet_id.overflowing_add(1);
self.packet_id = new_id;
if overflow {
self.generation_id += 1;
}
}
}
/// 已发送的数据包信息
#[derive(Debug, Clone)]
pub struct SentPacket {
pub data: Vec<u8>,
pub sent_at: Instant,
pub retry_count: u32,
pub timeout: Duration,
}
impl SentPacket {
pub fn new(data: Vec<u8>) -> Self {
Self {
data,
sent_at: Instant::now(),
retry_count: 0,
timeout: Duration::from_millis(500), // 初始超时 500ms
}
}
pub fn is_expired(&self) -> bool {
self.sent_at.elapsed() > self.timeout
}
pub fn should_retry(&self, max_retries: u32) -> bool {
self.is_expired() && self.retry_count < max_retries
}
pub fn retry(&mut self) {
self.retry_count += 1;
self.sent_at = Instant::now();
// 指数退避
self.timeout = Duration::from_millis(500 * (1 << self.retry_count).min(32));
}
}
/// 重传管理器
pub struct ResendManager {
/// 等待确认的数据包
pending: BTreeMap<PacketId, SentPacket>,
/// 最大重试次数
max_retries: u32,
/// 连接超时
connection_timeout: Duration,
}
impl ResendManager {
pub fn new() -> Self {
Self {
pending: BTreeMap::new(),
max_retries: 10,
connection_timeout: Duration::from_secs(30),
}
}
/// 添加已发送的数据包
pub fn add_sent(&mut self, id: PacketId, data: Vec<u8>) {
self.pending.insert(id, SentPacket::new(data));
}
/// 确认数据包
pub fn ack(&mut self, id: &PacketId) -> bool {
self.pending.remove(id).is_some()
}
/// 获取需要重传的数据包
pub fn get_retransmissions(&mut self) -> Vec<(PacketId, Vec<u8>)> {
let mut retransmissions = Vec::new();
let mut to_retry = Vec::new();
for (id, packet) in self.pending.iter() {
if packet.should_retry(self.max_retries) {
to_retry.push(*id);
}
}
for id in to_retry {
if let Some(packet) = self.pending.get_mut(&id) {
packet.retry();
retransmissions.push((id, packet.data.clone()));
}
}
retransmissions
}
/// 检查是否连接超时
pub fn is_connection_timeout(&self) -> bool {
self.pending.values().any(|p| p.sent_at.elapsed() > self.connection_timeout)
}
/// 获取待确认数据包数量
pub fn pending_count(&self) -> usize {
self.pending.len()
}
/// 清空所有待确认数据包
pub fn clear(&mut self) {
self.pending.clear();
}
/// 设置最大重试次数
pub fn set_max_retries(&mut self, max_retries: u32) {
self.max_retries = max_retries;
}
/// 设置连接超时
pub fn set_connection_timeout(&mut self, timeout: Duration) {
self.connection_timeout = timeout;
}
}
impl Default for ResendManager {
fn default() -> Self {
Self::new()
}
}
/// RTT 估算器
pub struct RttEstimator {
srtt: Duration,
rtt_var: Duration,
rto: Duration,
}
impl RttEstimator {
pub fn new() -> Self {
Self {
srtt: Duration::from_millis(500),
rtt_var: Duration::from_millis(250),
rto: Duration::from_millis(1000),
}
}
/// 更新 RTT 估算
pub fn update(&mut self, measured_rtt: Duration) {
let alpha = 0.125;
let beta = 0.25;
let diff = if measured_rtt > self.srtt {
measured_rtt - self.srtt
} else {
self.srtt - measured_rtt
};
self.rtt_var = Duration::from_secs_f64(
(1.0 - beta) * self.rtt_var.as_secs_f64() + beta * diff.as_secs_f64(),
);
self.srtt = Duration::from_secs_f64(
(1.0 - alpha) * self.srtt.as_secs_f64() + alpha * measured_rtt.as_secs_f64(),
);
self.rto = self.srtt + self.rtt_var * 4;
// 限制 RTO 范围
if self.rto < Duration::from_millis(100) {
self.rto = Duration::from_millis(100);
}
if self.rto > Duration::from_secs(60) {
self.rto = Duration::from_secs(60);
}
}
/// 获取当前 RTO
pub fn rto(&self) -> Duration {
self.rto
}
/// 获取平滑 RTT
pub fn srtt(&self) -> Duration {
self.srtt
}
}
impl Default for RttEstimator {
fn default() -> Self {
Self::new()
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_resend_manager() {
let mut manager = ResendManager::new();
let id = PacketId::new(0, 1);
manager.add_sent(id, vec![1, 2, 3]);
assert_eq!(manager.pending_count(), 1);
// 确认
assert!(manager.ack(&id));
assert_eq!(manager.pending_count(), 0);
}
#[test]
fn test_rtt_estimator() {
let mut estimator = RttEstimator::new();
// 初始 SRTT 是 500ms
assert_eq!(estimator.srtt(), Duration::from_millis(500));
// 更新多次，SRTT 应该逐渐收敛
for _ in 0..100 {
estimator.update(Duration::from_millis(100));
}
// 经过多次更新后，SRTT 应该接近 100ms
assert!(estimator.srtt() < Duration::from_millis(150));
// RTO 应该大于 SRTT
assert!(estimator.rto() > estimator.srtt());
}
#[test]
fn test_sent_packet_retry() {
let mut packet = SentPacket::new(vec![1, 2, 3]);
assert!(!packet.is_expired());
// 模拟超时
packet.sent_at = Instant::now() - Duration::from_millis(600);
assert!(packet.is_expired());
assert!(packet.should_retry(10));
packet.retry();
assert_eq!(packet.retry_count, 1);
assert!(!packet.is_expired());
}
}
src/tscore/src/connection/state.rs
+90
View File
@@ -0,0 +1,90 @@
//! 连接状态管理
use std::fmt;
/// 连接状态
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ConnectionState {
Disconnected,
Connecting,
IdentityLevelIncreasing,
Connected,
ChannelListFinished,
DisconnectedTemporarily,
Error,
}
impl ConnectionState {
pub fn is_connected(&self) -> bool {
matches!(self, Self::Connected | Self::ChannelListFinished)
}
pub fn is_connecting(&self) -> bool {
matches!(self, Self::Connecting | Self::IdentityLevelIncreasing)
}
pub fn is_disconnected(&self) -> bool {
matches!(self, Self::Disconnected | Self::Error)
}
}
impl fmt::Display for ConnectionState {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Disconnected => write!(f, "Disconnected"),
Self::Connecting => write!(f, "Connecting"),
Self::IdentityLevelIncreasing => write!(f, "IdentityLevelIncreasing"),
Self::Connected => write!(f, "Connected"),
Self::ChannelListFinished => write!(f, "ChannelListFinished"),
Self::DisconnectedTemporarily => write!(f, "DisconnectedTemporarily"),
Self::Error => write!(f, "Error"),
}
}
}
/// 连接状态机
pub struct ConnectionStateMachine {
state: ConnectionState,
}
impl ConnectionStateMachine {
pub fn new() -> Self {
Self {
state: ConnectionState::Disconnected,
}
}
pub fn state(&self) -> ConnectionState {
self.state
}
pub fn transition(&mut self, new_state: ConnectionState) -> Result<(), String> {
let valid = matches!(
(self.state, new_state),
(ConnectionState::Disconnected, ConnectionState::Connecting)
| (ConnectionState::Connecting, ConnectionState::IdentityLevelIncreasing)
| (ConnectionState::Connecting, ConnectionState::Connected)
| (ConnectionState::IdentityLevelIncreasing, ConnectionState::Connected)
| (ConnectionState::Connected, ConnectionState::ChannelListFinished)
| (ConnectionState::Connected, ConnectionState::DisconnectedTemporarily)
| (ConnectionState::ChannelListFinished, ConnectionState::DisconnectedTemporarily)
| (ConnectionState::DisconnectedTemporarily, ConnectionState::Connected)
| (ConnectionState::DisconnectedTemporarily, ConnectionState::Disconnected)
| (_, ConnectionState::Error)
| (ConnectionState::Error, ConnectionState::Disconnected)
);
if valid {
self.state = new_state;
Ok(())
} else {
Err(format!("Invalid state transition: {} -> {}", self.state, new_state))
}
}
}
impl Default for ConnectionStateMachine {
fn default() -> Self {
Self::new()
}
}
src/tscore/src/crypto/eax.rs
+118
View File
@@ -0,0 +1,118 @@
//! EAX 模式加密
use aes::Aes128;
use eax::aead::consts::U8;
use eax::{AeadInPlace, Eax, KeyInit};
use generic_array::GenericArray;
use super::keys;
use crate::protocol::{InPacket, OutPacket};
use crate::ProtocolError;
/// EAX 加密器
pub struct EaxCipher {
cipher: Eax<Aes128, U8>,
}
impl EaxCipher {
pub fn new(key: &[u8; 16]) -> Self {
let key = GenericArray::from_slice(key);
Self {
cipher: Eax::<Aes128, U8>::new(key),
}
}
pub fn encrypt(
&self,
nonce: &[u8; 16],
header: &[u8],
data: &mut [u8],
) -> Result<[u8; 8], ProtocolError> {
let nonce = GenericArray::from_slice(nonce);
let tag = self
.cipher
.encrypt_in_place_detached(nonce, header, data)
.map_err(|_| ProtocolError::Encryption("EAX 加密失败".to_string()))?;
let mut mac = [0u8; 8];
mac.copy_from_slice(&tag[..8]);
Ok(mac)
}
pub fn decrypt(
&self,
nonce: &[u8; 16],
header: &[u8],
data: &mut [u8],
mac: &[u8; 8],
) -> Result<(), ProtocolError> {
let nonce = GenericArray::from_slice(nonce);
let tag = GenericArray::from_slice(mac);
self.cipher
.decrypt_in_place_detached(nonce, header, data, tag)
.map_err(|_| ProtocolError::Decryption("MAC 验证失败".to_string()))
}
}
/// 加密数据包
pub fn encrypt_packet(
packet: &mut OutPacket,
generation_id: u32,
iv: &[u8; 64],
key_cache: &mut keys::KeyCache,
) -> Result<(), ProtocolError> {
let packet_type = packet.header.flags.packet_type();
let direction = packet.direction;
let packet_id = packet.header.packet_id;
let (key, nonce) = key_cache.get_or_create(packet_type, direction, generation_id, iv);
let enc_key = keys::create_encryption_key(&key, packet_id);
let cipher = EaxCipher::new(&enc_key);
let meta = packet.header.get_meta(direction);
let mac = cipher.encrypt(&nonce, &meta, &mut packet.data)?;
packet.header.mac = mac;
Ok(())
}
/// 解密数据包
pub fn decrypt_packet(
packet: &InPacket,
generation_id: u32,
iv: &[u8; 64],
key_cache: &mut keys::KeyCache,
) -> Result<Vec<u8>, ProtocolError> {
let packet_type = packet.header.flags.packet_type();
let direction = packet.direction;
let packet_id = packet.header.packet_id;
let (key, nonce) = key_cache.get_or_create(packet_type, direction, generation_id, iv);
let enc_key = keys::create_encryption_key(&key, packet_id);
let cipher = EaxCipher::new(&enc_key);
let meta = packet.header.get_meta(direction);
let mut data = packet.data.clone();
cipher.decrypt(&nonce, &meta, &mut data, &packet.header.mac)?;
Ok(data)
}
/// 假加密
pub fn encrypt_fake(packet: &mut OutPacket) -> Result<(), ProtocolError> {
let cipher = EaxCipher::new(&keys::FAKE_KEY);
let meta = packet.header.get_meta(packet.direction);
let mac = cipher.encrypt(&keys::FAKE_NONCE, &meta, &mut packet.data)?;
packet.header.mac = mac;
Ok(())
}
/// 假解密
pub fn decrypt_fake(packet: &InPacket) -> Result<Vec<u8>, ProtocolError> {
let cipher = EaxCipher::new(&keys::FAKE_KEY);
let meta = packet.header.get_meta(packet.direction);
let mut data = packet.data.clone();
cipher.decrypt(&keys::FAKE_NONCE, &meta, &mut data, &packet.header.mac)?;
Ok(data)
}
src/tscore/src/crypto/hash.rs
+40
View File
@@ -0,0 +1,40 @@
//! 哈希函数
use sha1::Sha1;
use sha2::{Digest, Sha256, Sha512};
/// SHA-1 哈希
pub fn sha1(data: &[u8]) -> [u8; 20] {
let mut hasher = Sha1::new();
hasher.update(data);
let result = hasher.finalize();
let mut hash = [0u8; 20];
hash.copy_from_slice(&result);
hash
}
/// SHA-256 哈希
pub fn sha256(data: &[u8]) -> [u8; 32] {
let mut hasher = Sha256::new();
hasher.update(data);
let result = hasher.finalize();
let mut hash = [0u8; 32];
hash.copy_from_slice(&result);
hash
}
/// SHA-512 哈希
pub fn sha512(data: &[u8]) -> [u8; 64] {
let mut hasher = Sha512::new();
hasher.update(data);
let result = hasher.finalize();
let mut hash = [0u8; 64];
hash.copy_from_slice(&result);
hash
}
/// 计算密码哈希
pub fn hash_password(password: &str) -> String {
let hash = sha1(password.as_bytes());
base64::Engine::encode(&base64::engine::general_purpose::STANDARD, hash)
}
src/tscore/src/crypto/keys.rs
+229
View File
@@ -0,0 +1,229 @@
//! 密钥管理
use sha1::Sha1;
use sha2::{Digest, Sha256, Sha512};
use crate::protocol::PacketType;
use crate::protocol::Direction;
/// 假加密密钥
pub const FAKE_KEY: [u8; 16] = *b"c:\\windows\\syste";
/// 假加密 Nonce
pub const FAKE_NONCE: [u8; 16] = *b"m\\firewall32.cpl";
/// 许可证根密钥
pub const ROOT_KEY: [u8; 32] = [
0xcd, 0x0d, 0xe2, 0xae, 0xd4, 0x63, 0x45, 0x50, 0x9a, 0x7e, 0x3c, 0xfd, 0x8f, 0x68, 0xb3,
0xdc, 0x75, 0x55, 0xb2, 0x9d, 0xcc, 0xec, 0x73, 0xcd, 0x18, 0x75, 0x0f, 0x99, 0x38, 0x12,
0x40, 0x8a,
];
/// 共享密钥
#[derive(Clone)]
pub struct SharedSecret {
pub iv: [u8; 64],
pub mac: [u8; 8],
}
impl SharedSecret {
pub fn new(iv: [u8; 64], mac: [u8; 8]) -> Self {
Self { iv, mac }
}
pub fn compute_old(alpha: &[u8; 10], beta: &[u8; 10], shared_data: &[u8; 32]) -> Self {
let mut hasher = Sha1::new();
hasher.update(shared_data);
let hash = hasher.finalize();
let mut iv = [0u8; 64];
iv[..20].copy_from_slice(&hash);
for i in 0..10 {
iv[i] ^= alpha[i];
}
for i in 0..10 {
iv[i + 10] ^= beta[i];
}
let mut hasher = Sha1::new();
hasher.update(&iv);
let mac_hash = hasher.finalize();
let mut mac = [0u8; 8];
mac.copy_from_slice(&mac_hash[..8]);
Self::new(iv, mac)
}
pub fn compute_new(alpha: &[u8; 10], beta: &[u8; 54], shared_data: &[u8; 32]) -> Self {
let mut hasher = Sha512::new();
hasher.update(shared_data);
let hash = hasher.finalize();
let mut iv = [0u8; 64];
iv.copy_from_slice(&hash);
for i in 0..10 {
iv[i] ^= alpha[i];
}
for i in 0..54 {
iv[i + 10] ^= beta[i];
}
let mut hasher = Sha1::new();
hasher.update(&iv);
let mac_hash = hasher.finalize();
let mut mac = [0u8; 8];
mac.copy_from_slice(&mac_hash[..8]);
Self::new(iv, mac)
}
}
impl std::fmt::Debug for SharedSecret {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "SharedSecret {{ iv: [hidden], mac: [hidden] }}")
}
}
/// 缓存的密钥
#[derive(Debug, Clone)]
pub struct CachedKey {
pub generation_id: u32,
pub key: [u8; 16],
pub nonce: [u8; 16],
}
impl CachedKey {
pub fn new() -> Self {
Self {
generation_id: u32::MAX,
key: [0; 16],
nonce: [0; 16],
}
}
pub fn is_valid(&self, generation_id: u32) -> bool {
self.generation_id == generation_id
}
}
impl Default for CachedKey {
fn default() -> Self {
Self::new()
}
}
/// 密钥缓存
pub struct KeyCache {
cache: [[CachedKey; 2]; 8],
}
impl KeyCache {
pub fn new() -> Self {
Self {
cache: Default::default(),
}
}
pub fn get_or_create(
&mut self,
packet_type: PacketType,
direction: Direction,
generation_id: u32,
iv: &[u8; 64],
) -> ([u8; 16], [u8; 16]) {
let type_idx = packet_type.to_usize();
let dir_idx = match direction {
Direction::C2S => 1,
Direction::S2C => 0,
};
let cached = &mut self.cache[type_idx][dir_idx];
if !cached.is_valid(generation_id) {
let (key, nonce) = create_key_nonce(packet_type, direction, generation_id, iv);
cached.generation_id = generation_id;
cached.key = key;
cached.nonce = nonce;
}
(cached.key, cached.nonce)
}
pub fn invalidate(&mut self) {
self.cache = Default::default();
}
}
impl Default for KeyCache {
fn default() -> Self {
Self::new()
}
}
/// 创建密钥和 Nonce
pub fn create_key_nonce(
packet_type: PacketType,
direction: Direction,
generation_id: u32,
iv: &[u8; 64],
) -> ([u8; 16], [u8; 16]) {
let mut temp = [0u8; 70];
temp[0] = match direction {
Direction::C2S => 0x31,
Direction::S2C => 0x30,
};
temp[1] = packet_type.to_u8();
temp[2..6].copy_from_slice(&generation_id.to_be_bytes());
temp[6..].copy_from_slice(iv);
let mut hasher = Sha256::new();
hasher.update(&temp);
let hash = hasher.finalize();
let mut key = [0u8; 16];
let mut nonce = [0u8; 16];
key.copy_from_slice(&hash[..16]);
nonce.copy_from_slice(&hash[16..]);
(key, nonce)
}
/// 创建用于加密的密钥
pub fn create_encryption_key(key: &[u8; 16], packet_id: u16) -> [u8; 16] {
let mut result = *key;
result[0] ^= (packet_id >> 8) as u8;
result[1] ^= (packet_id & 0xff) as u8;
result
}
/// 计算 Hash Cash 级别
pub fn get_hash_cash_level(omega: &str, offset: u64) -> u8 {
let mut hasher = Sha1::new();
hasher.update(format!("{}{}", omega, offset).as_bytes());
let hash = hasher.finalize();
let mut level = 0;
for &byte in hash.iter() {
if byte == 0 {
level += 8;
} else {
level += byte.trailing_zeros() as u8;
break;
}
}
level
}
/// 计算 UID
pub fn compute_uid(public_key: &[u8]) -> String {
let mut hasher = Sha1::new();
hasher.update(public_key);
let hash = hasher.finalize();
base64::Engine::encode(&base64::engine::general_purpose::STANDARD, hash)
}
src/tscore/src/crypto/mod.rs
+10
View File
@@ -0,0 +1,10 @@
//! 加密模块
pub mod eax;
pub mod keys;
pub mod hash;
mod tests;
pub use eax::*;
pub use keys::*;
pub use hash::*;
src/tscore/src/crypto/tests.rs
+156
View File
@@ -0,0 +1,156 @@
//! 加密测试
#[cfg(test)]
mod tests {
use crate::crypto::*;
use crate::protocol::{Direction, Flags, InPacket, OutPacket, PacketType};
#[test]
fn test_sha1() {
let hash = sha1(b"hello");
assert_eq!(hash.len(), 20);
// SHA1("hello") = aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d
assert_eq!(hash[0], 0xaa);
}
#[test]
fn test_sha256() {
let hash = sha256(b"hello");
assert_eq!(hash.len(), 32);
}
#[test]
fn test_sha512() {
let hash = sha512(b"hello");
assert_eq!(hash.len(), 64);
}
#[test]
fn test_hash_password() {
let hash = hash_password("password");
assert!(!hash.is_empty());
// base64(sha1("password"))
assert!(hash.contains("=") || hash.len() > 20);
}
#[test]
fn test_create_key_nonce() {
let iv = [0u8; 64];
let (key, nonce) = create_key_nonce(PacketType::Command, Direction::C2S, 0, &iv);
assert_ne!(key, [0u8; 16]);
assert_ne!(nonce, [0u8; 16]);
}
#[test]
fn test_create_encryption_key() {
let key = [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10];
let encrypted = create_encryption_key(&key, 0x1234);
assert_eq!(encrypted[0], key[0] ^ 0x12);
assert_eq!(encrypted[1], key[1] ^ 0x34);
// 其他字节不变
assert_eq!(encrypted[2], key[2]);
}
#[test]
fn test_shared_secret_old() {
let alpha = [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a];
let beta = [0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14];
let shared_data = [0x15; 32];
let secret = SharedSecret::compute_old(&alpha, &beta, &shared_data);
assert_ne!(secret.iv, [0u8; 64]);
assert_ne!(secret.mac, [0u8; 8]);
}
#[test]
fn test_shared_secret_new() {
let alpha = [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a];
let beta = [0x0b; 54];
let shared_data = [0x15; 32];
let secret = SharedSecret::compute_new(&alpha, &beta, &shared_data);
assert_ne!(secret.iv, [0u8; 64]);
assert_ne!(secret.mac, [0u8; 8]);
}
#[test]
fn test_key_cache() {
let mut cache = KeyCache::new();
let iv = [0u8; 64];
let (key1, nonce1) = cache.get_or_create(PacketType::Command, Direction::C2S, 0, &iv);
let (key2, nonce2) = cache.get_or_create(PacketType::Command, Direction::C2S, 0, &iv);
assert_eq!(key1, key2);
assert_eq!(nonce1, nonce2);
// 不同的 generation_id 应该返回不同的密钥
let (key3, _) = cache.get_or_create(PacketType::Command, Direction::C2S, 1, &iv);
assert_ne!(key1, key3);
}
#[test]
fn test_eax_encrypt_decrypt() {
let key = [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10];
let nonce = [0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20];
let cipher = EaxCipher::new(&key);
let header = b"test header";
let mut data = b"Hello, World!".to_vec();
// 加密
let mac = cipher.encrypt(&nonce, header, &mut data).unwrap();
// 解密
cipher.decrypt(&nonce, header, &mut data, &mac).unwrap();
assert_eq!(data, b"Hello, World!");
}
#[test]
fn test_fake_encrypt_decrypt() {
let mut packet = OutPacket::new(
Direction::C2S,
Flags::new(PacketType::Command.to_u8()),
b"test data".to_vec(),
);
packet.header.packet_id = 1;
// 假加密
encrypt_fake(&mut packet).unwrap();
// 假解密
let in_packet = InPacket {
direction: Direction::C2S,
header: packet.header.clone(),
data: packet.data.clone(),
};
let decrypted = decrypt_fake(&in_packet).unwrap();
assert_eq!(decrypted, b"test data");
}
#[test]
fn test_hash_cash_level() {
// 测试不同的 offset 产生不同的 level
let level0 = get_hash_cash_level("test_key", 0);
let level1 = get_hash_cash_level("test_key", 1);
// level 应该 >= 0
assert!(level0 >= 0);
assert!(level1 >= 0);
// 使用一个会产生更高 level 的 key
let level_high = get_hash_cash_level("a", 12345);
assert!(level_high >= 0);
}
#[test]
fn test_compute_uid() {
let public_key = b"test_public_key_data";
let uid = compute_uid(public_key);
assert!(!uid.is_empty());
// UID 应该是 base64 编码的 SHA1 哈希
assert!(uid.len() > 20);
}
}
src/tscore/src/lib.rs
+74
View File
@@ -0,0 +1,74 @@
//! TeamSpeak 3 协议核心实现
pub mod protocol;
pub mod crypto;
pub mod network;
pub mod connection;
pub use protocol::*;
pub use crypto::*;
pub use network::*;
pub use connection::*;
use thiserror::Error;
/// 协议错误
#[derive(Error, Debug)]
pub enum ProtocolError {
#[error("数据包解析错误: {0}")]
PacketParse(String),
#[error("加密错误: {0}")]
Encryption(String),
#[error("解密错误: {0}")]
Decryption(String),
#[error("压缩错误: {0}")]
Compression(String),
#[error("解压错误: {0}")]
Decompression(String),
#[error("无效的数据包类型: {0}")]
InvalidPacketType(u8),
#[error("无效的标志位: {0}")]
InvalidFlags(u8),
#[error("数据包过大: {size} > {max}")]
PacketTooLarge { size: usize, max: usize },
#[error("数据包过小: {size} < {min}")]
PacketTooSmall { size: usize, min: usize },
#[error("无效的客户端 ID: {0}")]
InvalidClientId(u16),
#[error("无效的数据包 ID: {0}")]
InvalidPacketId(u16),
#[error("MAC 验证失败")]
MacVerificationFailed,
#[error("超时: {0}")]
Timeout(String),
#[error("连接关闭")]
ConnectionClosed,
#[error("命令错误: {0}")]
Command(String),
#[error("网络错误: {0}")]
Network(#[from] std::io::Error),
}
/// 协议结果类型
pub type ProtocolResult<T> = Result<T, ProtocolError>;
impl From<protocol::CommandError> for ProtocolError {
fn from(err: protocol::CommandError) -> Self {
ProtocolError::Command(err.to_string())
}
}
src/tscore/src/network/mod.rs
+7
View File
@@ -0,0 +1,7 @@
//! 网络模块
pub mod socket;
pub mod resolver;
pub use socket::*;
pub use resolver::*;
src/tscore/src/network/resolver.rs
+38
View File
@@ -0,0 +1,38 @@
//! 地址解析
use std::net::SocketAddr;
/// 服务器地址
#[derive(Debug, Clone)]
pub enum ServerAddress {
/// 直接 IP 地址
Ip(SocketAddr),
/// 域名
Domain(String),
/// 服务器昵称
Nickname(String),
}
impl ServerAddress {
pub async fn resolve(&self) -> Result<SocketAddr, Box<dyn std::error::Error>> {
match self {
Self::Ip(addr) => Ok(*addr),
Self::Domain(domain) => resolve_domain(domain).await,
Self::Nickname(nickname) => resolve_nickname(nickname).await,
}
}
}
async fn resolve_domain(domain: &str) -> Result<SocketAddr, Box<dyn std::error::Error>> {
// 尝试直接解析
let addrs = tokio::net::lookup_host(format!("{}:9987", domain)).await?;
addrs
.into_iter()
.next()
.ok_or_else(|| "无法解析域名".into())
}
async fn resolve_nickname(nickname: &str) -> Result<SocketAddr, Box<dyn std::error::Error>> {
// TODO: 实现 TSDNS 和昵称解析
resolve_domain(nickname).await
}
src/tscore/src/network/socket.rs
+62
View File
@@ -0,0 +1,62 @@
//! UDP Socket 抽象
use std::net::SocketAddr;
use std::task::{Context, Poll};
use tokio::net::UdpSocket;
/// Socket trait
pub trait Socket {
fn poll_recv_from(
&self,
cx: &mut Context,
buf: &mut tokio::io::ReadBuf,
) -> Poll<std::io::Result<SocketAddr>>;
fn poll_send_to(
&self,
cx: &mut Context,
buf: &[u8],
target: SocketAddr,
) -> Poll<std::io::Result<usize>>;
fn local_addr(&self) -> std::io::Result<SocketAddr>;
}
/// UDP Socket 实现
pub struct UdpSocketWrapper {
socket: UdpSocket,
}
impl UdpSocketWrapper {
pub async fn bind(addr: SocketAddr) -> std::io::Result<Self> {
let socket = UdpSocket::bind(addr).await?;
Ok(Self { socket })
}
pub async fn connect(&self, addr: SocketAddr) -> std::io::Result<()> {
self.socket.connect(addr).await
}
}
impl Socket for UdpSocketWrapper {
fn poll_recv_from(
&self,
cx: &mut Context,
buf: &mut tokio::io::ReadBuf,
) -> Poll<std::io::Result<SocketAddr>> {
self.socket.poll_recv_from(cx, buf)
}
fn poll_send_to(
&self,
cx: &mut Context,
buf: &[u8],
target: SocketAddr,
) -> Poll<std::io::Result<usize>> {
self.socket.poll_send_to(cx, buf, target)
}
fn local_addr(&self) -> std::io::Result<SocketAddr> {
self.socket.local_addr()
}
}
src/tscore/src/protocol/commands.rs
+239
View File
@@ -0,0 +1,239 @@
//! 命令解析和序列化
use std::fmt;
/// 命令解析错误
#[derive(Debug, Clone)]
pub enum CommandError {
InvalidFormat(String),
MissingParameter(String),
InvalidParameterValue { name: String, value: String },
EscapeError(String),
}
impl fmt::Display for CommandError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::InvalidFormat(msg) => write!(f, "无效的命令格式: {}", msg),
Self::MissingParameter(name) => write!(f, "缺少必需的参数: {}", name),
Self::InvalidParameterValue { name, value } => {
write!(f, "无效的参数值: {}={}", name, value)
}
Self::EscapeError(msg) => write!(f, "转义序列错误: {}", msg),
}
}
}
impl std::error::Error for CommandError {}
pub type CommandResult<T> = Result<T, CommandError>;
/// 转义序列处理
pub mod escape {
use super::CommandError;
pub fn escape(input: &str) -> String {
let mut result = String::with_capacity(input.len());
for c in input.chars() {
match c {
'\\' => result.push_str("\\\\"),
' ' => result.push_str("\\s"),
'|' => result.push_str("\\p"),
'/' => result.push_str("\\/"),
'\n' => result.push_str("\\n"),
'\r' => result.push_str("\\r"),
'\t' => result.push_str("\\t"),
_ => result.push(c),
}
}
result
}
pub fn unescape(input: &str) -> Result<String, CommandError> {
let mut result = String::with_capacity(input.len());
let mut chars = input.chars();
while let Some(c) = chars.next() {
if c == '\\' {
match chars.next() {
Some('\\') => result.push('\\'),
Some('s') => result.push(' '),
Some('p') => result.push('|'),
Some('/') => result.push('/'),
Some('n') => result.push('\n'),
Some('r') => result.push('\r'),
Some('t') => result.push('\t'),
Some(other) => {
return Err(CommandError::EscapeError(format!("未知的转义序列: \\{}", other)))
}
None => {
return Err(CommandError::EscapeError("意外的转义序列结束".to_string()))
}
}
} else {
result.push(c);
}
}
Ok(result)
}
}
/// 命令参数
#[derive(Debug, Clone)]
pub struct CommandArgument {
pub name: String,
pub value: Option<String>,
}
impl CommandArgument {
pub fn new(name: &str, value: Option<&str>) -> Self {
Self {
name: name.to_string(),
value: value.map(|s| s.to_string()),
}
}
pub fn with_value(name: &str, value: &str) -> Self {
Self {
name: name.to_string(),
value: Some(value.to_string()),
}
}
pub fn without_value(name: &str) -> Self {
Self {
name: name.to_string(),
value: None,
}
}
pub fn to_string(&self) -> String {
match &self.value {
Some(value) => format!("{}={}", escape::escape(&self.name), escape::escape(value)),
None => escape::escape(&self.name),
}
}
}
/// 命令
#[derive(Debug, Clone)]
pub struct Command {
pub name: String,
pub args: Vec<CommandArgument>,
}
impl Command {
pub fn new(name: &str) -> Self {
Self {
name: name.to_string(),
args: Vec::new(),
}
}
pub fn with_args(name: &str, args: Vec<CommandArgument>) -> Self {
Self {
name: name.to_string(),
args,
}
}
pub fn arg(mut self, arg: CommandArgument) -> Self {
self.args.push(arg);
self
}
pub fn key_value(mut self, name: &str, value: &str) -> Self {
self.args.push(CommandArgument::with_value(name, value));
self
}
pub fn flag(mut self, name: &str) -> Self {
self.args.push(CommandArgument::without_value(name));
self
}
pub fn get(&self, name: &str) -> Option<&str> {
self.args
.iter()
.find(|a| a.name == name)
.and_then(|a| a.value.as_deref())
}
pub fn has(&self, name: &str) -> bool {
self.args.iter().any(|a| a.name == name)
}
pub fn parse(input: &str) -> CommandResult<Self> {
let input = input.trim();
if input.is_empty() {
return Err(CommandError::InvalidFormat("空命令".to_string()));
}
let parts: Vec<&str> = input.splitn(2, ' ').collect();
let name = parts[0].to_string();
let args_str = if parts.len() > 1 { parts[1] } else { "" };
let mut args = Vec::new();
if !args_str.is_empty() {
for arg_str in args_str.split(' ') {
if arg_str.is_empty() {
continue;
}
if let Some(eq_pos) = arg_str.find('=') {
let name = escape::unescape(&arg_str[..eq_pos])?;
let value = escape::unescape(&arg_str[eq_pos + 1..])?;
args.push(CommandArgument::with_value(&name, &value));
} else {
let name = escape::unescape(arg_str)?;
args.push(CommandArgument::without_value(&name));
}
}
}
Ok(Self { name, args })
}
pub fn to_string(&self) -> String {
let mut result = self.name.clone();
for arg in &self.args {
result.push(' ');
result.push_str(&arg.to_string());
}
result
}
}
impl fmt::Display for Command {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}", self.to_string())
}
}
/// 命令构建器
pub struct CommandBuilder {
command: Command,
}
impl CommandBuilder {
pub fn new(name: &str) -> Self {
Self {
command: Command::new(name),
}
}
pub fn arg(mut self, name: &str, value: &str) -> Self {
self.command = self.command.key_value(name, value);
self
}
pub fn flag(mut self, name: &str) -> Self {
self.command = self.command.flag(name);
self
}
pub fn build(self) -> Command {
self.command
}
}
src/tscore/src/protocol/mod.rs
+10
View File
@@ -0,0 +1,10 @@
//! 协议模块
pub mod packet;
pub mod types;
pub mod commands;
mod tests;
pub use packet::*;
pub use types::*;
pub use commands::*;
src/tscore/src/protocol/packet.rs
+607
View File
@@ -0,0 +1,607 @@
//! 数据包定义和处理
use std::fmt;
use super::types::*;
use crate::ProtocolError;
/// 最大数据包大小
pub const MAX_PACKET_SIZE: usize = 500;
/// C2S 头部大小
pub const C2S_HEADER_SIZE: usize = 13; // 8 (MAC) + 2 (PId) + 2 (CId) + 1 (PT)
/// S2C 头部大小
pub const S2C_HEADER_SIZE: usize = 11; // 8 (MAC) + 2 (PId) + 1 (PT)
/// 数据包方向
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Direction {
C2S,
S2C,
}
impl Direction {
pub fn reverse(&self) -> Self {
match self {
Self::C2S => Self::S2C,
Self::S2C => Self::C2S,
}
}
}
/// 数据包标志位
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Flags(pub u8);
impl Flags {
pub const UNENCRYPTED: u8 = 0x80;
pub const COMPRESSED: u8 = 0x40;
pub const NEWPROTOCOL: u8 = 0x20;
pub const FRAGMENTED: u8 = 0x10;
pub fn new(flags: u8) -> Self {
Self(flags)
}
pub fn empty() -> Self {
Self(0)
}
pub fn is_unencrypted(&self) -> bool {
self.0 & Self::UNENCRYPTED != 0
}
pub fn is_compressed(&self) -> bool {
self.0 & Self::COMPRESSED != 0
}
pub fn is_newprotocol(&self) -> bool {
self.0 & Self::NEWPROTOCOL != 0
}
pub fn is_fragmented(&self) -> bool {
self.0 & Self::FRAGMENTED != 0
}
pub fn packet_type(&self) -> PacketType {
PacketType::from_u8(self.0 & 0x0F)
}
pub fn set_unencrypted(&mut self, value: bool) {
if value {
self.0 |= Self::UNENCRYPTED;
} else {
self.0 &= !Self::UNENCRYPTED;
}
}
pub fn set_compressed(&mut self, value: bool) {
if value {
self.0 |= Self::COMPRESSED;
} else {
self.0 &= !Self::COMPRESSED;
}
}
pub fn set_newprotocol(&mut self, value: bool) {
if value {
self.0 |= Self::NEWPROTOCOL;
} else {
self.0 &= !Self::NEWPROTOCOL;
}
}
pub fn set_fragmented(&mut self, value: bool) {
if value {
self.0 |= Self::FRAGMENTED;
} else {
self.0 &= !Self::FRAGMENTED;
}
}
}
impl fmt::Display for Flags {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(
f,
"Flags({:08b}: UE={}, CP={}, NP={}, FR={}, Type={:?})",
self.0,
self.is_unencrypted(),
self.is_compressed(),
self.is_newprotocol(),
self.is_fragmented(),
self.packet_type()
)
}
}
/// 数据包头部
#[derive(Debug, Clone)]
pub struct Header {
pub mac: [u8; 8],
pub packet_id: u16,
pub client_id: Option<u16>,
pub flags: Flags,
}
impl Header {
pub fn parse_c2s(data: &[u8]) -> Result<Self, ProtocolError> {
if data.len() < C2S_HEADER_SIZE {
return Err(ProtocolError::PacketTooSmall {
size: data.len(),
min: C2S_HEADER_SIZE,
});
}
let mut mac = [0u8; 8];
mac.copy_from_slice(&data[0..8]);
let packet_id = u16::from_be_bytes([data[8], data[9]]);
let client_id = u16::from_be_bytes([data[10], data[11]]);
let flags = Flags::new(data[12]);
Ok(Self {
mac,
packet_id,
client_id: Some(client_id),
flags,
})
}
pub fn parse_s2c(data: &[u8]) -> Result<Self, ProtocolError> {
if data.len() < S2C_HEADER_SIZE {
return Err(ProtocolError::PacketTooSmall {
size: data.len(),
min: S2C_HEADER_SIZE,
});
}
let mut mac = [0u8; 8];
mac.copy_from_slice(&data[0..8]);
let packet_id = u16::from_be_bytes([data[8], data[9]]);
let flags = Flags::new(data[10]);
Ok(Self {
mac,
packet_id,
client_id: None,
flags,
})
}
pub fn to_c2s_bytes(&self) -> [u8; C2S_HEADER_SIZE] {
let mut bytes = [0u8; C2S_HEADER_SIZE];
bytes[0..8].copy_from_slice(&self.mac);
bytes[8..10].copy_from_slice(&self.packet_id.to_be_bytes());
if let Some(client_id) = self.client_id {
bytes[10..12].copy_from_slice(&client_id.to_be_bytes());
}
bytes[12] = self.flags.0;
bytes
}
pub fn to_s2c_bytes(&self) -> [u8; S2C_HEADER_SIZE] {
let mut bytes = [0u8; S2C_HEADER_SIZE];
bytes[0..8].copy_from_slice(&self.mac);
bytes[8..10].copy_from_slice(&self.packet_id.to_be_bytes());
bytes[10] = self.flags.0;
bytes
}
pub fn size(&self, direction: Direction) -> usize {
match direction {
Direction::C2S => C2S_HEADER_SIZE,
Direction::S2C => S2C_HEADER_SIZE,
}
}
pub fn get_meta(&self, direction: Direction) -> Vec<u8> {
match direction {
Direction::C2S => {
let mut meta = Vec::with_capacity(5);
meta.extend_from_slice(&self.packet_id.to_be_bytes());
meta.extend_from_slice(&self.client_id.unwrap_or(0).to_be_bytes());
meta.push(self.flags.0);
meta
}
Direction::S2C => {
let mut meta = Vec::with_capacity(3);
meta.extend_from_slice(&self.packet_id.to_be_bytes());
meta.push(self.flags.0);
meta
}
}
}
}
/// 输入数据包
#[derive(Debug, Clone)]
pub struct InPacket {
pub direction: Direction,
pub header: Header,
pub data: Vec<u8>,
}
impl InPacket {
pub fn parse(direction: Direction, data: &[u8]) -> Result<Self, ProtocolError> {
let header = match direction {
Direction::C2S => Header::parse_c2s(data)?,
Direction::S2C => Header::parse_s2c(data)?,
};
let header_size = header.size(direction);
let content = data[header_size..].to_vec();
Ok(Self {
direction,
header,
data: content,
})
}
pub fn content(&self) -> &[u8] {
&self.data
}
pub fn content_size(&self) -> usize {
self.data.len()
}
pub fn total_size(&self) -> usize {
self.header.size(self.direction) + self.data.len()
}
}
/// 输出数据包
#[derive(Debug, Clone)]
pub struct OutPacket {
pub direction: Direction,
pub header: Header,
pub data: Vec<u8>,
}
impl OutPacket {
pub fn new(direction: Direction, flags: Flags, content: Vec<u8>) -> Self {
let header = Header {
mac: [0; 8],
packet_id: 0,
client_id: if direction == Direction::C2S { Some(0) } else { None },
flags,
};
Self {
direction,
header,
data: content,
}
}
pub fn set_packet_id(&mut self, id: u16) {
self.header.packet_id = id;
}
pub fn set_client_id(&mut self, id: u16) {
self.header.client_id = Some(id);
}
pub fn set_mac(&mut self, mac: [u8; 8]) {
self.header.mac = mac;
}
pub fn content(&self) -> &[u8] {
&self.data
}
pub fn content_mut(&mut self) -> &mut Vec<u8> {
&mut self.data
}
pub fn to_bytes(&self) -> Vec<u8> {
let header_size = self.header.size(self.direction);
let mut bytes = Vec::with_capacity(header_size + self.data.len());
match self.direction {
Direction::C2S => {
bytes.extend_from_slice(&self.header.to_c2s_bytes());
}
Direction::S2C => {
bytes.extend_from_slice(&self.header.to_s2c_bytes());
}
}
bytes.extend_from_slice(&self.data);
bytes
}
pub fn total_size(&self) -> usize {
self.header.size(self.direction) + self.data.len()
}
}
/// 确认数据包
#[derive(Debug, Clone)]
pub struct AckPacket {
pub direction: Direction,
pub packet_type: PacketType,
pub acked_packet_id: u16,
}
impl AckPacket {
pub fn new(direction: Direction, packet_type: PacketType, acked_packet_id: u16) -> Self {
Self {
direction,
packet_type,
acked_packet_id,
}
}
pub fn to_out_packet(&self) -> OutPacket {
let flags = Flags::new(self.packet_type.to_u8());
let mut content = Vec::with_capacity(2);
content.extend_from_slice(&self.acked_packet_id.to_be_bytes());
OutPacket::new(self.direction, flags, content)
}
}
/// 初始化步骤
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum InitStep {
Init0,
Init1,
Init2,
Init3,
Init4,
Reset,
}
/// 初始化数据包
#[derive(Debug, Clone)]
pub struct InitPacket {
pub step: InitStep,
pub version: Option<u32>,
pub timestamp: Option<u32>,
pub random0: Option<[u8; 4]>,
pub random1: Option<[u8; 16]>,
pub random0_r: Option<[u8; 4]>,
pub x: Option<[u8; 64]>,
pub n: Option<[u8; 64]>,
pub level: Option<u32>,
pub random2: Option<[u8; 100]>,
pub y: Option<[u8; 64]>,
pub command: Option<Vec<u8>>,
}
impl InitPacket {
pub fn parse(data: &[u8]) -> Result<Self, ProtocolError> {
if data.is_empty() {
return Err(ProtocolError::PacketTooSmall {
size: 0,
min: 1,
});
}
let step = match data[0] {
0 => InitStep::Init0,
1 => InitStep::Init1,
2 => InitStep::Init2,
3 => InitStep::Init3,
4 => InitStep::Init4,
127 => InitStep::Reset,
_ => return Err(ProtocolError::InvalidPacketType(data[0])),
};
let mut packet = Self {
step,
version: None,
timestamp: None,
random0: None,
random1: None,
random0_r: None,
x: None,
n: None,
level: None,
random2: None,
y: None,
command: None,
};
match step {
InitStep::Init0 => {
if data.len() < 21 {
return Err(ProtocolError::PacketTooSmall { size: data.len(), min: 21 });
}
packet.version = Some(u32::from_be_bytes([data[1], data[2], data[3], data[4]]));
packet.timestamp = Some(u32::from_be_bytes([data[6], data[7], data[8], data[9]]));
let mut random0 = [0u8; 4];
random0.copy_from_slice(&data[10..14]);
packet.random0 = Some(random0);
}
InitStep::Init1 => {
if data.len() < 21 {
return Err(ProtocolError::PacketTooSmall { size: data.len(), min: 21 });
}
let mut random1 = [0u8; 16];
random1.copy_from_slice(&data[1..17]);
packet.random1 = Some(random1);
let mut random0_r = [0u8; 4];
random0_r.copy_from_slice(&data[17..21]);
packet.random0_r = Some(random0_r);
}
InitStep::Init2 => {
if data.len() < 26 {
return Err(ProtocolError::PacketTooSmall { size: data.len(), min: 26 });
}
packet.version = Some(u32::from_be_bytes([data[1], data[2], data[3], data[4]]));
let mut random1 = [0u8; 16];
random1.copy_from_slice(&data[6..22]);
packet.random1 = Some(random1);
let mut random0_r = [0u8; 4];
random0_r.copy_from_slice(&data[22..26]);
packet.random0_r = Some(random0_r);
}
InitStep::Init3 => {
if data.len() < 233 {
return Err(ProtocolError::PacketTooSmall { size: data.len(), min: 233 });
}
let mut x = [0u8; 64];
x.copy_from_slice(&data[1..65]);
packet.x = Some(x);
let mut n = [0u8; 64];
n.copy_from_slice(&data[65..129]);
packet.n = Some(n);
packet.level = Some(u32::from_be_bytes([data[129], data[130], data[131], data[132]]));
let mut random2 = [0u8; 100];
random2.copy_from_slice(&data[133..233]);
packet.random2 = Some(random2);
}
InitStep::Init4 => {
if data.len() < 361 {
return Err(ProtocolError::PacketTooSmall { size: data.len(), min: 361 });
}
packet.version = Some(u32::from_be_bytes([data[1], data[2], data[3], data[4]]));
let mut x = [0u8; 64];
x.copy_from_slice(&data[6..70]);
packet.x = Some(x);
let mut n = [0u8; 64];
n.copy_from_slice(&data[70..134]);
packet.n = Some(n);
packet.level = Some(u32::from_be_bytes([data[134], data[135], data[136], data[137]]));
let mut random2 = [0u8; 100];
random2.copy_from_slice(&data[138..238]);
packet.random2 = Some(random2);
let mut y = [0u8; 64];
y.copy_from_slice(&data[238..302]);
packet.y = Some(y);
if data.len() > 302 {
packet.command = Some(data[302..].to_vec());
}
}
InitStep::Reset => {}
}
Ok(packet)
}
pub fn to_bytes(&self) -> Vec<u8> {
let mut bytes = Vec::new();
match self.step {
InitStep::Init0 => {
bytes.push(0);
if let Some(version) = self.version {
bytes.extend_from_slice(&version.to_be_bytes());
} else {
bytes.extend_from_slice(&[0; 4]);
}
bytes.push(0);
if let Some(timestamp) = self.timestamp {
bytes.extend_from_slice(&timestamp.to_be_bytes());
} else {
bytes.extend_from_slice(&[0; 4]);
}
if let Some(random0) = self.random0 {
bytes.extend_from_slice(&random0);
} else {
bytes.extend_from_slice(&[0; 4]);
}
bytes.extend_from_slice(&[0; 8]);
}
InitStep::Init1 => {
bytes.push(1);
if let Some(random1) = self.random1 {
bytes.extend_from_slice(&random1);
} else {
bytes.extend_from_slice(&[0; 16]);
}
if let Some(random0_r) = self.random0_r {
bytes.extend_from_slice(&random0_r);
} else {
bytes.extend_from_slice(&[0; 4]);
}
}
InitStep::Init2 => {
bytes.push(2);
if let Some(version) = self.version {
bytes.extend_from_slice(&version.to_be_bytes());
} else {
bytes.extend_from_slice(&[0; 4]);
}
if let Some(random1) = self.random1 {
bytes.extend_from_slice(&random1);
} else {
bytes.extend_from_slice(&[0; 16]);
}
if let Some(random0_r) = self.random0_r {
bytes.extend_from_slice(&random0_r);
} else {
bytes.extend_from_slice(&[0; 4]);
}
}
InitStep::Init3 => {
bytes.push(3);
if let Some(x) = self.x {
bytes.extend_from_slice(&x);
} else {
bytes.extend_from_slice(&[0; 64]);
}
if let Some(n) = self.n {
bytes.extend_from_slice(&n);
} else {
bytes.extend_from_slice(&[0; 64]);
}
if let Some(level) = self.level {
bytes.extend_from_slice(&level.to_be_bytes());
} else {
bytes.extend_from_slice(&[0; 4]);
}
if let Some(random2) = self.random2 {
bytes.extend_from_slice(&random2);
} else {
bytes.extend_from_slice(&[0; 100]);
}
}
InitStep::Init4 => {
bytes.push(4);
if let Some(version) = self.version {
bytes.extend_from_slice(&version.to_be_bytes());
} else {
bytes.extend_from_slice(&[0; 4]);
}
if let Some(x) = self.x {
bytes.extend_from_slice(&x);
} else {
bytes.extend_from_slice(&[0; 64]);
}
if let Some(n) = self.n {
bytes.extend_from_slice(&n);
} else {
bytes.extend_from_slice(&[0; 64]);
}
if let Some(level) = self.level {
bytes.extend_from_slice(&level.to_be_bytes());
} else {
bytes.extend_from_slice(&[0; 4]);
}
if let Some(random2) = self.random2 {
bytes.extend_from_slice(&random2);
} else {
bytes.extend_from_slice(&[0; 100]);
}
if let Some(y) = self.y {
bytes.extend_from_slice(&y);
} else {
bytes.extend_from_slice(&[0; 64]);
}
if let Some(ref command) = self.command {
bytes.extend_from_slice(command);
}
}
InitStep::Reset => {
bytes.push(127);
bytes.push(0);
}
}
bytes
}
}
src/tscore/src/protocol/tests.rs
+202
View File
@@ -0,0 +1,202 @@
//! 数据包处理测试
#[cfg(test)]
mod tests {
use crate::protocol::*;
#[test]
fn test_packet_type_conversion() {
assert_eq!(PacketType::from_u8(0x00), PacketType::Voice);
assert_eq!(PacketType::from_u8(0x02), PacketType::Command);
assert_eq!(PacketType::from_u8(0x08), PacketType::Init);
assert_eq!(PacketType::Voice.to_u8(), 0x00);
assert_eq!(PacketType::Command.to_u8(), 0x02);
}
#[test]
fn test_flags() {
let flags = Flags::new(0x80);
assert!(flags.is_unencrypted());
assert!(!flags.is_compressed());
assert!(!flags.is_newprotocol());
assert!(!flags.is_fragmented());
let flags = Flags::new(0x40);
assert!(!flags.is_unencrypted());
assert!(flags.is_compressed());
let flags = Flags::new(0x20);
assert!(flags.is_newprotocol());
let flags = Flags::new(0x10);
assert!(flags.is_fragmented());
let flags = Flags::new(0x02);
assert_eq!(flags.packet_type(), PacketType::Command);
}
#[test]
fn test_header_c2s() {
let mut data = vec![0u8; 13];
// MAC
data[0..8].copy_from_slice(&[0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08]);
// Packet ID = 42
data[8..10].copy_from_slice(&42u16.to_be_bytes());
// Client ID = 1
data[10..12].copy_from_slice(&1u16.to_be_bytes());
// Flags = Command
data[12] = 0x02;
let header = Header::parse_c2s(&data).unwrap();
assert_eq!(header.packet_id, 42);
assert_eq!(header.client_id, Some(1));
assert_eq!(header.flags.packet_type(), PacketType::Command);
}
#[test]
fn test_header_s2c() {
let mut data = vec![0u8; 11];
// MAC
data[0..8].copy_from_slice(&[0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08]);
// Packet ID = 10
data[8..10].copy_from_slice(&10u16.to_be_bytes());
// Flags = Voice
data[10] = 0x00;
let header = Header::parse_s2c(&data).unwrap();
assert_eq!(header.packet_id, 10);
assert!(header.client_id.is_none());
assert_eq!(header.flags.packet_type(), PacketType::Voice);
}
#[test]
fn test_in_packet_parse() {
let mut data = vec![0u8; 15];
// S2C header
data[0..8].copy_from_slice(&[0; 8]); // MAC
data[8..10].copy_from_slice(&1u16.to_be_bytes()); // PId
data[10] = 0x02; // Command type
// Content
data[11] = b'H';
data[12] = b'i';
data[13] = b'!';
data[14] = 0;
let packet = InPacket::parse(Direction::S2C, &data).unwrap();
assert_eq!(packet.header.packet_id, 1);
assert_eq!(packet.content(), b"Hi!\0");
}
#[test]
fn test_out_packet() {
let content = b"Hello".to_vec();
let mut packet = OutPacket::new(Direction::C2S, Flags::new(0x02), content);
packet.set_packet_id(42);
packet.set_client_id(1);
let bytes = packet.to_bytes();
assert_eq!(bytes.len(), 13 + 5); // header + content
assert_eq!(packet.header.packet_id, 42);
assert_eq!(packet.header.client_id, Some(1));
}
#[test]
fn test_command_parse() {
let cmd = Command::parse("clientinit client_nickname=Test\\sUser client_version=3.0.19.3").unwrap();
assert_eq!(cmd.name, "clientinit");
assert_eq!(cmd.get("client_nickname"), Some("Test User"));
assert_eq!(cmd.get("client_version"), Some("3.0.19.3"));
}
#[test]
fn test_command_serialize() {
let cmd = Command::new("sendtextmessage")
.key_value("targetmode", "2")
.key_value("msg", "Hello World!");
assert_eq!(cmd.to_string(), "sendtextmessage targetmode=2 msg=Hello\\sWorld!");
}
#[test]
fn test_command_builder() {
let cmd = CommandBuilder::new("clientinit")
.arg("client_nickname", "Test")
.arg("client_version", "3.0.19.3")
.flag("verbose")
.build();
assert_eq!(cmd.name, "clientinit");
assert_eq!(cmd.get("client_nickname"), Some("Test"));
assert!(cmd.has("verbose"));
}
#[test]
fn test_escape_sequences() {
use crate::protocol::commands::escape;
assert_eq!(escape::escape("hello world"), "hello\\sworld");
assert_eq!(escape::escape("a|b"), "a\\pb");
assert_eq!(escape::escape("a\\b"), "a\\\\b");
assert_eq!(escape::unescape("hello\\sworld").unwrap(), "hello world");
assert_eq!(escape::unescape("a\\pb").unwrap(), "a|b");
assert_eq!(escape::unescape("a\\\\b").unwrap(), "a\\b");
}
#[test]
fn test_init_packet_parse() {
// Init0
let mut data = vec![0u8; 21];
data[0] = 0; // step
data[1..5].copy_from_slice(&1466672534u32.to_be_bytes()); // version
data[6..10].copy_from_slice(&1000000u32.to_be_bytes()); // timestamp
data[10..14].copy_from_slice(&[0xAA, 0xBB, 0xCC, 0xDD]); // random0
let init = InitPacket::parse(&data).unwrap();
assert_eq!(init.step, InitStep::Init0);
assert_eq!(init.version, Some(1466672534));
assert_eq!(init.random0, Some([0xAA, 0xBB, 0xCC, 0xDD]));
}
#[test]
fn test_init_packet_serialize() {
let init = InitPacket {
step: InitStep::Init0,
version: Some(1466672534),
timestamp: Some(1000000),
random0: Some([0xAA, 0xBB, 0xCC, 0xDD]),
random1: None,
random0_r: None,
x: None,
n: None,
level: None,
random2: None,
y: None,
command: None,
};
let data = init.to_bytes();
assert_eq!(data[0], 0); // step
assert_eq!(data[1..5], 1466672534u32.to_be_bytes());
}
#[test]
fn test_ack_packet() {
let ack = AckPacket::new(Direction::C2S, PacketType::Ack, 42);
let packet = ack.to_out_packet();
assert_eq!(packet.header.flags.packet_type(), PacketType::Ack);
assert_eq!(packet.data, 42u16.to_be_bytes());
}
#[test]
fn test_packet_type_properties() {
assert!(PacketType::Command.must_encrypt());
assert!(!PacketType::Voice.must_encrypt());
assert!(PacketType::Command.can_fragment());
assert!(!PacketType::Voice.can_fragment());
assert!(PacketType::Command.needs_ack());
assert!(!PacketType::Voice.needs_ack());
assert!(PacketType::Voice.is_voice());
assert!(PacketType::VoiceWhisper.is_voice());
assert!(!PacketType::Command.is_voice());
}
}
src/tscore/src/protocol/types.rs
+227
View File
@@ -0,0 +1,227 @@
//! 协议类型定义
use std::fmt;
/// 数据包类型
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum PacketType {
Voice,
VoiceWhisper,
Command,
CommandLow,
Ping,
Pong,
Ack,
AckLow,
Init,
}
impl PacketType {
pub fn from_u8(value: u8) -> Self {
match value {
0x00 => Self::Voice,
0x01 => Self::VoiceWhisper,
0x02 => Self::Command,
0x03 => Self::CommandLow,
0x04 => Self::Ping,
0x05 => Self::Pong,
0x06 => Self::Ack,
0x07 => Self::AckLow,
0x08 => Self::Init,
_ => Self::Init,
}
}
pub fn to_u8(&self) -> u8 {
match self {
Self::Voice => 0x00,
Self::VoiceWhisper => 0x01,
Self::Command => 0x02,
Self::CommandLow => 0x03,
Self::Ping => 0x04,
Self::Pong => 0x05,
Self::Ack => 0x06,
Self::AckLow => 0x07,
Self::Init => 0x08,
}
}
pub fn to_usize(&self) -> usize {
self.to_u8() as usize
}
pub fn is_voice(&self) -> bool {
matches!(self, Self::Voice | Self::VoiceWhisper)
}
pub fn needs_ack(&self) -> bool {
matches!(self, Self::Command | Self::CommandLow | Self::Ping | Self::Init)
}
pub fn can_resend(&self) -> bool {
matches!(self, Self::Command | Self::CommandLow | Self::Ack | Self::AckLow | Self::Init)
}
pub fn can_encrypt(&self) -> bool {
!matches!(self, Self::Init)
}
pub fn must_encrypt(&self) -> bool {
matches!(self, Self::Command | Self::CommandLow)
}
pub fn can_fragment(&self) -> bool {
matches!(self, Self::Command | Self::CommandLow)
}
pub fn can_compress(&self) -> bool {
matches!(self, Self::Command | Self::CommandLow)
}
pub fn ack_type(&self) -> Option<Self> {
match self {
Self::Command => Some(Self::Ack),
Self::CommandLow => Some(Self::AckLow),
Self::Ping => Some(Self::Pong),
Self::Init => Some(Self::Init),
_ => None,
}
}
}
impl fmt::Display for PacketType {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Voice => write!(f, "Voice"),
Self::VoiceWhisper => write!(f, "VoiceWhisper"),
Self::Command => write!(f, "Command"),
Self::CommandLow => write!(f, "CommandLow"),
Self::Ping => write!(f, "Ping"),
Self::Pong => write!(f, "Pong"),
Self::Ack => write!(f, "Ack"),
Self::AckLow => write!(f, "AckLow"),
Self::Init => write!(f, "Init"),
}
}
}
/// 编解码器类型
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum CodecType {
SpeexNarrowband,
SpeexWideband,
SpeexUltrawideband,
CeltMono,
OpusVoice,
OpusMusic,
}
impl CodecType {
pub fn from_u8(value: u8) -> Self {
match value {
0 => Self::SpeexNarrowband,
1 => Self::SpeexWideband,
2 => Self::SpeexUltrawideband,
3 => Self::CeltMono,
4 => Self::OpusVoice,
5 => Self::OpusMusic,
_ => Self::OpusVoice,
}
}
pub fn to_u8(&self) -> u8 {
match self {
Self::SpeexNarrowband => 0,
Self::SpeexWideband => 1,
Self::SpeexUltrawideband => 2,
Self::CeltMono => 3,
Self::OpusVoice => 4,
Self::OpusMusic => 5,
}
}
pub fn sample_rate(&self) -> u32 {
match self {
Self::SpeexNarrowband => 8000,
Self::SpeexWideband => 16000,
Self::SpeexUltrawideband => 32000,
Self::CeltMono | Self::OpusVoice | Self::OpusMusic => 48000,
}
}
pub fn channels(&self) -> u16 {
match self {
Self::OpusMusic => 2,
_ => 1,
}
}
}
/// 私语类型
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum GroupWhisperType {
ServerGroup,
ChannelGroup,
ChannelCommander,
AllClients,
}
impl GroupWhisperType {
pub fn from_u8(value: u8) -> Self {
match value {
0 => Self::ServerGroup,
1 => Self::ChannelGroup,
2 => Self::ChannelCommander,
3 => Self::AllClients,
_ => Self::AllClients,
}
}
pub fn to_u8(&self) -> u8 {
match self {
Self::ServerGroup => 0,
Self::ChannelGroup => 1,
Self::ChannelCommander => 2,
Self::AllClients => 3,
}
}
}
/// 私语目标
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum GroupWhisperTarget {
AllChannels,
CurrentChannel,
ParentChannel,
AllParentChannel,
ChannelFamily,
CompleteChannelFamily,
Subchannels,
}
impl GroupWhisperTarget {
pub fn from_u8(value: u8) -> Self {
match value {
0 => Self::AllChannels,
1 => Self::CurrentChannel,
2 => Self::ParentChannel,
3 => Self::AllParentChannel,
4 => Self::ChannelFamily,
5 => Self::CompleteChannelFamily,
6 => Self::Subchannels,
_ => Self::AllChannels,
}
}
pub fn to_u8(&self) -> u8 {
match self {
Self::AllChannels => 0,
Self::CurrentChannel => 1,
Self::ParentChannel => 2,
Self::AllParentChannel => 3,
Self::ChannelFamily => 4,
Self::CompleteChannelFamily => 5,
Self::Subchannels => 6,
}
}
}
src/tsdb/Cargo.toml
+28
View File
@@ -0,0 +1,28 @@
[package]
name = "tsdb"
version.workspace = true
edition.workspace = true
license.workspace = true
description = "TeamSpeak 数据存储"
[dependencies]
# Error handling
thiserror = { workspace = true }
anyhow = { workspace = true }
# Logging
tracing = { workspace = true }
# Database
rusqlite = { workspace = true }
# Serialization
serde = { workspace = true }
serde_json = { workspace = true }
# Utils
chrono = { workspace = true }
uuid = { workspace = true }
# Internal
shared = { workspace = true }
src/tsdb/src/bookmark.rs
+176
View File
@@ -0,0 +1,176 @@
//! 书签管理
use rusqlite::params;
use chrono::Utc;
use super::{DatabaseManager, DatabaseResult, DatabaseError};
/// 书签信息
#[derive(Debug, Clone)]
pub struct Bookmark {
pub id: String,
pub name: String,
pub address: String,
pub port: u16,
pub nickname: Option<String>,
pub server_password: Option<String>,
pub channel: Option<String>,
pub channel_password: Option<String>,
pub default_token: Option<String>,
pub auto_connect: bool,
pub last_connected: Option<String>,
pub created_at: String,
pub updated_at: String,
}
impl DatabaseManager {
/// 创建书签
pub fn create_bookmark(
&self,
name: &str,
address: &str,
port: u16,
nickname: Option<&str>,
) -> DatabaseResult<Bookmark> {
let id = uuid::Uuid::new_v4().to_string();
let now = Utc::now().to_rfc3339();
self.connection().execute(
"INSERT INTO bookmarks (id, name, address, port, nickname, auto_connect, created_at, updated_at) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8)",
params![id, name, address, port, nickname, false, now, now],
)?;
Ok(Bookmark {
id,
name: name.to_string(),
address: address.to_string(),
port,
nickname: nickname.map(|s| s.to_string()),
server_password: None,
channel: None,
channel_password: None,
default_token: None,
auto_connect: false,
last_connected: None,
created_at: now.clone(),
updated_at: now,
})
}
/// 获取书签
pub fn get_bookmark(&self, id: &str) -> DatabaseResult<Bookmark> {
let conn = self.connection();
let mut stmt = conn.prepare(
"SELECT id, name, address, port, nickname, server_password, channel, channel_password, default_token, auto_connect, last_connected, created_at, updated_at FROM bookmarks WHERE id = ?1"
)?;
let bookmark = stmt.query_row(params![id], |row| {
Ok(Bookmark {
id: row.get(0)?,
name: row.get(1)?,
address: row.get(2)?,
port: row.get(3)?,
nickname: row.get(4)?,
server_password: row.get(5)?,
channel: row.get(6)?,
channel_password: row.get(7)?,
default_token: row.get(8)?,
auto_connect: row.get::<_, i32>(9)? != 0,
last_connected: row.get(10)?,
created_at: row.get(11)?,
updated_at: row.get(12)?,
})
}).map_err(|_| DatabaseError::NotFound(format!("书签 {} 未找到", id)))?;
Ok(bookmark)
}
/// 获取所有书签
pub fn get_all_bookmarks(&self) -> DatabaseResult<Vec<Bookmark>> {
let conn = self.connection();
let mut stmt = conn.prepare(
"SELECT id, name, address, port, nickname, server_password, channel, channel_password, default_token, auto_connect, last_connected, created_at, updated_at FROM bookmarks ORDER BY name"
)?;
let bookmarks = stmt.query_map([], |row| {
Ok(Bookmark {
id: row.get(0)?,
name: row.get(1)?,
address: row.get(2)?,
port: row.get(3)?,
nickname: row.get(4)?,
server_password: row.get(5)?,
channel: row.get(6)?,
channel_password: row.get(7)?,
default_token: row.get(8)?,
auto_connect: row.get::<_, i32>(9)? != 0,
last_connected: row.get(10)?,
created_at: row.get(11)?,
updated_at: row.get(12)?,
})
})?.collect::<Result<Vec<_>, _>>()?;
Ok(bookmarks)
}
/// 更新书签
pub fn update_bookmark(
&self,
id: &str,
name: Option<&str>,
address: Option<&str>,
port: Option<u16>,
nickname: Option<&str>,
) -> DatabaseResult<()> {
let now = Utc::now().to_rfc3339();
if let Some(name) = name {
self.connection().execute(
"UPDATE bookmarks SET name = ?1, updated_at = ?2 WHERE id = ?3",
params![name, now, id],
)?;
}
if let Some(address) = address {
self.connection().execute(
"UPDATE bookmarks SET address = ?1, updated_at = ?2 WHERE id = ?3",
params![address, now, id],
)?;
}
if let Some(port) = port {
self.connection().execute(
"UPDATE bookmarks SET port = ?1, updated_at = ?2 WHERE id = ?3",
params![port, now, id],
)?;
}
if let Some(nickname) = nickname {
self.connection().execute(
"UPDATE bookmarks SET nickname = ?1, updated_at = ?2 WHERE id = ?3",
params![nickname, now, id],
)?;
}
Ok(())
}
/// 删除书签
pub fn delete_bookmark(&self, id: &str) -> DatabaseResult<()> {
self.connection().execute(
"DELETE FROM bookmarks WHERE id = ?1",
params![id],
)?;
Ok(())
}
/// 更新最后连接时间
pub fn update_bookmark_last_connected(&self, id: &str) -> DatabaseResult<()> {
let now = Utc::now().to_rfc3339();
self.connection().execute(
"UPDATE bookmarks SET last_connected = ?1, updated_at = ?2 WHERE id = ?3",
params![now, now, id],
)?;
Ok(())
}
}
src/tsdb/src/config.rs
+50
View File
@@ -0,0 +1,50 @@
//! 配置管理
use rusqlite::params;
use rusqlite::OptionalExtension;
use chrono::Utc;
use super::{DatabaseManager, DatabaseResult};
impl DatabaseManager {
pub fn get_setting(&self, key: &str) -> DatabaseResult<Option<String>> {
let conn = self.connection();
let mut stmt = conn.prepare("SELECT value FROM settings WHERE key = ?1")?;
let result = stmt.query_row(params![key], |row| {
Ok(row.get::<_, String>(0)?)
}).optional()?;
Ok(result)
}
pub fn set_setting(&self, key: &str, value: &str) -> DatabaseResult<()> {
let now = Utc::now().to_rfc3339();
self.connection().execute(
"INSERT OR REPLACE INTO settings (key, value, updated_at) VALUES (?1, ?2, ?3)",
params![key, value, now],
)?;
Ok(())
}
pub fn delete_setting(&self, key: &str) -> DatabaseResult<()> {
self.connection().execute(
"DELETE FROM settings WHERE key = ?1",
params![key],
)?;
Ok(())
}
pub fn get_all_settings(&self) -> DatabaseResult<Vec<(String, String)>> {
let conn = self.connection();
let mut stmt = conn.prepare("SELECT key, value FROM settings ORDER BY key")?;
let settings = stmt.query_map([], |row| {
Ok((row.get(0)?, row.get(1)?))
})?.collect::<Result<Vec<_>, _>>()?;
Ok(settings)
}
}
src/tsdb/src/identity.rs
+115
View File
@@ -0,0 +1,115 @@
//! 身份管理
use rusqlite::params;
use chrono::Utc;
use super::{DatabaseManager, DatabaseResult, DatabaseError};
/// 身份信息
#[derive(Debug, Clone)]
pub struct Identity {
pub id: String,
pub name: String,
pub private_key: String,
pub counter: u64,
pub max_counter: u64,
pub created_at: String,
pub updated_at: String,
}
impl DatabaseManager {
/// 创建身份
pub fn create_identity(&self, name: &str, private_key: &str) -> DatabaseResult<Identity> {
let id = uuid::Uuid::new_v4().to_string();
let now = Utc::now().to_rfc3339();
self.connection().execute(
"INSERT INTO identities (id, name, private_key, counter, max_counter, created_at, updated_at) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7)",
params![id, name, private_key, 0, 0, now, now],
)?;
Ok(Identity {
id,
name: name.to_string(),
private_key: private_key.to_string(),
counter: 0,
max_counter: 0,
created_at: now.clone(),
updated_at: now,
})
}
/// 获取身份
pub fn get_identity(&self, id: &str) -> DatabaseResult<Identity> {
let conn = self.connection();
let mut stmt = conn.prepare(
"SELECT id, name, private_key, counter, max_counter, created_at, updated_at FROM identities WHERE id = ?1"
)?;
let identity = stmt.query_row(params![id], |row| {
Ok(Identity {
id: row.get(0)?,
name: row.get(1)?,
private_key: row.get(2)?,
counter: row.get(3)?,
max_counter: row.get(4)?,
created_at: row.get(5)?,
updated_at: row.get(6)?,
})
}).map_err(|_| DatabaseError::NotFound(format!("身份 {} 未找到", id)))?;
Ok(identity)
}
/// 获取所有身份
pub fn get_all_identities(&self) -> DatabaseResult<Vec<Identity>> {
let conn = self.connection();
let mut stmt = conn.prepare(
"SELECT id, name, private_key, counter, max_counter, created_at, updated_at FROM identities ORDER BY name"
)?;
let identities = stmt.query_map([], |row| {
Ok(Identity {
id: row.get(0)?,
name: row.get(1)?,
private_key: row.get(2)?,
counter: row.get(3)?,
max_counter: row.get(4)?,
created_at: row.get(5)?,
updated_at: row.get(6)?,
})
})?.collect::<Result<Vec<_>, _>>()?;
Ok(identities)
}
/// 更新身份
pub fn update_identity(&self, id: &str, name: Option<&str>, counter: Option<u64>) -> DatabaseResult<()> {
let now = Utc::now().to_rfc3339();
if let Some(name) = name {
self.connection().execute(
"UPDATE identities SET name = ?1, updated_at = ?2 WHERE id = ?3",
params![name, now, id],
)?;
}
if let Some(counter) = counter {
self.connection().execute(
"UPDATE identities SET counter = ?1, max_counter = MAX(max_counter, ?1), updated_at = ?2 WHERE id = ?3",
params![counter, now, id],
)?;
}
Ok(())
}
/// 删除身份
pub fn delete_identity(&self, id: &str) -> DatabaseResult<()> {
self.connection().execute(
"DELETE FROM identities WHERE id = ?1",
params![id],
)?;
Ok(())
}
}
src/tsdb/src/lib.rs
+104
View File
@@ -0,0 +1,104 @@
//! 数据存储
pub mod identity;
pub mod bookmark;
pub mod message;
pub mod config;
pub use identity::*;
pub use bookmark::*;
pub use message::*;
use thiserror::Error;
/// 数据库错误
#[derive(Error, Debug)]
pub enum DatabaseError {
#[error("SQLite 错误: {0}")]
Sqlite(#[from] rusqlite::Error),
#[error("序列化错误: {0}")]
Serialization(#[from] serde_json::Error),
#[error("IO 错误: {0}")]
Io(#[from] std::io::Error),
#[error("未找到: {0}")]
NotFound(String),
#[error("已存在: {0}")]
AlreadyExists(String),
}
/// 数据库结果类型
pub type DatabaseResult<T> = Result<T, DatabaseError>;
/// 数据库管理器
pub struct DatabaseManager {
conn: rusqlite::Connection,
}
impl DatabaseManager {
pub fn new(path: &str) -> DatabaseResult<Self> {
let conn = rusqlite::Connection::open(path)?;
let manager = Self { conn };
manager.init_tables()?;
Ok(manager)
}
fn init_tables(&self) -> DatabaseResult<()> {
self.conn.execute_batch(
"
CREATE TABLE IF NOT EXISTS identities (
id TEXT PRIMARY KEY,
name TEXT NOT NULL,
private_key TEXT NOT NULL,
counter INTEGER NOT NULL DEFAULT 0,
max_counter INTEGER NOT NULL DEFAULT 0,
created_at TEXT NOT NULL,
updated_at TEXT NOT NULL
);
CREATE TABLE IF NOT EXISTS bookmarks (
id TEXT PRIMARY KEY,
name TEXT NOT NULL,
address TEXT NOT NULL,
port INTEGER NOT NULL DEFAULT 9987,
nickname TEXT,
server_password TEXT,
channel TEXT,
channel_password TEXT,
default_token TEXT,
auto_connect INTEGER NOT NULL DEFAULT 0,
last_connected TEXT,
created_at TEXT NOT NULL,
updated_at TEXT NOT NULL
);
CREATE TABLE IF NOT EXISTS messages (
id INTEGER PRIMARY KEY AUTOINCREMENT,
server_address TEXT NOT NULL,
invoker_id INTEGER NOT NULL,
invoker_name TEXT NOT NULL,
invoker_uid TEXT NOT NULL,
target_type TEXT NOT NULL,
target_id INTEGER,
message TEXT NOT NULL,
is_read INTEGER NOT NULL DEFAULT 0,
timestamp TEXT NOT NULL
);
CREATE TABLE IF NOT EXISTS settings (
key TEXT PRIMARY KEY,
value TEXT NOT NULL,
updated_at TEXT NOT NULL
);
"
)?;
Ok(())
}
pub fn connection(&self) -> &rusqlite::Connection {
&self.conn
}
}
src/tsdb/src/message.rs
+139
View File
@@ -0,0 +1,139 @@
//! 消息管理
use rusqlite::params;
use chrono::Utc;
use super::{DatabaseManager, DatabaseResult, DatabaseError};
/// 消息信息
#[derive(Debug, Clone)]
pub struct Message {
pub id: i64,
pub server_address: String,
pub invoker_id: i64,
pub invoker_name: String,
pub invoker_uid: String,
pub target_type: String,
pub target_id: Option<i64>,
pub message: String,
pub is_read: bool,
pub timestamp: String,
}
impl DatabaseManager {
/// 创建消息
pub fn create_message(
&self,
server_address: &str,
invoker_id: i64,
invoker_name: &str,
invoker_uid: &str,
target_type: &str,
target_id: Option<i64>,
message: &str,
) -> DatabaseResult<Message> {
let now = Utc::now().to_rfc3339();
self.connection().execute(
"INSERT INTO messages (server_address, invoker_id, invoker_name, invoker_uid, target_type, target_id, message, is_read, timestamp) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9)",
params![server_address, invoker_id, invoker_name, invoker_uid, target_type, target_id, message, false, now],
)?;
let id = self.connection().last_insert_rowid();
Ok(Message {
id,
server_address: server_address.to_string(),
invoker_id,
invoker_name: invoker_name.to_string(),
invoker_uid: invoker_uid.to_string(),
target_type: target_type.to_string(),
target_id,
message: message.to_string(),
is_read: false,
timestamp: now,
})
}
/// 获取消息
pub fn get_message(&self, id: i64) -> DatabaseResult<Message> {
let conn = self.connection();
let mut stmt = conn.prepare(
"SELECT id, server_address, invoker_id, invoker_name, invoker_uid, target_type, target_id, message, is_read, timestamp FROM messages WHERE id = ?1"
)?;
let message = stmt.query_row(params![id], |row| {
Ok(Message {
id: row.get(0)?,
server_address: row.get(1)?,
invoker_id: row.get(2)?,
invoker_name: row.get(3)?,
invoker_uid: row.get(4)?,
target_type: row.get(5)?,
target_id: row.get(6)?,
message: row.get(7)?,
is_read: row.get::<_, i32>(8)? != 0,
timestamp: row.get(9)?,
})
}).map_err(|_| DatabaseError::NotFound(format!("消息 {} 未找到", id)))?;
Ok(message)
}
/// 获取服务器消息
pub fn get_server_messages(
&self,
server_address: &str,
limit: i64,
offset: i64,
) -> DatabaseResult<Vec<Message>> {
let conn = self.connection();
let mut stmt = conn.prepare(
"SELECT id, server_address, invoker_id, invoker_name, invoker_uid, target_type, target_id, message, is_read, timestamp FROM messages WHERE server_address = ?1 ORDER BY timestamp DESC LIMIT ?2 OFFSET ?3"
)?;
let messages = stmt.query_map(params![server_address, limit, offset], |row| {
Ok(Message {
id: row.get(0)?,
server_address: row.get(1)?,
invoker_id: row.get(2)?,
invoker_name: row.get(3)?,
invoker_uid: row.get(4)?,
target_type: row.get(5)?,
target_id: row.get(6)?,
message: row.get(7)?,
is_read: row.get::<_, i32>(8)? != 0,
timestamp: row.get(9)?,
})
})?.collect::<Result<Vec<_>, _>>()?;
Ok(messages)
}
/// 标记消息为已读
pub fn mark_message_read(&self, id: i64) -> DatabaseResult<()> {
self.connection().execute(
"UPDATE messages SET is_read = 1 WHERE id = ?1",
params![id],
)?;
Ok(())
}
/// 删除消息
pub fn delete_message(&self, id: i64) -> DatabaseResult<()> {
self.connection().execute(
"DELETE FROM messages WHERE id = ?1",
params![id],
)?;
Ok(())
}
/// 清空服务器消息
pub fn clear_server_messages(&self, server_address: &str) -> DatabaseResult<()> {
self.connection().execute(
"DELETE FROM messages WHERE server_address = ?1",
params![server_address],
)?;
Ok(())
}
}