三周目: SukiSU Ultra 是一个正经项目吗？

#define LOG_TAG "User_UID_Scanner"
#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)

typedef enum {
    LANG_EN = 0,
    LANG_ZH = 1
} language_t;

struct scanner_config {
    language_t language;
    int multi_user_scan;
    int scan_interval;
    int log_level;
    int auto_scan;
};

typedef struct {
    const char *en;
    const char *zh;
} message_t;

static struct scanner_config config = {
    .language = LANG_EN,
    .multi_user_scan = 0,
    .scan_interval = 5,
    .log_level = 1,
    .auto_scan = 0
};

// message dictionary
static const message_t messages[] = {
    {"Signal %d received", "收到信号 %d"},
    {"Reload signal", "重载信号"},
    {"User signal", "用户信号"},
    {"Log rotated", "日志轮转"},
    {"Fork failed: %s", "Fork失败: %s"},
    {"setsid failed: %s", "setsid失败: %s"},
    {"Second fork failed: %s", "第二次fork失败: %s"},
    {"chdir failed: %s", "目录切换失败: %s"},
    {"PID file create failed %s: %s", "PID文件创建失败 %s: %s"},
    {"PID file created: %d", "PID文件已创建: %d"},
    {"Daemon not running", "守护进程未运行"},
    {"Stopping daemon (PID: %d)", "停止守护进程 (PID: %d)"},
    {"Kill signal failed: %s", "终止信号失败: %s"},
    {"Daemon stopped", "守护进程已停止"},
    {"Force terminating", "强制终止中"},
    {"Daemon killed", "守护进程已杀死"},
    {"Cannot stop daemon", "无法停止守护进程"},
    {"Restarting daemon", "重启守护进程"},
    {"Cannot stop old daemon", "无法停止旧守护进程"},
    {"Starting new daemon", "启动新守护进程"},
    {"Status: Not running", "状态: 未运行"},
    {"Status: Running (PID: %d)", "状态: 运行中 (PID: %d)"},
    {"Recent logs:", "最近日志:"},
    {"Status: Stopped (stale PID)", "状态: 已停止 (陈旧PID)"},
    {"Sending reload signal (PID: %d)", "发送重载信号 (PID: %d)"},
    {"Reload signal sent", "重载信号已发送"},
    {"Reload signal failed: %s", "重载信号失败: %s"},
    {"Directory open failed %s: %s", "目录打开失败 %s: %s"},
    {"Scan started", "扫描开始"},
    {"Package name too long: %s", "包名过长: %s"},
    {"File stat failed %s: %s", "文件状态获取失败 %s: %s"},
    {"Memory allocation failed", "内存分配失败"},
    {"Scan complete, found %d packages", "扫描完成，发现 %d 个包"},
    {"Whitelist file open failed %s: %s", "白名单文件打开失败 %s: %s"},
    {"Whitelist written %d entries", "白名单写入 %d 个条目"},
    {"Kernel comm file open failed %s: %s", "内核通信文件打开失败 %s: %s"},
    {"Kernel comm write failed %s: %s", "内核通信写入失败 %s: %s"},
    {"Kernel notified", "内核已通知"},
    {"Performing scan and update", "执行扫描和更新"},
    {"Scan failed", "扫描失败"},
    {"Whitelist write failed", "白名单写入失败"},
    {"Scan completed successfully", "扫描成功完成"},
    {"Whitelist not found: %s", "白名单未找到: %s"},
    {"Current whitelist:", "当前白名单:"},
    {"One-time scan", "一次性扫描"},
    {"Invalid argument: %s", "无效参数: %s"},
    {"Daemon already running", "守护进程已运行"},
    {"Starting daemon", "启动守护进程"},
    {"Daemon startup failed", "守护进程启动失败"},
    {"Daemon started", "守护进程已启动"},
    {"Reload request received", "收到重载请求"},
    {"Kernel rescan request", "内核重扫描请求"},
    {"Daemon exiting", "守护进程退出中"},
    {"Daemon exited", "守护进程已退出"},
    {"Config loaded", "配置已加载"},
    {"Config saved", "配置已保存"},
    {"Config load failed: %s", "配置加载失败: %s"},
    {"Config save failed: %s", "配置保存失败: %s"},
    {"Language switched to English", "语言切换到英文"},
    {"Language switched to Chinese", "语言切换到中文"},
    {"Multi-user scan enabled", "多用户扫描启用"},
    {"Multi-user scan disabled", "多用户扫描禁用"},
    {"Scanning directory: %s", "扫描目录: %s"},
    {"Found %d users", "发现 %d 个用户"},
    {"Using fallback user detection", "使用备用用户检测"},
    {"Auto scan enabled", "自动扫描启用"},
    {"Auto scan disabled", "自动扫描禁用"},
    {"Auto scan disabled, daemon loaded", "自动扫描禁用，守护进程已加载"},
    {"Auto scan disabled, skipping", "自动扫描禁用，跳过"},
    {"Auto scan disabled, ignoring kernel request", "自动扫描禁用，忽略内核请求"},
    {"Retry attempt %d/%d", "重试 %d/%d"},
    {"Max retries reached, waiting %d seconds", "达到最大重试次数，等待 %d 秒"},
    {"Operation failed after retries", "重试后操作失败"},
    {"Auto scan disabled, operation not allowed", "自动扫描禁用，操作不被允许"},
    {"Manual scan requested, ignoring auto_scan setting", "手动扫描请求，忽略自动扫描设置"}
};

#define MSG_COUNT (sizeof(messages) / sizeof(messages[0]))

const char* get_message(int msg_id) {
    if (msg_id < 0 || msg_id >= (int)MSG_COUNT) {
        return "Unknown message";
    }
    return (config.language == LANG_ZH) ? messages[msg_id].zh : messages[msg_id].en;
}

void write_log(const char *level, int msg_id, ...) {
    char buffer[1024];
    char formatted_msg[1024];
    time_t now = time(NULL);
    struct tm *tm_info = localtime(&now);
    va_list args;

    va_start(args, msg_id);
    vsnprintf(formatted_msg, sizeof(formatted_msg), get_message(msg_id), args);
    va_end(args);

    strftime(buffer, 64, "[%H:%M:%S]", tm_info);
    snprintf(buffer + strlen(buffer), sizeof(buffer) - strlen(buffer), " %s: %s", level, formatted_msg);

    if (log_fd != -1) {
        dprintf(log_fd, "%s\n", buffer);
        fsync(log_fd);
    }

    if (strcmp(level, "ERROR") == 0) {
        LOGE("%s", formatted_msg);
    } else {
        LOGI("%s", formatted_msg);
    }
}

int handle_config_command(int argc, char *argv[]) {
    if (strcmp(argv[1], "--lang") == 0) {
        if (argc < 3) return 1;
        if (strcmp(argv[2], "zh") == 0) {
            set_language(LANG_ZH);
        } else if (strcmp(argv[2], "en") == 0) {
            set_language(LANG_EN);
        } else {
            return 1;
        }
        return 0;
    } else if (strcmp(argv[1], "--multi-user") == 0) {
        if (argc < 3) return 1;
        int value = atoi(argv[2]);
        if (value != 0 && value != 1) return 1;
        set_multi_user_scan(value);
        return 0;
    } else if (strcmp(argv[1], "--auto-scan") == 0) {
        if (argc < 3) return 1;
        int value = atoi(argv[2]);
        if (value != 0 && value != 1) return 1;
        set_auto_scan(value);
        return 0;
    } else if (strcmp(argv[1], "--config") == 0) {
        show_config();
        return 0;
    }
    return -1;
}

// Retry wrapper for operations
int retry_operation(int (*operation)(void), const char *op_name) {
    (void)op_name;
    for (int attempt = 1; attempt <= MAX_RETRIES; attempt++) {
        int result = operation();
        if (result == 0) {
            return 0; // Success
        }

        if (attempt < MAX_RETRIES) {
            write_log("WARN", 69, attempt, MAX_RETRIES); // Retry attempt X/Y
            sleep(1);
        } else {
            write_log("ERROR", 70, RETRY_DELAY); // Max retries reached
            sleep(RETRY_DELAY);
            write_log("ERROR", 71); // Operation failed after retries
        }
    }
    return -1;
}

void ensure_directory_exists(void) {
    const char *path = "/data/misc/user_uid";
    struct stat st;

    if (stat(path, &st) != 0) {
        if (mkdir(path, 0777) != 0) {
            LOGE("Failed to create directory %s: %s", path, strerror(errno));
            return;
        }
    }

    if (chmod(path, 0777) != 0) {
        LOGE("Failed to chmod directory %s: %s", path, strerror(errno));
    }
}

int load_config(void) {
    FILE *fp = fopen(CONFIG_FILE_PATH, "r");
    if (!fp) {
        write_log("WARN", 56, "配置文件不存在，使用默认配置");
        return save_config();
    }

    char line[256];
    while (fgets(line, sizeof(line), fp)) {
        line[strcspn(line, "\n")] = 0;

        if (line[0] == '#' || line[0] == '\0') continue;

        char key[64], value[64];
        if (sscanf(line, "%63[^=]=%63s", key, value) == 2) {
            parse_config_line(key, value);
        }
    }

    fclose(fp);
    write_log("INFO", 54); // Config loaded
    write_log("INFO", config.auto_scan ? 64 : 65); // 记录当前自动扫描状态
    return 0;
}

int save_config(void) {
    ensure_directory_exists();

    FILE *fp = fopen(CONFIG_FILE_PATH, "w");
    if (!fp) {
        write_log("ERROR", 57, strerror(errno)); // Config save failed
        return -1;
    }

    fprintf(fp, "# UID Scanner Configuration\n");
    fprintf(fp, "# Language: en (English) or zh (Chinese)\n");
    fprintf(fp, "language=%s\n", (config.language == LANG_ZH) ? "zh" : "en");
    fprintf(fp, "# Multi-user scanning: 0=disabled, 1=enabled\n");
    fprintf(fp, "multi_user_scan=%d\n", config.multi_user_scan);
    fprintf(fp, "# Scan interval in seconds\n");
    fprintf(fp, "scan_interval=%d\n", config.scan_interval);
    fprintf(fp, "# Log level: 0=minimal, 1=normal, 2=verbose\n");
    fprintf(fp, "log_level=%d\n", config.log_level);
    fprintf(fp, "# Auto scan: 0=disabled, 1=enabled\n");
    fprintf(fp, "auto_scan=%d\n", config.auto_scan);

    fclose(fp);
    write_log("INFO", 55); // Config saved
    return 0;
}

void set_language(language_t lang) {
    config.language = lang;
    save_config();
    write_log("INFO", (lang == LANG_ZH) ? 59 : 58);
}

int stop_daemon(void) {
    pid_t pid = read_pid_file();
    if (pid <= 0) {
        printf("%s\n", get_message(10));
        return 0;
    }

    printf(get_message(11), pid);
    printf("\n");

    if (kill(pid, SIGTERM) != 0) {
        printf(get_message(12), strerror(errno));
        printf("\n");
        return -1;
    }

    // Wait up to 30 seconds
    for (int i = 0; i < 30; i++) {
        if (kill(pid, 0) != 0) {
            printf("%s\n", get_message(13));
            unlink(PID_FILE_PATH);
            return 0;
        }
        sleep(1);
    }

    printf("%s\n", get_message(14));
    if (kill(pid, SIGKILL) == 0) {
        printf("%s\n", get_message(15));
        unlink(PID_FILE_PATH);
        return 0;
    }

    printf("%s\n", get_message(16));
    return -1;
}

void show_status(void) {
    pid_t pid = read_pid_file();
    if (pid <= 0) {
        printf("%s\n", get_message(20));
        return;
    }

    if (kill(pid, 0) == 0) {
        printf(get_message(21), pid);
        printf("\n");

        if (access(LOG_FILE_PATH, R_OK) == 0) {
            printf("\n%s\n", get_message(22));
            char cmd[512];
            snprintf(cmd, sizeof(cmd), "tail -n 10 %s", LOG_FILE_PATH);
            system(cmd);
        }
    } else {
        printf("%s\n", get_message(23));
        unlink(PID_FILE_PATH);
    }
}

void print_usage(const char *prog) {
    if (config.language == LANG_ZH) {
        printf("用法: %s [选项]\n", prog);
        printf("KSU UID 扫描器 - 管理UID白名单\n\n");
        printf("选项:\n");
        printf("  start                启动守护进程\n");
        printf("  stop                 停止守护进程\n");
        printf("  restart              重启守护进程\n");
        printf("  status               显示守护进程状态\n");
        printf("  reload               重新加载守护进程配置\n");
        printf("  -s, --scan           执行一次扫描并退出 (忽略auto_scan设置)\n");
        printf("  -l, --list           列出当前UID白名单\n");
        printf("  --lang <en|zh>       设置语言 (英文|中文)\n");
        printf("  --multi-user <0|1>   设置多用户扫描 (0=禁用, 1=启用)\n");
        printf("  --auto-scan <0|1>    设置自动扫描 (0=禁用, 1=启用)\n");
        printf("  --config             显示当前配置\n");
        printf("  -h, --help           显示此帮助信息\n");
    } else {
        printf("Usage: %s [options]\n", prog);
        printf("KSU UID Scanner - Manage UID whitelist\n\n");
        printf("Options:\n");
        printf("  start                Start daemon\n");
        printf("  stop                 Stop daemon\n");
        printf("  restart              Restart daemon\n");
        printf("  status               Show daemon status\n");
        printf("  reload               Reload daemon config\n");
        printf("  -s, --scan           Perform one scan and exit (ignore auto_scan setting)\n");
        printf("  -l, --list           List current UID whitelist\n");
        printf("  --lang <en|zh>       Set language\n");
        printf("  --multi-user <0|1>   Set multi-user scanning\n");
        printf("  --auto-scan <0|1>    Set auto scanning\n");
        printf("  --config             Show current config\n");
        printf("  -h, --help           Show this help\n");
    }
}

void list_whitelist(void) {
    FILE *fp = fopen(KSU_UID_LIST_PATH, "r");
    if (!fp) {
        printf(get_message(42), strerror(errno));
        printf("\n");
        return;
    }

    printf("%s\n", get_message(43));
    printf("%-8s %-40s\n", "UID", (config.language == LANG_ZH) ? "包名" : "Package");
    printf("%-8s %-40s\n", "--------", "----------------------------------------");

    char line[512];
    while (fgets(line, sizeof(line), fp)) {
        int uid;
        char package[256];
        if (sscanf(line, "%d %255s", &uid, package) == 2) {
            printf("%-8d %-40s\n", uid, package);
        }
    }
    fclose(fp);
}

void show_config(void) {
    if (config.language == LANG_ZH) {
        printf("当前配置:\n");
        printf("  语言: %s\n", (config.language == LANG_ZH) ? "中文" : "英文");
        printf("  多用户扫描: %s\n", config.multi_user_scan ? "启用" : "禁用");
        printf("  自动扫描: %s\n", config.auto_scan ? "启用" : "禁用");
        printf("  扫描间隔: %d 秒\n", config.scan_interval);
        printf("  日志级别: %d\n", config.log_level);
    } else {
        printf("Current Configuration:\n");
        printf("  Language: %s\n", (config.language == LANG_ZH) ? "Chinese" : "English");
        printf("  Multi-user scan: %s\n", config.multi_user_scan ? "Enabled" : "Disabled");
        printf("  Auto scan: %s\n", config.auto_scan ? "Enabled" : "Disabled");
        printf("  Scan interval: %d seconds\n", config.scan_interval);
        printf("  Log level: %d\n", config.log_level);
    }
}

const SCANNER_PATH: &str = "/data/adb/uid_scanner";
const LINK_DIR: &str = "/data/adb/ksu/bin";
const LINK_PATH: &str = "/data/adb/ksu/bin/uid_scanner";
const SERVICE_DIR: &str = "/data/adb/service.d";
const SERVICE_PATH: &str = "/data/adb/service.d/uid_scanner.sh";

pub fn start_uid_scanner_daemon() -> Result<()> {
    if !fs::exists(SCANNER_PATH)? {
        warn!("uid scanner binary not found at {SCANNER_PATH}");
        return Ok(());
    }

    if let Err(e) = fs::set_permissions(SCANNER_PATH, fs::Permissions::from_mode(0o755)) {
        warn!("failed to set permissions for {SCANNER_PATH}: {e}");
    }

    #[cfg(unix)]
    {
        if let Err(e) = fs::create_dir_all(LINK_DIR) {
            warn!("failed to create {LINK_DIR}: {e}");
        } else if !fs::exists(LINK_PATH)? {
            match symlink(SCANNER_PATH, LINK_PATH) {
                Ok(()) => info!("created symlink {SCANNER_PATH} -> {LINK_PATH}"),
                Err(e) => warn!("failed to create symlink: {e}"),
            }
        }
    }

    if let Err(e) = fs::create_dir_all(SERVICE_DIR) {
        warn!("failed to create {SERVICE_DIR}: {e}");
    }

    if !fs::exists(SERVICE_PATH)? {
        let content = include_str!("uid_scanner.sh");

        match fs::OpenOptions::new()
            .write(true)
            .create_new(true)
            .open(SERVICE_PATH)
            .and_then(|mut f| {
                f.write_all(content.as_bytes())?;
                f.sync_all()?;
                fs::set_permissions(SERVICE_PATH, fs::Permissions::from_mode(0o755))
            }) {
            Ok(()) => info!("created service script {SERVICE_PATH}"),
            Err(e) => warn!("failed to write {SERVICE_PATH}: {e}"),
        }
    }

    info!("starting uid scanner daemon with highest priority");
    let mut cmd = Command::new(SCANNER_PATH);
    cmd.arg("start")
        .stdin(Stdio::null())
        .stdout(Stdio::null())
        .stderr(Stdio::null())
        .current_dir("/");

    unsafe {
        cmd.pre_exec(|| {
            libc::nice(-20);
            libc::setsid();
            Ok(())
        });
    }

    match cmd.spawn() {
        Ok(child) => {
            info!("uid scanner daemon started with pid: {}", child.id());
            std::mem::drop(child);
        }
        Err(e) => warn!("failed to start uid scanner daemon: {e}"),
    }

    Ok(())
}

void setup_daemon_stdio(void) {
    close(STDIN_FILENO);
    close(STDOUT_FILENO);
    close(STDERR_FILENO);
    open("/dev/null", O_RDONLY);
    open("/dev/null", O_WRONLY);
    open("/dev/null", O_WRONLY);
}

int daemonize(void) {
    pid_t pid = fork();
    if (pid < 0) {
        LOGE(get_message(4), strerror(errno));
        return -1;
    }
    if (pid > 0) exit(0);

    if (setsid() < 0) {
        LOGE(get_message(5), strerror(errno));
        return -1;
    }

    signal(SIGHUP, SIG_IGN);
    pid = fork();
    if (pid < 0) {
        LOGE(get_message(6), strerror(errno));
        return -1;
    }
    if (pid > 0) exit(0);

    umask(0);
    if (chdir("/") < 0) {
        LOGE(get_message(7), strerror(errno));
        return -1;
    }

    setup_daemon_stdio();
    return 0;
}