1745 lines
62 KiB
C++
1745 lines
62 KiB
C++
/*
|
||
* 增强版考勤服务器 - 支持AES加密数据
|
||
*
|
||
* 功能：
|
||
* 1. HTTP端口8082 - 接收STM32加密签到数据
|
||
* 2. HTTP API - 提供Qt客户端接口
|
||
* 3. AES-128-CBC解密支持
|
||
*
|
||
* 编译：g++ -o server_encrypted.exe server_encrypted.cpp -lws2_32 -lcrypto -lssl -std=c++11
|
||
*/
|
||
|
||
#include <iostream>
|
||
#include <string>
|
||
#include <fstream>
|
||
#include <sstream>
|
||
#include <thread>
|
||
#include <vector>
|
||
#include <map>
|
||
#include <set>
|
||
#include <ctime>
|
||
#include <algorithm>
|
||
|
||
#ifdef _WIN32
|
||
#include <winsock2.h>
|
||
#include <ws2tcpip.h>
|
||
#include <direct.h>
|
||
#pragma comment(lib, "ws2_32.lib")
|
||
typedef int socklen_t;
|
||
#else
|
||
#include <sys/socket.h>
|
||
#include <netinet/in.h>
|
||
#include <unistd.h>
|
||
#include <arpa/inet.h>
|
||
#include <cstring>
|
||
#include <dirent.h>
|
||
#include <sys/stat.h>
|
||
#define SOCKET int
|
||
#define INVALID_SOCKET -1
|
||
#define SOCKET_ERROR -1
|
||
#define closesocket(s) close(s)
|
||
#define _mkdir(d) mkdir(d, 0755)
|
||
#endif
|
||
|
||
// OpenSSL库用于AES解密和Base64
|
||
#include <openssl/evp.h>
|
||
#include <openssl/bio.h>
|
||
#include <openssl/buffer.h>
|
||
#include <openssl/aes.h>
|
||
|
||
const int HTTP_PORT = 8082;
|
||
const int BUFFER_SIZE = 4096;
|
||
const std::string LOG_FILE = "attendance.log";
|
||
const std::string DB_FILE = "attendance_database.csv";
|
||
const std::string TIMESLOTS_FILE = "timeslots_config.json"; // 时间段配置文件
|
||
const std::string MAPPING_CONFIG_FILE = "mapping_config.json"; // 映射配置文件
|
||
const std::string FACE_ID_MAPPING_FILE = "face_id_mapping.json"; // 人脸ID映射文件
|
||
const std::string FACES_DIR = "faces"; // 人脸照片目录
|
||
const std::string PENDING_DELETE_FILE = "pending_delete.json"; // 待删除人脸列表
|
||
const std::string SYNC_REQUEST_FILE = "sync_request.json"; // K210同步请求标志文件
|
||
|
||
// ⚠️ 重要：密钥和IV必须与STM32端完全一致！
|
||
static const unsigned char MY_AES_KEY[16] = {
|
||
0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6,
|
||
0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c
|
||
};
|
||
|
||
static const unsigned char MY_AES_IV[16] = {
|
||
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
|
||
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f
|
||
};
|
||
|
||
// ============= Base64解码 =============
|
||
std::string base64_decode(const std::string& encoded_string) {
|
||
BIO *bio, *b64;
|
||
int decode_len = encoded_string.length();
|
||
char* buffer = new char[decode_len];
|
||
|
||
bio = BIO_new_mem_buf(encoded_string.c_str(), -1);
|
||
b64 = BIO_new(BIO_f_base64());
|
||
bio = BIO_push(b64, bio);
|
||
|
||
BIO_set_flags(bio, BIO_FLAGS_BASE64_NO_NL);
|
||
int length = BIO_read(bio, buffer, decode_len);
|
||
BIO_free_all(bio);
|
||
|
||
std::string result(buffer, length);
|
||
delete[] buffer;
|
||
|
||
return result;
|
||
}
|
||
|
||
// ============= 添加PKCS#7填充 =============
|
||
std::string add_pkcs7_padding(const std::string& data) {
|
||
size_t padding_len = 16 - (data.length() % 16);
|
||
std::string result = data;
|
||
for (size_t i = 0; i < padding_len; i++) {
|
||
result += (char)padding_len;
|
||
}
|
||
return result;
|
||
}
|
||
|
||
// ============= 手动移除PKCS#7填充 =============
|
||
std::string remove_pkcs7_padding(const std::string& data) {
|
||
if (data.empty()) return "";
|
||
|
||
// 获取最后一个字节（填充长度）
|
||
unsigned char padding_len = (unsigned char)data[data.length() - 1];
|
||
|
||
// 验证填充长度
|
||
if (padding_len < 1 || padding_len > 16 || padding_len > data.length()) {
|
||
std::cerr << "[CRYPTO] Invalid padding length: " << (int)padding_len << std::endl;
|
||
return data; // 返回原数据
|
||
}
|
||
|
||
// 验证所有填充字节都相同
|
||
for (size_t i = data.length() - padding_len; i < data.length(); i++) {
|
||
if ((unsigned char)data[i] != padding_len) {
|
||
std::cerr << "[CRYPTO] Invalid padding at position " << i << std::endl;
|
||
return data; // 返回原数据
|
||
}
|
||
}
|
||
|
||
// 移除填充
|
||
return data.substr(0, data.length() - padding_len);
|
||
}
|
||
|
||
// ============= AES-CBC加密 (用于响应Qt客户端) =============
|
||
std::string aes_encrypt_cbc(const std::string& plaintext) {
|
||
// 添加PKCS#7填充
|
||
std::string padded = add_pkcs7_padding(plaintext);
|
||
|
||
EVP_CIPHER_CTX *ctx = EVP_CIPHER_CTX_new();
|
||
if (!ctx) {
|
||
std::cerr << "[CRYPTO] Failed to create context" << std::endl;
|
||
return "";
|
||
}
|
||
|
||
// 初始化加密
|
||
if (EVP_EncryptInit_ex(ctx, EVP_aes_128_cbc(), NULL, MY_AES_KEY, MY_AES_IV) != 1) {
|
||
std::cerr << "[CRYPTO] EncryptInit failed" << std::endl;
|
||
EVP_CIPHER_CTX_free(ctx);
|
||
return "";
|
||
}
|
||
|
||
// 禁用自动填充（我们已手动添加）
|
||
EVP_CIPHER_CTX_set_padding(ctx, 0);
|
||
|
||
// 加密数据
|
||
std::vector<unsigned char> ciphertext(padded.length() + 16);
|
||
int len;
|
||
int ciphertext_len = 0;
|
||
|
||
if (EVP_EncryptUpdate(ctx, ciphertext.data(), &len,
|
||
(unsigned char*)padded.c_str(),
|
||
padded.length()) != 1) {
|
||
std::cerr << "[CRYPTO] EncryptUpdate failed" << std::endl;
|
||
EVP_CIPHER_CTX_free(ctx);
|
||
return "";
|
||
}
|
||
ciphertext_len = len;
|
||
|
||
// 完成加密
|
||
if (EVP_EncryptFinal_ex(ctx, ciphertext.data() + len, &len) != 1) {
|
||
std::cerr << "[CRYPTO] EncryptFinal failed" << std::endl;
|
||
EVP_CIPHER_CTX_free(ctx);
|
||
return "";
|
||
}
|
||
ciphertext_len += len;
|
||
|
||
EVP_CIPHER_CTX_free(ctx);
|
||
|
||
return std::string((char*)ciphertext.data(), ciphertext_len);
|
||
}
|
||
|
||
// ============= AES-CBC解密 (使用OpenSSL标准库) =============
|
||
std::string aes_decrypt_cbc(const std::string& encrypted_data) {
|
||
if (encrypted_data.empty() || encrypted_data.length() % 16 != 0) {
|
||
std::cerr << "[CRYPTO] Invalid encrypted data length: " << encrypted_data.length() << std::endl;
|
||
return "";
|
||
}
|
||
|
||
EVP_CIPHER_CTX *ctx = EVP_CIPHER_CTX_new();
|
||
if (!ctx) {
|
||
std::cerr << "[CRYPTO] Failed to create context" << std::endl;
|
||
return "";
|
||
}
|
||
|
||
// 初始化解密（使用标准AES-128-CBC）
|
||
if (EVP_DecryptInit_ex(ctx, EVP_aes_128_cbc(), NULL, MY_AES_KEY, MY_AES_IV) != 1) {
|
||
std::cerr << "[CRYPTO] DecryptInit failed" << std::endl;
|
||
EVP_CIPHER_CTX_free(ctx);
|
||
return "";
|
||
}
|
||
|
||
// 禁用自动填充，我们手动处理PKCS#7
|
||
EVP_CIPHER_CTX_set_padding(ctx, 0);
|
||
|
||
// 解密数据
|
||
std::vector<unsigned char> plaintext(encrypted_data.length() + 16);
|
||
int len;
|
||
int plaintext_len = 0;
|
||
|
||
if (EVP_DecryptUpdate(ctx, plaintext.data(), &len,
|
||
(unsigned char*)encrypted_data.c_str(),
|
||
encrypted_data.length()) != 1) {
|
||
std::cerr << "[CRYPTO] DecryptUpdate failed" << std::endl;
|
||
EVP_CIPHER_CTX_free(ctx);
|
||
return "";
|
||
}
|
||
plaintext_len = len;
|
||
|
||
// 完成解密
|
||
if (EVP_DecryptFinal_ex(ctx, plaintext.data() + len, &len) != 1) {
|
||
std::cerr << "[CRYPTO] DecryptFinal failed" << std::endl;
|
||
EVP_CIPHER_CTX_free(ctx);
|
||
return "";
|
||
}
|
||
plaintext_len += len;
|
||
|
||
EVP_CIPHER_CTX_free(ctx);
|
||
|
||
std::string result((char*)plaintext.data(), plaintext_len);
|
||
|
||
// 手动移除PKCS#7填充
|
||
result = remove_pkcs7_padding(result);
|
||
|
||
return result;
|
||
}
|
||
|
||
// ============= 十六进制输出辅助函数 =============
|
||
void print_hex(const std::string& label, const unsigned char* data, size_t len) {
|
||
std::cout << label << " (" << len << " bytes): ";
|
||
for (size_t i = 0; i < len && i < 32; i++) {
|
||
printf("%02x ", data[i]);
|
||
}
|
||
if (len > 32) std::cout << "...";
|
||
std::cout << std::endl;
|
||
}
|
||
|
||
// ============= Base64编码 =============
|
||
std::string base64_encode(const std::string& input) {
|
||
BIO *bio, *b64;
|
||
BUF_MEM *bufferPtr;
|
||
|
||
b64 = BIO_new(BIO_f_base64());
|
||
bio = BIO_new(BIO_s_mem());
|
||
bio = BIO_push(b64, bio);
|
||
|
||
BIO_set_flags(bio, BIO_FLAGS_BASE64_NO_NL);
|
||
BIO_write(bio, input.c_str(), input.length());
|
||
BIO_flush(bio);
|
||
BIO_get_mem_ptr(bio, &bufferPtr);
|
||
|
||
std::string result(bufferPtr->data, bufferPtr->length);
|
||
BIO_free_all(bio);
|
||
|
||
return result;
|
||
}
|
||
|
||
// ============= 加密JSON数据（用于响应Qt客户端）=============
|
||
std::string encryptJSON(const std::string& json_data) {
|
||
std::cout << "[CRYPTO] Encrypting response..." << std::endl;
|
||
|
||
// AES加密
|
||
std::string encrypted = aes_encrypt_cbc(json_data);
|
||
if (encrypted.empty()) {
|
||
std::cerr << "[CRYPTO] Encryption failed!" << std::endl;
|
||
return "";
|
||
}
|
||
|
||
// Base64编码
|
||
std::string encrypted_base64 = base64_encode(encrypted);
|
||
|
||
std::cout << "[CRYPTO] ✓ Response encrypted" << std::endl;
|
||
return encrypted_base64;
|
||
}
|
||
|
||
// ============= 解密JSON数据 =============
|
||
std::string decryptJSON(const std::string& encrypted_base64) {
|
||
try {
|
||
std::cout << "[CRYPTO] Decrypting data..." << std::endl;
|
||
std::cout << "[CRYPTO] Base64 input: " << encrypted_base64 << std::endl;
|
||
std::cout << "[CRYPTO] Base64 length: " << encrypted_base64.length() << std::endl;
|
||
|
||
// 1. Base64解码
|
||
std::string encrypted_binary = base64_decode(encrypted_base64);
|
||
std::cout << "[CRYPTO] Binary length: " << encrypted_binary.length() << std::endl;
|
||
print_hex("[CRYPTO] Encrypted binary", (unsigned char*)encrypted_binary.c_str(), encrypted_binary.length());
|
||
|
||
// 调试：打印密钥和IV
|
||
print_hex("[CRYPTO] Using KEY", MY_AES_KEY, 16);
|
||
print_hex("[CRYPTO] Using IV", MY_AES_IV, 16);
|
||
|
||
// 2. AES解密
|
||
std::string decrypted = aes_decrypt_cbc(encrypted_binary);
|
||
|
||
if (decrypted.empty()) {
|
||
std::cerr << "[CRYPTO] Decryption failed!" << std::endl;
|
||
return "";
|
||
}
|
||
|
||
std::cout << "[CRYPTO] ✓ Decryption successful" << std::endl;
|
||
std::cout << "[CRYPTO] Decrypted length: " << decrypted.length() << std::endl;
|
||
print_hex("[CRYPTO] Decrypted hex", (unsigned char*)decrypted.c_str(), decrypted.length());
|
||
std::cout << "[CRYPTO] Decrypted text: " << decrypted << std::endl;
|
||
|
||
return decrypted;
|
||
|
||
} catch (const std::exception& e) {
|
||
std::cerr << "[CRYPTO] Exception: " << e.what() << std::endl;
|
||
return "";
|
||
}
|
||
}
|
||
|
||
// ============= 工具函数 =============
|
||
std::string getCurrentTimestamp() {
|
||
time_t now = time(0);
|
||
tm ltm;
|
||
#ifdef _WIN32
|
||
localtime_s(<m, &now);
|
||
#else
|
||
localtime_r(&now, <m);
|
||
#endif
|
||
char buffer[80];
|
||
strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", <m);
|
||
return std::string(buffer);
|
||
}
|
||
|
||
// 清理字符串中的控制字符（\r, \n等）
|
||
std::string cleanString(const std::string& str) {
|
||
std::string result;
|
||
result.reserve(str.length());
|
||
for (char c : str) {
|
||
// 只保留可打印字符和空格，过滤掉\r\n\t等控制字符
|
||
if (c >= 32 && c <= 126) {
|
||
result += c;
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
|
||
std::string urlDecode(const std::string& str) {
|
||
std::string result;
|
||
for (size_t i = 0; i < str.length(); ++i) {
|
||
if (str[i] == '%' && i + 2 < str.length()) {
|
||
int value;
|
||
std::istringstream is(str.substr(i + 1, 2));
|
||
if (is >> std::hex >> value) {
|
||
result += static_cast<char>(value);
|
||
i += 2;
|
||
} else {
|
||
result += str[i];
|
||
}
|
||
} else if (str[i] == '+') {
|
||
result += ' ';
|
||
} else {
|
||
result += str[i];
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
|
||
std::map<std::string, std::string> parseQueryParams(const std::string& query) {
|
||
std::map<std::string, std::string> params;
|
||
std::istringstream stream(query);
|
||
std::string pair;
|
||
|
||
while (std::getline(stream, pair, '&')) {
|
||
size_t pos = pair.find('=');
|
||
if (pos != std::string::npos) {
|
||
std::string key = urlDecode(pair.substr(0, pos));
|
||
std::string value = urlDecode(pair.substr(pos + 1));
|
||
params[key] = value;
|
||
}
|
||
}
|
||
return params;
|
||
}
|
||
|
||
// 简单的JSON解析
|
||
std::map<std::string, std::string> parseJSON(const std::string& json) {
|
||
std::map<std::string, std::string> result;
|
||
|
||
std::string content = json;
|
||
size_t start = content.find('{');
|
||
size_t end = content.rfind('}');
|
||
if (start != std::string::npos && end != std::string::npos) {
|
||
content = content.substr(start + 1, end - start - 1);
|
||
}
|
||
|
||
std::istringstream ss(content);
|
||
std::string token;
|
||
|
||
while (std::getline(ss, token, ',')) {
|
||
size_t colon = token.find(':');
|
||
if (colon != std::string::npos) {
|
||
std::string key = token.substr(0, colon);
|
||
std::string value = token.substr(colon + 1);
|
||
|
||
// 移除引号和空格
|
||
key.erase(std::remove_if(key.begin(), key.end(),
|
||
[](char c) { return c == '\"' || c == ' ' || c == '\t'; }), key.end());
|
||
value.erase(std::remove_if(value.begin(), value.end(),
|
||
[](char c) { return c == '\"'; }), value.end());
|
||
|
||
// 保留timestamp中的空格
|
||
if (key != "timestamp") {
|
||
value.erase(std::remove(value.begin(), value.end(), ' '), value.end());
|
||
}
|
||
|
||
result[key] = value;
|
||
}
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
// ============= 数据库操作（与原server_with_api.cpp相同）=============
|
||
std::string readDatabase(int limit = -1, int offset = 0) {
|
||
std::ifstream db(DB_FILE);
|
||
if (!db.is_open()) {
|
||
return "[]";
|
||
}
|
||
|
||
std::vector<std::string> lines;
|
||
std::string line;
|
||
std::getline(db, line); // 跳过表头
|
||
|
||
while (std::getline(db, line)) {
|
||
if (!line.empty()) {
|
||
lines.push_back(line);
|
||
}
|
||
}
|
||
db.close();
|
||
|
||
std::reverse(lines.begin(), lines.end());
|
||
|
||
std::ostringstream json;
|
||
json << "[";
|
||
|
||
int start = offset;
|
||
int end = (limit > 0) ? std::min(start + limit, (int)lines.size()) : lines.size();
|
||
|
||
for (int i = start; i < end; ++i) {
|
||
if (i > start) json << ",";
|
||
|
||
std::istringstream ss(lines[i]);
|
||
std::string timestamp, student_id, name, conf, status, class_id;
|
||
|
||
std::getline(ss, timestamp, ',');
|
||
std::getline(ss, student_id, ',');
|
||
std::getline(ss, name, ',');
|
||
std::getline(ss, conf, ',');
|
||
std::getline(ss, status, ',');
|
||
std::getline(ss, class_id, ',');
|
||
|
||
// 兼容旧数据：如果没有class_id字段，默认为"0"
|
||
if (class_id.empty()) class_id = "0";
|
||
|
||
json << "{"
|
||
<< "\"timestamp\":\"" << timestamp << "\","
|
||
<< "\"student_id\":\"" << student_id << "\","
|
||
<< "\"name\":\"" << name << "\","
|
||
<< "\"confidence\":" << conf << ","
|
||
<< "\"status\":\"" << status << "\","
|
||
<< "\"class_id\":\"" << class_id << "\""
|
||
<< "}";
|
||
}
|
||
|
||
json << "]";
|
||
return json.str();
|
||
}
|
||
|
||
std::string getStatistics() {
|
||
std::ifstream db(DB_FILE);
|
||
if (!db.is_open()) {
|
||
return "{\"total\":0,\"today\":0}";
|
||
}
|
||
|
||
std::string line;
|
||
std::getline(db, line);
|
||
|
||
int total = 0;
|
||
int today = 0;
|
||
std::string todayDate = getCurrentTimestamp().substr(0, 10);
|
||
|
||
while (std::getline(db, line)) {
|
||
if (!line.empty()) {
|
||
total++;
|
||
if (line.find(todayDate) == 0) {
|
||
today++;
|
||
}
|
||
}
|
||
}
|
||
db.close();
|
||
|
||
std::ostringstream json;
|
||
json << "{"
|
||
<< "\"total\":" << total << ","
|
||
<< "\"today\":" << today << ","
|
||
<< "\"server_time\":\"" << getCurrentTimestamp() << "\""
|
||
<< "}";
|
||
return json.str();
|
||
}
|
||
|
||
bool clearDatabase() {
|
||
std::ofstream db(DB_FILE);
|
||
if (!db.is_open()) return false;
|
||
db << "Timestamp,Student_ID,Name,Confidence,Status\n";
|
||
db.close();
|
||
return true;
|
||
}
|
||
|
||
// ============= 时间段配置管理 =============
|
||
bool saveTimeSlots(const std::string& json_data) {
|
||
std::cout << "[TIMESLOTS] Attempting to save " << json_data.size() << " bytes" << std::endl;
|
||
|
||
if (json_data.empty()) {
|
||
std::cerr << "[TIMESLOTS] ERROR: json_data is empty!" << std::endl;
|
||
return false;
|
||
}
|
||
|
||
std::ofstream file(TIMESLOTS_FILE);
|
||
if (!file.is_open()) {
|
||
std::cerr << "[TIMESLOTS] Failed to open file for writing: " << TIMESLOTS_FILE << std::endl;
|
||
return false;
|
||
}
|
||
|
||
file << json_data;
|
||
file.flush();
|
||
file.close();
|
||
|
||
std::cout << "[TIMESLOTS] ✓ Configuration saved successfully to " << TIMESLOTS_FILE << std::endl;
|
||
std::cout << "[TIMESLOTS] Preview: " << json_data.substr(0, 100) << "..." << std::endl;
|
||
return true;
|
||
}
|
||
|
||
std::string readTimeSlots() {
|
||
std::ifstream file(TIMESLOTS_FILE);
|
||
if (!file.is_open()) {
|
||
std::cout << "[TIMESLOTS] File not found, returning default config" << std::endl;
|
||
return "{\"time_slots\":[]}";
|
||
}
|
||
|
||
std::stringstream buffer;
|
||
buffer << file.rdbuf();
|
||
file.close();
|
||
|
||
std::string content = buffer.str();
|
||
std::cout << "[TIMESLOTS] Read " << content.size() << " bytes from config file" << std::endl;
|
||
return content;
|
||
}
|
||
|
||
// ============= 检查重复签到 =============
|
||
// 参数: student_id - 学号, slot_start - 时段开始时间(HH:MM), slot_end - 时段结束时间(HH:MM)
|
||
// 返回: JSON格式 {"duplicate": true/false, "record_time": "..."}
|
||
std::string checkDuplicate(const std::string& student_id, const std::string& slot_start, const std::string& slot_end) {
|
||
std::ifstream db(DB_FILE);
|
||
if (!db.is_open()) {
|
||
return "{\"duplicate\":false}";
|
||
}
|
||
|
||
// 获取今天的日期
|
||
std::string todayDate = getCurrentTimestamp().substr(0, 10);
|
||
|
||
// 解析时段开始和结束时间
|
||
int start_hour = 0, start_minute = 0, end_hour = 23, end_minute = 59;
|
||
if (slot_start.length() >= 5) {
|
||
start_hour = std::stoi(slot_start.substr(0, 2));
|
||
start_minute = std::stoi(slot_start.substr(3, 2));
|
||
}
|
||
if (slot_end.length() >= 5) {
|
||
end_hour = std::stoi(slot_end.substr(0, 2));
|
||
end_minute = std::stoi(slot_end.substr(3, 2));
|
||
}
|
||
|
||
std::string line;
|
||
std::getline(db, line); // 跳过表头
|
||
|
||
while (std::getline(db, line)) {
|
||
if (line.empty()) continue;
|
||
|
||
// 解析CSV: Timestamp,Student_ID,Name,Confidence,Status
|
||
std::istringstream ss(line);
|
||
std::string timestamp, record_student_id, name, conf, status;
|
||
|
||
std::getline(ss, timestamp, ',');
|
||
std::getline(ss, record_student_id, ',');
|
||
std::getline(ss, name, ',');
|
||
std::getline(ss, conf, ',');
|
||
std::getline(ss, status, ',');
|
||
|
||
// 检查是否是同一个学生
|
||
if (record_student_id != student_id) continue;
|
||
|
||
// 检查是否是今天的记录
|
||
if (timestamp.substr(0, 10) != todayDate) continue;
|
||
|
||
// 解析记录的时间 (格式: YYYY-MM-DD HH:MM:SS)
|
||
if (timestamp.length() >= 16) {
|
||
int record_hour = std::stoi(timestamp.substr(11, 2));
|
||
int record_minute = std::stoi(timestamp.substr(14, 2));
|
||
int record_total_minutes = record_hour * 60 + record_minute;
|
||
int start_total_minutes = start_hour * 60 + start_minute;
|
||
int end_total_minutes = end_hour * 60 + end_minute;
|
||
|
||
// 检查记录是否在指定时段内
|
||
if (record_total_minutes >= start_total_minutes && record_total_minutes <= end_total_minutes) {
|
||
db.close();
|
||
std::cout << "[CHECK] Duplicate found: " << student_id << " at " << timestamp << std::endl;
|
||
return "{\"duplicate\":true,\"record_time\":\"" + timestamp + "\"}";
|
||
}
|
||
}
|
||
}
|
||
|
||
db.close();
|
||
return "{\"duplicate\":false}";
|
||
}
|
||
|
||
// ============= 删除记录 =============
|
||
bool deleteRecord(const std::string& timestamp, const std::string& student_id) {
|
||
std::ifstream inFile(DB_FILE);
|
||
if (!inFile.is_open()) return false;
|
||
|
||
std::vector<std::string> lines;
|
||
std::string line;
|
||
|
||
std::getline(inFile, line);
|
||
lines.push_back(line);
|
||
|
||
bool found = false;
|
||
while (std::getline(inFile, line)) {
|
||
if (line.empty()) continue;
|
||
|
||
if (line.find(timestamp) == 0 && line.find(student_id) != std::string::npos) {
|
||
found = true;
|
||
std::cout << "[DELETE] 删除记录: " << line << std::endl;
|
||
continue;
|
||
}
|
||
|
||
lines.push_back(line);
|
||
}
|
||
inFile.close();
|
||
|
||
if (!found) return false;
|
||
|
||
std::ofstream outFile(DB_FILE);
|
||
if (!outFile.is_open()) return false;
|
||
|
||
for (const auto& l : lines) {
|
||
outFile << l << "\n";
|
||
}
|
||
outFile.close();
|
||
|
||
return true;
|
||
}
|
||
|
||
// ============= 人脸照片管理函数 =============
|
||
|
||
// 保存人脸ID映射配置
|
||
bool saveFaceIdMapping(const std::string& json_data) {
|
||
std::cout << "[FACE_MAPPING] Saving " << json_data.size() << " bytes" << std::endl;
|
||
std::ofstream file(FACE_ID_MAPPING_FILE);
|
||
if (!file.is_open()) return false;
|
||
file << json_data;
|
||
file.close();
|
||
return true;
|
||
}
|
||
|
||
// 根据映射重命名照片文件
|
||
void renameFacePhotos(const std::string& json_data) {
|
||
std::cout << "[FACE_PHOTO] Renaming photos based on mapping..." << std::endl;
|
||
|
||
// 解析JSON: {"mappings":{"1":"20210001","2":"20210002"}}
|
||
size_t mappings_start = json_data.find("\"mappings\":{");
|
||
if (mappings_start == std::string::npos) return;
|
||
|
||
mappings_start += 12; // 跳过 "mappings":{
|
||
size_t mappings_end = json_data.find("}", mappings_start);
|
||
if (mappings_end == std::string::npos) return;
|
||
|
||
std::string mappings_str = json_data.substr(mappings_start, mappings_end - mappings_start);
|
||
|
||
// 解析每个映射对
|
||
std::map<std::string, std::string> mappings;
|
||
size_t pos = 0;
|
||
while (pos < mappings_str.length()) {
|
||
// 找到键
|
||
size_t key_start = mappings_str.find("\"", pos);
|
||
if (key_start == std::string::npos) break;
|
||
size_t key_end = mappings_str.find("\"", key_start + 1);
|
||
if (key_end == std::string::npos) break;
|
||
|
||
// 找到值
|
||
size_t val_start = mappings_str.find("\"", key_end + 1);
|
||
if (val_start == std::string::npos) break;
|
||
size_t val_end = mappings_str.find("\"", val_start + 1);
|
||
if (val_end == std::string::npos) break;
|
||
|
||
std::string key = mappings_str.substr(key_start + 1, key_end - key_start - 1);
|
||
std::string value = mappings_str.substr(val_start + 1, val_end - val_start - 1);
|
||
|
||
if (!key.empty() && !value.empty()) {
|
||
mappings[key] = value;
|
||
}
|
||
|
||
pos = val_end + 1;
|
||
}
|
||
|
||
// 遍历faces目录，重命名匹配的照片
|
||
std::vector<std::pair<std::string, std::string>> rename_list;
|
||
|
||
#ifdef _WIN32
|
||
WIN32_FIND_DATAA findData;
|
||
std::string searchPath = FACES_DIR + "\\*.jpg";
|
||
HANDLE hFind = FindFirstFileA(searchPath.c_str(), &findData);
|
||
if (hFind != INVALID_HANDLE_VALUE) {
|
||
do {
|
||
std::string filename = findData.cFileName;
|
||
std::string base_name = filename.substr(0, filename.length() - 4); // 去掉.jpg
|
||
|
||
// 检查是否以某个face_id开头
|
||
for (const auto& m : mappings) {
|
||
// 匹配 "face_id.jpg" 或 "face_id_xxx.jpg"
|
||
if (base_name == m.first ||
|
||
(base_name.find(m.first + "_") == 0)) {
|
||
// 直接使用学号作为新文件名（不保留时间戳）
|
||
std::string new_filename = m.second + ".jpg";
|
||
|
||
if (filename != new_filename) {
|
||
rename_list.push_back({filename, new_filename});
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
} while (FindNextFileA(hFind, &findData));
|
||
FindClose(hFind);
|
||
}
|
||
#else
|
||
DIR* dir = opendir(FACES_DIR.c_str());
|
||
if (dir) {
|
||
struct dirent* entry;
|
||
while ((entry = readdir(dir)) != NULL) {
|
||
std::string filename = entry->d_name;
|
||
if (filename.size() > 4 && filename.substr(filename.size() - 4) == ".jpg") {
|
||
std::string base_name = filename.substr(0, filename.length() - 4);
|
||
|
||
for (const auto& m : mappings) {
|
||
if (base_name == m.first ||
|
||
(base_name.find(m.first + "_") == 0)) {
|
||
std::string new_filename = m.second + ".jpg";
|
||
|
||
if (filename != new_filename) {
|
||
rename_list.push_back({filename, new_filename});
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
closedir(dir);
|
||
}
|
||
#endif
|
||
|
||
// 执行重命名
|
||
for (const auto& r : rename_list) {
|
||
std::string old_path = FACES_DIR + "/" + r.first;
|
||
std::string new_path = FACES_DIR + "/" + r.second;
|
||
|
||
// 如果目标文件已存在，先删除旧照片
|
||
std::remove(new_path.c_str());
|
||
|
||
if (std::rename(old_path.c_str(), new_path.c_str()) == 0) {
|
||
std::cout << "[FACE_PHOTO] Renamed: " << r.first << " -> " << r.second << std::endl;
|
||
} else {
|
||
std::cerr << "[FACE_PHOTO] Rename failed: " << r.first << std::endl;
|
||
}
|
||
}
|
||
|
||
std::cout << "[FACE_PHOTO] Renamed " << rename_list.size() << " photos" << std::endl;
|
||
}
|
||
|
||
// 读取人脸ID映射配置
|
||
std::string readFaceIdMapping() {
|
||
std::ifstream file(FACE_ID_MAPPING_FILE);
|
||
if (!file.is_open()) return "{\"mappings\":{}}";
|
||
std::stringstream buffer;
|
||
buffer << file.rdbuf();
|
||
file.close();
|
||
std::string content = buffer.str();
|
||
return content.empty() ? "{\"mappings\":{}}" : content;
|
||
}
|
||
|
||
// 获取人脸照片列表
|
||
std::string getFacePhotosList() {
|
||
std::ostringstream json;
|
||
json << "{\"photos\":[";
|
||
|
||
std::vector<std::string> photos;
|
||
|
||
#ifdef _WIN32
|
||
WIN32_FIND_DATAA findData;
|
||
std::string searchPath = FACES_DIR + "\\*.jpg";
|
||
HANDLE hFind = FindFirstFileA(searchPath.c_str(), &findData);
|
||
if (hFind != INVALID_HANDLE_VALUE) {
|
||
do {
|
||
photos.push_back(findData.cFileName);
|
||
} while (FindNextFileA(hFind, &findData));
|
||
FindClose(hFind);
|
||
}
|
||
#else
|
||
DIR* dir = opendir(FACES_DIR.c_str());
|
||
if (dir) {
|
||
struct dirent* entry;
|
||
while ((entry = readdir(dir)) != NULL) {
|
||
std::string name = entry->d_name;
|
||
if (name.size() > 4 && name.substr(name.size() - 4) == ".jpg") {
|
||
photos.push_back(name);
|
||
}
|
||
}
|
||
closedir(dir);
|
||
}
|
||
#endif
|
||
|
||
std::sort(photos.begin(), photos.end());
|
||
|
||
for (size_t i = 0; i < photos.size(); ++i) {
|
||
if (i > 0) json << ",";
|
||
std::string id = photos[i].substr(0, photos[i].size() - 4);
|
||
json << "{\"id\":\"" << id << "\",\"filename\":\"" << photos[i] << "\"}";
|
||
}
|
||
|
||
json << "]}";
|
||
return json.str();
|
||
}
|
||
|
||
// 保存人脸照片
|
||
bool saveFacePhoto(const std::string& face_id, const std::string& photo_data) {
|
||
_mkdir(FACES_DIR.c_str());
|
||
std::string filepath = FACES_DIR + "/" + face_id + ".jpg";
|
||
std::ofstream file(filepath, std::ios::binary);
|
||
if (!file.is_open()) {
|
||
std::cerr << "[FACE_PHOTO] Failed to create: " << filepath << std::endl;
|
||
return false;
|
||
}
|
||
file.write(photo_data.c_str(), photo_data.size());
|
||
file.close();
|
||
std::cout << "[FACE_PHOTO] Saved: " << filepath << " (" << photo_data.size() << " bytes)" << std::endl;
|
||
return true;
|
||
}
|
||
|
||
// 读取人脸照片
|
||
std::string readFacePhoto(const std::string& face_id) {
|
||
std::string filepath = FACES_DIR + "/" + face_id + ".jpg";
|
||
std::ifstream file(filepath, std::ios::binary);
|
||
if (!file.is_open()) return "";
|
||
std::string content((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
|
||
file.close();
|
||
return content;
|
||
}
|
||
|
||
// 删除人脸照片
|
||
bool deleteFacePhoto(const std::string& face_id) {
|
||
std::string filepath = FACES_DIR + "/" + face_id + ".jpg";
|
||
if (std::remove(filepath.c_str()) == 0) {
|
||
std::cout << "[FACE_PHOTO] Deleted: " << filepath << std::endl;
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
// 从人脸ID映射中删除指定ID
|
||
bool removeFaceIdFromMapping(const std::string& face_id) {
|
||
std::ifstream inFile(FACE_ID_MAPPING_FILE);
|
||
if (!inFile.is_open()) return false;
|
||
|
||
std::stringstream buffer;
|
||
buffer << inFile.rdbuf();
|
||
inFile.close();
|
||
std::string content = buffer.str();
|
||
|
||
// 简单的JSON处理：移除 "face_id":"xxx" 条目
|
||
std::string search_pattern1 = "\"" + face_id + "\":\"";
|
||
size_t pos = content.find(search_pattern1);
|
||
if (pos != std::string::npos) {
|
||
// 找到值的结束位置
|
||
size_t value_start = pos + search_pattern1.length();
|
||
size_t value_end = content.find("\"", value_start);
|
||
if (value_end != std::string::npos) {
|
||
// 检查是否需要删除前面的逗号
|
||
size_t delete_start = pos;
|
||
size_t delete_end = value_end + 1;
|
||
|
||
// 检查后面是否有逗号
|
||
if (delete_end < content.length() && content[delete_end] == ',') {
|
||
delete_end++;
|
||
} else if (delete_start > 0 && content[delete_start - 1] == ',') {
|
||
delete_start--;
|
||
}
|
||
|
||
content = content.substr(0, delete_start) + content.substr(delete_end);
|
||
|
||
// 保存修改后的内容
|
||
std::ofstream outFile(FACE_ID_MAPPING_FILE);
|
||
if (outFile.is_open()) {
|
||
outFile << content;
|
||
outFile.close();
|
||
std::cout << "[FACE_MAPPING] Removed face_id: " << face_id << std::endl;
|
||
return true;
|
||
}
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
// 删除指定学生ID的所有考勤记录
|
||
int deleteRecordsByStudentId(const std::string& student_id) {
|
||
std::ifstream inFile(DB_FILE);
|
||
if (!inFile.is_open()) return 0;
|
||
|
||
std::vector<std::string> lines;
|
||
std::string line;
|
||
|
||
// 读取表头
|
||
std::getline(inFile, line);
|
||
lines.push_back(line);
|
||
|
||
int deleted_count = 0;
|
||
while (std::getline(inFile, line)) {
|
||
if (line.empty()) continue;
|
||
|
||
// 解析CSV找到student_id字段
|
||
std::istringstream ss(line);
|
||
std::string timestamp, record_student_id;
|
||
std::getline(ss, timestamp, ',');
|
||
std::getline(ss, record_student_id, ',');
|
||
|
||
if (record_student_id == student_id) {
|
||
deleted_count++;
|
||
std::cout << "[DELETE] 删除考勤记录: " << line << std::endl;
|
||
continue;
|
||
}
|
||
|
||
lines.push_back(line);
|
||
}
|
||
inFile.close();
|
||
|
||
if (deleted_count == 0) return 0;
|
||
|
||
std::ofstream outFile(DB_FILE);
|
||
if (!outFile.is_open()) return 0;
|
||
|
||
for (const auto& l : lines) {
|
||
outFile << l << "\n";
|
||
}
|
||
outFile.close();
|
||
|
||
return deleted_count;
|
||
}
|
||
|
||
// 获取所有学生ID（从考勤记录提取，包括没有照片的）
|
||
std::string getAllStudentIds() {
|
||
std::set<std::string> student_ids;
|
||
|
||
// 从考勤记录中提取所有学生ID
|
||
std::ifstream db(DB_FILE);
|
||
if (db.is_open()) {
|
||
std::string line;
|
||
std::getline(db, line); // 跳过表头
|
||
|
||
while (std::getline(db, line)) {
|
||
if (line.empty()) continue;
|
||
|
||
std::istringstream ss(line);
|
||
std::string timestamp, student_id;
|
||
std::getline(ss, timestamp, ',');
|
||
std::getline(ss, student_id, ',');
|
||
|
||
if (!student_id.empty()) {
|
||
student_ids.insert(student_id);
|
||
}
|
||
}
|
||
db.close();
|
||
}
|
||
|
||
// 构建JSON响应
|
||
std::ostringstream json;
|
||
json << "{\"student_ids\":[";
|
||
|
||
bool first = true;
|
||
for (const auto& id : student_ids) {
|
||
if (!first) json << ",";
|
||
json << "\"" << id << "\"";
|
||
first = false;
|
||
}
|
||
|
||
json << "]}";
|
||
return json.str();
|
||
}
|
||
|
||
// 添加人脸ID到待删除列表
|
||
bool addToPendingDelete(const std::string& face_id) {
|
||
std::set<std::string> pending_ids;
|
||
|
||
// 读取现有列表
|
||
std::ifstream inFile(PENDING_DELETE_FILE);
|
||
if (inFile.is_open()) {
|
||
std::stringstream buffer;
|
||
buffer << inFile.rdbuf();
|
||
inFile.close();
|
||
std::string content = buffer.str();
|
||
|
||
// 简单解析JSON数组
|
||
size_t start = content.find('[');
|
||
size_t end = content.rfind(']');
|
||
if (start != std::string::npos && end != std::string::npos) {
|
||
std::string arr = content.substr(start + 1, end - start - 1);
|
||
std::istringstream ss(arr);
|
||
std::string token;
|
||
while (std::getline(ss, token, ',')) {
|
||
token.erase(std::remove(token.begin(), token.end(), '"'), token.end());
|
||
token.erase(std::remove(token.begin(), token.end(), ' '), token.end());
|
||
if (!token.empty()) {
|
||
pending_ids.insert(token);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// 添加新ID
|
||
pending_ids.insert(face_id);
|
||
|
||
// 写回文件
|
||
std::ofstream outFile(PENDING_DELETE_FILE);
|
||
if (!outFile.is_open()) return false;
|
||
|
||
outFile << "{\"pending_delete\":[";
|
||
bool first = true;
|
||
for (const auto& id : pending_ids) {
|
||
if (!first) outFile << ",";
|
||
outFile << "\"" << id << "\"";
|
||
first = false;
|
||
}
|
||
outFile << "]}";
|
||
outFile.close();
|
||
|
||
std::cout << "[PENDING_DELETE] Added: " << face_id << std::endl;
|
||
return true;
|
||
}
|
||
|
||
// 获取待删除列表
|
||
std::string getPendingDeleteList() {
|
||
std::ifstream file(PENDING_DELETE_FILE);
|
||
if (!file.is_open()) {
|
||
return "{\"pending_delete\":[]}";
|
||
}
|
||
std::stringstream buffer;
|
||
buffer << file.rdbuf();
|
||
file.close();
|
||
std::string content = buffer.str();
|
||
return content.empty() ? "{\"pending_delete\":[]}" : content;
|
||
}
|
||
|
||
// 从待删除列表中移除指定ID（K210确认删除后调用）
|
||
bool removeFromPendingDelete(const std::string& face_id) {
|
||
std::set<std::string> pending_ids;
|
||
|
||
// 读取现有列表
|
||
std::ifstream inFile(PENDING_DELETE_FILE);
|
||
if (inFile.is_open()) {
|
||
std::stringstream buffer;
|
||
buffer << inFile.rdbuf();
|
||
inFile.close();
|
||
std::string content = buffer.str();
|
||
|
||
size_t start = content.find('[');
|
||
size_t end = content.rfind(']');
|
||
if (start != std::string::npos && end != std::string::npos) {
|
||
std::string arr = content.substr(start + 1, end - start - 1);
|
||
std::istringstream ss(arr);
|
||
std::string token;
|
||
while (std::getline(ss, token, ',')) {
|
||
token.erase(std::remove(token.begin(), token.end(), '"'), token.end());
|
||
token.erase(std::remove(token.begin(), token.end(), ' '), token.end());
|
||
if (!token.empty() && token != face_id) {
|
||
pending_ids.insert(token);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// 写回文件
|
||
std::ofstream outFile(PENDING_DELETE_FILE);
|
||
if (!outFile.is_open()) return false;
|
||
|
||
outFile << "{\"pending_delete\":[";
|
||
bool first = true;
|
||
for (const auto& id : pending_ids) {
|
||
if (!first) outFile << ",";
|
||
outFile << "\"" << id << "\"";
|
||
first = false;
|
||
}
|
||
outFile << "]}";
|
||
outFile.close();
|
||
|
||
std::cout << "[PENDING_DELETE] Removed: " << face_id << std::endl;
|
||
return true;
|
||
}
|
||
|
||
// ============= K210同步请求管理 =============
|
||
// 设置同步请求标志（QT端调用）
|
||
bool setSyncRequest(bool sync) {
|
||
std::ofstream file(SYNC_REQUEST_FILE);
|
||
if (!file.is_open()) return false;
|
||
file << "{\"sync\":" << (sync ? "true" : "false") << "}";
|
||
file.close();
|
||
std::cout << "[SYNC] Sync request set to: " << (sync ? "true" : "false") << std::endl;
|
||
return true;
|
||
}
|
||
|
||
// 获取同步请求状态（K210轮询调用）
|
||
std::string getSyncRequest() {
|
||
std::ifstream file(SYNC_REQUEST_FILE);
|
||
if (!file.is_open()) {
|
||
return "{\"sync\":false}";
|
||
}
|
||
std::stringstream buffer;
|
||
buffer << file.rdbuf();
|
||
file.close();
|
||
std::string content = buffer.str();
|
||
return content.empty() ? "{\"sync\":false}" : content;
|
||
}
|
||
|
||
// 清除同步请求标志（K210确认后调用）
|
||
bool clearSyncRequest() {
|
||
return setSyncRequest(false);
|
||
}
|
||
|
||
// 根据K210的face_id查询真实学号
|
||
std::string getMappedStudentId(const std::string& face_id) {
|
||
std::cout << "[MAPPING] Looking up face_id: " << face_id << std::endl;
|
||
|
||
std::ifstream file(FACE_ID_MAPPING_FILE);
|
||
if (!file.is_open()) {
|
||
std::cout << "[MAPPING] File not found: " << FACE_ID_MAPPING_FILE << ", using original ID" << std::endl;
|
||
return face_id; // 没有映射文件，返回原ID
|
||
}
|
||
|
||
std::stringstream buffer;
|
||
buffer << file.rdbuf();
|
||
file.close();
|
||
std::string content = buffer.str();
|
||
|
||
std::cout << "[MAPPING] File content: " << content << std::endl;
|
||
|
||
// 简单解析JSON查找 "face_id":"student_id"
|
||
// 格式: {"mappings":{"1":"20210001","2":"20210002"}}
|
||
std::string search_key = "\"" + face_id + "\":\"";
|
||
size_t pos = content.find(search_key);
|
||
if (pos != std::string::npos) {
|
||
size_t start = pos + search_key.length();
|
||
size_t end = content.find("\"", start);
|
||
if (end != std::string::npos) {
|
||
std::string mapped_id = content.substr(start, end - start);
|
||
if (!mapped_id.empty()) {
|
||
std::cout << "[MAPPING] ✓ Face ID " << face_id << " -> Student ID " << mapped_id << std::endl;
|
||
return mapped_id;
|
||
}
|
||
}
|
||
}
|
||
|
||
std::cout << "[MAPPING] No mapping found for face_id: " << face_id << std::endl;
|
||
return face_id; // 没找到映射，返回原ID
|
||
}
|
||
|
||
// ============= HTTP请求处理 =============
|
||
void handleHttpRequest(SOCKET client_socket) {
|
||
char buffer[BUFFER_SIZE] = {0};
|
||
int bytes = recv(client_socket, buffer, BUFFER_SIZE - 1, 0);
|
||
|
||
if (bytes <= 0) {
|
||
closesocket(client_socket);
|
||
return;
|
||
}
|
||
|
||
std::string request(buffer, bytes);
|
||
std::istringstream stream(request);
|
||
std::string method, path, version;
|
||
stream >> method >> path >> version;
|
||
|
||
std::cout << "[HTTP] " << method << " " << path << std::endl;
|
||
|
||
std::string response_body;
|
||
std::string content_type = "application/json";
|
||
int status_code = 200;
|
||
std::string status_text = "OK";
|
||
|
||
std::string endpoint = path;
|
||
std::string query;
|
||
size_t q_pos = path.find('?');
|
||
if (q_pos != std::string::npos) {
|
||
endpoint = path.substr(0, q_pos);
|
||
query = path.substr(q_pos + 1);
|
||
}
|
||
|
||
// 提取请求体
|
||
std::string request_body;
|
||
if (method == "POST") {
|
||
size_t content_length = 0;
|
||
size_t cl_pos = request.find("Content-Length:");
|
||
if (cl_pos != std::string::npos) {
|
||
size_t cl_end = request.find("\r\n", cl_pos);
|
||
std::string cl_str = request.substr(cl_pos + 15, cl_end - cl_pos - 15);
|
||
cl_str.erase(0, cl_str.find_first_not_of(" \t"));
|
||
content_length = std::stoi(cl_str);
|
||
}
|
||
|
||
size_t header_end = request.find("\r\n\r\n");
|
||
if (header_end != std::string::npos) {
|
||
size_t body_start = header_end + 4;
|
||
size_t current_body_size = request.size() - body_start;
|
||
|
||
if (current_body_size >= content_length) {
|
||
request_body = request.substr(body_start, content_length);
|
||
} else {
|
||
request_body = request.substr(body_start);
|
||
size_t remaining = content_length - current_body_size;
|
||
|
||
while (remaining > 0 && remaining < BUFFER_SIZE * 10) {
|
||
char extra_buffer[BUFFER_SIZE] = {0};
|
||
int extra_bytes = recv(client_socket, extra_buffer,
|
||
std::min(remaining, (size_t)BUFFER_SIZE - 1), 0);
|
||
if (extra_bytes <= 0) break;
|
||
|
||
request_body.append(extra_buffer, extra_bytes);
|
||
remaining -= extra_bytes;
|
||
}
|
||
}
|
||
}
|
||
|
||
std::cout << "[HTTP] POST body size: " << request_body.size()
|
||
<< " bytes (expected: " << content_length << ")" << std::endl;
|
||
}
|
||
|
||
// ============= 路由处理 =============
|
||
|
||
// 新增：处理加密签到数据
|
||
if (method == "POST" && endpoint == "/api/checkin") {
|
||
std::cout << "[CHECKIN] Processing encrypted checkin data..." << std::endl;
|
||
|
||
// 检查是否是加密数据
|
||
if (request.find("X-Encrypted: AES128-CBC") != std::string::npos) {
|
||
std::cout << "[CHECKIN] Encrypted data detected" << std::endl;
|
||
|
||
// 解密数据
|
||
std::string decrypted_json = decryptJSON(request_body);
|
||
|
||
if (decrypted_json.empty()) {
|
||
response_body = "{\"success\":false,\"message\":\"解密失败\"}";
|
||
status_code = 400;
|
||
status_text = "Bad Request";
|
||
} else {
|
||
// 解析JSON
|
||
auto json_data = parseJSON(decrypted_json);
|
||
|
||
if (json_data.find("student_id") != json_data.end()) {
|
||
// 构建考勤记录
|
||
std::string timestamp = getCurrentTimestamp();
|
||
std::string student_id = json_data["student_id"]; // K210已发送真实学号
|
||
std::string name = json_data["name"];
|
||
std::string confidence = json_data["confidence"];
|
||
std::string status = json_data["status"];
|
||
std::string class_id = json_data.count("class_id") ? json_data["class_id"] : "0";
|
||
|
||
std::cout << "[CHECKIN] Student ID: " << student_id << std::endl;
|
||
|
||
// 保存到CSV（包含班级编号）
|
||
std::ofstream db(DB_FILE, std::ios::app);
|
||
if (db.is_open()) {
|
||
db << timestamp << ","
|
||
<< student_id << ","
|
||
<< name << ","
|
||
<< confidence << ","
|
||
<< status << ","
|
||
<< class_id << "\n";
|
||
db.close();
|
||
|
||
response_body = "{\"success\":true,\"message\":\"签到成功\",\"timestamp\":\""
|
||
+ timestamp + "\"}";
|
||
std::cout << "[CHECKIN] ✓ " << name << " (ID:" << student_id << ", Class:" << class_id << ")" << std::endl;
|
||
} else {
|
||
response_body = "{\"success\":false,\"message\":\"数据库写入失败\"}";
|
||
status_code = 500;
|
||
status_text = "Internal Server Error";
|
||
}
|
||
} else {
|
||
response_body = "{\"success\":false,\"message\":\"缺少必要字段\"}";
|
||
status_code = 400;
|
||
status_text = "Bad Request";
|
||
}
|
||
}
|
||
} else {
|
||
response_body = "{\"success\":false,\"message\":\"未加密数据\"}";
|
||
status_code = 400;
|
||
status_text = "Bad Request";
|
||
}
|
||
}
|
||
// API端点：返回加密数据
|
||
else if (method == "GET" && endpoint == "/api/records") {
|
||
auto params = parseQueryParams(query);
|
||
int limit = params.count("limit") ? std::stoi(params["limit"]) : 100;
|
||
int offset = params.count("offset") ? std::stoi(params["offset"]) : 0;
|
||
|
||
std::string json_data = readDatabase(limit, offset);
|
||
|
||
// 🔒 强制加密所有响应（不再是可选）
|
||
response_body = encryptJSON(json_data);
|
||
if (response_body.empty()) {
|
||
response_body = "{\\\"error\\\":\\\"Encryption failed\\\"}";
|
||
status_code = 500;
|
||
status_text = "Internal Server Error";
|
||
}
|
||
|
||
} else if (method == "GET" && endpoint == "/api/statistics") {
|
||
std::string json_data = getStatistics();
|
||
|
||
// 🔒 强制加密所有响应
|
||
response_body = encryptJSON(json_data);
|
||
if (response_body.empty()) {
|
||
response_body = "{\\\"error\\\":\\\"Encryption failed\\\"}";
|
||
status_code = 500;
|
||
status_text = "Internal Server Error";
|
||
}
|
||
|
||
} else if (method == "POST" && endpoint == "/api/clear") {
|
||
if (clearDatabase()) {
|
||
response_body = "{\"success\":true,\"message\":\"Database cleared\"}";
|
||
} else {
|
||
response_body = "{\"success\":false,\"message\":\"Failed to clear database\"}";
|
||
status_code = 500;
|
||
status_text = "Internal Server Error";
|
||
}
|
||
|
||
} else if (method == "DELETE" && endpoint == "/api/record") {
|
||
auto params = parseQueryParams(query);
|
||
if (params.count("timestamp") && params.count("student_id")) {
|
||
std::string timestamp = params["timestamp"];
|
||
std::string student_id = params["student_id"];
|
||
|
||
if (deleteRecord(timestamp, student_id)) {
|
||
response_body = "{\"success\":true,\"message\":\"Record deleted\"}";
|
||
} else {
|
||
response_body = "{\"success\":false,\"message\":\"Record not found\"}";
|
||
status_code = 404;
|
||
status_text = "Not Found";
|
||
}
|
||
} else {
|
||
response_body = "{\"success\":false,\"message\":\"Missing parameters\"}";
|
||
status_code = 400;
|
||
status_text = "Bad Request";
|
||
}
|
||
|
||
} else if (method == "GET" && endpoint == "/api/health") {
|
||
response_body = "{\"status\":\"healthy\",\"time\":\"" + getCurrentTimestamp() + "\"}";
|
||
|
||
} else if (method == "GET" && endpoint == "/api/time") {
|
||
// 返回服务器当前Unix时间戳（UTC秒）和可读时间
|
||
std::ostringstream json;
|
||
json << "{"
|
||
<< "\"epoch\":" << static_cast<long long>(time(0)) << ","
|
||
<< "\"server_time\":\"" << getCurrentTimestamp() << "\""
|
||
<< "}";
|
||
response_body = json.str();
|
||
|
||
} else if (method == "POST" && endpoint == "/api/timeslots") {
|
||
// 上传时间段配置: POST /api/timeslots
|
||
std::cout << "[TIMESLOTS] Received upload request, data size: " << request_body.size() << " bytes" << std::endl;
|
||
|
||
if (saveTimeSlots(request_body)) {
|
||
response_body = "{\"success\":true,\"message\":\"时间段配置已更新\"}";
|
||
std::cout << "[TIMESLOTS] ✓ Configuration uploaded successfully" << std::endl;
|
||
} else {
|
||
response_body = "{\"success\":false,\"message\":\"保存时间段配置失败\"}";
|
||
status_code = 500;
|
||
status_text = "Internal Server Error";
|
||
}
|
||
|
||
} else if (method == "GET" && endpoint == "/api/timeslots") {
|
||
// 获取时间段配置: GET /api/timeslots
|
||
std::cout << "[TIMESLOTS] Reading configuration" << std::endl;
|
||
response_body = readTimeSlots();
|
||
|
||
} else if (method == "GET" && endpoint == "/api/check_duplicate") {
|
||
// 检查重复签到: GET /api/check_duplicate?student_id=xxx&slot_start=08:00&slot_end=09:30
|
||
auto params = parseQueryParams(query);
|
||
if (params.count("student_id") && params.count("slot_start") && params.count("slot_end")) {
|
||
response_body = checkDuplicate(params["student_id"], params["slot_start"], params["slot_end"]);
|
||
std::cout << "[CHECK] student_id=" << params["student_id"]
|
||
<< ", slot=" << params["slot_start"] << "-" << params["slot_end"]
|
||
<< ", result=" << response_body << std::endl;
|
||
} else {
|
||
response_body = "{\"error\":\"Missing parameters: student_id, slot_start, slot_end\"}";
|
||
status_code = 400;
|
||
status_text = "Bad Request";
|
||
}
|
||
|
||
} else if (method == "GET" && endpoint == "/api/today_records") {
|
||
// 获取今日已签到记录（供STM32开机下载）
|
||
// GET /api/today_records?slot_start=08:00&slot_end=09:30
|
||
auto params = parseQueryParams(query);
|
||
std::string slot_start = params.count("slot_start") ? params["slot_start"] : "00:00";
|
||
std::string slot_end = params.count("slot_end") ? params["slot_end"] : "23:59";
|
||
|
||
std::ifstream db(DB_FILE);
|
||
std::string todayDate = getCurrentTimestamp().substr(0, 10);
|
||
|
||
// 解析时段
|
||
int start_hour = 0, start_minute = 0, end_hour = 23, end_minute = 59;
|
||
if (slot_start.length() >= 5) {
|
||
start_hour = std::stoi(slot_start.substr(0, 2));
|
||
start_minute = std::stoi(slot_start.substr(3, 2));
|
||
}
|
||
if (slot_end.length() >= 5) {
|
||
end_hour = std::stoi(slot_end.substr(0, 2));
|
||
end_minute = std::stoi(slot_end.substr(3, 2));
|
||
}
|
||
|
||
std::ostringstream json;
|
||
json << "{\"date\":\"" << todayDate << "\",\"records\":[";
|
||
|
||
if (db.is_open()) {
|
||
std::string line;
|
||
std::getline(db, line); // 跳过表头
|
||
bool first = true;
|
||
|
||
while (std::getline(db, line)) {
|
||
if (line.empty()) continue;
|
||
|
||
// 检查是否是今天的记录
|
||
if (line.substr(0, 10) != todayDate) continue;
|
||
|
||
// 解析时间
|
||
if (line.length() >= 16) {
|
||
int record_hour = std::stoi(line.substr(11, 2));
|
||
int record_minute = std::stoi(line.substr(14, 2));
|
||
int record_total = record_hour * 60 + record_minute;
|
||
int start_total = start_hour * 60 + start_minute;
|
||
int end_total = end_hour * 60 + end_minute;
|
||
|
||
if (record_total >= start_total && record_total <= end_total) {
|
||
// 提取学号
|
||
std::istringstream ss(line);
|
||
std::string timestamp, student_id;
|
||
std::getline(ss, timestamp, ',');
|
||
std::getline(ss, student_id, ',');
|
||
|
||
if (!first) json << ",";
|
||
json << "\"" << student_id << "\"";
|
||
first = false;
|
||
}
|
||
}
|
||
}
|
||
db.close();
|
||
}
|
||
|
||
json << "]}";
|
||
response_body = json.str();
|
||
std::cout << "[TODAY] Returning today's records: " << response_body << std::endl;
|
||
|
||
} else if (method == "POST" && endpoint == "/api/mapping_config") {
|
||
// 上传映射配置: POST /api/mapping_config
|
||
std::cout << "[MAPPING] Received upload request, data size: " << request_body.size() << " bytes" << std::endl;
|
||
|
||
std::ofstream file(MAPPING_CONFIG_FILE);
|
||
if (file.is_open()) {
|
||
file << request_body;
|
||
file.flush();
|
||
file.close();
|
||
response_body = "{\"success\":true,\"message\":\"映射配置已保存\"}";
|
||
std::cout << "[MAPPING] ✓ Configuration saved successfully" << std::endl;
|
||
} else {
|
||
response_body = "{\"success\":false,\"message\":\"保存映射配置失败\"}";
|
||
status_code = 500;
|
||
status_text = "Internal Server Error";
|
||
}
|
||
|
||
} else if (method == "GET" && endpoint == "/api/mapping_config") {
|
||
// 获取映射配置: GET /api/mapping_config
|
||
std::cout << "[MAPPING] Reading configuration" << std::endl;
|
||
|
||
std::ifstream file(MAPPING_CONFIG_FILE);
|
||
if (file.is_open()) {
|
||
std::stringstream buffer;
|
||
buffer << file.rdbuf();
|
||
file.close();
|
||
response_body = buffer.str();
|
||
std::cout << "[MAPPING] Returning config: " << response_body.size() << " bytes" << std::endl;
|
||
} else {
|
||
// 返回空配置
|
||
response_body = "{\"student_name_map\":{},\"class_name_map\":{}}";
|
||
std::cout << "[MAPPING] Config file not found, returning empty config" << std::endl;
|
||
}
|
||
|
||
// ============= 人脸照片管理 API =============
|
||
} else if (method == "GET" && endpoint == "/api/face_photos") {
|
||
// 获取人脸照片列表
|
||
_mkdir(FACES_DIR.c_str());
|
||
response_body = getFacePhotosList();
|
||
std::cout << "[FACE_PHOTO] Photos list fetched" << std::endl;
|
||
|
||
} else if (method == "GET" && endpoint.find("/api/face_photo/") == 0) {
|
||
// 获取指定人脸照片: GET /api/face_photo/<id>
|
||
std::string face_id = endpoint.substr(16);
|
||
std::string photo_data = readFacePhoto(face_id);
|
||
|
||
if (!photo_data.empty()) {
|
||
response_body = photo_data;
|
||
content_type = "image/jpeg";
|
||
std::cout << "[FACE_PHOTO] Photo fetched for id: " << face_id << std::endl;
|
||
} else {
|
||
response_body = "{\"error\":\"Photo not found\"}";
|
||
status_code = 404;
|
||
status_text = "Not Found";
|
||
}
|
||
|
||
} else if (method == "POST" && endpoint.find("/api/face_photo_simple/") == 0) {
|
||
// 简化版人脸照片上传: POST /api/face_photo_simple/<face_id>
|
||
std::string face_id = endpoint.substr(23);
|
||
std::cout << "[FACE_PHOTO] Simple upload for face_id: " << face_id << ", size: " << request_body.size() << " bytes" << std::endl;
|
||
|
||
if (!face_id.empty() && !request_body.empty()) {
|
||
if (saveFacePhoto(face_id, request_body)) {
|
||
response_body = "{\"success\":true,\"message\":\"Photo saved\",\"face_id\":\"" + face_id + "\"}";
|
||
} else {
|
||
response_body = "{\"success\":false,\"message\":\"Failed to save photo\"}";
|
||
status_code = 500;
|
||
status_text = "Internal Server Error";
|
||
}
|
||
} else {
|
||
response_body = "{\"success\":false,\"message\":\"Invalid face_id or empty data\"}";
|
||
status_code = 400;
|
||
status_text = "Bad Request";
|
||
}
|
||
|
||
} else if (method == "POST" && endpoint == "/api/face_id_mapping") {
|
||
// 保存人脸ID映射
|
||
std::cout << "[FACE_MAPPING] Saving mapping, size: " << request_body.size() << " bytes" << std::endl;
|
||
if (saveFaceIdMapping(request_body)) {
|
||
// 根据新映射重命名照片文件
|
||
renameFacePhotos(request_body);
|
||
// 自动触发K210同步
|
||
setSyncRequest(true);
|
||
std::cout << "[FACE_MAPPING] Auto-triggered K210 sync" << std::endl;
|
||
response_body = "{\"success\":true,\"message\":\"Face ID mapping saved, K210 sync triggered\"}";
|
||
} else {
|
||
response_body = "{\"success\":false,\"message\":\"Failed to save mapping\"}";
|
||
status_code = 500;
|
||
status_text = "Internal Server Error";
|
||
}
|
||
|
||
} else if (method == "GET" && endpoint == "/api/face_id_mapping") {
|
||
// 获取人脸ID映射
|
||
response_body = readFaceIdMapping();
|
||
std::cout << "[FACE_MAPPING] Mapping fetched" << std::endl;
|
||
|
||
} else if (method == "GET" && endpoint == "/api/all_student_ids") {
|
||
// 获取所有学生ID（从考勤记录提取）
|
||
response_body = getAllStudentIds();
|
||
std::cout << "[STUDENT_IDS] All student IDs fetched" << std::endl;
|
||
|
||
} else if (method == "DELETE" && endpoint.find("/api/face/") == 0) {
|
||
// 删除人脸信息: DELETE /api/face/<student_id>?delete_records=true
|
||
std::string student_id = endpoint.substr(10); // 去掉 "/api/face/"
|
||
auto params = parseQueryParams(query);
|
||
bool delete_records = (params.count("delete_records") && params["delete_records"] == "true");
|
||
|
||
std::cout << "[DELETE_FACE] Deleting face for student_id: " << student_id
|
||
<< ", delete_records: " << (delete_records ? "yes" : "no") << std::endl;
|
||
|
||
bool photo_deleted = deleteFacePhoto(student_id);
|
||
bool mapping_deleted = removeFaceIdFromMapping(student_id);
|
||
int records_deleted = 0;
|
||
|
||
if (delete_records) {
|
||
records_deleted = deleteRecordsByStudentId(student_id);
|
||
}
|
||
|
||
// 添加到待删除列表，等待K210同步删除
|
||
addToPendingDelete(student_id);
|
||
|
||
std::ostringstream result;
|
||
result << "{\"success\":true,"
|
||
<< "\"photo_deleted\":" << (photo_deleted ? "true" : "false") << ","
|
||
<< "\"mapping_deleted\":" << (mapping_deleted ? "true" : "false") << ","
|
||
<< "\"records_deleted\":" << records_deleted << ","
|
||
<< "\"k210_pending\":true}";
|
||
response_body = result.str();
|
||
|
||
std::cout << "[DELETE_FACE] Result: " << response_body << std::endl;
|
||
|
||
} else if (method == "GET" && endpoint == "/api/pending_delete") {
|
||
// K210查询待删除列表
|
||
response_body = getPendingDeleteList();
|
||
std::cout << "[PENDING_DELETE] List fetched" << std::endl;
|
||
|
||
} else if (method == "POST" && endpoint == "/api/confirm_delete") {
|
||
// K210确认删除完成，从待删除列表移除
|
||
// 请求体格式: {"face_id":"xxx"}
|
||
std::string face_id;
|
||
size_t pos = request_body.find("\"face_id\":\"");
|
||
if (pos != std::string::npos) {
|
||
size_t start = pos + 11;
|
||
size_t end = request_body.find("\"", start);
|
||
if (end != std::string::npos) {
|
||
face_id = request_body.substr(start, end - start);
|
||
}
|
||
}
|
||
|
||
if (!face_id.empty() && removeFromPendingDelete(face_id)) {
|
||
response_body = "{\"success\":true,\"message\":\"Confirmed delete: " + face_id + "\"}";
|
||
std::cout << "[PENDING_DELETE] K210 confirmed delete: " << face_id << std::endl;
|
||
} else {
|
||
response_body = "{\"success\":false,\"message\":\"Invalid face_id or not in pending list\"}";
|
||
status_code = 400;
|
||
status_text = "Bad Request";
|
||
}
|
||
|
||
// ============= K210同步请求 API =============
|
||
} else if (method == "GET" && endpoint == "/api/sync_request") {
|
||
// K210查询是否需要同步
|
||
response_body = getSyncRequest();
|
||
std::cout << "[SYNC] K210 checking sync request: " << response_body << std::endl;
|
||
|
||
} else if (method == "POST" && endpoint == "/api/sync_ack") {
|
||
// K210确认收到同步请求，清除标志
|
||
if (clearSyncRequest()) {
|
||
response_body = "{\"success\":true,\"message\":\"Sync acknowledged\"}";
|
||
std::cout << "[SYNC] K210 acknowledged sync request" << std::endl;
|
||
} else {
|
||
response_body = "{\"success\":false,\"message\":\"Failed to clear sync request\"}";
|
||
status_code = 500;
|
||
status_text = "Internal Server Error";
|
||
}
|
||
|
||
} else if (method == "POST" && endpoint == "/api/trigger_sync") {
|
||
// QT端触发K210同步
|
||
if (setSyncRequest(true)) {
|
||
response_body = "{\"success\":true,\"message\":\"Sync request sent to K210\"}";
|
||
std::cout << "[SYNC] QT triggered K210 sync" << std::endl;
|
||
} else {
|
||
response_body = "{\"success\":false,\"message\":\"Failed to set sync request\"}";
|
||
status_code = 500;
|
||
status_text = "Internal Server Error";
|
||
}
|
||
|
||
} else {
|
||
response_body = "{\"error\":\"Not Found\"}";
|
||
status_code = 404;
|
||
status_text = "Not Found";
|
||
}
|
||
|
||
// 构建HTTP响应
|
||
std::ostringstream response;
|
||
response << "HTTP/1.1 " << status_code << " " << status_text << "\r\n";
|
||
response << "Content-Type: " << content_type << "; charset=utf-8\r\n";
|
||
response << "Content-Length: " << response_body.length() << "\r\n";
|
||
response << "Access-Control-Allow-Origin: *\r\n";
|
||
response << "Connection: close\r\n";
|
||
response << "\r\n";
|
||
response << response_body;
|
||
|
||
std::string resp_str = response.str();
|
||
send(client_socket, resp_str.c_str(), resp_str.length(), 0);
|
||
closesocket(client_socket);
|
||
}
|
||
|
||
// ============= HTTP服务器线程 =============
|
||
void httpServerThread() {
|
||
SOCKET server_socket = socket(AF_INET, SOCK_STREAM, 0);
|
||
if (server_socket == INVALID_SOCKET) {
|
||
std::cerr << "[HTTP] Failed to create socket" << std::endl;
|
||
return;
|
||
}
|
||
|
||
int opt = 1;
|
||
setsockopt(server_socket, SOL_SOCKET, SO_REUSEADDR, (char*)&opt, sizeof(opt));
|
||
|
||
sockaddr_in server_addr;
|
||
server_addr.sin_family = AF_INET;
|
||
server_addr.sin_addr.s_addr = INADDR_ANY;
|
||
server_addr.sin_port = htons(HTTP_PORT);
|
||
|
||
if (bind(server_socket, (sockaddr*)&server_addr, sizeof(server_addr)) == SOCKET_ERROR) {
|
||
std::cerr << "[HTTP] Bind failed" << std::endl;
|
||
closesocket(server_socket);
|
||
return;
|
||
}
|
||
|
||
listen(server_socket, 10);
|
||
std::cout << "[HTTP] Server listening on port " << HTTP_PORT << std::endl;
|
||
|
||
while (true) {
|
||
sockaddr_in client_addr;
|
||
socklen_t client_len = sizeof(client_addr);
|
||
SOCKET client_socket = accept(server_socket, (sockaddr*)&client_addr, &client_len);
|
||
|
||
if (client_socket != INVALID_SOCKET) {
|
||
std::thread(handleHttpRequest, client_socket).detach();
|
||
}
|
||
}
|
||
}
|
||
|
||
int main() {
|
||
#ifdef _WIN32
|
||
WSADATA wsa;
|
||
WSAStartup(MAKEWORD(2, 2), &wsa);
|
||
#endif
|
||
|
||
std::cout << "========================================" << std::endl;
|
||
std::cout << " Face Recognition Attendance Server" << std::endl;
|
||
std::cout << " with AES-128-CBC Encryption" << std::endl;
|
||
std::cout << "========================================" << std::endl;
|
||
std::cout << "HTTP Port " << HTTP_PORT << " - Encrypted API" << std::endl;
|
||
std::cout << "Database: " << DB_FILE << std::endl;
|
||
std::cout << "----------------------------------------" << std::endl;
|
||
|
||
// 确保CSV文件存在
|
||
std::ifstream test(DB_FILE);
|
||
if (!test.good()) {
|
||
std::ofstream create(DB_FILE);
|
||
create << "Timestamp,Student_ID,Name,Confidence,Status,Class_ID\n";
|
||
create.close();
|
||
}
|
||
test.close();
|
||
|
||
// 启动HTTP服务器
|
||
std::thread http_thread(httpServerThread);
|
||
http_thread.join();
|
||
|
||
#ifdef _WIN32
|
||
WSACleanup();
|
||
#endif
|
||
|
||
return 0;
|
||
}
|