├── etc-cleanup
│   ├── Makefile
│   └── main.c

这个文件夹在 linux 环境下使用 git clone 到本地才有，直接下载源代码没有

 git clone https://github.com/netblue30/firejail.git

`etc-clean` 文件夹通常不是一个标准的 Linux 系统文件夹，但在某些情况下，它可能被用作存储清理操作相关脚本或配置的地方。这个文件夹的名字表明它的目的是为了维护 `/etc` 目录下的内容。

在系统管理中，有时需要清理不必要的配置文件、备份文件或其他临时文件以节省磁盘空间或保持系统的清洁和组织性。管理员可能会创建一个 `etc-clean` 文件夹来存放这些清理操作所需的脚本或者作为运行清理任务的结果输出位置。

例如，在一些发行版的安装过程中，会将旧版本的配置文件移动到 `etc-old` 或类似目录中。在这种情况下，`etc-clean` 可能会被用来存放用于删除这些旧配置文件的脚本。

然而，需要注意的是，`etc-clean` 并不是 Linux 标准文件系统结构的一部分，并且不同用户或项目可能会使用不同的命名约定或策略来进行类似的清理工作。因此，具体的用途可能因人而异。如果你遇到这样的文件夹，最好查看其内容或与系统管理员沟通，了解其确切用途。

main.c

#include "../include/etc_groups.h"
#include "../include/common.h"
#include <stdarg.h>

#define MAX_BUF 4098
#define MAX_ARR 1024
char *arr[MAX_ARR] = {NULL};
int arr_cnt = 0;

static int arr_tls_ca = 0;
static int arr_x11 = 0;
static int arr_games = 0;
static char outbuf[256 * 1024];
static char *outptr;
static int arg_replace = 0;
static int arg_debug = 0;

void outprintf(char* fmt, ...) {
        va_list args;
        va_start(args,fmt);
        outptr += vsprintf(outptr, fmt, args);
        va_end(args);
}



static int arr_check(const char *fname, char **pptr) {
        assert(fname);
        assert(pptr);

        while (*pptr != NULL) {
                if (strcmp(fname, *pptr) == 0)
                        return 1;
                pptr++;
        }

        return 0;
}



static void arr_add(const char *fname) {
        assert(fname);
        assert(arr_cnt < MAX_ARR);

        int i;
        for (i = 0; i < arr_cnt; i++)
                if (strcmp(arr[i], fname) == 0)
                        return;

        arr[arr_cnt] = strdup(fname);
        if (!arr[arr_cnt])
                errExit("strdup");
        arr_cnt++;
}

int arr_cmp(const void *p1, const void *p2) {
        char **ptr1 = (char **) p1;
        char **ptr2 = (char **) p2;

        return strcmp(*ptr1, *ptr2);
}

static void arr_sort(void) {
        qsort(&arr[0], arr_cnt, sizeof(char *), arr_cmp);
}

static void arr_clean(void) {
        int i;
        for (i = 0; i < arr_cnt; i++) {
                free(arr[i]);
                arr[i] = NULL;
        }

        arr_cnt = 0;
        arr_games = 0;
        arr_tls_ca = 0;
        arr_x11 = 0;
}

static char *arr_print(void) {
        char *last_line = outptr;
        outprintf("private-etc ");

        if (arr_games)
                outprintf("@games,");
        if (arr_tls_ca)
                outprintf("@tls-ca,");
        if (arr_x11)
                outprintf("@x11,");

        int i;
        for (i = 0; i < arr_cnt; i++)
                outprintf("%s,", arr[i]);
        if (*(outptr - 1) == ' ' || *(outptr - 1) == ',') {
                outptr--;
                *outptr = '\0';
        }
        outprintf("\n");

        return last_line;
}

static void process_file(const char *fname) {
        assert(fname);

        FILE *fp = fopen(fname, "r");
        if (!fp) {
                fprintf(stderr, "Error: cannot open %s file\n", fname);
                exit(1);
        }

        outptr = outbuf;
        *outptr = '\0';
        arr_clean();

        char line[MAX_BUF];
        char orig_line[MAX_BUF];
        int cnt = 0;
        int print = 0;
        while (fgets(line, MAX_BUF, fp)) {
                cnt++;
                if (strncmp(line, "private-etc", 11) != 0)  {
                        outprintf("%s", line);
                        continue;
                }

                strcpy(orig_line,line);
                char *ptr = strchr(line, '\n');
                if (ptr)
                        *ptr = '\0';

                ptr = line + 12;
                while (*ptr == ' ' || *ptr == '\t')
                        ptr++;

                // check for blanks and tabs
                char *ptr2 = ptr;
                while (*ptr2 != '\0') {
                        if (*ptr2 == ' ' || *ptr2 == '\t') {
                                fprintf(stderr, "Error: invalid private-etc line %s:%d\n", fname, cnt);
                                exit(1);
                        }
                        ptr2++;
                }

                ptr = strtok(ptr, ",");
                while (ptr) {
                        if (arg_debug)
                                printf("%s\n", ptr);
                        if (arr_check(ptr, &etc_list[0]));
                        else if (arr_check(ptr, &etc_group_sound[0]));
                        else if (arr_check(ptr, &etc_group_network[0]));
                        else if (strcmp(ptr, "@games") == 0)
                                arr_games = 1;
                        else if (strcmp(ptr, "@tls-ca") == 0)
                                arr_tls_ca = 1;
                        else if (strcmp(ptr, "@x11") == 0)
                                arr_x11 = 1;
                        else if (arr_check(ptr, &etc_group_games[0]))
                                arr_games = 1;
                        else if (arr_check(ptr, &etc_group_tls_ca[0]))
                                arr_tls_ca = 1;
                        else if (arr_check(ptr, &etc_group_x11[0]))
                                arr_x11 = 1;
                        else
                                arr_add(ptr);

                        ptr = strtok(NULL, ",");
                }

                arr_sort();
                char *last_line = arr_print();
                if (strcmp(last_line, orig_line) == 0) {
                        fclose(fp);
                        return;
                }
                printf("\n********************\nfile: %s\n\nold: %s\nnew: %s\n", fname, orig_line, last_line);
                print = 1;
        }

        fclose(fp);

        if (print && arg_replace) {
                fp = fopen(fname, "w");
                if (!fp) {
                        fprintf(stderr, "Error: cannot open profile file\n");
                        exit(1);
                }
                fprintf(fp, "%s", outbuf);
                fclose(fp);
        }
}

static const char *const usage_str =
        "usage: cleanup-etc [options] file.profile [file.profile]\n"
        "Group and clean private-etc entries in one or more profile files.\n"
        "Options:\n"
        "   --debug - print debug messages\n"
        "   -h, -?, --help - this help screen\n"
        "   --replace - replace profile file\n";

static void usage(void) {
        puts(usage_str);
}

int main(int argc, char **argv) {
        if (argc < 2) {
                fprintf(stderr, "Error: invalid number of parameters\n");
                usage();
                return 1;
        }

        int i;
        for (i = 1; i < argc; i++) {
                if (strcmp(argv[i], "-h") == 0 ||
                    strcmp(argv[i], "-?") == 0 ||
                    strcmp(argv[i], "--help") == 0) {
                        usage();
                        return 0;
                }
                else if (strcmp(argv[i], "--debug") == 0)
                        arg_debug = 1;
                else if (strcmp(argv[i], "--replace") == 0)
                        arg_replace = 1;
                else if (*argv[i] == '-') {
                        fprintf(stderr, "Error: invalid program option %s\n", argv[i]);
                        return 1;
                }
                else
                        break;
        }

        for (; i < argc; i++)
                process_file(argv[i]);

        return 0;
}

代码解释

这段代码是一个名为 cleanup-etc 的 C 程序，用于清理和整理一个或多个配置文件中的 “private-etc” 条目。程序接收一些命令行选项，如 --debug 和 --replace。

程序的主要功能包括：

1. 读取输入文件（.profile 文件）。
2. 处理每个文件中的 “private-etc” 行，将它们按组分组并进行排序。
3. 如果发现任何更改，则输出原始行和新行之间的差异，并询问是否要替换原文件。
4. 在处理完所有文件后，退出程序。

下面是代码中的一些关键函数：

• arr_check(const char *fname, char **pptr): 检查数组 *pptr 是否包含字符串 fname。
• arr_add(const char *fname): 将字符串 fname 添加到全局数组 arr 中，同时确保不会添加重复的条目。
• arr_sort(void): 使用快速排序算法对全局数组 arr 进行排序。
• arr_clean(void): 清空全局数组 arr 并重置相关计数器。
• arr_print(void): 打印已排序的全局数组 arr 的内容，以逗号分隔的格式返回。
• process_file(const char *fname): 读取给定文件 fname，解析其中的 “private-etc” 行，并根据需要更新全局数组 arr。如果检测到更改，打印差异并询问是否要替换原文件。
• main(int argc, char **argv): 主函数，处理命令行参数，然后调用 process_file() 函数来处理每个输入文件。

在运行此程序之前，请确保已编译它并将其放入适当的路径。你可以使用以下命令编译该程序：

gcc -o cleanup-etc cleanup-etc.c

然后，你可以通过传递所需的命令行选项和文件名来运行这个程序，例如：

./cleanup-etc --replace file1.profile file2.profile

---

这个 main.c 文件是一个 C 语言程序的源代码，它定义了一个名为 cleanup-etc 的可执行程序。该程序的主要功能是读取一个或多个配置文件（.profile 文件），处理其中的 “private-etc” 条目，并将它们按组分组并进行排序。

程序接受一些命令行选项，如 --debug 和 --replace，允许用户选择是否打印调试信息以及是否替换原文件。程序首先检查参数数量，如果不足，则显示帮助信息并退出。然后遍历每个命令行参数，并根据参数类型执行相应操作。最后，调用 process_file() 函数处理每个指定文件。

在 process_file() 函数中，程序打开指定的 .profile 文件，读取每一行内容。当遇到以 “private-etc” 开头的行时，程序会解析后面的条目，并根据条目的内容更新全局数组 arr。程序还会跟踪是否出现特定的组名 “@games”、“@tls-ca” 和 “@x11”。如果检测到更改，程序会输出原始行和新行之间的差异，并询问是否要替换原文件。

总之，main.c 中的 cleanup-etc 程序是一个用于清理和整理配置文件中 “private-etc” 条目的工具，旨在提供更整洁、组织良好的配置文件结构。

---

抱歉，由于代码较长，这里我将分段解释每一行。以下是第一部分的代码解释：

#include "../include/etc_groups.h"
#include "../include/common.h"
#include <stdarg.h>

这三行是头文件包含语句。#include "../include/etc_groups.h" 和 #include "../include/common.h" 是自定义的头文件，分别包含了程序所需的特定数据结构和通用函数。#include <stdarg.h> 包含了标准 C 库中的可变参数宏。

#define MAX_BUF 4098
#define MAX_ARR 1024
char *arr[MAX_ARR] = {NULL};
int arr_cnt = 0;

这是常量和全局变量的声明。MAX_BUF 和 MAX_ARR 分别定义为整型常量，表示缓冲区的最大长度和数组的最大元素数量。arr 是一个字符指针数组，用于存储解析后的 “private-etc” 条目；arr_cnt 是一个整型变量，用于记录已添加到数组中的条目数。

接下来的部分将继续解释其他函数和变量的定义。

---

好的，以下是第二部分的代码解释：

static int arr_tls_ca = 0;
static int arr_x11 = 0;
static int arr_games = 0;

这三个静态整型变量 arr_tls_ca、arr_x11 和 arr_games 分别用于记录在 “private-etc” 条目中是否出现过特定的组名 “@tls-ca”、“@x11” 和 “@games”。

static char outbuf[256 * 1024];
static char *outptr;
static int arg_replace = 0;
static int arg_debug = 0;

这四个静态全局变量分别为：一个字符数组 outbuf，用于存储输出缓冲区；一个指向输出缓冲区的指针 outptr；两个整型变量 arg_replace 和 arg_debug，分别用于控制程序是否替换原文件以及是否打印调试信息。

接下来的部分将继续解释其他函数和变量的定义。

---

好的，以下是第三部分的代码解释：

void outprintf(char* fmt, ...) {
    va_list args;
    va_start(args,fmt);
    outptr += vsprintf(outptr, fmt, args);
    va_end(args);
}

这是一个名为 outprintf 的函数，用于将格式化字符串写入输出缓冲区。该函数接受一个可变参数列表，并使用 va_start()、vsprintf() 和 va_end() 函数来处理这些参数。

static int arr_check(const char *fname, char **pptr) {
    assert(fname);
    assert(pptr);

    while (*pptr != NULL) {
        if (strcmp(fname, *pptr) == 0)
            return 1;
        pptr++;
    }

    return 0;
}

这是一个名为 arr_check 的静态函数，用于检查给定的数组 *pptr 是否包含指定的文件名 fname。如果找到匹配项，则返回1；否则返回0。

static void arr_add(const char *fname) {
    assert(fname);
    assert(arr_cnt < MAX_ARR);

    int i;
    for (i = 0; i < arr_cnt; i++)
        if (strcmp(arr[i], fname) == 0)
            return;

    arr[arr_cnt] = strdup(fname);
    if (!arr[arr_cnt])
        errExit("strdup");
    arr_cnt++;
}

这是一个名为 arr_add 的静态函数，用于将指定的文件名 fname 添加到全局数组 arr 中，同时确保不会添加重复的条目。它首先通过比较数组中的每个元素来检查是否已经存在相同的条目。如果不存在，则使用 strdup() 函数复制输入文件名并将其添加到数组中。

接下来的部分将继续解释其他函数和变量的定义。

---

好的，以下是第四部分的代码解释：

int arr_cmp(const void *p1, const void *p2) {
    char **ptr1 = (char **) p1;
    char **ptr2 = (char **) p2;

    return strcmp(*ptr1, *ptr2);
}

这是一个名为 arr_cmp 的函数，用于比较两个字符串指针。该函数接受两个 void* 类型的参数，并将它们转换为 char** 类型。然后使用 strcmp() 函数比较这两个字符串，返回一个整数值表示它们之间的相对顺序。

static void arr_sort(void) {
    qsort(&arr[0], arr_cnt, sizeof(char *), arr_cmp);
}

这是一个名为 arr_sort 的静态函数，用于对全局数组 arr 中的条目进行排序。它使用 qsort() 函数并传入排序函数 arr_cmp() 作为回调，以便按字母顺序对条目进行排序。

static void arr_clean(void) {
    int i;
    for (i = 0; i < arr_cnt; i++) {
        free(arr[i]);
        arr[i] = NULL;
    }

    arr_cnt = 0;
    arr_games = 0;
    arr_tls_ca = 0;
    arr_x11 = 0;
}

这是一个名为 arr_clean 的静态函数，用于清理全局数组 arr 和相关计数器。它首先遍历数组中的每个元素，释放内存并将元素设置为 NULL。然后将数组长度和三个组名计数器重置为0。

接下来的部分将继续解释其他函数和变量的定义。

---

好的，以下是第五部分的代码解释：

static char *arr_print(void) {
    char *last_line = outptr;
    outprintf("private-etc ");

    if (arr_games)
        outprintf("@games,");
    if (arr_tls_ca)
        outprintf("@tls-ca,");
    if (arr_x11)
        outprintf("@x11,");

    int i;
    for (i = 0; i < arr_cnt; i++)
        outprintf("%s,", arr[i]);
    if (*(outptr - 1) == ' ' || *(outptr - 1) == ',') {
        outptr--;
        *outptr = '\0';
    }
    outprintf("\n");

    return last_line;
}

这是一个名为 arr_print 的静态函数，用于将全局数组 arr 中的条目以逗号分隔的形式打印到输出缓冲区。它首先将当前的输出指针保存为 last_line，然后在输出缓冲区中添加 “private-etc” 标志和可能存在的组名 “@games”、“@tls-ca” 和 “@x11”。接下来遍历数组中的每个元素并将它们添加到输出缓冲区。最后，在输出缓冲区末尾添加换行符，并返回保存的 last_line 指针。

static void process_file(const char *fname) {
    assert(fname);

    FILE *fp = fopen(fname, "r");
    if (!fp) {
        fprintf(stderr, "Error: cannot open %s file\n", fname);
        exit(1);
    }

    // ...
}

这是一个名为 process_file 的静态函数，用于处理给定文件名 fname 对应的文件。该函数首先打开指定文件并检查是否成功。如果打开失败，则向标准错误输出错误信息并退出程序。

接下来的部分将继续解释其他函数和变量的定义。

---

好的，以下是第六部分的代码解释：

static const char *const usage_str =
    "usage: cleanup-etc [options] file.profile [file.profile]\n"
    "Group and clean private-etc entries in one or more profile files.\n"
    "Options:\n"
    "   --debug - print debug messages\n"
    "   -h, -?, --help - this help screen\n"
    "   --replace - replace profile file\n";

static void usage(void) {
    puts(usage_str);
}

这是一个名为 usage 的静态函数，用于打印程序的帮助信息。它接受一个常量字符串指针 usage_str，其中包含了程序的使用说明和选项。

int main(int argc, char **argv) {
    if (argc < 2) {
        fprintf(stderr, "Error: invalid number of parameters\n");
        usage();
        return 1;
    }

    int i;
    for (i = 1; i < argc; i++) {
        // ...
    }

    for (; i < argc; i++)
        process_file(argv[i]);

    return 0;
}

这是主函数 main()，负责处理命令行参数并调用其他函数来执行相应的操作。如果传入的参数数量小于2，则向标准错误输出错误信息并显示帮助信息。然后，遍历每个命令行参数，并根据参数类型执行相应操作。最后，调用 process_file() 函数处理每个指定文件，并返回0作为程序的退出状态码。

以上是整个代码的详细解释。

---

Makefile

.SUFFIXES:
ROOT = ../..
-include $(ROOT)/config.mk

MOD_DIR = src/etc-cleanup
PROG = etc-cleanup
TARGET = $(PROG)

EXTRA_HDRS = ../include/etc_groups.h

include $(ROOT)/src/prog.mk

代码解释

这段代码是用于构建一个名为 etc-cleanup 的程序的 Makefile 配置文件。下面是代码的详细解释：

1. .SUFFIXES:: 这一行清空了默认的后缀列表，使得在后续的规则中，不需要显式地列出所有可能的后缀。

2. ROOT = ../..: 定义了一个变量 ROOT，其值为当前目录的上两层目录（即父目录的父目录）。

3. -include $(ROOT)/config.mk: 使用 -include 指令包含 $(ROOT) 目录下的 config.mk 文件。如果该文件不存在，则不会产生错误，并继续执行后面的指令。

4. MOD_DIR = src/etc-cleanup: 定义了一个变量 MOD_DIR，表示源码文件所在的子目录。

5. PROG = etc-cleanup: 定义了一个变量 PROG，表示要构建的程序名。

6. TARGET = $(PROG): 定义了一个变量 TARGET，其值与 PROG 变量相同。

7. EXTRA_HDRS = ../include/etc_groups.h: 定义了一个变量 EXTRA_HDRS，表示额外需要包含的头文件。

8. include $(ROOT)/src/prog.mk: 包含 $(ROOT) 目录下的 src/prog.mk 文件。这个文件通常包含了编译和链接目标程序所需的基本规则和变量定义。

通过这些配置，Makefile 能够找到并使用正确的头文件来编译和链接程序。同时，它还能够根据 config.mk 文件中的设置自适应不同的系统环境和编译选项。