├── assets
    ├── photo.png
    ├── ping.png
    └── status.png
├── code
    ├── wifi_config.h
    └── code.ino
├── LICENSE
├── .github
    └── ISSUE_TEMPLATE
    │   ├── feature-request.yml
    │   └── bug-report.yml
└── README.md


/assets/photo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chenxuuu/sms_forwarding/HEAD/assets/photo.png


--------------------------------------------------------------------------------
/assets/ping.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chenxuuu/sms_forwarding/HEAD/assets/ping.png


--------------------------------------------------------------------------------
/assets/status.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/chenxuuu/sms_forwarding/HEAD/assets/status.png


--------------------------------------------------------------------------------
/code/wifi_config.h:
--------------------------------------------------------------------------------
1 | //WIFI - 仍使用宏定义，因为需要先联网才能配置其他参数
2 | #define WIFI_SSID "你家wifi"
3 | #define WIFI_PASS "你家wifi密码"


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2025 chenxuuu
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE/feature-request.yml:
--------------------------------------------------------------------------------
 1 | name: "\U0001F680 请求某功能 / Feature request"
 2 | description: "为这个项目出一个好点子 / Suggest an idea for this project"
 3 | labels: ["待分类"]
 4 | body:
 5 |   - type: markdown
 6 |     attributes:
 7 |       value: |
 8 |         感谢你提供新的想法！ / Thanks for taking the time to fill out this Feature request!
 9 |   - type: textarea
10 |     id: problem
11 |     attributes:
12 |       label: 您的功能请求是否与解决某些问题有关？请描述一下。/ Is your feature request related to a problem? Please describe.
13 |     validations:
14 |       required: true
15 |   - type: textarea
16 |     id: description
17 |     attributes:
18 |       label: 描述您想要的解决方案 / Describe the solution you'd like
19 |     validations:
20 |       required: true
21 |   - type: textarea
22 |     id: usage
23 |     attributes:
24 |       label: 描述您想要的详细使用步骤描述 / Describe the solution you'd like to use in what way
25 |     validations:
26 |       required: true
27 |   - type: textarea
28 |     id: other
29 |     attributes:
30 |       label: 其他备注信息或截图 / Add any other context or screenshots about the feature request here
31 |     validations:
32 |       required: false
33 | 


--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE/bug-report.yml:
--------------------------------------------------------------------------------
 1 | name: "\U0001F41E 上报bug / Bug report"
 2 | description: "提交bug以让改进软件功能 / Create a report to help us improve"
 3 | labels: ["待分类"]
 4 | body:
 5 |   - type: markdown
 6 |     attributes:
 7 |       value: |
 8 |         感谢你上报新的问题！ / Thanks for taking the time to fill out this bug report!
 9 |   - type: textarea
10 |     id: bug-description
11 |     attributes:
12 |       label: 描述一下这个bug / Describe the bug
13 |       description: 请使用简介并详细的语句，来描述这个bug。 / A clear and concise description of what the bug is.
14 |       placeholder: 我准备……我想要……但是实际上它……了 / I am doing ... What I expect is ... What actually happening is ...
15 |     validations:
16 |       required: true
17 |   - type: textarea
18 |     id: reproduction
19 |     attributes:
20 |       label: 复现步骤 / To Reproduce
21 |       description: 按照下面的步骤，可以复现bug / Steps to reproduce the behavior
22 |       placeholder: 首先……然后……接着…… / Go to '...', Click on '....', Scroll down to '....'
23 |     validations:
24 |       required: true
25 |   - type: textarea
26 |     id: expected
27 |     attributes:
28 |       label: 预期的行为 / Expected behavior
29 |       description: 清楚简洁地描述你希望发生的事情。 / A clear and concise description of what you expected to happen.
30 |       placeholder: 它应该…… / It should be...
31 |     validations:
32 |       required: true
33 |   - type: textarea
34 |     id: screenshots
35 |     attributes:
36 |       label: 截图 / Screenshots
37 |       description: 如果需要，请放上你的截图。 / If applicable, add screenshots to help explain your problem.
38 |     validations:
39 |       required: false
40 |   - type: textarea
41 |     id: logs
42 |     attributes:
43 |       label: 日志 / Logs
44 |       description: 日志贴到这里 / Upload your log files.
45 |       description: 请使用```markdown语法进行包裹！
46 |     validations:
47 |       required: true
48 | 
49 |   - type: checkboxes
50 |     id: checkboxes
51 |     attributes:
52 |       label: 验证
53 |       description: 提交前请确认已经做过以下操作 / Before submitting the issue, please make sure you do the following
54 |       options:
55 |         - label: 检查该问题是否已被提过 / Check that there isn't already an issue that reports the same bug to avoid creating a duplicate.
56 |           required: true
57 |         - label: 提供了最小可复现工程或详细的复现步骤，确保开发者可以复现 / The provided reproduction is a [minimal reproducible example](https://stackoverflow.com/help/minimal-reproducible-example) of the bug.
58 |           required: true
59 |         - label: 我已经提供了完整的日志 / I have provided complete logs.
60 |           required: true
61 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # 低成本短信转发器
  2 | 
  3 | > 当前分支为新方案，老方案请前往[luatos分支](https://github.com/chenxuuu/sms_forwarding/tree/old-luatos)。  
  4 | 该项目可能不支持电信卡（CDMA），具体请自测。  
  5 | 本项目仅用于接收短信与进行保号相关功能。多卡控制、通话、主动拨号等功能永远不会支持，请勿提出相关需求。
  6 | 
  7 | [后台页面演示](https://sms.j2.cx/)
  8 | 
  9 | 本项目旨在使用低成本的硬件设备，实现短信的自动转发功能，支持多种推送方式同时启用。
 10 | 
 11 | > 视频教程：[B站视频](https://www.bilibili.com/video/BV1cSmABYEiX)
 12 | 
 13 | <img src="assets/photo.png" width="200" />
 14 | 
 15 | ## 功能
 16 | 
 17 | - 支持使用通用AT指令与模块进行通信
 18 | - 开启后支持通过WEB界面配置短信转发参数、查询当前状态
 19 | - **支持多达5个推送通道同时启用**，每个通道可独立配置
 20 | - 支持将收到的短信转发到指定的邮箱
 21 | - 支持通过WEB界面主动发送短信，以便消耗余额
 22 | - 支持通过WEB界面进行Ping测试，以极低的成本消耗余额
 23 | - 支持长短信自动合并（30秒超时）
 24 | - 支持管理员短信远程发送短信和重启设备
 25 | 
 26 | ## 推送通道支持
 27 | 
 28 | 支持以下7种推送方式，可同时启用多个通道：
 29 | 
 30 | | 推送方式 | 说明 | 需要配置 |
 31 | |---------|------|---------|
 32 | | **POST JSON** | 通用HTTP POST | URL |
 33 | | **Bark** | iOS推送服务 | Bark服务器URL |
 34 | | **GET请求** | URL参数方式 | URL |
 35 | | **钉钉机器人** | 企业群通知 | Webhook URL，可选Secret加签 |
 36 | | **PushPlus** | 微信公众号推送 | Token |
 37 | | **Server酱** | 微信推送服务 | SendKey |
 38 | | **自定义模板** | 灵活的JSON模板 | URL + 请求体模板 |
 39 | | **飞书机器人** | 自定义通知 | Webhook URL |
 40 | 
 41 | ### 推送格式说明
 42 | 
 43 | - **POST JSON**: `{"sender":"发送者号码","message":"短信内容","timestamp":"时间戳"}`
 44 | - **Bark**: `{"title":"发送者号码","body":"短信内容"}`
 45 | - **GET请求**: `URL?sender=xxx&message=xxx&timestamp=xxx`（自动URL编码）
 46 | - **钉钉机器人**: 文本消息格式，支持加签验证
 47 | - **PushPlus**: 使用Token推送，支持HTML格式
 48 | - **Server酱**: 使用SendKey推送，支持Markdown格式
 49 | - **自定义模板**: 使用`{sender}`、`{message}`、`{timestamp}`占位符
 50 | - **飞书机器人**: 文本消息格式，支持加签验证
 51 | 
 52 | |状态信息|主动ping|
 53 | |-|-|
 54 | |![](assets/status.png)|![](assets/ping.png)|
 55 | 
 56 | ## 硬件搭配
 57 | 
 58 | - ESP32C3开发板，当前选用[ESP32C3 Super Mini](https://item.taobao.com/item.htm?id=852057780489&skuId=5813710390565)，¥9.5包邮
 59 | - ML307R-DC开发板，当前选用[小蓝鲸ML307R-DC核心板](https://item.taobao.com/item.htm?id=797466121802&skuId=5722077108045)，¥16.3包邮
 60 | - [4G FPC天线](https://item.taobao.com/item.htm?id=797466121802&skuId=5722077108045)，¥2，与核心板同购
 61 | 
 62 | 当前成本约¥27.8
 63 | 
 64 | ## 硬件连接
 65 | 
 66 | ESP32C3 与 ML307R-DC 通过串口（UART）连接，接线如下：
 67 | 
 68 | ```
 69 |     ESP32C3 Super Mini       ML307R-DC核心板
 70 |   ┌───────────────────┐    ┌─────────────────┐
 71 |   │                   │    │                 │
 72 |   │       GPIO3 (TX) ─┼───►│ RX              │
 73 |   │                   │    │             EN ─┼─┐
 74 |   │       GPIO4 (RX) ◄┼────┤ TX              │ │
 75 |   │                   │    │                 │ │
 76 |   │              GND ─┼────┤ GND             │ │
 77 |   │                   │    │                 │ │
 78 |   │               5V ─┼────┤ VCC (5V)    5V ─┼─┘
 79 |   │                   │    │                 │
 80 |   └───────────────────┘    └─────────────────┘
 81 |                            │                 │
 82 |                            │  SIM卡槽        │
 83 |                            │  (插入Nano SIM) │
 84 |                            │                 │
 85 |                            │  天线接口       │
 86 |                            │  (连接4G天线)   │
 87 |                            └─────────────────┘
 88 | ```
 89 | 
 90 | 可通过USB连接ESP32C3进行编程和供电，正常工作时，ESP32C3的虚拟串口数据将直接被转发到ML307R-DC，方便调试。
 91 | 
 92 | ## 软件组成
 93 | 
 94 | - ESP32C3运行自己的`Arduino`固件，负责连接WiFi和接收ML307R-DC发送过来的短信数据，然后转发到指定HTTP接口或邮箱
 95 | - ML307R-DC运行默认的AT固件，不用动
 96 | 
 97 | 需要在`Arduino IDE`中单独安装这些库：
 98 | 
 99 | - **ReadyMail** by Mobizt
100 | - **pdulib** by David Henry
101 | 
102 | 需要在`Arduino IDE`中安装ESP32开发板支持，参考[官方文档](https://docs.espressif.com/projects/arduino-esp32/en/latest/installing.html)，版型选`MakerGO ESP32 C3 SuperMini`。
103 | 


--------------------------------------------------------------------------------
/code/code.ino:
--------------------------------------------------------------------------------
   1 | #include <Arduino.h>
   2 | #include <WiFi.h>
   3 | #include <WiFiMulti.h>
   4 | #include <WiFiClientSecure.h>
   5 | #include <WebServer.h>
   6 | #include <Preferences.h>
   7 | #include <pdulib.h>
   8 | #define ENABLE_SMTP
   9 | #define ENABLE_DEBUG
  10 | #include <ReadyMail.h>
  11 | #include <HTTPClient.h>
  12 | #include <mbedtls/md.h>  // 用于钉钉签名的HMAC-SHA256
  13 | #include <base64.h>      // Base64编码
  14 | 
  15 | //wifi信息，需要你打开这个去改
  16 | #include "wifi_config.h"
  17 | 
  18 | //串口映射
  19 | #define TXD 3
  20 | #define RXD 4
  21 | 
  22 | // 推送通道类型
  23 | enum PushType {
  24 |   PUSH_TYPE_NONE = 0,      // 未启用
  25 |   PUSH_TYPE_POST_JSON = 1, // POST JSON格式 {"sender":"xxx","message":"xxx","timestamp":"xxx"}
  26 |   PUSH_TYPE_BARK = 2,      // Bark格式 POST {"title":"xxx","body":"xxx"}
  27 |   PUSH_TYPE_GET = 3,       // GET请求，参数放URL中
  28 |   PUSH_TYPE_DINGTALK = 4,  // 钉钉机器人
  29 |   PUSH_TYPE_PUSHPLUS = 5,  // PushPlus
  30 |   PUSH_TYPE_SERVERCHAN = 6,// Server酱
  31 |   PUSH_TYPE_CUSTOM = 7,    // 自定义模板
  32 |   PUSH_TYPE_FEISHU = 8     // 飞书机器人
  33 | };
  34 | 
  35 | // 最大推送通道数
  36 | #define MAX_PUSH_CHANNELS 5
  37 | 
  38 | // 推送通道配置（通用设计，支持多种推送方式）
  39 | struct PushChannel {
  40 |   bool enabled;           // 是否启用
  41 |   PushType type;          // 推送类型
  42 |   String name;            // 通道名称（用于显示）
  43 |   String url;             // 推送URL（webhook地址）
  44 |   String key1;            // 额外参数1（如：钉钉secret、pushplus token等）
  45 |   String key2;            // 额外参数2（备用）
  46 |   String customBody;      // 自定义请求体模板（使用 {sender} {message} {timestamp} 占位符）
  47 | };
  48 | 
  49 | // 配置参数结构体
  50 | struct Config {
  51 |   String smtpServer;
  52 |   int smtpPort;
  53 |   String smtpUser;
  54 |   String smtpPass;
  55 |   String smtpSendTo;
  56 |   String adminPhone;
  57 |   PushChannel pushChannels[MAX_PUSH_CHANNELS];  // 多推送通道
  58 |   String webUser;      // Web管理账号
  59 |   String webPass;      // Web管理密码
  60 | };
  61 | 
  62 | // 默认Web管理账号密码
  63 | #define DEFAULT_WEB_USER "admin"
  64 | #define DEFAULT_WEB_PASS "admin123"
  65 | 
  66 | Config config;
  67 | Preferences preferences;
  68 | WiFiMulti WiFiMulti;
  69 | PDU pdu = PDU(4096);
  70 | WiFiClientSecure ssl_client;
  71 | SMTPClient smtp(ssl_client);
  72 | WebServer server(80);
  73 | 
  74 | bool configValid = false;  // 配置是否有效
  75 | bool timeSynced = false;   // NTP时间是否已同步
  76 | unsigned long lastPrintTime = 0;  // 上次打印IP的时间
  77 | 
  78 | #define SERIAL_BUFFER_SIZE 500
  79 | #define MAX_PDU_LENGTH 300
  80 | char serialBuf[SERIAL_BUFFER_SIZE];
  81 | int serialBufLen = 0;
  82 | 
  83 | // 长短信合并相关定义
  84 | #define MAX_CONCAT_PARTS 10       // 最大支持的长短信分段数
  85 | #define CONCAT_TIMEOUT_MS 30000   // 长短信等待超时时间(毫秒)
  86 | #define MAX_CONCAT_MESSAGES 5     // 最多同时缓存的长短信组数
  87 | 
  88 | // 长短信分段结构
  89 | struct SmsPart {
  90 |   bool valid;           // 该分段是否有效
  91 |   String text;          // 分段内容
  92 | };
  93 | 
  94 | // 长短信缓存结构
  95 | struct ConcatSms {
  96 |   bool inUse;                           // 是否正在使用
  97 |   int refNumber;                        // 参考号
  98 |   String sender;                        // 发送者
  99 |   String timestamp;                     // 时间戳（使用第一个收到的分段的时间戳）
 100 |   int totalParts;                       // 总分段数
 101 |   int receivedParts;                    // 已收到的分段数
 102 |   unsigned long firstPartTime;          // 收到第一个分段的时间
 103 |   SmsPart parts[MAX_CONCAT_PARTS];      // 各分段内容
 104 | };
 105 | 
 106 | ConcatSms concatBuffer[MAX_CONCAT_MESSAGES];  // 长短信缓存
 107 | 
 108 | // 保存配置到NVS
 109 | void saveConfig() {
 110 |   preferences.begin("sms_config", false);
 111 |   preferences.putString("smtpServer", config.smtpServer);
 112 |   preferences.putInt("smtpPort", config.smtpPort);
 113 |   preferences.putString("smtpUser", config.smtpUser);
 114 |   preferences.putString("smtpPass", config.smtpPass);
 115 |   preferences.putString("smtpSendTo", config.smtpSendTo);
 116 |   preferences.putString("adminPhone", config.adminPhone);
 117 |   preferences.putString("webUser", config.webUser);
 118 |   preferences.putString("webPass", config.webPass);
 119 |   
 120 |   // 保存推送通道配置
 121 |   for (int i = 0; i < MAX_PUSH_CHANNELS; i++) {
 122 |     String prefix = "push" + String(i);
 123 |     preferences.putBool((prefix + "en").c_str(), config.pushChannels[i].enabled);
 124 |     preferences.putUChar((prefix + "type").c_str(), (uint8_t)config.pushChannels[i].type);
 125 |     preferences.putString((prefix + "url").c_str(), config.pushChannels[i].url);
 126 |     preferences.putString((prefix + "name").c_str(), config.pushChannels[i].name);
 127 |     preferences.putString((prefix + "k1").c_str(), config.pushChannels[i].key1);
 128 |     preferences.putString((prefix + "k2").c_str(), config.pushChannels[i].key2);
 129 |     preferences.putString((prefix + "body").c_str(), config.pushChannels[i].customBody);
 130 |   }
 131 |   
 132 |   preferences.end();
 133 |   Serial.println("配置已保存");
 134 | }
 135 | 
 136 | // 从NVS加载配置
 137 | void loadConfig() {
 138 |   preferences.begin("sms_config", true);
 139 |   config.smtpServer = preferences.getString("smtpServer", "");
 140 |   config.smtpPort = preferences.getInt("smtpPort", 465);
 141 |   config.smtpUser = preferences.getString("smtpUser", "");
 142 |   config.smtpPass = preferences.getString("smtpPass", "");
 143 |   config.smtpSendTo = preferences.getString("smtpSendTo", "");
 144 |   config.adminPhone = preferences.getString("adminPhone", "");
 145 |   config.webUser = preferences.getString("webUser", DEFAULT_WEB_USER);
 146 |   config.webPass = preferences.getString("webPass", DEFAULT_WEB_PASS);
 147 |   
 148 |   // 加载推送通道配置
 149 |   for (int i = 0; i < MAX_PUSH_CHANNELS; i++) {
 150 |     String prefix = "push" + String(i);
 151 |     config.pushChannels[i].enabled = preferences.getBool((prefix + "en").c_str(), false);
 152 |     config.pushChannels[i].type = (PushType)preferences.getUChar((prefix + "type").c_str(), PUSH_TYPE_POST_JSON);
 153 |     config.pushChannels[i].url = preferences.getString((prefix + "url").c_str(), "");
 154 |     config.pushChannels[i].name = preferences.getString((prefix + "name").c_str(), "通道" + String(i + 1));
 155 |     config.pushChannels[i].key1 = preferences.getString((prefix + "k1").c_str(), "");
 156 |     config.pushChannels[i].key2 = preferences.getString((prefix + "k2").c_str(), "");
 157 |     config.pushChannels[i].customBody = preferences.getString((prefix + "body").c_str(), "");
 158 |   }
 159 |   
 160 |   // 兼容旧配置：如果有旧的httpUrl配置，迁移到第一个通道
 161 |   String oldHttpUrl = preferences.getString("httpUrl", "");
 162 |   if (oldHttpUrl.length() > 0 && !config.pushChannels[0].enabled) {
 163 |     config.pushChannels[0].enabled = true;
 164 |     config.pushChannels[0].url = oldHttpUrl;
 165 |     config.pushChannels[0].type = preferences.getUChar("barkMode", 0) != 0 ? PUSH_TYPE_BARK : PUSH_TYPE_POST_JSON;
 166 |     config.pushChannels[0].name = "迁移通道";
 167 |     Serial.println("已迁移旧HTTP配置到推送通道1");
 168 |   }
 169 |   
 170 |   preferences.end();
 171 |   Serial.println("配置已加载");
 172 | }
 173 | 
 174 | // 检查推送通道是否有效配置
 175 | bool isPushChannelValid(const PushChannel& ch) {
 176 |   if (!ch.enabled) return false;
 177 |   
 178 |   switch (ch.type) {
 179 |     case PUSH_TYPE_POST_JSON:
 180 |     case PUSH_TYPE_BARK:
 181 |     case PUSH_TYPE_GET:
 182 |     case PUSH_TYPE_DINGTALK:
 183 |     case PUSH_TYPE_FEISHU:
 184 |     case PUSH_TYPE_CUSTOM:
 185 |       return ch.url.length() > 0;
 186 |     case PUSH_TYPE_PUSHPLUS:
 187 |     case PUSH_TYPE_SERVERCHAN:
 188 |       return ch.key1.length() > 0;  // 这两个主要靠key1（token/sendkey）
 189 |     default:
 190 |       return false;
 191 |   }
 192 | }
 193 | 
 194 | // 检查配置是否有效（至少配置了邮件或任一推送通道）
 195 | bool isConfigValid() {
 196 |   bool emailValid = config.smtpServer.length() > 0 && 
 197 |                     config.smtpUser.length() > 0 && 
 198 |                     config.smtpPass.length() > 0 && 
 199 |                     config.smtpSendTo.length() > 0;
 200 |   
 201 |   bool pushValid = false;
 202 |   for (int i = 0; i < MAX_PUSH_CHANNELS; i++) {
 203 |     if (isPushChannelValid(config.pushChannels[i])) {
 204 |       pushValid = true;
 205 |       break;
 206 |     }
 207 |   }
 208 |   
 209 |   return emailValid || pushValid;
 210 | }
 211 | 
 212 | // 获取当前设备URL
 213 | String getDeviceUrl() {
 214 |   return "http://" + WiFi.localIP().toString() + "/";
 215 | }
 216 | 
 217 | // HTML配置页面
 218 | const char* htmlPage = R"rawliteral(
 219 | <!DOCTYPE html>
 220 | <html>
 221 | <head>
 222 |   <meta charset="UTF-8">
 223 |   <meta name="viewport" content="width=device-width, initial-scale=1.0">
 224 |   <title>短信转发配置</title>
 225 |   <style>
 226 |     body { font-family: Arial, sans-serif; margin: 20px; background: #f5f5f5; }
 227 |     .container { max-width: 600px; margin: 0 auto; background: white; padding: 20px; border-radius: 10px; box-shadow: 0 2px 10px rgba(0,0,0,0.1); }
 228 |     h1 { color: #333; text-align: center; }
 229 |     .form-group { margin-bottom: 15px; }
 230 |     label { display: block; margin-bottom: 5px; font-weight: bold; color: #555; }
 231 |     input[type="text"], input[type="password"], input[type="number"], textarea, select { width: 100%; padding: 10px; border: 1px solid #ddd; border-radius: 5px; box-sizing: border-box; }
 232 |     textarea { resize: vertical; min-height: 80px; }
 233 |     button { width: 100%; padding: 12px; background: #4CAF50; color: white; border: none; border-radius: 5px; cursor: pointer; font-size: 16px; margin-top: 10px; }
 234 |     button:hover { background: #45a049; }
 235 |     .label-inline { display:inline; font-weight:normal; margin-left: 5px; }
 236 |     .btn-send { background: #2196F3; }
 237 |     .btn-send:hover { background: #1976D2; }
 238 |     .section { border: 1px solid #ddd; padding: 15px; margin-bottom: 20px; border-radius: 5px; }
 239 |     .section-title { font-size: 18px; color: #333; margin-bottom: 10px; }
 240 |     .status { padding: 10px; background: #e7f3fe; border-left: 4px solid #2196F3; margin-bottom: 20px; }
 241 |     .warning { padding: 10px; background: #fff3cd; border-left: 4px solid #ffc107; margin-bottom: 20px; font-size: 12px; }
 242 |     .hint { font-size: 12px; color: #888; }
 243 |     .nav { display: flex; gap: 10px; margin-bottom: 20px; }
 244 |     .nav a { flex: 1; text-align: center; padding: 10px; background: #eee; border-radius: 5px; text-decoration: none; color: #333; }
 245 |     .nav a.active { background: #4CAF50; color: white; }
 246 |     .push-channel { border: 1px solid #e0e0e0; padding: 12px; margin-bottom: 15px; border-radius: 5px; background: #fafafa; }
 247 |     .push-channel-header { display: flex; align-items: center; margin-bottom: 10px; }
 248 |     .push-channel-header input[type="checkbox"] { width: auto; margin-right: 8px; }
 249 |     .push-channel-header label { margin: 0; font-weight: bold; }
 250 |     .push-channel-body { display: none; }
 251 |     .push-channel.enabled .push-channel-body { display: block; }
 252 |     .push-type-hint { font-size: 11px; color: #666; margin-top: 5px; padding: 8px; background: #f0f0f0; border-radius: 3px; }
 253 |   </style>
 254 | </head>
 255 | <body>
 256 |   <div class="container">
 257 |     <h1>📱 短信转发器</h1>
 258 |     <div class="nav">
 259 |       <a href="/" class="active">⚙️ 系统配置</a>
 260 |       <a href="/tools">🧰 工具箱</a>
 261 |     </div>
 262 |     <div class="status" id="status">设备IP: <strong>%IP%</strong></div>
 263 |     
 264 |     <form action="/save" method="POST">
 265 |       <div class="section">
 266 |         <div class="section-title">🔐 Web管理账号设置</div>
 267 |         <div class="warning">⚠️ 首次使用请修改默认密码！默认账号: )rawliteral" DEFAULT_WEB_USER "，默认密码: " DEFAULT_WEB_PASS R"rawliteral(
 268 |         </div>
 269 |         <div class="form-group">
 270 |           <label>管理账号</label>
 271 |           <input type="text" name="webUser" value="%WEB_USER%" placeholder="admin">
 272 |         </div>
 273 |         <div class="form-group">
 274 |           <label>管理密码</label>
 275 |           <input type="password" name="webPass" value="%WEB_PASS%" placeholder="请设置复杂密码">
 276 |         </div>
 277 |       </div>
 278 |       
 279 |       <div class="section">
 280 |         <div class="section-title">📧 邮件通知设置</div>
 281 |         <div class="form-group">
 282 |           <label>SMTP服务器</label>
 283 |           <input type="text" name="smtpServer" value="%SMTP_SERVER%" placeholder="smtp.qq.com">
 284 |         </div>
 285 |         <div class="form-group">
 286 |           <label>SMTP端口</label>
 287 |           <input type="number" name="smtpPort" value="%SMTP_PORT%" placeholder="465">
 288 |         </div>
 289 |         <div class="form-group">
 290 |           <label>邮箱账号</label>
 291 |           <input type="text" name="smtpUser" value="%SMTP_USER%" placeholder="your@qq.com">
 292 |         </div>
 293 |         <div class="form-group">
 294 |           <label>邮箱密码/授权码</label>
 295 |           <input type="password" name="smtpPass" value="%SMTP_PASS%" placeholder="授权码">
 296 |         </div>
 297 |         <div class="form-group">
 298 |           <label>接收邮件地址</label>
 299 |           <input type="text" name="smtpSendTo" value="%SMTP_SEND_TO%" placeholder="receiver@example.com">
 300 |         </div>
 301 |       </div>
 302 |       
 303 |       <div class="section">
 304 |         <div class="section-title">🔗 HTTP推送通道设置</div>
 305 |         <div class="hint" style="margin-bottom:15px;">可同时启用多个推送通道，每个通道独立配置。支持POST JSON、Bark、GET、钉钉、PushPlus、Server酱等多种方式。</div>
 306 |         
 307 |         %PUSH_CHANNELS%
 308 |       </div>
 309 |       
 310 |       <div class="section">
 311 |         <div class="section-title">👤 管理员设置</div>
 312 |         <div class="form-group">
 313 |           <label>管理员手机号</label>
 314 |           <input type="text" name="adminPhone" value="%ADMIN_PHONE%" placeholder="13800138000">
 315 |         </div>
 316 |       </div>
 317 |       
 318 |       <button type="submit">💾 保存配置</button>
 319 |     </form>
 320 |   </div>
 321 |   <script>
 322 |     function toggleChannel(idx) {
 323 |       var ch = document.getElementById('channel' + idx);
 324 |       var cb = document.getElementById('push' + idx + 'en');
 325 |       if (cb.checked) {
 326 |         ch.classList.add('enabled');
 327 |       } else {
 328 |         ch.classList.remove('enabled');
 329 |       }
 330 |     }
 331 |     function updateTypeHint(idx) {
 332 |       var sel = document.getElementById('push' + idx + 'type');
 333 |       var hint = document.getElementById('hint' + idx);
 334 |       var extraFields = document.getElementById('extra' + idx);
 335 |       var customFields = document.getElementById('custom' + idx);
 336 |       var type = parseInt(sel.value);
 337 |       
 338 |       // 隐藏所有额外字段
 339 |       extraFields.style.display = 'none';
 340 |       customFields.style.display = 'none';
 341 |       document.getElementById('key1label' + idx).innerText = '参数1';
 342 |       document.getElementById('key2label' + idx).innerText = '参数2';
 343 |       document.getElementById('key1' + idx).placeholder = '';
 344 |       document.getElementById('key2' + idx).placeholder = '';
 345 |       
 346 |       if (type == 1) {
 347 |         hint.innerHTML = '<b>POST JSON格式：</b><br>{"sender":"发送者号码","message":"短信内容","timestamp":"时间戳"}';
 348 |       } else if (type == 2) {
 349 |         hint.innerHTML = '<b>Bark格式：</b><br>POST {"title":"发送者号码","body":"短信内容"}';
 350 |       } else if (type == 3) {
 351 |         hint.innerHTML = '<b>GET请求格式：</b><br>URL?sender=xxx&message=xxx&timestamp=xxx';
 352 |       } else if (type == 4) {
 353 |         hint.innerHTML = '<b>钉钉机器人：</b><br>填写Webhook地址，如需加签请填Secret';
 354 |         extraFields.style.display = 'block';
 355 |         document.getElementById('key1label' + idx).innerText = 'Secret（加签密钥，可选）';
 356 |         document.getElementById('key1' + idx).placeholder = 'SEC...';
 357 |       } else if (type == 5) {
 358 |         hint.innerHTML = '<b>PushPlus：</b><br>填写Token，URL留空使用默认';
 359 |         extraFields.style.display = 'block';
 360 |         document.getElementById('key1label' + idx).innerText = 'Token';
 361 |         document.getElementById('key1' + idx).placeholder = 'pushplus的token';
 362 |       } else if (type == 6) {
 363 |         hint.innerHTML = '<b>Server酱：</b><br>填写SendKey，URL留空使用默认';
 364 |         extraFields.style.display = 'block';
 365 |         document.getElementById('key1label' + idx).innerText = 'SendKey';
 366 |         document.getElementById('key1' + idx).placeholder = 'SCT...';
 367 |       } else if (type == 7) {
 368 |         hint.innerHTML = '<b>自定义模板：</b><br>在请求体模板中使用 {sender} {message} {timestamp} 作为占位符';
 369 |         customFields.style.display = 'block';
 370 |       } else if (type == 8) {
 371 |         hint.innerHTML = '<b>飞书机器人：</b><br>填写Webhook地址，如需签名验证请填Secret';
 372 |         extraFields.style.display = 'block';
 373 |         document.getElementById('key1label' + idx).innerText = 'Secret（签名密钥，可选）';
 374 |         document.getElementById('key1' + idx).placeholder = '飞书机器人的签名密钥';
 375 |       }
 376 |     }
 377 |     document.addEventListener('DOMContentLoaded', function() {
 378 |       for (var i = 0; i < 5; i++) {
 379 |         toggleChannel(i);
 380 |         updateTypeHint(i);
 381 |       }
 382 |     });
 383 |   </script>
 384 | </body>
 385 | </html>
 386 | )rawliteral";
 387 | 
 388 | // HTML工具箱页面
 389 | const char* htmlToolsPage = R"rawliteral(
 390 | <!DOCTYPE html>
 391 | <html>
 392 | <head>
 393 |   <meta charset="UTF-8">
 394 |   <meta name="viewport" content="width=device-width, initial-scale=1.0">
 395 |   <title>工具箱</title>
 396 |   <style>
 397 |     body { font-family: Arial, sans-serif; margin: 20px; background: #f5f5f5; }
 398 |     .container { max-width: 600px; margin: 0 auto; background: white; padding: 20px; border-radius: 10px; box-shadow: 0 2px 10px rgba(0,0,0,0.1); }
 399 |     h1 { color: #333; text-align: center; }
 400 |     .form-group { margin-bottom: 15px; }
 401 |     label { display: block; margin-bottom: 5px; font-weight: bold; color: #555; }
 402 |     input[type="text"], textarea { width: 100%; padding: 10px; border: 1px solid #ddd; border-radius: 5px; box-sizing: border-box; }
 403 |     textarea { resize: vertical; min-height: 100px; }
 404 |     button { width: 100%; padding: 12px; background: #2196F3; color: white; border: none; border-radius: 5px; cursor: pointer; font-size: 16px; margin-top: 10px; }
 405 |     button:hover { background: #1976D2; }
 406 |     .btn-query { background: #9C27B0; }
 407 |     .btn-query:hover { background: #7B1FA2; }
 408 |     .btn-ping { background: #FF9800; }
 409 |     .btn-ping:hover { background: #F57C00; }
 410 |     .btn-info { background: #607D8B; }
 411 |     .btn-info:hover { background: #455A64; }
 412 |     button:disabled { background: #ccc; cursor: not-allowed; }
 413 |     .section { border: 1px solid #ddd; padding: 15px; margin-bottom: 20px; border-radius: 5px; }
 414 |     .section-title { font-size: 18px; color: #333; margin-bottom: 10px; }
 415 |     .status { padding: 10px; background: #e7f3fe; border-left: 4px solid #2196F3; margin-bottom: 20px; }
 416 |     .nav { display: flex; gap: 10px; margin-bottom: 20px; }
 417 |     .nav a { flex: 1; text-align: center; padding: 10px; background: #eee; border-radius: 5px; text-decoration: none; color: #333; }
 418 |     .nav a.active { background: #2196F3; color: white; }
 419 |     .char-count { font-size: 12px; color: #888; text-align: right; }
 420 |     .hint { font-size: 12px; color: #888; margin-top: 5px; }
 421 |     .result-box { margin-top: 10px; padding: 10px; border-radius: 5px; display: none; }
 422 |     .result-success { background: #e8f5e9; border-left: 4px solid #4CAF50; color: #2e7d32; }
 423 |     .result-error { background: #ffebee; border-left: 4px solid #f44336; color: #c62828; }
 424 |     .result-loading { background: #fff3e0; border-left: 4px solid #FF9800; color: #e65100; }
 425 |     .result-info { background: #e3f2fd; border-left: 4px solid #2196F3; color: #1565c0; }
 426 |     .info-table { width: 100%; border-collapse: collapse; margin-top: 8px; }
 427 |     .info-table td { padding: 5px 8px; border-bottom: 1px solid #ddd; }
 428 |     .info-table td:first-child { font-weight: bold; width: 40%; color: #555; }
 429 |     .btn-group { display: flex; gap: 10px; flex-wrap: wrap; }
 430 |     .btn-group button { flex: 1; min-width: 120px; }
 431 |   </style>
 432 | </head>
 433 | <body>
 434 |   <div class="container">
 435 |     <h1>📱 短信转发器</h1>
 436 |     <div class="nav">
 437 |       <a href="/">⚙️ 系统配置</a>
 438 |       <a href="/tools" class="active">🧰 工具箱</a>
 439 |     </div>
 440 |     <div class="status" id="status">设备IP: <strong>%IP%</strong></div>
 441 |     
 442 |     <form action="/sendsms" method="POST">
 443 |       <div class="section">
 444 |         <div class="section-title">📤 发送短信</div>
 445 |         <div class="form-group">
 446 |           <label>目标号码</label>
 447 |           <input type="text" name="phone" placeholder="13800138000" required>
 448 |         </div>
 449 |         <div class="form-group">
 450 |           <label>短信内容</label>
 451 |           <textarea name="content" placeholder="请输入短信内容..." required oninput="updateCount(this)"></textarea>
 452 |           <div class="char-count">已输入 <span id="charCount">0</span> 字符</div>
 453 |         </div>
 454 |         <button type="submit">📨 发送短信</button>
 455 |       </div>
 456 |     </form>
 457 |     
 458 |     <div class="section">
 459 |       <div class="section-title">📊 模组信息查询</div>
 460 |       <div class="btn-group">
 461 |         <button type="button" class="btn-query" onclick="queryInfo('ati')">📋 固件信息</button>
 462 |         <button type="button" class="btn-query" onclick="queryInfo('signal')">📶 信号质量</button>
 463 |       </div>
 464 |       <div class="btn-group">
 465 |         <button type="button" class="btn-info" onclick="queryInfo('siminfo')">💳 SIM卡信息</button>
 466 |         <button type="button" class="btn-info" onclick="queryInfo('network')">🌍 网络状态</button>
 467 |       </div>
 468 |       <div class="btn-group">
 469 |         <button type="button" class="btn-info" onclick="queryInfo('wifi')" style="background:#00BCD4;">📡 WiFi状态</button>
 470 |       </div>
 471 |       <div class="result-box" id="queryResult"></div>
 472 |     </div>
 473 |     
 474 |     <div class="section">
 475 |       <div class="section-title">🌐 网络测试</div>
 476 |       <button type="button" class="btn-ping" id="pingBtn" onclick="confirmPing()">📡 点我消耗一点流量</button>
 477 |       <div class="hint">将向 8.8.8.8 进行 ping 操作，一次性消耗极少流量费用</div>
 478 |       <div class="result-box" id="pingResult"></div>
 479 |     </div>
 480 |   </div>
 481 |   <script>
 482 |     function updateCount(el) {
 483 |       document.getElementById('charCount').textContent = el.value.length;
 484 |     }
 485 |     
 486 |     function queryInfo(type) {
 487 |       var result = document.getElementById('queryResult');
 488 |       result.className = 'result-box result-loading';
 489 |       result.style.display = 'block';
 490 |       result.textContent = '正在查询，请稍候...';
 491 |       
 492 |       fetch('/query?type=' + type)
 493 |         .then(response => response.json())
 494 |         .then(data => {
 495 |           if (data.success) {
 496 |             result.className = 'result-box result-info';
 497 |             result.innerHTML = data.message;
 498 |           } else {
 499 |             result.className = 'result-box result-error';
 500 |             result.innerHTML = '❌ 查询失败<br>' + data.message;
 501 |           }
 502 |         })
 503 |         .catch(error => {
 504 |           result.className = 'result-box result-error';
 505 |           result.textContent = '❌ 请求失败: ' + error;
 506 |         });
 507 |     }
 508 | 
 509 |     function confirmPing() {
 510 |       if (confirm("确定要执行 Ping 操作吗？\n\n这将消耗少量流量。")) {
 511 |         doPing();
 512 |       }
 513 |     }
 514 | 
 515 |     function doPing() {
 516 |       var btn = document.getElementById('pingBtn');
 517 |       var result = document.getElementById('pingResult');
 518 |       
 519 |       btn.disabled = true;
 520 |       btn.textContent = '⏳ 正在 Ping...';
 521 |       result.className = 'result-box result-loading';
 522 |       result.style.display = 'block';
 523 |       result.textContent = '正在执行 Ping 操作，请稍候（最长等待30秒）...';
 524 |       
 525 |       fetch('/ping', { method: 'POST' })
 526 |         .then(response => response.json())
 527 |         .then(data => {
 528 |           btn.disabled = false;
 529 |           btn.textContent = '📡 点我消耗一点流量';
 530 |           if (data.success) {
 531 |             result.className = 'result-box result-success';
 532 |             result.innerHTML = '✅ Ping 成功！<br>' + data.message;
 533 |           } else {
 534 |             result.className = 'result-box result-error';
 535 |             result.innerHTML = '❌ Ping 失败<br>' + data.message;
 536 |           }
 537 |         })
 538 |         .catch(error => {
 539 |           btn.disabled = false;
 540 |           btn.textContent = '📡 点我消耗一点流量';
 541 |           result.className = 'result-box result-error';
 542 |           result.textContent = '❌ 请求失败: ' + error;
 543 |         });
 544 |     }
 545 |   </script>
 546 | </body>
 547 | </html>
 548 | )rawliteral";
 549 | 
 550 | // 检查HTTP Basic认证
 551 | bool checkAuth() {
 552 |   if (!server.authenticate(config.webUser.c_str(), config.webPass.c_str())) {
 553 |     server.requestAuthentication(BASIC_AUTH, "SMS Forwarding", "请输入管理员账号密码");
 554 |     return false;
 555 |   }
 556 |   return true;
 557 | }
 558 | 
 559 | // 处理配置页面请求
 560 | void handleRoot() {
 561 |   if (!checkAuth()) return;
 562 |   
 563 |   String html = String(htmlPage);
 564 |   html.replace("%IP%", WiFi.localIP().toString());
 565 |   html.replace("%WEB_USER%", config.webUser);
 566 |   html.replace("%WEB_PASS%", config.webPass);
 567 |   html.replace("%SMTP_SERVER%", config.smtpServer);
 568 |   html.replace("%SMTP_PORT%", String(config.smtpPort));
 569 |   html.replace("%SMTP_USER%", config.smtpUser);
 570 |   html.replace("%SMTP_PASS%", config.smtpPass);
 571 |   html.replace("%SMTP_SEND_TO%", config.smtpSendTo);
 572 |   html.replace("%ADMIN_PHONE%", config.adminPhone);
 573 |   
 574 |   // 生成推送通道HTML
 575 |   String channelsHtml = "";
 576 |   for (int i = 0; i < MAX_PUSH_CHANNELS; i++) {
 577 |     String idx = String(i);
 578 |     String enabledClass = config.pushChannels[i].enabled ? " enabled" : "";
 579 |     String checked = config.pushChannels[i].enabled ? " checked" : "";
 580 |     
 581 |     channelsHtml += "<div class=\"push-channel" + enabledClass + "\" id=\"channel" + idx + "\">";
 582 |     channelsHtml += "<div class=\"push-channel-header\">";
 583 |     channelsHtml += "<input type=\"checkbox\" name=\"push" + idx + "en\" id=\"push" + idx + "en\" onchange=\"toggleChannel(" + idx + ")\"" + checked + ">";
 584 |     channelsHtml += "<label for=\"push" + idx + "en\" class=\"label-inline\">启用推送通道 " + String(i + 1) + "</label>";
 585 |     channelsHtml += "</div>";
 586 |     channelsHtml += "<div class=\"push-channel-body\">";
 587 |     
 588 |     // 通道名称
 589 |     channelsHtml += "<div class=\"form-group\">";
 590 |     channelsHtml += "<label>通道名称</label>";
 591 |     channelsHtml += "<input type=\"text\" name=\"push" + idx + "name\" value=\"" + config.pushChannels[i].name + "\" placeholder=\"自定义名称\">";
 592 |     channelsHtml += "</div>";
 593 |     
 594 |     // 推送类型
 595 |     channelsHtml += "<div class=\"form-group\">";
 596 |     channelsHtml += "<label>推送方式</label>";
 597 |     channelsHtml += "<select name=\"push" + idx + "type\" id=\"push" + idx + "type\" onchange=\"updateTypeHint(" + idx + ")\">";
 598 |     channelsHtml += "<option value=\"1\"" + String(config.pushChannels[i].type == PUSH_TYPE_POST_JSON ? " selected" : "") + ">POST JSON（通用格式）</option>";
 599 |     channelsHtml += "<option value=\"2\"" + String(config.pushChannels[i].type == PUSH_TYPE_BARK ? " selected" : "") + ">Bark（iOS推送）</option>";
 600 |     channelsHtml += "<option value=\"3\"" + String(config.pushChannels[i].type == PUSH_TYPE_GET ? " selected" : "") + ">GET请求（参数在URL中）</option>";
 601 |     channelsHtml += "<option value=\"4\"" + String(config.pushChannels[i].type == PUSH_TYPE_DINGTALK ? " selected" : "") + ">钉钉机器人</option>";
 602 |     channelsHtml += "<option value=\"5\"" + String(config.pushChannels[i].type == PUSH_TYPE_PUSHPLUS ? " selected" : "") + ">PushPlus</option>";
 603 |     channelsHtml += "<option value=\"6\"" + String(config.pushChannels[i].type == PUSH_TYPE_SERVERCHAN ? " selected" : "") + ">Server酱</option>";
 604 |     channelsHtml += "<option value=\"7\"" + String(config.pushChannels[i].type == PUSH_TYPE_CUSTOM ? " selected" : "") + ">自定义模板</option>";
 605 |     channelsHtml += "<option value=\"8\"" + String(config.pushChannels[i].type == PUSH_TYPE_FEISHU ? " selected" : "") + ">飞书机器人</option>";
 606 |     channelsHtml += "</select>";
 607 |     channelsHtml += "<div class=\"push-type-hint\" id=\"hint" + idx + "\"></div>";
 608 |     channelsHtml += "</div>";
 609 |     
 610 |     // URL
 611 |     channelsHtml += "<div class=\"form-group\">";
 612 |     channelsHtml += "<label>推送URL/Webhook</label>";
 613 |     channelsHtml += "<input type=\"text\" name=\"push" + idx + "url\" value=\"" + config.pushChannels[i].url + "\" placeholder=\"http://your-server.com/api 或 webhook地址\">";
 614 |     channelsHtml += "</div>";
 615 |     
 616 |     // 额外参数区域（钉钉/PushPlus/Server酱等需要）
 617 |     channelsHtml += "<div id=\"extra" + idx + "\" style=\"display:none;\">";
 618 |     channelsHtml += "<div class=\"form-group\">";
 619 |     channelsHtml += "<label id=\"key1label" + idx + "\">参数1</label>";
 620 |     channelsHtml += "<input type=\"text\" name=\"push" + idx + "key1\" id=\"key1" + idx + "\" value=\"" + config.pushChannels[i].key1 + "\">";
 621 |     channelsHtml += "</div>";
 622 |     channelsHtml += "<div class=\"form-group\" style=\"display:none;\">";
 623 |     channelsHtml += "<label id=\"key2label" + idx + "\">参数2</label>";
 624 |     channelsHtml += "<input type=\"text\" name=\"push" + idx + "key2\" id=\"key2" + idx + "\" value=\"" + config.pushChannels[i].key2 + "\">";
 625 |     channelsHtml += "</div>";
 626 |     channelsHtml += "</div>";
 627 |     
 628 |     // 自定义模板区域
 629 |     channelsHtml += "<div id=\"custom" + idx + "\" style=\"display:none;\">";
 630 |     channelsHtml += "<div class=\"form-group\">";
 631 |     channelsHtml += "<label>请求体模板（使用 {sender} {message} {timestamp} 占位符）</label>";
 632 |     channelsHtml += "<textarea name=\"push" + idx + "body\" rows=\"4\" style=\"width:100%;font-family:monospace;\">" + config.pushChannels[i].customBody + "</textarea>";
 633 |     channelsHtml += "</div>";
 634 |     channelsHtml += "</div>";
 635 |     
 636 |     channelsHtml += "</div></div>";
 637 |   }
 638 |   html.replace("%PUSH_CHANNELS%", channelsHtml);
 639 |   
 640 |   server.send(200, "text/html", html);
 641 | }
 642 | 
 643 | // 处理工具箱页面请求
 644 | void handleToolsPage() {
 645 |   if (!checkAuth()) return;
 646 |   
 647 |   String html = String(htmlToolsPage);
 648 |   html.replace("%IP%", WiFi.localIP().toString());
 649 |   server.send(200, "text/html", html);
 650 | }
 651 | 
 652 | // 发送AT命令并获取响应
 653 | String sendATCommand(const char* cmd, unsigned long timeout) {
 654 |   while (Serial1.available()) Serial1.read();
 655 |   Serial1.println(cmd);
 656 |   
 657 |   unsigned long start = millis();
 658 |   String resp = "";
 659 |   while (millis() - start < timeout) {
 660 |     while (Serial1.available()) {
 661 |       char c = Serial1.read();
 662 |       resp += c;
 663 |       if (resp.indexOf("OK") >= 0 || resp.indexOf("ERROR") >= 0) {
 664 |         delay(50);  // 等待剩余数据
 665 |         while (Serial1.available()) resp += (char)Serial1.read();
 666 |         return resp;
 667 |       }
 668 |     }
 669 |   }
 670 |   return resp;
 671 | }
 672 | 
 673 | // 处理模组信息查询请求
 674 | void handleQuery() {
 675 |   if (!checkAuth()) return;
 676 |   
 677 |   String type = server.arg("type");
 678 |   String json = "{";
 679 |   bool success = false;
 680 |   String message = "";
 681 |   
 682 |   if (type == "ati") {
 683 |     // 固件信息查询
 684 |     String resp = sendATCommand("ATI", 2000);
 685 |     Serial.println("ATI响应: " + resp);
 686 |     
 687 |     if (resp.indexOf("OK") >= 0) {
 688 |       success = true;
 689 |       // 解析ATI响应
 690 |       String manufacturer = "未知";
 691 |       String model = "未知";
 692 |       String version = "未知";
 693 |       
 694 |       // 按行解析
 695 |       int lineStart = 0;
 696 |       int lineNum = 0;
 697 |       for (int i = 0; i < resp.length(); i++) {
 698 |         if (resp.charAt(i) == '\n' || i == resp.length() - 1) {
 699 |           String line = resp.substring(lineStart, i);
 700 |           line.trim();
 701 |           if (line.length() > 0 && line != "ATI" && line != "OK") {
 702 |             lineNum++;
 703 |             if (lineNum == 1) manufacturer = line;
 704 |             else if (lineNum == 2) model = line;
 705 |             else if (lineNum == 3) version = line;
 706 |           }
 707 |           lineStart = i + 1;
 708 |         }
 709 |       }
 710 |       
 711 |       message = "<table class='info-table'>";
 712 |       message += "<tr><td>制造商</td><td>" + manufacturer + "</td></tr>";
 713 |       message += "<tr><td>模组型号</td><td>" + model + "</td></tr>";
 714 |       message += "<tr><td>固件版本</td><td>" + version + "</td></tr>";
 715 |       message += "</table>";
 716 |     } else {
 717 |       message = "查询失败";
 718 |     }
 719 |   }
 720 |   else if (type == "signal") {
 721 |     // 信号质量查询
 722 |     String resp = sendATCommand("AT+CESQ", 2000);
 723 |     Serial.println("CESQ响应: " + resp);
 724 |     
 725 |     if (resp.indexOf("+CESQ:") >= 0) {
 726 |       success = true;
 727 |       // 解析 +CESQ: <rxlev>,<ber>,<rscp>,<ecno>,<rsrq>,<rsrp>
 728 |       int idx = resp.indexOf("+CESQ:");
 729 |       String params = resp.substring(idx + 6);
 730 |       int endIdx = params.indexOf('\r');
 731 |       if (endIdx < 0) endIdx = params.indexOf('\n');
 732 |       if (endIdx > 0) params = params.substring(0, endIdx);
 733 |       params.trim();
 734 |       
 735 |       // 分割参数
 736 |       String values[6];
 737 |       int valIdx = 0;
 738 |       int startPos = 0;
 739 |       for (int i = 0; i <= params.length() && valIdx < 6; i++) {
 740 |         if (i == params.length() || params.charAt(i) == ',') {
 741 |           values[valIdx] = params.substring(startPos, i);
 742 |           values[valIdx].trim();
 743 |           valIdx++;
 744 |           startPos = i + 1;
 745 |         }
 746 |       }
 747 |       
 748 |       // RSRP转换为dBm (0-97映射到-140到-44 dBm, 99表示未知)
 749 |       int rsrp = values[5].toInt();
 750 |       String rsrpStr;
 751 |       if (rsrp == 99 || rsrp == 255) {
 752 |         rsrpStr = "未知";
 753 |       } else {
 754 |         int rsrpDbm = -140 + rsrp;
 755 |         rsrpStr = String(rsrpDbm) + " dBm";
 756 |         if (rsrpDbm >= -80) rsrpStr += " (信号极好)";
 757 |         else if (rsrpDbm >= -90) rsrpStr += " (信号良好)";
 758 |         else if (rsrpDbm >= -100) rsrpStr += " (信号一般)";
 759 |         else if (rsrpDbm >= -110) rsrpStr += " (信号较弱)";
 760 |         else rsrpStr += " (信号很差)";
 761 |       }
 762 |       
 763 |       // RSRQ转换 (0-34映射到-19.5到-3 dB)
 764 |       int rsrq = values[4].toInt();
 765 |       String rsrqStr;
 766 |       if (rsrq == 99 || rsrq == 255) {
 767 |         rsrqStr = "未知";
 768 |       } else {
 769 |         float rsrqDb = -19.5 + rsrq * 0.5;
 770 |         rsrqStr = String(rsrqDb, 1) + " dB";
 771 |       }
 772 |       
 773 |       message = "<table class='info-table'>";
 774 |       message += "<tr><td>信号强度 (RSRP)</td><td>" + rsrpStr + "</td></tr>";
 775 |       message += "<tr><td>信号质量 (RSRQ)</td><td>" + rsrqStr + "</td></tr>";
 776 |       message += "<tr><td>原始数据</td><td>" + params + "</td></tr>";
 777 |       message += "</table>";
 778 |     } else {
 779 |       message = "查询失败";
 780 |     }
 781 |   }
 782 |   else if (type == "siminfo") {
 783 |     // SIM卡信息查询
 784 |     success = true;
 785 |     message = "<table class='info-table'>";
 786 |     
 787 |     // 查询IMSI
 788 |     String resp = sendATCommand("AT+CIMI", 2000);
 789 |     String imsi = "未知";
 790 |     if (resp.indexOf("OK") >= 0) {
 791 |       int start = resp.indexOf('\n');
 792 |       if (start >= 0) {
 793 |         int end = resp.indexOf('\n', start + 1);
 794 |         if (end < 0) end = resp.indexOf('\r', start + 1);
 795 |         if (end > start) {
 796 |           imsi = resp.substring(start + 1, end);
 797 |           imsi.trim();
 798 |           if (imsi == "OK" || imsi.length() < 10) imsi = "未知";
 799 |         }
 800 |       }
 801 |     }
 802 |     message += "<tr><td>IMSI</td><td>" + imsi + "</td></tr>";
 803 |     
 804 |     // 查询ICCID
 805 |     resp = sendATCommand("AT+ICCID", 2000);
 806 |     String iccid = "未知";
 807 |     if (resp.indexOf("+ICCID:") >= 0) {
 808 |       int idx = resp.indexOf("+ICCID:");
 809 |       String tmp = resp.substring(idx + 7);
 810 |       int endIdx = tmp.indexOf('\r');
 811 |       if (endIdx < 0) endIdx = tmp.indexOf('\n');
 812 |       if (endIdx > 0) iccid = tmp.substring(0, endIdx);
 813 |       iccid.trim();
 814 |     }
 815 |     message += "<tr><td>ICCID</td><td>" + iccid + "</td></tr>";
 816 |     
 817 |     // 查询本机号码 (如果SIM卡支持)
 818 |     resp = sendATCommand("AT+CNUM", 2000);
 819 |     String phoneNum = "未存储或不支持";
 820 |     if (resp.indexOf("+CNUM:") >= 0) {
 821 |       int idx = resp.indexOf(",\"");
 822 |       if (idx >= 0) {
 823 |         int endIdx = resp.indexOf("\"", idx + 2);
 824 |         if (endIdx > idx) {
 825 |           phoneNum = resp.substring(idx + 2, endIdx);
 826 |         }
 827 |       }
 828 |     }
 829 |     message += "<tr><td>本机号码</td><td>" + phoneNum + "</td></tr>";
 830 |     
 831 |     message += "</table>";
 832 |   }
 833 |   else if (type == "network") {
 834 |     // 网络状态查询
 835 |     success = true;
 836 |     message = "<table class='info-table'>";
 837 |     
 838 |     // 查询网络注册状态
 839 |     String resp = sendATCommand("AT+CEREG?", 2000);
 840 |     String regStatus = "未知";
 841 |     if (resp.indexOf("+CEREG:") >= 0) {
 842 |       int idx = resp.indexOf("+CEREG:");
 843 |       String tmp = resp.substring(idx + 7);
 844 |       int commaIdx = tmp.indexOf(',');
 845 |       if (commaIdx >= 0) {
 846 |         String stat = tmp.substring(commaIdx + 1, commaIdx + 2);
 847 |         int s = stat.toInt();
 848 |         switch(s) {
 849 |           case 0: regStatus = "未注册，未搜索"; break;
 850 |           case 1: regStatus = "已注册，本地网络"; break;
 851 |           case 2: regStatus = "未注册，正在搜索"; break;
 852 |           case 3: regStatus = "注册被拒绝"; break;
 853 |           case 4: regStatus = "未知"; break;
 854 |           case 5: regStatus = "已注册，漫游"; break;
 855 |           default: regStatus = "状态码: " + stat;
 856 |         }
 857 |       }
 858 |     }
 859 |     message += "<tr><td>网络注册</td><td>" + regStatus + "</td></tr>";
 860 |     
 861 |     // 查询运营商
 862 |     resp = sendATCommand("AT+COPS?", 2000);
 863 |     String oper = "未知";
 864 |     if (resp.indexOf("+COPS:") >= 0) {
 865 |       int idx = resp.indexOf(",\"");
 866 |       if (idx >= 0) {
 867 |         int endIdx = resp.indexOf("\"", idx + 2);
 868 |         if (endIdx > idx) {
 869 |           oper = resp.substring(idx + 2, endIdx);
 870 |         }
 871 |       }
 872 |     }
 873 |     message += "<tr><td>运营商</td><td>" + oper + "</td></tr>";
 874 |     
 875 |     // 查询PDP上下文激活状态
 876 |     resp = sendATCommand("AT+CGACT?", 2000);
 877 |     String pdpStatus = "未激活";
 878 |     if (resp.indexOf("+CGACT: 1,1") >= 0) {
 879 |       pdpStatus = "已激活";
 880 |     } else if (resp.indexOf("+CGACT:") >= 0) {
 881 |       pdpStatus = "未激活";
 882 |     }
 883 |     message += "<tr><td>数据连接</td><td>" + pdpStatus + "</td></tr>";
 884 |     
 885 |     // 查询APN
 886 |     resp = sendATCommand("AT+CGDCONT?", 2000);
 887 |     String apn = "未知";
 888 |     if (resp.indexOf("+CGDCONT:") >= 0) {
 889 |       int idx = resp.indexOf(",\"");
 890 |       if (idx >= 0) {
 891 |         idx = resp.indexOf(",\"", idx + 2);  // 跳过PDP类型
 892 |         if (idx >= 0) {
 893 |           int endIdx = resp.indexOf("\"", idx + 2);
 894 |           if (endIdx > idx) {
 895 |             apn = resp.substring(idx + 2, endIdx);
 896 |             if (apn.length() == 0) apn = "(自动)";
 897 |           }
 898 |         }
 899 |       }
 900 |     }
 901 |     message += "<tr><td>APN</td><td>" + apn + "</td></tr>";
 902 |     
 903 |     message += "</table>";
 904 |   }
 905 |   else if (type == "wifi") {
 906 |     // WiFi状态查询
 907 |     success = true;
 908 |     message = "<table class='info-table'>";
 909 |     
 910 |     // WiFi连接状态
 911 |     String wifiStatus = WiFi.isConnected() ? "已连接" : "未连接";
 912 |     message += "<tr><td>连接状态</td><td>" + wifiStatus + "</td></tr>";
 913 |     
 914 |     // SSID
 915 |     String ssid = WiFi.SSID();
 916 |     if (ssid.length() == 0) ssid = "未知";
 917 |     message += "<tr><td>当前SSID</td><td>" + ssid + "</td></tr>";
 918 |     
 919 |     // 信号强度 RSSI
 920 |     int rssi = WiFi.RSSI();
 921 |     String rssiStr = String(rssi) + " dBm";
 922 |     if (rssi >= -50) rssiStr += " (信号极好)";
 923 |     else if (rssi >= -60) rssiStr += " (信号很好)";
 924 |     else if (rssi >= -70) rssiStr += " (信号良好)";
 925 |     else if (rssi >= -80) rssiStr += " (信号一般)";
 926 |     else if (rssi >= -90) rssiStr += " (信号较弱)";
 927 |     else rssiStr += " (信号很差)";
 928 |     message += "<tr><td>信号强度 (RSSI)</td><td>" + rssiStr + "</td></tr>";
 929 |     
 930 |     // IP地址
 931 |     message += "<tr><td>IP地址</td><td>" + WiFi.localIP().toString() + "</td></tr>";
 932 |     
 933 |     // 网关
 934 |     message += "<tr><td>网关</td><td>" + WiFi.gatewayIP().toString() + "</td></tr>";
 935 |     
 936 |     // 子网掩码
 937 |     message += "<tr><td>子网掩码</td><td>" + WiFi.subnetMask().toString() + "</td></tr>";
 938 |     
 939 |     // DNS
 940 |     message += "<tr><td>DNS服务器</td><td>" + WiFi.dnsIP().toString() + "</td></tr>";
 941 |     
 942 |     // MAC地址
 943 |     message += "<tr><td>MAC地址</td><td>" + WiFi.macAddress() + "</td></tr>";
 944 |     
 945 |     // BSSID (路由器MAC)
 946 |     message += "<tr><td>路由器BSSID</td><td>" + WiFi.BSSIDstr() + "</td></tr>";
 947 |     
 948 |     // 信道
 949 |     message += "<tr><td>WiFi信道</td><td>" + String(WiFi.channel()) + "</td></tr>";
 950 |     
 951 |     message += "</table>";
 952 |   }
 953 |   else {
 954 |     message = "未知的查询类型";
 955 |   }
 956 |   
 957 |   json += "\"success\":" + String(success ? "true" : "false") + ",";
 958 |   json += "\"message\":\"" + message + "\"";
 959 |   json += "}";
 960 |   
 961 |   server.send(200, "application/json", json);
 962 | }
 963 | 
 964 | // 前置声明
 965 | void sendEmailNotification(const char* subject, const char* body);
 966 | bool sendSMS(const char* phoneNumber, const char* message);
 967 | 
 968 | // 处理发送短信请求
 969 | void handleSendSms() {
 970 |   if (!checkAuth()) return;
 971 |   
 972 |   String phone = server.arg("phone");
 973 |   String content = server.arg("content");
 974 |   
 975 |   phone.trim();
 976 |   content.trim();
 977 |   
 978 |   bool success = false;
 979 |   String resultMsg = "";
 980 |   
 981 |   if (phone.length() == 0) {
 982 |     resultMsg = "错误：请输入目标号码";
 983 |   } else if (content.length() == 0) {
 984 |     resultMsg = "错误：请输入短信内容";
 985 |   } else {
 986 |     Serial.println("网页端发送短信请求");
 987 |     Serial.println("目标号码: " + phone);
 988 |     Serial.println("短信内容: " + content);
 989 |     
 990 |     success = sendSMS(phone.c_str(), content.c_str());
 991 |     resultMsg = success ? "短信发送成功！" : "短信发送失败，请检查模组状态";
 992 |   }
 993 |   
 994 |   String html = R"rawliteral(
 995 | <!DOCTYPE html>
 996 | <html>
 997 | <head>
 998 |   <meta charset="UTF-8">
 999 |   <meta http-equiv="refresh" content="3;url=/sms">
1000 |   <title>发送结果</title>
1001 |   <style>
1002 |     body { font-family: Arial, sans-serif; text-align: center; padding-top: 100px; background: #f5f5f5; }
1003 |     .result { padding: 20px; border-radius: 10px; display: inline-block; }
1004 |     .success { background: #4CAF50; color: white; }
1005 |     .error { background: #f44336; color: white; }
1006 |   </style>
1007 | </head>
1008 | <body>
1009 |   <div class="result %CLASS%">
1010 |     <h2>%ICON% %MSG%</h2>
1011 |     <p>3秒后返回发送页面...</p>
1012 |   </div>
1013 | </body>
1014 | </html>
1015 | )rawliteral";
1016 |   
1017 |   html.replace("%CLASS%", success ? "success" : "error");
1018 |   html.replace("%ICON%", success ? "✅" : "❌");
1019 |   html.replace("%MSG%", resultMsg);
1020 |   
1021 |   server.send(200, "text/html", html);
1022 | }
1023 | 
1024 | // 处理Ping请求
1025 | void handlePing() {
1026 |   if (!checkAuth()) return;
1027 |   
1028 |   Serial.println("网页端发起Ping请求");
1029 |   
1030 |   // 清空串口缓冲区
1031 |   while (Serial1.available()) Serial1.read();
1032 |   
1033 |   // 先激活PDP上下文（数据连接）
1034 |   Serial.println("激活数据连接...");
1035 |   String activateResp = sendATCommand("AT+CGACT=1,1", 10000);
1036 |   Serial.println("CGACT响应: " + activateResp);
1037 |   
1038 |   // 检查激活是否成功（OK或已激活的情况）
1039 |   bool networkActivated = (activateResp.indexOf("OK") >= 0);
1040 |   if (!networkActivated) {
1041 |     Serial.println("数据连接激活失败，尝试继续执行...");
1042 |   }
1043 |   
1044 |   // 清空串口缓冲区
1045 |   while (Serial1.available()) Serial1.read();
1046 |   delay(500);  // 等待网络稳定
1047 |   
1048 |   // 发送MPING命令，ping 8.8.8.8，超时30秒，ping 1次
1049 |   Serial1.println("AT+MPING=\"8.8.8.8\",30,1");
1050 |   
1051 |   // 等待响应
1052 |   unsigned long start = millis();
1053 |   String resp = "";
1054 |   bool gotOK = false;
1055 |   bool gotError = false;
1056 |   bool gotPingResult = false;
1057 |   String pingResultMsg = "";
1058 |   
1059 |   // 等待最多35秒（30秒超时 + 5秒余量）
1060 |   while (millis() - start < 35000) {
1061 |     while (Serial1.available()) {
1062 |       char c = Serial1.read();
1063 |       resp += c;
1064 |       Serial.print(c);  // 调试输出
1065 |       
1066 |       // 检查是否收到OK
1067 |       if (resp.indexOf("OK") >= 0 && !gotOK) {
1068 |         gotOK = true;
1069 |       }
1070 |       
1071 |       // 检查是否收到ERROR
1072 |       if (resp.indexOf("+CME ERROR") >= 0 || resp.indexOf("ERROR") >= 0) {
1073 |         gotError = true;
1074 |         pingResultMsg = "模组返回错误";
1075 |         break;
1076 |       }
1077 |       
1078 |       // 检查是否收到Ping结果URC
1079 |       // 成功格式: +MPING: 1,8.8.8.8,32,xxx,xxx
1080 |       // 失败格式: +MPING: 2 或其他
1081 |       int mpingIdx = resp.indexOf("+MPING:");
1082 |       if (mpingIdx >= 0) {
1083 |         // 找到换行符确定完整的一行
1084 |         int lineEnd = resp.indexOf('\n', mpingIdx);
1085 |         if (lineEnd >= 0) {
1086 |           String mpingLine = resp.substring(mpingIdx, lineEnd);
1087 |           mpingLine.trim();
1088 |           Serial.println("收到MPING结果: " + mpingLine);
1089 |           
1090 |           // 解析结果
1091 |           // +MPING: <result>[,<ip>,<packet_len>,<time>,<ttl>]
1092 |           int colonIdx = mpingLine.indexOf(':');
1093 |           if (colonIdx >= 0) {
1094 |             String params = mpingLine.substring(colonIdx + 1);
1095 |             params.trim();
1096 |             
1097 |             // 获取第一个参数（result）
1098 |             int commaIdx = params.indexOf(',');
1099 |             String resultStr;
1100 |             if (commaIdx >= 0) {
1101 |               resultStr = params.substring(0, commaIdx);
1102 |             } else {
1103 |               resultStr = params;
1104 |             }
1105 |             resultStr.trim();
1106 |             int result = resultStr.toInt();
1107 |             
1108 |             gotPingResult = true;
1109 |             
1110 |             // result=0或1都表示成功（不同模组可能返回不同值）
1111 |             // 如果有完整的响应参数（IP、时间等），也视为成功
1112 |             bool pingSuccess = (result == 0 || result == 1) || (params.indexOf(',') >= 0 && params.length() > 5);
1113 |             
1114 |             if (pingSuccess) {
1115 |               // 成功，解析详细信息
1116 |               // 格式: 0/1,"8.8.8.8",16,时间,TTL
1117 |               int idx1 = params.indexOf(',');
1118 |               if (idx1 >= 0) {
1119 |                 String rest = params.substring(idx1 + 1);
1120 |                 // 处理IP地址（可能带引号）
1121 |                 String ip;
1122 |                 int idx2;
1123 |                 if (rest.startsWith("\"")) {
1124 |                   // 带引号的IP
1125 |                   int quoteEnd = rest.indexOf('\"', 1);
1126 |                   if (quoteEnd >= 0) {
1127 |                     ip = rest.substring(1, quoteEnd);
1128 |                     idx2 = rest.indexOf(',', quoteEnd);
1129 |                   } else {
1130 |                     idx2 = rest.indexOf(',');
1131 |                     ip = rest.substring(0, idx2);
1132 |                   }
1133 |                 } else {
1134 |                   idx2 = rest.indexOf(',');
1135 |                   ip = rest.substring(0, idx2);
1136 |                 }
1137 |                 
1138 |                 if (idx2 >= 0) {
1139 |                   rest = rest.substring(idx2 + 1);
1140 |                   int idx3 = rest.indexOf(',');  // packet_len后
1141 |                   if (idx3 >= 0) {
1142 |                     rest = rest.substring(idx3 + 1);
1143 |                     int idx4 = rest.indexOf(',');  // time后
1144 |                     String timeStr, ttlStr;
1145 |                     if (idx4 >= 0) {
1146 |                       timeStr = rest.substring(0, idx4);
1147 |                       ttlStr = rest.substring(idx4 + 1);
1148 |                     } else {
1149 |                       timeStr = rest;
1150 |                       ttlStr = "N/A";
1151 |                     }
1152 |                     timeStr.trim();
1153 |                     ttlStr.trim();
1154 |                     pingResultMsg = "目标: " + ip + ", 延迟: " + timeStr + "ms, TTL: " + ttlStr;
1155 |                   }
1156 |                 }
1157 |               }
1158 |               if (pingResultMsg.length() == 0) {
1159 |                 pingResultMsg = "Ping成功";
1160 |               }
1161 |             } else {
1162 |               // 失败
1163 |               pingResultMsg = "Ping超时或目标不可达 (错误码: " + String(result) + ")";
1164 |             }
1165 |             break;
1166 |           }
1167 |         }
1168 |       }
1169 |     }
1170 |     
1171 |     if (gotError || gotPingResult) break;
1172 |     delay(10);
1173 |   }
1174 |   
1175 |   Serial.println("\nPing操作完成");
1176 |   
1177 |   // 关闭数据连接以节省流量
1178 |   Serial.println("关闭数据连接...");
1179 |   String deactivateResp = sendATCommand("AT+CGACT=0,1", 5000);
1180 |   Serial.println("CGACT关闭响应: " + deactivateResp);
1181 |   
1182 |   // 构建JSON响应
1183 |   String json = "{";
1184 |   if (gotPingResult && pingResultMsg.indexOf("延迟") >= 0) {
1185 |     json += "\"success\":true,";
1186 |     json += "\"message\":\"" + pingResultMsg + "\"";
1187 |   } else if (gotError) {
1188 |     json += "\"success\":false,";
1189 |     json += "\"message\":\"" + pingResultMsg + "\"";
1190 |   } else if (gotPingResult) {
1191 |     json += "\"success\":false,";
1192 |     json += "\"message\":\"" + pingResultMsg + "\"";
1193 |   } else {
1194 |     json += "\"success\":false,";
1195 |     json += "\"message\":\"操作超时，未收到Ping结果\"";
1196 |   }
1197 |   json += "}";
1198 |   
1199 |   server.send(200, "application/json", json);
1200 | }
1201 | 
1202 | // 处理保存配置请求
1203 | void handleSave() {
1204 |   if (!checkAuth()) return;
1205 |   
1206 |   // 获取新的Web账号密码
1207 |   String newWebUser = server.arg("webUser");
1208 |   String newWebPass = server.arg("webPass");
1209 |   
1210 |   // 验证Web账号密码不能为空
1211 |   if (newWebUser.length() == 0) newWebUser = DEFAULT_WEB_USER;
1212 |   if (newWebPass.length() == 0) newWebPass = DEFAULT_WEB_PASS;
1213 |   
1214 |   config.webUser = newWebUser;
1215 |   config.webPass = newWebPass;
1216 |   config.smtpServer = server.arg("smtpServer");
1217 |   config.smtpPort = server.arg("smtpPort").toInt();
1218 |   if (config.smtpPort == 0) config.smtpPort = 465;
1219 |   config.smtpUser = server.arg("smtpUser");
1220 |   config.smtpPass = server.arg("smtpPass");
1221 |   config.smtpSendTo = server.arg("smtpSendTo");
1222 |   config.adminPhone = server.arg("adminPhone");
1223 |   
1224 |   // 保存推送通道配置
1225 |   for (int i = 0; i < MAX_PUSH_CHANNELS; i++) {
1226 |     String idx = String(i);
1227 |     config.pushChannels[i].enabled = server.arg("push" + idx + "en") == "on";
1228 |     config.pushChannels[i].type = (PushType)server.arg("push" + idx + "type").toInt();
1229 |     config.pushChannels[i].url = server.arg("push" + idx + "url");
1230 |     config.pushChannels[i].name = server.arg("push" + idx + "name");
1231 |     config.pushChannels[i].key1 = server.arg("push" + idx + "key1");
1232 |     config.pushChannels[i].key2 = server.arg("push" + idx + "key2");
1233 |     config.pushChannels[i].customBody = server.arg("push" + idx + "body");
1234 |     if (config.pushChannels[i].name.length() == 0) {
1235 |       config.pushChannels[i].name = "通道" + String(i + 1);
1236 |     }
1237 |   }
1238 |   
1239 |   saveConfig();
1240 |   configValid = isConfigValid();
1241 |   
1242 |   String html = R"rawliteral(
1243 | <!DOCTYPE html>
1244 | <html>
1245 | <head>
1246 |   <meta charset="UTF-8">
1247 |   <meta http-equiv="refresh" content="3;url=/">
1248 |   <title>保存成功</title>
1249 |   <style>
1250 |     body { font-family: Arial, sans-serif; text-align: center; padding-top: 100px; background: #f5f5f5; }
1251 |     .success { background: #4CAF50; color: white; padding: 20px; border-radius: 10px; display: inline-block; }
1252 |   </style>
1253 | </head>
1254 | <body>
1255 |   <div class="success">
1256 |     <h2>✅ 配置保存成功！</h2>
1257 |     <p>3秒后返回配置页面...</p>
1258 |     <p>如果修改了账号密码，请使用新的账号密码登录</p>
1259 |   </div>
1260 | </body>
1261 | </html>
1262 | )rawliteral";
1263 |   server.send(200, "text/html", html);
1264 |   
1265 |   // 如果配置有效，发送启动通知
1266 |   if (configValid) {
1267 |     Serial.println("配置有效，发送启动通知...");
1268 |     String subject = "短信转发器配置已更新";
1269 |     String body = "设备配置已更新\n设备地址: " + getDeviceUrl();
1270 |     sendEmailNotification(subject.c_str(), body.c_str());
1271 |   }
1272 | }
1273 | 
1274 | // 发送邮件通知函数
1275 | void sendEmailNotification(const char* subject, const char* body) {
1276 |   if (config.smtpServer.length() == 0 || config.smtpUser.length() == 0 || 
1277 |       config.smtpPass.length() == 0 || config.smtpSendTo.length() == 0) {
1278 |     Serial.println("邮件配置不完整，跳过发送");
1279 |     return;
1280 |   }
1281 |   
1282 |   auto statusCallback = [](SMTPStatus status) {
1283 |     Serial.println(status.text);
1284 |   };
1285 |   smtp.connect(config.smtpServer.c_str(), config.smtpPort, statusCallback);
1286 |   if (smtp.isConnected()) {
1287 |     smtp.authenticate(config.smtpUser.c_str(), config.smtpPass.c_str(), readymail_auth_password);
1288 | 
1289 |     SMTPMessage msg;
1290 |     String from = "sms notify <"; from += config.smtpUser; from += ">";
1291 |     msg.headers.add(rfc822_from, from.c_str());
1292 |     String to = "your_email <"; to += config.smtpSendTo; to += ">";
1293 |     msg.headers.add(rfc822_to, to.c_str());
1294 |     msg.headers.add(rfc822_subject, subject);
1295 |     msg.text.body(body);
1296 |     msg.timestamp = time(nullptr);
1297 |     smtp.send(msg);
1298 |     Serial.println("邮件发送完成");
1299 |   } else {
1300 |     Serial.println("邮件服务器连接失败");
1301 |   }
1302 | }
1303 | 
1304 | // 发送短信（PDU模式）
1305 | bool sendSMS(const char* phoneNumber, const char* message) {
1306 |   Serial.println("准备发送短信...");
1307 |   Serial.print("目标号码: "); Serial.println(phoneNumber);
1308 |   Serial.print("短信内容: "); Serial.println(message);
1309 | 
1310 |   // 使用pdulib编码PDU
1311 |   pdu.setSCAnumber();  // 使用默认短信中心
1312 |   int pduLen = pdu.encodePDU(phoneNumber, message);
1313 |   
1314 |   if (pduLen < 0) {
1315 |     Serial.print("PDU编码失败，错误码: ");
1316 |     Serial.println(pduLen);
1317 |     return false;
1318 |   }
1319 |   
1320 |   Serial.print("PDU数据: "); Serial.println(pdu.getSMS());
1321 |   Serial.print("PDU长度: "); Serial.println(pduLen);
1322 |   
1323 |   // 发送AT+CMGS命令
1324 |   String cmgsCmd = "AT+CMGS=";
1325 |   cmgsCmd += pduLen;
1326 |   
1327 |   while (Serial1.available()) Serial1.read();
1328 |   Serial1.println(cmgsCmd);
1329 |   
1330 |   // 等待 > 提示符
1331 |   unsigned long start = millis();
1332 |   bool gotPrompt = false;
1333 |   while (millis() - start < 5000) {
1334 |     if (Serial1.available()) {
1335 |       char c = Serial1.read();
1336 |       Serial.print(c);
1337 |       if (c == '>') {
1338 |         gotPrompt = true;
1339 |         break;
1340 |       }
1341 |     }
1342 |   }
1343 |   
1344 |   if (!gotPrompt) {
1345 |     Serial.println("未收到>提示符");
1346 |     return false;
1347 |   }
1348 |   
1349 |   // 发送PDU数据
1350 |   Serial1.print(pdu.getSMS());
1351 |   Serial1.write(0x1A);  // Ctrl+Z 结束
1352 |   
1353 |   // 等待响应
1354 |   start = millis();
1355 |   String resp = "";
1356 |   while (millis() - start < 30000) {
1357 |     while (Serial1.available()) {
1358 |       char c = Serial1.read();
1359 |       resp += c;
1360 |       Serial.print(c);
1361 |       if (resp.indexOf("OK") >= 0) {
1362 |         Serial.println("\n短信发送成功");
1363 |         return true;
1364 |       }
1365 |       if (resp.indexOf("ERROR") >= 0) {
1366 |         Serial.println("\n短信发送失败");
1367 |         return false;
1368 |       }
1369 |     }
1370 |   }
1371 |   Serial.println("短信发送超时");
1372 |   return false;
1373 | }
1374 | 
1375 | // 重启模组
1376 | void resetModule() {
1377 |   Serial.println("正在重启模组...");
1378 |   Serial1.println("AT+CFUN=1,1");
1379 |   delay(3000);
1380 | }
1381 | 
1382 | // 检查发送者是否为管理员
1383 | bool isAdmin(const char* sender) {
1384 |   if (config.adminPhone.length() == 0) return false;
1385 |   
1386 |   // 去除可能的国际区号前缀进行比较
1387 |   String senderStr = String(sender);
1388 |   String adminStr = config.adminPhone;
1389 |   
1390 |   // 去除+86前缀
1391 |   if (senderStr.startsWith("+86")) {
1392 |     senderStr = senderStr.substring(3);
1393 |   }
1394 |   if (adminStr.startsWith("+86")) {
1395 |     adminStr = adminStr.substring(3);
1396 |   }
1397 |   
1398 |   return senderStr.equals(adminStr);
1399 | }
1400 | 
1401 | // 处理管理员命令
1402 | void processAdminCommand(const char* sender, const char* text) {
1403 |   String cmd = String(text);
1404 |   cmd.trim();
1405 |   
1406 |   Serial.println("处理管理员命令: " + cmd);
1407 |   
1408 |   // 处理 SMS:号码:内容 命令
1409 |   if (cmd.startsWith("SMS:")) {
1410 |     int firstColon = cmd.indexOf(':');
1411 |     int secondColon = cmd.indexOf(':', firstColon + 1);
1412 |     
1413 |     if (secondColon > firstColon + 1) {
1414 |       String targetPhone = cmd.substring(firstColon + 1, secondColon);
1415 |       String smsContent = cmd.substring(secondColon + 1);
1416 |       
1417 |       targetPhone.trim();
1418 |       smsContent.trim();
1419 |       
1420 |       Serial.println("目标号码: " + targetPhone);
1421 |       Serial.println("短信内容: " + smsContent);
1422 |       
1423 |       bool success = sendSMS(targetPhone.c_str(), smsContent.c_str());
1424 |       
1425 |       // 发送邮件通知结果
1426 |       String subject = success ? "短信发送成功" : "短信发送失败";
1427 |       String body = "管理员命令执行结果:\n";
1428 |       body += "命令: " + cmd + "\n";
1429 |       body += "目标号码: " + targetPhone + "\n";
1430 |       body += "短信内容: " + smsContent + "\n";
1431 |       body += "执行结果: " + String(success ? "成功" : "失败");
1432 |       
1433 |       sendEmailNotification(subject.c_str(), body.c_str());
1434 |     } else {
1435 |       Serial.println("SMS命令格式错误");
1436 |       sendEmailNotification("命令执行失败", "SMS命令格式错误，正确格式: SMS:号码:内容");
1437 |     }
1438 |   }
1439 |   // 处理 RESET 命令
1440 |   else if (cmd.equals("RESET")) {
1441 |     Serial.println("执行RESET命令");
1442 |     
1443 |     // 先发送邮件通知（因为重启后就发不了了）
1444 |     sendEmailNotification("重启命令已执行", "收到RESET命令，即将重启模组和ESP32...");
1445 |     
1446 |     // 重启模组
1447 |     resetModule();
1448 |     
1449 |     // 重启ESP32
1450 |     Serial.println("正在重启ESP32...");
1451 |     delay(1000);
1452 |     ESP.restart();
1453 |   }
1454 |   else {
1455 |     Serial.println("未知命令: " + cmd);
1456 |   }
1457 | }
1458 | 
1459 | // 初始化长短信缓存
1460 | void initConcatBuffer() {
1461 |   for (int i = 0; i < MAX_CONCAT_MESSAGES; i++) {
1462 |     concatBuffer[i].inUse = false;
1463 |     concatBuffer[i].receivedParts = 0;
1464 |     for (int j = 0; j < MAX_CONCAT_PARTS; j++) {
1465 |       concatBuffer[i].parts[j].valid = false;
1466 |       concatBuffer[i].parts[j].text = "";
1467 |     }
1468 |   }
1469 | }
1470 | 
1471 | // 查找或创建长短信缓存槽位
1472 | int findOrCreateConcatSlot(int refNumber, const char* sender, int totalParts) {
1473 |   // 先查找是否已存在
1474 |   for (int i = 0; i < MAX_CONCAT_MESSAGES; i++) {
1475 |     if (concatBuffer[i].inUse && 
1476 |         concatBuffer[i].refNumber == refNumber &&
1477 |         concatBuffer[i].sender.equals(sender)) {
1478 |       return i;
1479 |     }
1480 |   }
1481 |   
1482 |   // 查找空闲槽位
1483 |   for (int i = 0; i < MAX_CONCAT_MESSAGES; i++) {
1484 |     if (!concatBuffer[i].inUse) {
1485 |       concatBuffer[i].inUse = true;
1486 |       concatBuffer[i].refNumber = refNumber;
1487 |       concatBuffer[i].sender = String(sender);
1488 |       concatBuffer[i].totalParts = totalParts;
1489 |       concatBuffer[i].receivedParts = 0;
1490 |       concatBuffer[i].firstPartTime = millis();
1491 |       for (int j = 0; j < MAX_CONCAT_PARTS; j++) {
1492 |         concatBuffer[i].parts[j].valid = false;
1493 |         concatBuffer[i].parts[j].text = "";
1494 |       }
1495 |       return i;
1496 |     }
1497 |   }
1498 |   
1499 |   // 没有空闲槽位，查找最老的槽位覆盖
1500 |   int oldestSlot = 0;
1501 |   unsigned long oldestTime = concatBuffer[0].firstPartTime;
1502 |   for (int i = 1; i < MAX_CONCAT_MESSAGES; i++) {
1503 |     if (concatBuffer[i].firstPartTime < oldestTime) {
1504 |       oldestTime = concatBuffer[i].firstPartTime;
1505 |       oldestSlot = i;
1506 |     }
1507 |   }
1508 |   
1509 |   // 覆盖最老的槽位
1510 |   Serial.println("⚠️ 长短信缓存已满，覆盖最老的槽位");
1511 |   concatBuffer[oldestSlot].inUse = true;
1512 |   concatBuffer[oldestSlot].refNumber = refNumber;
1513 |   concatBuffer[oldestSlot].sender = String(sender);
1514 |   concatBuffer[oldestSlot].totalParts = totalParts;
1515 |   concatBuffer[oldestSlot].receivedParts = 0;
1516 |   concatBuffer[oldestSlot].firstPartTime = millis();
1517 |   for (int j = 0; j < MAX_CONCAT_PARTS; j++) {
1518 |     concatBuffer[oldestSlot].parts[j].valid = false;
1519 |     concatBuffer[oldestSlot].parts[j].text = "";
1520 |   }
1521 |   return oldestSlot;
1522 | }
1523 | 
1524 | // 合并长短信各分段
1525 | String assembleConcatSms(int slot) {
1526 |   String result = "";
1527 |   for (int i = 0; i < concatBuffer[slot].totalParts; i++) {
1528 |     if (concatBuffer[slot].parts[i].valid) {
1529 |       result += concatBuffer[slot].parts[i].text;
1530 |     } else {
1531 |       result += "[缺失分段" + String(i + 1) + "]";
1532 |     }
1533 |   }
1534 |   return result;
1535 | }
1536 | 
1537 | // 清空长短信槽位
1538 | void clearConcatSlot(int slot) {
1539 |   concatBuffer[slot].inUse = false;
1540 |   concatBuffer[slot].receivedParts = 0;
1541 |   concatBuffer[slot].sender = "";
1542 |   concatBuffer[slot].timestamp = "";
1543 |   for (int j = 0; j < MAX_CONCAT_PARTS; j++) {
1544 |     concatBuffer[slot].parts[j].valid = false;
1545 |     concatBuffer[slot].parts[j].text = "";
1546 |   }
1547 | }
1548 | 
1549 | // 前置声明
1550 | void processSmsContent(const char* sender, const char* text, const char* timestamp);
1551 | 
1552 | // 检查长短信超时并转发
1553 | void checkConcatTimeout() {
1554 |   unsigned long now = millis();
1555 |   for (int i = 0; i < MAX_CONCAT_MESSAGES; i++) {
1556 |     if (concatBuffer[i].inUse) {
1557 |       if (now - concatBuffer[i].firstPartTime >= CONCAT_TIMEOUT_MS) {
1558 |         Serial.println("⏰ 长短信超时，强制转发不完整消息");
1559 |         Serial.printf("  参考号: %d, 已收到: %d/%d\n", 
1560 |                       concatBuffer[i].refNumber,
1561 |                       concatBuffer[i].receivedParts,
1562 |                       concatBuffer[i].totalParts);
1563 |         
1564 |         // 合并已收到的分段
1565 |         String fullText = assembleConcatSms(i);
1566 |         
1567 |         // 处理短信内容
1568 |         processSmsContent(concatBuffer[i].sender.c_str(), 
1569 |                          fullText.c_str(), 
1570 |                          concatBuffer[i].timestamp.c_str());
1571 |         
1572 |         // 清空槽位
1573 |         clearConcatSlot(i);
1574 |       }
1575 |     }
1576 |   }
1577 | }
1578 | 
1579 | // 发送短信数据到服务器
1580 | // URL编码辅助函数
1581 | String urlEncode(const String& str) {
1582 |   String encoded = "";
1583 |   char c;
1584 |   char code0;
1585 |   char code1;
1586 |   for (unsigned int i = 0; i < str.length(); i++) {
1587 |     c = str.charAt(i);
1588 |     if (c == ' ') {
1589 |       encoded += '+';
1590 |     } else if (isalnum(c)) {
1591 |       encoded += c;
1592 |     } else {
1593 |       code1 = (c & 0xf) + '0';
1594 |       if ((c & 0xf) > 9) code1 = (c & 0xf) - 10 + 'A';
1595 |       c = (c >> 4) & 0xf;
1596 |       code0 = c + '0';
1597 |       if (c > 9) code0 = c - 10 + 'A';
1598 |       encoded += '%';
1599 |       encoded += code0;
1600 |       encoded += code1;
1601 |     }
1602 |   }
1603 |   return encoded;
1604 | }
1605 | 
1606 | // 钉钉签名函数（时间戳为UTC毫秒级）
1607 | String dingtalkSign(const String& secret, int64_t timestamp) {
1608 |   String stringToSign = String(timestamp) + "\n" + secret;
1609 |   
1610 |   uint8_t hmacResult[32];
1611 |   mbedtls_md_context_t ctx;
1612 |   mbedtls_md_init(&ctx);
1613 |   mbedtls_md_setup(&ctx, mbedtls_md_info_from_type(MBEDTLS_MD_SHA256), 1);
1614 |   mbedtls_md_hmac_starts(&ctx, (const unsigned char*)secret.c_str(), secret.length());
1615 |   mbedtls_md_hmac_update(&ctx, (const unsigned char*)stringToSign.c_str(), stringToSign.length());
1616 |   mbedtls_md_hmac_finish(&ctx, hmacResult);
1617 |   mbedtls_md_free(&ctx);
1618 |   
1619 |   String base64Encoded = base64::encode(hmacResult, 32);
1620 |   return urlEncode(base64Encoded);
1621 | }
1622 | 
1623 | // 获取当前UTC毫秒级时间戳（用于钉钉签名）
1624 | int64_t getUtcMillis() {
1625 |   struct timeval tv;
1626 |   if (gettimeofday(&tv, NULL) == 0) {
1627 |     return (int64_t)tv.tv_sec * 1000LL + tv.tv_usec / 1000;
1628 |   }
1629 |   // 如果获取失败，使用time()函数
1630 |   return (int64_t)time(nullptr) * 1000LL;
1631 | }
1632 | 
1633 | // JSON转义函数
1634 | String jsonEscape(const String& str) {
1635 |   String result = "";
1636 |   for (unsigned int i = 0; i < str.length(); i++) {
1637 |     char c = str.charAt(i);
1638 |     if (c == '"') result += "\\\"";
1639 |     else if (c == '\\') result += "\\\\";
1640 |     else if (c == '\n') result += "\\n";
1641 |     else if (c == '\r') result += "\\r";
1642 |     else if (c == '\t') result += "\\t";
1643 |     else result += c;
1644 |   }
1645 |   return result;
1646 | }
1647 | 
1648 | // 发送单个推送通道
1649 | void sendToChannel(const PushChannel& channel, const char* sender, const char* message, const char* timestamp) {
1650 |   if (!channel.enabled) return;
1651 |   
1652 |   // 对于某些推送方式，URL可以为空（使用默认URL）
1653 |   bool needUrl = (channel.type == PUSH_TYPE_POST_JSON || channel.type == PUSH_TYPE_BARK || 
1654 |                   channel.type == PUSH_TYPE_GET || channel.type == PUSH_TYPE_DINGTALK || 
1655 |                   channel.type == PUSH_TYPE_CUSTOM);
1656 |   if (needUrl && channel.url.length() == 0) return;
1657 |   
1658 |   HTTPClient http;
1659 |   String channelName = channel.name.length() > 0 ? channel.name : ("通道" + String(channel.type));
1660 |   Serial.println("发送到推送通道: " + channelName);
1661 |   
1662 |   int httpCode = 0;
1663 |   String senderEscaped = jsonEscape(String(sender));
1664 |   String messageEscaped = jsonEscape(String(message));
1665 |   String timestampEscaped = jsonEscape(String(timestamp));
1666 |   
1667 |   switch (channel.type) {
1668 |     case PUSH_TYPE_POST_JSON: {
1669 |       // 标准POST JSON格式
1670 |       http.begin(channel.url);
1671 |       http.addHeader("Content-Type", "application/json");
1672 |       String jsonData = "{";
1673 |       jsonData += "\"sender\":\"" + senderEscaped + "\",";
1674 |       jsonData += "\"message\":\"" + messageEscaped + "\",";
1675 |       jsonData += "\"timestamp\":\"" + timestampEscaped + "\"";
1676 |       jsonData += "}";
1677 |       Serial.println("POST JSON: " + jsonData);
1678 |       httpCode = http.POST(jsonData);
1679 |       break;
1680 |     }
1681 |     
1682 |     case PUSH_TYPE_BARK: {
1683 |       // Bark推送格式
1684 |       http.begin(channel.url);
1685 |       http.addHeader("Content-Type", "application/json");
1686 |       String jsonData = "{";
1687 |       jsonData += "\"title\":\"" + senderEscaped + "\",";
1688 |       jsonData += "\"body\":\"" + messageEscaped + "\"";
1689 |       jsonData += "}";
1690 |       Serial.println("BARK JSON: " + jsonData);
1691 |       httpCode = http.POST(jsonData);
1692 |       break;
1693 |     }
1694 |     
1695 |     case PUSH_TYPE_GET: {
1696 |       // GET请求，参数放URL里
1697 |       String getUrl = channel.url;
1698 |       if (getUrl.indexOf('?') == -1) {
1699 |         getUrl += "?";
1700 |       } else {
1701 |         getUrl += "&";
1702 |       }
1703 |       getUrl += "sender=" + urlEncode(String(sender));
1704 |       getUrl += "&message=" + urlEncode(String(message));
1705 |       getUrl += "&timestamp=" + urlEncode(String(timestamp));
1706 |       Serial.println("GET URL: " + getUrl);
1707 |       http.begin(getUrl);
1708 |       httpCode = http.GET();
1709 |       break;
1710 |     }
1711 |     
1712 |     case PUSH_TYPE_DINGTALK: {
1713 |       // 钉钉机器人
1714 |       String webhookUrl = channel.url;
1715 |       
1716 |       // 如果配置了secret，需要添加签名
1717 |       if (channel.key1.length() > 0) {
1718 |         // 获取UTC毫秒级时间戳（钉钉要求）
1719 |         int64_t ts = getUtcMillis();
1720 |         String sign = dingtalkSign(channel.key1, ts);
1721 |         if (webhookUrl.indexOf('?') == -1) {
1722 |           webhookUrl += "?";
1723 |         } else {
1724 |           webhookUrl += "&";
1725 |         }
1726 |         // 使用字符串拼接避免int64_t转换问题
1727 |         char tsBuf[21];
1728 |         snprintf(tsBuf, sizeof(tsBuf), "%lld", ts);
1729 |         webhookUrl += "timestamp=" + String(tsBuf) + "&sign=" + sign;
1730 |       }
1731 |       
1732 |       http.begin(webhookUrl);
1733 |       http.addHeader("Content-Type", "application/json");
1734 |       String jsonData = "{\"msgtype\":\"text\",\"text\":{\"content\":\"";
1735 |       jsonData += "📱短信通知\\n发送者: " + senderEscaped + "\\n内容: " + messageEscaped + "\\n时间: " + timestampEscaped;
1736 |       jsonData += "\"}}";
1737 |       Serial.println("钉钉: " + jsonData);
1738 |       httpCode = http.POST(jsonData);
1739 |       break;
1740 |     }
1741 |     
1742 |     case PUSH_TYPE_PUSHPLUS: {
1743 |       // PushPlus
1744 |       String pushUrl = channel.url.length() > 0 ? channel.url : "http://www.pushplus.plus/send";
1745 |       http.begin(pushUrl);
1746 |       http.addHeader("Content-Type", "application/json");
1747 |       String jsonData = "{";
1748 |       jsonData += "\"token\":\"" + channel.key1 + "\",";
1749 |       jsonData += "\"title\":\"短信来自: " + senderEscaped + "\",";
1750 |       jsonData += "\"content\":\"<b>发送者:</b> " + senderEscaped + "<br><b>时间:</b> " + timestampEscaped + "<br><b>内容:</b><br>" + messageEscaped + "\"";
1751 |       jsonData += "}";
1752 |       Serial.println("PushPlus: " + jsonData);
1753 |       httpCode = http.POST(jsonData);
1754 |       break;
1755 |     }
1756 |     
1757 |     case PUSH_TYPE_SERVERCHAN: {
1758 |       // Server酱
1759 |       String scUrl = channel.url.length() > 0 ? channel.url : ("https://sctapi.ftqq.com/" + channel.key1 + ".send");
1760 |       http.begin(scUrl);
1761 |       http.addHeader("Content-Type", "application/x-www-form-urlencoded");
1762 |       String postData = "title=" + urlEncode("短信来自: " + String(sender));
1763 |       postData += "&desp=" + urlEncode("**发送者:** " + String(sender) + "\n\n**时间:** " + String(timestamp) + "\n\n**内容:**\n\n" + String(message));
1764 |       Serial.println("Server酱: " + postData);
1765 |       httpCode = http.POST(postData);
1766 |       break;
1767 |     }
1768 |     
1769 |     case PUSH_TYPE_CUSTOM: {
1770 |       // 自定义模板
1771 |       if (channel.customBody.length() == 0) {
1772 |         Serial.println("自定义模板为空，跳过");
1773 |         return;
1774 |       }
1775 |       http.begin(channel.url);
1776 |       http.addHeader("Content-Type", "application/json");
1777 |       String body = channel.customBody;
1778 |       body.replace("{sender}", senderEscaped);
1779 |       body.replace("{message}", messageEscaped);
1780 |       body.replace("{timestamp}", timestampEscaped);
1781 |       Serial.println("自定义: " + body);
1782 |       httpCode = http.POST(body);
1783 |       break;
1784 |     }
1785 |     
1786 |     case PUSH_TYPE_FEISHU: {
1787 |       // 飞书机器人
1788 |       String webhookUrl = channel.url;
1789 |       String jsonData = "{";
1790 |       
1791 |       // 如果配置了secret，需要添加签名
1792 |       if (channel.key1.length() > 0) {
1793 |         // 飞书使用秒级时间戳
1794 |         int64_t ts = time(nullptr);
1795 |         // 飞书签名: base64(hmac-sha256(timestamp + "\n" + secret, secret))
1796 |         String stringToSign = String(ts) + "\n" + channel.key1;
1797 |         uint8_t hmacResult[32];
1798 |         mbedtls_md_context_t ctx;
1799 |         mbedtls_md_init(&ctx);
1800 |         mbedtls_md_setup(&ctx, mbedtls_md_info_from_type(MBEDTLS_MD_SHA256), 1);
1801 |         mbedtls_md_hmac_starts(&ctx, (const unsigned char*)channel.key1.c_str(), channel.key1.length());
1802 |         mbedtls_md_hmac_update(&ctx, (const unsigned char*)stringToSign.c_str(), stringToSign.length());
1803 |         mbedtls_md_hmac_finish(&ctx, hmacResult);
1804 |         mbedtls_md_free(&ctx);
1805 |         String sign = base64::encode(hmacResult, 32);
1806 |         
1807 |         jsonData += "\"timestamp\":\"" + String(ts) + "\",";
1808 |         jsonData += "\"sign\":\"" + sign + "\",";
1809 |       }
1810 |       
1811 |       // 飞书消息体
1812 |       jsonData += "\"msg_type\":\"text\",";
1813 |       jsonData += "\"content\":{\"text\":\"";
1814 |       jsonData += "📱短信通知\\n发送者: " + senderEscaped + "\\n内容: " + messageEscaped + "\\n时间: " + timestampEscaped;
1815 |       jsonData += "\"}}";
1816 |       
1817 |       http.begin(webhookUrl);
1818 |       http.addHeader("Content-Type", "application/json");
1819 |       Serial.println("飞书: " + jsonData);
1820 |       httpCode = http.POST(jsonData);
1821 |       break;
1822 |     }
1823 |     
1824 |     default:
1825 |       Serial.println("未知推送类型");
1826 |       return;
1827 |   }
1828 |   
1829 |   if (httpCode > 0) {
1830 |     Serial.printf("[%s] 响应码: %d\n", channelName.c_str(), httpCode);
1831 |     if (httpCode == HTTP_CODE_OK || httpCode == HTTP_CODE_CREATED) {
1832 |       String response = http.getString();
1833 |       Serial.println("响应: " + response);
1834 |     }
1835 |   } else {
1836 |     Serial.printf("[%s] HTTP请求失败: %s\n", channelName.c_str(), http.errorToString(httpCode).c_str());
1837 |   }
1838 |   http.end();
1839 | }
1840 | 
1841 | // 发送短信到所有启用的推送通道
1842 | void sendSMSToServer(const char* sender, const char* message, const char* timestamp) {
1843 |   if (WiFi.status() != WL_CONNECTED) {
1844 |     Serial.println("WiFi未连接，跳过推送");
1845 |     return;
1846 |   }
1847 |   
1848 |   bool hasEnabledChannel = false;
1849 |   for (int i = 0; i < MAX_PUSH_CHANNELS; i++) {
1850 |     if (isPushChannelValid(config.pushChannels[i])) {
1851 |       hasEnabledChannel = true;
1852 |       break;
1853 |     }
1854 |   }
1855 |   
1856 |   if (!hasEnabledChannel) {
1857 |     Serial.println("没有启用的推送通道");
1858 |     return;
1859 |   }
1860 |   
1861 |   Serial.println("\n=== 开始多通道推送 ===");
1862 |   for (int i = 0; i < MAX_PUSH_CHANNELS; i++) {
1863 |     if (isPushChannelValid(config.pushChannels[i])) {
1864 |       sendToChannel(config.pushChannels[i], sender, message, timestamp);
1865 |       delay(100); // 短暂延迟避免请求过快
1866 |     }
1867 |   }
1868 |   Serial.println("=== 多通道推送完成 ===\n");
1869 | }
1870 | 
1871 | // 读取串口一行（含回车换行），返回行字符串，无新行时返回空
1872 | String readSerialLine(HardwareSerial& port) {
1873 |   static char lineBuf[SERIAL_BUFFER_SIZE];
1874 |   static int linePos = 0;
1875 | 
1876 |   while (port.available()) {
1877 |     char c = port.read();
1878 |     if (c == '\n') {
1879 |       lineBuf[linePos] = 0;
1880 |       String res = String(lineBuf);
1881 |       linePos = 0;
1882 |       return res;
1883 |     } else if (c != '\r') {  // 跳过\r
1884 |       if (linePos < SERIAL_BUFFER_SIZE - 1)
1885 |         lineBuf[linePos++] = c;
1886 |       else
1887 |         linePos = 0;  //超长报错保护，重头计
1888 |     }
1889 |   }
1890 |   return "";
1891 | }
1892 | 
1893 | // 检查字符串是否为有效的十六进制PDU数据
1894 | bool isHexString(const String& str) {
1895 |   if (str.length() == 0) return false;
1896 |   for (unsigned int i = 0; i < str.length(); i++) {
1897 |     char c = str.charAt(i);
1898 |     if (!((c >= '0' && c <= '9') || (c >= 'A' && c <= 'F') || (c >= 'a' && c <= 'f'))) {
1899 |       return false;
1900 |     }
1901 |   }
1902 |   return true;
1903 | }
1904 | 
1905 | // 处理最终的短信内容（管理员命令检查和转发）
1906 | void processSmsContent(const char* sender, const char* text, const char* timestamp) {
1907 |   Serial.println("=== 处理短信内容 ===");
1908 |   Serial.println("发送者: " + String(sender));
1909 |   Serial.println("时间戳: " + String(timestamp));
1910 |   Serial.println("内容: " + String(text));
1911 |   Serial.println("====================");
1912 | 
1913 |   // 检查是否为管理员命令
1914 |   if (isAdmin(sender)) {
1915 |     Serial.println("收到管理员短信，检查命令...");
1916 |     String smsText = String(text);
1917 |     smsText.trim();
1918 |     
1919 |     // 检查是否为命令格式
1920 |     if (smsText.startsWith("SMS:") || smsText.equals("RESET")) {
1921 |       processAdminCommand(sender, text);
1922 |       // 命令已处理，不再发送普通通知邮件
1923 |       return;
1924 |     }
1925 |   }
1926 | 
1927 |   // 发送通知http（推送到所有启用的通道）
1928 |   sendSMSToServer(sender, text, timestamp);
1929 |   // 发送通知邮件
1930 |   String subject = ""; subject+="短信";subject+=sender;subject+=",";subject+=text;
1931 |   String body = ""; body+="来自：";body+=sender;body+="，时间：";body+=timestamp;body+="，内容：";body+=text;
1932 |   sendEmailNotification(subject.c_str(), body.c_str());
1933 | }
1934 | 
1935 | // 处理URC和PDU
1936 | void checkSerial1URC() {
1937 |   static enum { IDLE,
1938 |                 WAIT_PDU } state = IDLE;
1939 | 
1940 |   String line = readSerialLine(Serial1);
1941 |   if (line.length() == 0) return;
1942 | 
1943 |   // 打印到调试串口
1944 |   Serial.println("Debug> " + line);
1945 | 
1946 |   if (state == IDLE) {
1947 |     // 检测到短信上报URC头
1948 |     if (line.startsWith("+CMT:")) {
1949 |       Serial.println("检测到+CMT，等待PDU数据...");
1950 |       state = WAIT_PDU;
1951 |     }
1952 |   } else if (state == WAIT_PDU) {
1953 |     // 跳过空行
1954 |     if (line.length() == 0) {
1955 |       return;
1956 |     }
1957 |     
1958 |     // 如果是十六进制字符串，认为是PDU数据
1959 |     if (isHexString(line)) {
1960 |       Serial.println("收到PDU数据: " + line);
1961 |       Serial.println("PDU长度: " + String(line.length()) + " 字符");
1962 |       
1963 |       // 解析PDU
1964 |       if (!pdu.decodePDU(line.c_str())) {
1965 |         Serial.println("❌ PDU解析失败！");
1966 |       } else {
1967 |         Serial.println("✓ PDU解析成功");
1968 |         Serial.println("=== 短信内容 ===");
1969 |         Serial.println("发送者: " + String(pdu.getSender()));
1970 |         Serial.println("时间戳: " + String(pdu.getTimeStamp()));
1971 |         Serial.println("内容: " + String(pdu.getText()));
1972 |         
1973 |         // 获取长短信信息
1974 |         int* concatInfo = pdu.getConcatInfo();
1975 |         int refNumber = concatInfo[0];
1976 |         int partNumber = concatInfo[1];
1977 |         int totalParts = concatInfo[2];
1978 |         
1979 |         Serial.printf("长短信信息: 参考号=%d, 当前=%d, 总计=%d\n", refNumber, partNumber, totalParts);
1980 |         Serial.println("===============");
1981 | 
1982 |         // 判断是否为长短信
1983 |         if (totalParts > 1 && partNumber > 0) {
1984 |           // 这是长短信的一部分
1985 |           Serial.printf("📧 收到长短信分段 %d/%d\n", partNumber, totalParts);
1986 |           
1987 |           // 查找或创建缓存槽位
1988 |           int slot = findOrCreateConcatSlot(refNumber, pdu.getSender(), totalParts);
1989 |           
1990 |           // 存储该分段（partNumber从1开始，数组从0开始）
1991 |           int partIndex = partNumber - 1;
1992 |           if (partIndex >= 0 && partIndex < MAX_CONCAT_PARTS) {
1993 |             if (!concatBuffer[slot].parts[partIndex].valid) {
1994 |               concatBuffer[slot].parts[partIndex].valid = true;
1995 |               concatBuffer[slot].parts[partIndex].text = String(pdu.getText());
1996 |               concatBuffer[slot].receivedParts++;
1997 |               
1998 |               // 如果是第一个收到的分段，保存时间戳
1999 |               if (concatBuffer[slot].receivedParts == 1) {
2000 |                 concatBuffer[slot].timestamp = String(pdu.getTimeStamp());
2001 |               }
2002 |               
2003 |               Serial.printf("  已缓存分段 %d，当前已收到 %d/%d\n", 
2004 |                            partNumber, 
2005 |                            concatBuffer[slot].receivedParts, 
2006 |                            totalParts);
2007 |             } else {
2008 |               Serial.printf("  ⚠️ 分段 %d 已存在，跳过\n", partNumber);
2009 |             }
2010 |           }
2011 |           
2012 |           // 检查是否已收齐所有分段
2013 |           if (concatBuffer[slot].receivedParts >= totalParts) {
2014 |             Serial.println("✅ 长短信已收齐，开始合并转发");
2015 |             
2016 |             // 合并所有分段
2017 |             String fullText = assembleConcatSms(slot);
2018 |             
2019 |             // 处理完整短信
2020 |             processSmsContent(concatBuffer[slot].sender.c_str(), 
2021 |                              fullText.c_str(), 
2022 |                              concatBuffer[slot].timestamp.c_str());
2023 |             
2024 |             // 清空槽位
2025 |             clearConcatSlot(slot);
2026 |           }
2027 |         } else {
2028 |           // 普通短信，直接处理
2029 |           processSmsContent(pdu.getSender(), pdu.getText(), pdu.getTimeStamp());
2030 |         }
2031 |       }
2032 |       
2033 |       // 返回IDLE状态
2034 |       state = IDLE;
2035 |     } 
2036 |     // 如果是其他内容（OK、ERROR等），也返回IDLE
2037 |     else {
2038 |       Serial.println("收到非PDU数据，返回IDLE状态");
2039 |       state = IDLE;
2040 |     }
2041 |   }
2042 | }
2043 | 
2044 | void blink_short(unsigned long gap_time = 500) {
2045 |   digitalWrite(LED_BUILTIN, LOW);
2046 |   delay(50);
2047 |   digitalWrite(LED_BUILTIN, HIGH);
2048 |   delay(gap_time);
2049 | }
2050 | 
2051 | bool sendATandWaitOK(const char* cmd, unsigned long timeout) {
2052 |   while (Serial1.available()) Serial1.read();
2053 |   Serial1.println(cmd);
2054 |   unsigned long start = millis();
2055 |   String resp = "";
2056 |   while (millis() - start < timeout) {
2057 |     while (Serial1.available()) {
2058 |       char c = Serial1.read();
2059 |       resp += c;
2060 |       if (resp.indexOf("OK") >= 0) return true;
2061 |       if (resp.indexOf("ERROR") >= 0) return false;
2062 |     }
2063 |   }
2064 |   return false;
2065 | }
2066 | 
2067 | bool waitCGATT1() {
2068 |   Serial1.println("AT+CGATT?");
2069 |   unsigned long start = millis();
2070 |   String resp = "";
2071 |   while (millis() - start < 2000) {
2072 |     while (Serial1.available()) {
2073 |       char c = Serial1.read();
2074 |       resp += c;
2075 |       if (resp.indexOf("+CGATT: 1") >= 0) return true;
2076 |       if (resp.indexOf("+CGATT: 0") >= 0) return false;
2077 |     }
2078 |   }
2079 |   return false;
2080 | }
2081 | 
2082 | void setup() {
2083 |   pinMode(LED_BUILTIN, OUTPUT);
2084 |   digitalWrite(LED_BUILTIN, HIGH);
2085 |   Serial.begin(115200);
2086 |   Serial1.begin(115200, SERIAL_8N1, RXD, TXD);
2087 |   Serial1.setRxBufferSize(SERIAL_BUFFER_SIZE);
2088 |   
2089 |   // 初始化长短信缓存
2090 |   initConcatBuffer();
2091 |   
2092 |   // 加载配置
2093 |   loadConfig();
2094 |   configValid = isConfigValid();
2095 |   
2096 |   WiFiMulti.addAP(WIFI_SSID, WIFI_PASS);
2097 |   Serial.println("连接wifi");
2098 |   Serial.println(WIFI_SSID);
2099 |   while (WiFiMulti.run() != WL_CONNECTED) blink_short();
2100 |   Serial.println("wifi已连接");
2101 |   Serial.print("IP地址: ");
2102 |   Serial.println(WiFi.localIP());
2103 |   
2104 |   // NTP时间同步（获取UTC时间）
2105 |   Serial.println("正在同步NTP时间...");
2106 |   configTime(0, 0, "ntp.ntsc.ac.cn", "ntp.aliyun.com", "pool.ntp.org");
2107 |   int ntpRetry = 0;
2108 |   while (time(nullptr) < 100000 && ntpRetry < 100) {
2109 |     delay(100);
2110 |     ntpRetry++;
2111 |   }
2112 |   if (time(nullptr) >= 100000) {
2113 |     timeSynced = true;
2114 |     Serial.println("NTP时间同步成功");
2115 |     time_t now = time(nullptr);
2116 |     Serial.print("当前UTC时间戳: ");
2117 |     Serial.println(now);
2118 |   } else {
2119 |     Serial.println("NTP时间同步失败，将使用设备时间");
2120 |   }
2121 |   
2122 |   // 启动HTTP服务器
2123 |   server.on("/", handleRoot);
2124 |   server.on("/save", HTTP_POST, handleSave);
2125 |   server.on("/tools", handleToolsPage);
2126 |   server.on("/sms", handleToolsPage);  // 兼容旧链接
2127 |   server.on("/sendsms", HTTP_POST, handleSendSms);
2128 |   server.on("/ping", HTTP_POST, handlePing);
2129 |   server.on("/query", handleQuery);
2130 |   server.begin();
2131 |   Serial.println("HTTP服务器已启动");
2132 |   
2133 |   ssl_client.setInsecure();
2134 |   while (!sendATandWaitOK("AT", 1000)) {
2135 |     Serial.println("AT未响应，重试...");
2136 |     blink_short();
2137 |   }
2138 |   Serial.println("模组AT响应正常");
2139 |   //设置短信自动上报
2140 |   while (!sendATandWaitOK("AT+CNMI=2,2,0,0,0", 1000)) {
2141 |     Serial.println("设置CNMI失败，重试...");
2142 |     blink_short();
2143 |   }
2144 |   Serial.println("CNMI参数设置完成");
2145 |   //配置PDU模式
2146 |   while (!sendATandWaitOK("AT+CMGF=0", 1000)) {
2147 |     Serial.println("设置PDU模式失败，重试...");
2148 |     blink_short();
2149 |   }
2150 |   Serial.println("PDU模式设置完成");
2151 |   //等待CGATT附着
2152 |   while (!waitCGATT1()) {
2153 |     Serial.println("等待CGATT附着...");
2154 |     blink_short();
2155 |   }
2156 |   Serial.println("CGATT已附着");
2157 |   digitalWrite(LED_BUILTIN, LOW);
2158 |   
2159 |   // 如果配置有效，发送启动通知
2160 |   if (configValid) {
2161 |     Serial.println("配置有效，发送启动通知...");
2162 |     String subject = "短信转发器已启动";
2163 |     String body = "设备已启动\n设备地址: " + getDeviceUrl();
2164 |     sendEmailNotification(subject.c_str(), body.c_str());
2165 |   }
2166 | }
2167 | 
2168 | void loop() {
2169 |   // 处理HTTP请求
2170 |   server.handleClient();
2171 |   
2172 |   // 如果配置无效，每秒打印一次IP地址
2173 |   if (!configValid) {
2174 |     if (millis() - lastPrintTime >= 1000) {
2175 |       lastPrintTime = millis();
2176 |       Serial.println("⚠️ 请访问 " + getDeviceUrl() + " 配置系统参数");
2177 |     }
2178 |   }
2179 |   
2180 |   // 检查长短信超时
2181 |   checkConcatTimeout();
2182 |   
2183 |   // 本地透传
2184 |   if (Serial.available()) Serial1.write(Serial.read());
2185 |   // 检查URC和解析
2186 |   checkSerial1URC();
2187 | }
2188 | 


--------------------------------------------------------------------------------