629 lines
23 KiB
C
629 lines
23 KiB
C
#include <stdio.h>
|
||
#include <stdlib.h>
|
||
#include <string.h>
|
||
#include <ctype.h>
|
||
#include <unistd.h>
|
||
#include <errno.h>
|
||
#include <stdarg.h>
|
||
#include <fcntl.h>
|
||
#include <linux/input.h>
|
||
#include <poll.h>
|
||
#include <pthread.h>
|
||
#include <time.h>
|
||
#include <sys/wait.h>
|
||
#include "hiredis.h"
|
||
|
||
// 黄灯控制相关变量
|
||
static volatile int led_running = 0;
|
||
static pthread_t led_thread;
|
||
|
||
// 黄灯控制函数声明
|
||
static void gpio_init_yellow(void);
|
||
static void* led_fast_blink_thread(void* arg);
|
||
static void start_yellow_fast_blink(void);
|
||
static void stop_yellow_blink(void);
|
||
static void set_yellow_off(void);
|
||
|
||
static void to_upper_str(char* s) {
|
||
for (; *s; ++s) *s = (char)toupper((unsigned char)*s);
|
||
}
|
||
|
||
// 提取批次号（支持 batch=XXXX / Batch:XXXX / 扫码包含"D"+14位数字）
|
||
static int extract_batch(const char* input, char* out_batch, size_t out_size) {
|
||
if (!input || !out_batch || out_size < 16) return -1;
|
||
size_t n = strlen(input);
|
||
// 主匹配：任意位置出现 'D' 或 'd' 后跟 14 位数字
|
||
for (size_t i = 0; i + 15 <= n; ++i) {
|
||
char c = input[i];
|
||
if (c == 'M' || c == 'm') {
|
||
int ok = 1;
|
||
for (int k = 1; k <= 14; ++k) {
|
||
char d = input[i + k];
|
||
if (d < '0' || d > '9') { ok = 0; break; }
|
||
}
|
||
if (ok) {
|
||
out_batch[0] = 'M';
|
||
memcpy(out_batch + 1, input + i + 1, 14);
|
||
out_batch[15] = '\0';
|
||
return 0;
|
||
}
|
||
}
|
||
}
|
||
// 回退：按键名解析（batch/Batch/BATCH/批次）
|
||
const char* keys[] = {"batch", "Batch", "BATCH", "批次"};
|
||
for (size_t i = 0; i < sizeof(keys)/sizeof(keys[0]); ++i) {
|
||
const char* p = strstr(input, keys[i]);
|
||
if (!p) continue;
|
||
// 跳过键名后的分隔符
|
||
p += strlen(keys[i]);
|
||
while (*p == ' ' || *p == '=' || *p == ':' || (unsigned char)*p == 0xEF) {
|
||
if ((unsigned char)*p == 0xEF) { p++; if ((unsigned char)*p == 0xBC) { p++; if ((unsigned char)*p == 0x9A) { p++; } } }
|
||
else { p++; }
|
||
}
|
||
// 读取字母数字序列作为批次号
|
||
size_t j = 0;
|
||
while (*p && j < out_size - 1) {
|
||
if ((*p >= '0' && *p <= '9') || (*p >= 'A' && *p <= 'Z') || (*p >= 'a' && *p <= 'z') || *p == '_' || *p == '-') {
|
||
out_batch[j++] = *p++;
|
||
} else {
|
||
break;
|
||
}
|
||
}
|
||
out_batch[j] = '\0';
|
||
if (j > 0) {
|
||
// 规范化：若形如 d+14位数字，转为大写D
|
||
if (j >= 15 && (out_batch[0] == 'm' || out_batch[0] == 'M')) {
|
||
int ok2 = 1;
|
||
for (int k = 1; k <= 14; ++k) {
|
||
char d = out_batch[k];
|
||
if (d < '0' || d > '9') { ok2 = 0; break; }
|
||
}
|
||
if (ok2) out_batch[0] = 'M';
|
||
}
|
||
return 0;
|
||
}
|
||
}
|
||
return -1;
|
||
}
|
||
|
||
// 通过redis-cli查询批次映射得到MAC和密钥
|
||
static int redis_query_device_info(const char* host_opt, const char* port_opt, const char* db_opt,
|
||
const char* pool_opt, const char* batch,
|
||
char* out_mac, size_t mac_size,
|
||
char* out_secret, size_t secret_size) {
|
||
if (!batch || !out_mac || mac_size < 18 || !out_secret || secret_size < 64) return -1;
|
||
|
||
const char* host = host_opt ? host_opt : (getenv("REDIS_HOST") ? getenv("REDIS_HOST") : "180.163.74.83");
|
||
int port = port_opt ? atoi(port_opt) : (getenv("REDIS_PORT") ? atoi(getenv("REDIS_PORT")) : 6379);
|
||
int db = db_opt ? atoi(db_opt) : (getenv("REDIS_DB") ? atoi(getenv("REDIS_DB")) : 0);
|
||
const char* pool = pool_opt ? pool_opt : (getenv("REDIS_POOL") ? getenv("REDIS_POOL") : "batch_sn_mapping_mt");
|
||
const char* auth = getenv("REDIS_AUTH");
|
||
if (!auth || !*auth) auth = "Zzh08165511";
|
||
|
||
fprintf(stderr, "[redis] connect host=%s port=%d db=%d pool=%s batch=%s\n", host, port, db, pool, batch);
|
||
|
||
struct timeval tv; tv.tv_sec = 3; tv.tv_usec = 0;
|
||
redisContext* c = redisConnectWithTimeout(host, port, tv);
|
||
if (!c || c->err) {
|
||
fprintf(stderr, "[redis] connect error: %s\n", c ? c->errstr : "unknown");
|
||
if (c) redisFree(c);
|
||
return -1;
|
||
}
|
||
|
||
if (auth && *auth) {
|
||
redisReply* ra = (redisReply*)redisCommand(c, "AUTH %s", auth);
|
||
if (!ra || (ra->type == REDIS_REPLY_ERROR)) {
|
||
fprintf(stderr, "[redis] AUTH error: %s\n", ra && ra->str ? ra->str : "no-reply");
|
||
if (ra) freeReplyObject(ra);
|
||
redisFree(c);
|
||
return -1;
|
||
}
|
||
fprintf(stderr, "[redis] AUTH ok\n");
|
||
freeReplyObject(ra);
|
||
}
|
||
|
||
if (db > 0) {
|
||
redisReply* rs = (redisReply*)redisCommand(c, "SELECT %d", db);
|
||
if (!rs || (rs->type == REDIS_REPLY_ERROR)) {
|
||
fprintf(stderr, "[redis] SELECT %d error: %s\n", db, rs && rs->str ? rs->str : "no-reply");
|
||
if (rs) freeReplyObject(rs);
|
||
redisFree(c);
|
||
return -1;
|
||
}
|
||
fprintf(stderr, "[redis] SELECT %d ok\n", db);
|
||
freeReplyObject(rs);
|
||
}
|
||
|
||
// 尝试 HGET pool batch
|
||
redisReply* r = (redisReply*)redisCommand(c, "HGET %s %s", pool, batch);
|
||
if (r) {
|
||
fprintf(stderr, "[redis] HGET %s %s -> type=%d len=%ld\n", pool, batch, r->type, (long)(r->type==REDIS_REPLY_STRING ? r->len : 0));
|
||
if (r->type == REDIS_REPLY_STRING && r->str && r->len > 0) {
|
||
fprintf(stderr, "[redis] HGET value: %.*s\n", (int)((r->len>128)?128:r->len), r->str);
|
||
|
||
// 解析格式: "90A9F73002CD:kapoePfwbQ2tFkeRpR3Nut"
|
||
char* colon = strchr(r->str, ':');
|
||
if (colon) {
|
||
// 提取MAC部分（12个字符）
|
||
size_t mac_len = colon - r->str;
|
||
if (mac_len == 12) {
|
||
// 格式化为MAC地址格式 XX:XX:XX:XX:XX:XX
|
||
snprintf(out_mac, mac_size, "%c%c:%c%c:%c%c:%c%c:%c%c:%c%c",
|
||
r->str[0], r->str[1], r->str[2], r->str[3],
|
||
r->str[4], r->str[5], r->str[6], r->str[7],
|
||
r->str[8], r->str[9], r->str[10], r->str[11]);
|
||
to_upper_str(out_mac);
|
||
|
||
// 提取密钥部分（冒号后面的内容）
|
||
strncpy(out_secret, colon + 1, secret_size - 1);
|
||
out_secret[secret_size - 1] = '\0';
|
||
|
||
fprintf(stderr, "[redis] Parsed MAC: %s, Secret: %s\n", out_mac, out_secret);
|
||
freeReplyObject(r);
|
||
redisFree(c);
|
||
return 0;
|
||
}
|
||
}
|
||
}
|
||
freeReplyObject(r);
|
||
} else {
|
||
fprintf(stderr, "[redis] HGET no-reply\n");
|
||
}
|
||
|
||
fprintf(stderr, "[redis] not found or value not parsable\n");
|
||
redisFree(c);
|
||
return -1;
|
||
}
|
||
|
||
// 审计：在Redis记录每次使用的MAC、批次与时间
|
||
static int redis_audit_log(const char* host_opt, const char* port_opt, const char* db_opt,
|
||
const char* audit_key_opt, const char* batch, const char* mac, const char* note_opt) {
|
||
if (!batch || !*batch || !mac || !*mac) return -1;
|
||
|
||
const char* host = host_opt ? host_opt : (getenv("REDIS_HOST") ? getenv("REDIS_HOST") : "180.163.74.83");
|
||
int port = port_opt ? atoi(port_opt) : (getenv("REDIS_PORT") ? atoi(getenv("REDIS_PORT")) : 6379);
|
||
int db = db_opt ? atoi(db_opt) : (getenv("REDIS_DB") ? atoi(getenv("REDIS_DB")) : 0);
|
||
const char* auth = getenv("REDIS_AUTH");
|
||
if (!auth || !*auth) auth = "Zzh08165511";
|
||
const char* audit_key = audit_key_opt ? audit_key_opt : (getenv("REDIS_AUDIT_KEY") ? getenv("REDIS_AUDIT_KEY") : "mac_batch_audit_mt");
|
||
|
||
struct timeval tv; tv.tv_sec = 3; tv.tv_usec = 0;
|
||
redisContext* c = redisConnectWithTimeout(host, port, tv);
|
||
if (!c || c->err) {
|
||
fprintf(stderr, "[redis-audit] connect error: %s\n", c ? c->errstr : "unknown");
|
||
if (c) redisFree(c);
|
||
return -1;
|
||
}
|
||
|
||
if (auth && *auth) {
|
||
redisReply* ra = (redisReply*)redisCommand(c, "AUTH %s", auth);
|
||
if (!ra || (ra->type == REDIS_REPLY_ERROR)) {
|
||
fprintf(stderr, "[redis-audit] AUTH error: %s\n", ra && ra->str ? ra->str : "no-reply");
|
||
if (ra) freeReplyObject(ra);
|
||
redisFree(c);
|
||
return -1;
|
||
}
|
||
freeReplyObject(ra);
|
||
}
|
||
|
||
if (db > 0) {
|
||
redisReply* rs = (redisReply*)redisCommand(c, "SELECT %d", db);
|
||
if (!rs || (rs->type == REDIS_REPLY_ERROR)) {
|
||
fprintf(stderr, "[redis-audit] SELECT %d error: %s\n", db, rs && rs->str ? rs->str : "no-reply");
|
||
if (rs) freeReplyObject(rs);
|
||
redisFree(c);
|
||
return -1;
|
||
}
|
||
freeReplyObject(rs);
|
||
}
|
||
|
||
// 优先使用 Redis 服务器时间，避免设备本地时间不准
|
||
long long sv_secs = -1;
|
||
{
|
||
redisReply* tr = (redisReply*)redisCommand(c, "TIME");
|
||
if (tr && tr->type == REDIS_REPLY_ARRAY && tr->elements >= 2 &&
|
||
tr->element[0] && tr->element[0]->str) {
|
||
sv_secs = atoll(tr->element[0]->str);
|
||
} else {
|
||
fprintf(stderr, "[redis-audit] TIME failed, fallback to local time\n");
|
||
}
|
||
if (tr) freeReplyObject(tr);
|
||
}
|
||
|
||
time_t base = (sv_secs > 0) ? (time_t)sv_secs : time(NULL);
|
||
// 中国时区（+08:00），不依赖设备TZ；格式为 YYYY-MM-DD HH:MM:SS
|
||
time_t base_cn = base + 8 * 3600;
|
||
struct tm tm_sv_cn; gmtime_r(&base_cn, &tm_sv_cn);
|
||
char ts_cn[24];
|
||
strftime(ts_cn, sizeof(ts_cn), "%Y-%m-%d %H:%M:%S", &tm_sv_cn);
|
||
|
||
char val[320];
|
||
snprintf(val, sizeof(val), "ts_cn=%s batch=%s mac=%s%s%s", ts_cn, batch, mac,
|
||
(note_opt && *note_opt) ? " note=" : "",
|
||
(note_opt && *note_opt) ? note_opt : "");
|
||
|
||
// 写入总审计列表
|
||
redisReply* r = (redisReply*)redisCommand(c, "LPUSH %s %s", audit_key, val);
|
||
if (!r || r->type == REDIS_REPLY_ERROR) {
|
||
fprintf(stderr, "[redis-audit] LPUSH %s failed: %s\n", audit_key, r && r->str ? r->str : "no-reply");
|
||
if (r) freeReplyObject(r);
|
||
redisFree(c);
|
||
return -1;
|
||
}
|
||
freeReplyObject(r);
|
||
|
||
// 同时按批次维度记录，key为 <audit_key>:<batch>
|
||
char batch_key[128];
|
||
snprintf(batch_key, sizeof(batch_key), "%s:%s", audit_key, batch);
|
||
r = (redisReply*)redisCommand(c, "LPUSH %s %s", batch_key, val);
|
||
if (!r || r->type == REDIS_REPLY_ERROR) {
|
||
fprintf(stderr, "[redis-audit] LPUSH %s failed: %s\n", batch_key, r && r->str ? r->str : "no-reply");
|
||
if (r) freeReplyObject(r);
|
||
redisFree(c);
|
||
return -1;
|
||
}
|
||
freeReplyObject(r);
|
||
|
||
redisFree(c);
|
||
fprintf(stderr, "[redis-audit] logged: %s | %s\n", batch, mac);
|
||
return 0;
|
||
}
|
||
|
||
// 读取interfaces文件中的MAC地址
|
||
static int get_mac_from_interfaces(const char* interfaces_path, char* out_mac, size_t out_size) {
|
||
FILE* f = fopen(interfaces_path, "r");
|
||
if (!f) return -1;
|
||
|
||
char line[256];
|
||
while (fgets(line, sizeof(line), f)) {
|
||
if (strstr(line, "hwaddress ether")) {
|
||
char* mac_start = strstr(line, "ether");
|
||
if (mac_start) {
|
||
mac_start += 6; // 跳过"ether "
|
||
char* mac_end = strchr(mac_start, '\n');
|
||
if (mac_end) {
|
||
size_t len = mac_end - mac_start;
|
||
if (len > 0 && len < out_size) {
|
||
strncpy(out_mac, mac_start, len);
|
||
out_mac[len] = '\0';
|
||
// 去除可能的空格
|
||
char* space = strchr(out_mac, ' ');
|
||
if (space) *space = '\0';
|
||
fclose(f);
|
||
return 0;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
fclose(f);
|
||
return -1;
|
||
}
|
||
|
||
static int write_file(const char* path, const char* buf, size_t len) {
|
||
FILE* f = fopen(path, "wb");
|
||
if (!f) return -1;
|
||
size_t n = fwrite(buf, 1, len, f);
|
||
// 确保数据写入到内核缓冲区
|
||
fflush(f);
|
||
int rc = 0;
|
||
// 将数据与元数据刷新到磁盘，避免重启丢失
|
||
int fd = fileno(f);
|
||
if (fd >= 0) {
|
||
if (fsync(fd) != 0) rc = -1;
|
||
}
|
||
fclose(f);
|
||
if (n != len) rc = -1;
|
||
return rc;
|
||
}
|
||
|
||
// 写入interfaces文件，使用DHCP并设置MAC
|
||
static int update_interfaces_with_mac_dhcp(const char* interfaces_path, const char* mac_colon) {
|
||
const char* tmpl =
|
||
"# interfaces(5) file used by ifup(8) and ifdown(8)\n"
|
||
"# Include files from /etc/network/interfaces.d:\n"
|
||
"source-directory /etc/network/interfaces.d\n"
|
||
"auto lo\n"
|
||
"iface lo inet loopback\n"
|
||
"auto eth0\n"
|
||
"iface eth0 inet dhcp\n"
|
||
"hwaddress ether %s\n";
|
||
|
||
char* newbuf = (char*)malloc(1024);
|
||
if (!newbuf) {
|
||
fprintf(stderr, "malloc failed\n");
|
||
return -1;
|
||
}
|
||
int n = snprintf(newbuf, 1024, tmpl, mac_colon);
|
||
if (n <= 0) {
|
||
free(newbuf);
|
||
return -1;
|
||
}
|
||
|
||
int rc = write_file(interfaces_path, newbuf, (size_t)n);
|
||
if (rc == 0) {
|
||
sync();
|
||
printf("写入interfaces文件并更新MAC: %s (DHCP)\n", mac_colon);
|
||
} else {
|
||
fprintf(stderr, "写入失败 %s\n", interfaces_path);
|
||
}
|
||
|
||
free(newbuf);
|
||
return rc;
|
||
}
|
||
|
||
static int scanner_read_event2(char* out, size_t out_size) {
|
||
const char* force_stdin = getenv("SCANNER_FORCE_STDIN");
|
||
if (force_stdin && strcmp(force_stdin, "1") == 0) return -1;
|
||
|
||
int fd = open("/dev/input/event2", O_RDONLY);
|
||
if (fd < 0) return -1;
|
||
struct input_event ev;
|
||
size_t j = 0;
|
||
int shift = 0;
|
||
while (1) {
|
||
ssize_t r = read(fd, &ev, sizeof(ev));
|
||
if (r <= 0) continue;
|
||
if (ev.type != EV_KEY) continue;
|
||
|
||
// 维护Shift状态
|
||
if (ev.code == KEY_LEFTSHIFT || ev.code == KEY_RIGHTSHIFT) {
|
||
if (ev.value == 1) shift = 1; // 按下
|
||
else if (ev.value == 0) shift = 0; // 松开
|
||
continue;
|
||
}
|
||
|
||
// 只在松开(key up)时采集字符，避免重复
|
||
if (ev.value != 0) {
|
||
if (ev.code == KEY_ENTER || ev.code == KEY_KPENTER) {
|
||
break;
|
||
}
|
||
continue;
|
||
}
|
||
|
||
char ch = 0;
|
||
switch (ev.code) {
|
||
// 数字键行
|
||
case KEY_1: ch = shift ? '!' : '1'; break;
|
||
case KEY_2: ch = shift ? '@' : '2'; break;
|
||
case KEY_3: ch = shift ? '#' : '3'; break;
|
||
case KEY_4: ch = shift ? '$' : '4'; break;
|
||
case KEY_5: ch = shift ? '%' : '5'; break;
|
||
case KEY_6: ch = shift ? '^' : '6'; break;
|
||
case KEY_7: ch = shift ? '&' : '7'; break;
|
||
case KEY_8: ch = shift ? '*' : '8'; break;
|
||
case KEY_9: ch = shift ? '(' : '9'; break;
|
||
case KEY_0: ch = shift ? ')' : '0'; break;
|
||
// 小键盘数字
|
||
case KEY_KP1: ch = '1'; break; case KEY_KP2: ch = '2'; break; case KEY_KP3: ch = '3'; break;
|
||
case KEY_KP4: ch = '4'; break; case KEY_KP5: ch = '5'; break; case KEY_KP6: ch = '6'; break;
|
||
case KEY_KP7: ch = '7'; break; case KEY_KP8: ch = '8'; break; case KEY_KP9: ch = '9'; break;
|
||
case KEY_KP0: ch = '0'; break;
|
||
|
||
// 字母（显式映射，避免假设键码连续）
|
||
case KEY_A: ch = shift ? 'A' : 'a'; break;
|
||
case KEY_B: ch = shift ? 'B' : 'b'; break;
|
||
case KEY_C: ch = shift ? 'C' : 'c'; break;
|
||
case KEY_D: ch = shift ? 'D' : 'd'; break;
|
||
case KEY_E: ch = shift ? 'E' : 'e'; break;
|
||
case KEY_F: ch = shift ? 'F' : 'f'; break;
|
||
case KEY_G: ch = shift ? 'G' : 'g'; break;
|
||
case KEY_H: ch = shift ? 'H' : 'h'; break;
|
||
case KEY_I: ch = shift ? 'I' : 'i'; break;
|
||
case KEY_J: ch = shift ? 'J' : 'j'; break;
|
||
case KEY_K: ch = shift ? 'K' : 'k'; break;
|
||
case KEY_L: ch = shift ? 'L' : 'l'; break;
|
||
case KEY_M: ch = shift ? 'M' : 'm'; break;
|
||
case KEY_N: ch = shift ? 'N' : 'n'; break;
|
||
case KEY_O: ch = shift ? 'O' : 'o'; break;
|
||
case KEY_P: ch = shift ? 'P' : 'p'; break;
|
||
case KEY_Q: ch = shift ? 'Q' : 'q'; break;
|
||
case KEY_R: ch = shift ? 'R' : 'r'; break;
|
||
case KEY_S: ch = shift ? 'S' : 's'; break;
|
||
case KEY_T: ch = shift ? 'T' : 't'; break;
|
||
case KEY_U: ch = shift ? 'U' : 'u'; break;
|
||
case KEY_V: ch = shift ? 'V' : 'v'; break;
|
||
case KEY_W: ch = shift ? 'W' : 'w'; break;
|
||
case KEY_X: ch = shift ? 'X' : 'x'; break;
|
||
case KEY_Y: ch = shift ? 'Y' : 'y'; break;
|
||
case KEY_Z: ch = shift ? 'Z' : 'z'; break;
|
||
|
||
// 其他符号
|
||
case KEY_MINUS: ch = shift ? '_' : '-'; break;
|
||
case KEY_SEMICOLON: ch = shift ? ':' : ';'; break;
|
||
case KEY_APOSTROPHE: ch = shift ? '"' : '\''; break;
|
||
case KEY_BACKSLASH: ch = shift ? '|' : '\\'; break;
|
||
case KEY_EQUAL: ch = shift ? '+' : '='; break;
|
||
default: break;
|
||
}
|
||
|
||
if (ch) {
|
||
if (j < out_size - 1) out[j++] = ch;
|
||
}
|
||
}
|
||
out[j] = '\0';
|
||
close(fd);
|
||
return strlen(out) > 0 ? 0 : -1;
|
||
}
|
||
|
||
// 黄灯控制函数实现
|
||
static void gpio_init_yellow(void) {
|
||
int fd = open("/sys/class/gpio/export", O_WRONLY);
|
||
if (fd >= 0) {
|
||
write(fd, "113", 3);
|
||
close(fd);
|
||
}
|
||
fd = open("/sys/class/gpio/gpio113/direction", O_WRONLY);
|
||
if (fd >= 0) {
|
||
write(fd, "out", 3);
|
||
close(fd);
|
||
}
|
||
}
|
||
|
||
static void* led_fast_blink_thread(void* arg) {
|
||
int fd = open("/sys/class/gpio/gpio113/value", O_WRONLY);
|
||
if (fd < 0) return NULL;
|
||
while (led_running) {
|
||
write(fd, "1", 1);
|
||
usleep(100000); // 100ms - 快速闪烁
|
||
write(fd, "0", 1);
|
||
usleep(100000); // 100ms - 快速闪烁
|
||
}
|
||
// ensure off
|
||
write(fd, "0", 1);
|
||
close(fd);
|
||
return NULL;
|
||
}
|
||
|
||
static void start_yellow_fast_blink(void) {
|
||
if (led_running) return;
|
||
gpio_init_yellow();
|
||
led_running = 1;
|
||
pthread_create(&led_thread, NULL, led_fast_blink_thread, NULL);
|
||
}
|
||
|
||
static void stop_yellow_blink(void) {
|
||
if (!led_running) return;
|
||
led_running = 0;
|
||
// 等待线程退出
|
||
pthread_join(led_thread, NULL);
|
||
}
|
||
|
||
static void set_yellow_off(void) {
|
||
// 确保不再闪烁
|
||
stop_yellow_blink();
|
||
// 初始化GPIO并置为低电平（灭灯）
|
||
gpio_init_yellow();
|
||
int fd = open("/sys/class/gpio/gpio113/value", O_WRONLY);
|
||
if (fd < 0) return;
|
||
write(fd, "0", 1);
|
||
close(fd);
|
||
}
|
||
|
||
static int read_qrcode_string(char* out, size_t out_size) {
|
||
// Try hardware scanner first
|
||
printf("尝试读取硬件扫码内容...\n");
|
||
if (scanner_read_event2(out, out_size) == 0) return 0;
|
||
// Fallback: read a line from stdin (useful for piping during tests)
|
||
fprintf(stdout, "请在终端输入扫码内容并回车...\n");
|
||
if (fgets(out, (int)out_size, stdin) == NULL) return -1;
|
||
// trim newline
|
||
size_t n = strlen(out);
|
||
if (n && out[n-1] == '\n') out[n-1] = '\0';
|
||
return strlen(out) > 0 ? 0 : -1;
|
||
}
|
||
|
||
int main(int argc, char** argv) {
|
||
const char* interfaces_path = (argc >= 2) ? argv[1] : "/etc/network/interfaces";
|
||
|
||
setvbuf(stderr, NULL, _IONBF, 0);
|
||
|
||
// 首先检查当前MAC地址
|
||
char current_mac[32] = {0};
|
||
if (get_mac_from_interfaces(interfaces_path, current_mac, sizeof(current_mac)) == 0) {
|
||
to_upper_str(current_mac);
|
||
printf("当前MAC地址: %s\n", current_mac);
|
||
|
||
// 如果MAC不是默认值，程序退出
|
||
if (strcmp(current_mac, "90:A9:F7:30:00:00") != 0) {
|
||
printf("MAC地址非默认，程序退出\n");
|
||
set_yellow_off();
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
// MAC是默认值，开始快速闪烁黄灯
|
||
printf("MAC地址为默认值，开始快速闪烁黄灯\n");
|
||
start_yellow_fast_blink();
|
||
|
||
printf("等待扫码...\n");
|
||
|
||
while (1) {
|
||
char scanbuf[512] = {0};
|
||
if (read_qrcode_string(scanbuf, sizeof(scanbuf)) != 0) {
|
||
fprintf(stderr, "读取扫码内容失败，重试...\n");
|
||
continue;
|
||
}
|
||
|
||
printf("扫码原始内容: %s\n", scanbuf);
|
||
|
||
// 提取批次号
|
||
char batch[128] = {0};
|
||
if (extract_batch(scanbuf, batch, sizeof(batch)) != 0) {
|
||
fprintf(stderr, "未识别到批次号，请重新扫码...\n");
|
||
continue;
|
||
}
|
||
|
||
printf("识别到批次号: %s\n", batch);
|
||
|
||
// 查询Redis获取设备信息
|
||
char mac[32] = {0};
|
||
char secret[128] = {0};
|
||
if (redis_query_device_info(NULL, NULL, NULL, NULL, batch, mac, sizeof(mac), secret, sizeof(secret)) != 0) {
|
||
fprintf(stderr, "Redis查询失败，请重试...\n");
|
||
continue;
|
||
}
|
||
|
||
printf("查询成功 - MAC: %s, Secret: %s\n", mac, secret);
|
||
|
||
// 写入savedDevSn文件（不带冒号）
|
||
char mac_no_colon[13] = {0}; // 12位MAC + \0
|
||
for (int i = 0, j = 0; i < strlen(mac) && j < 12; i++) {
|
||
if (mac[i] != ':') {
|
||
mac_no_colon[j++] = mac[i];
|
||
}
|
||
}
|
||
if (write_file("/root/savedDevSn", mac_no_colon, strlen(mac_no_colon)) == 0) {
|
||
printf("已写入 /root/savedDevSn: %s\n", mac_no_colon);
|
||
} else {
|
||
fprintf(stderr, "写入 /root/savedDevSn 失败\n");
|
||
continue;
|
||
}
|
||
|
||
// 写入appSecret文件
|
||
if (write_file("/root/appSecret", secret, strlen(secret)) == 0) {
|
||
printf("已写入 /root/appSecret: %s\n", secret);
|
||
} else {
|
||
fprintf(stderr, "写入 /root/appSecret 失败\n");
|
||
continue;
|
||
}
|
||
|
||
// 写入interfaces文件（DHCP + MAC）
|
||
if (update_interfaces_with_mac_dhcp(interfaces_path, mac) == 0) {
|
||
printf("已更新 %s (DHCP + MAC: %s)\n", interfaces_path, mac);
|
||
} else {
|
||
fprintf(stderr, "更新 %s 失败\n", interfaces_path);
|
||
continue;
|
||
}
|
||
|
||
// 记录审计日志
|
||
redis_audit_log(NULL, NULL, NULL, NULL, batch, mac, "success");
|
||
|
||
// 停止黄灯闪烁
|
||
stop_yellow_blink();
|
||
set_yellow_off();
|
||
|
||
printf("所有配置更新完成！\n");
|
||
|
||
// 重启mt_server服务
|
||
printf("正在重启mt_server服务...\n");
|
||
|
||
// 先重新加载systemd配置
|
||
printf("重新加载systemd配置...\n");
|
||
system("systemctl daemon-reload");
|
||
|
||
// 然后重启服务
|
||
int ret = system("systemctl restart mt_server");
|
||
if (ret == 0) {
|
||
printf("mt_server服务重启成功\n");
|
||
} else {
|
||
printf("mt_server服务重启失败，返回码: %d\n", ret);
|
||
}
|
||
|
||
break;
|
||
}
|
||
|
||
return 0;
|
||
}
|