listxattr系统调用及示例

96. listxattr - 列出文件的扩展属性名称链接到标题

1. 函数介绍链接到标题

listxattr 是一个 Linux 系统调用，用于列出指定文件的所有扩展属性（extended attributes，简称 xattrs）的名称。扩展属性是文件系统提供的一种机制，允许用户为文件关联额外的元数据。

2. 函数原型链接到标题

#include <sys/types.h>
#include <attr/xattr.h>

ssize_t listxattr(const char *path, char *list, size_t size);

97. llistxattr - 列出符号链接的扩展属性名称链接到标题

1. 函数介绍链接到标题

llistxattr 是 listxattr 的变体，专门用于列出符号链接本身的扩展属性名称，而不跟随符号链接。这与 lstat 和 stat 的关系类似。

2. 函数原型链接到标题

#include <sys/types.h>
#include <attr/xattr.h>

ssize_t llistxattr(const char *path, char *list, size_t size);

3. 功能对比链接到标题

函数	功能	符号链接处理	使用场景
`listxattr(path, list, size)`	列出文件的扩展属性名称	跟随符号链接	普通文件属性查询
`llistxattr(path, list, size)`	列出符号链接的扩展属性名称	不跟随符号链接	符号链接属性查询

4. 参数说明链接到标题

共同参数:

const char *path: 文件或符号链接的路径名
char *list: 用于存储扩展属性名称列表的缓冲区
- 如果为 NULL：函数返回所需缓冲区大小（不实际复制数据）
- 如果非 NULL：将属性名称列表复制到该缓冲区中
size_t size: 缓冲区 list 的大小（以字节为单位）

5. 返回值链接到标题

成功时：
- 如果 list 为 NULL：返回所有属性名称的总长度（字节数）
- 如果 list 非 NULL：返回实际复制到缓冲区中的字节数
失败时返回 -1，并设置 errno

6. 常见 errno 错误码链接到标题

ENOTSUP: 文件系统不支持扩展属性
ENOENT: 指定的文件或路径不存在
EACCES: 权限不足
ENOMEM: 内存不足
ERANGE: 缓冲区大小不足
ELOOP: 符号链接层级过深
ENAMETOOLONG: 路径名过长
EFAULT: 指针参数指向无效内存地址

7. 相似函数，或关联函数链接到标题

flistxattr(): 通过文件描述符列出扩展属性名称
getxattr(), lgetxattr(), fgetxattr(): 获取扩展属性值
setxattr(), lsetxattr(), fsetxattr(): 设置扩展属性
removexattr(), lremovexattr(), fremovexattr(): 删除扩展属性
getxattr(2): 系统调用手册页

8. 示例代码链接到标题

示例1：基本使用 - 获取扩展属性名称列表链接到标题

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <attr/xattr.h>
#include <errno.h>
#include <string.h>
#include <fcntl.h>

void print_xattr_names(const char *filename) {
    printf("=== 文件 '%s' 的扩展属性 ===\n", filename);
    
    // 第一次调用：获取所需缓冲区大小
    ssize_t list_size = listxattr(filename, NULL, 0);
    if (list_size == -1) {
        switch (errno) {
            case ENOTSUP:
                printf("文件系统不支持扩展属性\n");
                return;
            case ENOENT:
                printf("文件不存在\n");
                return;
            case EACCES:
                printf("权限不足\n");
                return;
            default:
                printf("获取属性列表大小失败: %s\n", strerror(errno));
                return;
        }
    }
    
    if (list_size == 0) {
        printf("文件没有扩展属性\n");
        return;
    }
    
    printf("扩展属性名称列表大小: %zd 字节\n", list_size);
    
    // 分配缓冲区
    char *list_buffer = malloc(list_size);
    if (list_buffer == NULL) {
        printf("内存分配失败\n");
        return;
    }
    
    // 第二次调用：获取实际属性名称列表
    ssize_t bytes_copied = listxattr(filename, list_buffer, list_size);
    if (bytes_copied == -1) {
        printf("获取属性列表失败: %s\n", strerror(errno));
        free(list_buffer);
        return;
    }
    
    printf("成功获取 %zd 字节的属性名称列表\n", bytes_copied);
    
    // 解析并打印每个属性名称
    printf("扩展属性名称列表:\n");
    char *current = list_buffer;
    int attr_count = 0;
    
    while (current < list_buffer + bytes_copied) {
        printf("  [%d] %s\n", ++attr_count, current);
        current += strlen(current) + 1;  // 移动到下一个属性名称
    }
    
    printf("总共 %d 个扩展属性\n", attr_count);
    
    free(list_buffer);
}

int main() {
    const char *test_file = "xattr_test.txt";
    
    printf("=== listxattr 基本使用演示 ===\n");
    
    // 创建测试文件
    int fd = open(test_file, O_CREAT | O_WRONLY | O_TRUNC, 0644);
    if (fd == -1) {
        perror("创建测试文件失败");
        exit(EXIT_FAILURE);
    }
    
    const char *content = "This is a test file for extended attributes.\n";
    write(fd, content, strlen(content));
    close(fd);
    
    printf("创建测试文件: %s\n", test_file);
    
    // 为文件设置一些扩展属性
    const char *test_attrs[][2] = {
        {"user.test1", "value1"},
        {"user.test2", "value2"},
        {"user.description", "This is a test file"},
        {"user.author", "Test User"},
        {"user.version", "1.0"}
    };
    
    int attr_count = sizeof(test_attrs) / sizeof(test_attrs[0]);
    
    printf("设置测试扩展属性:\n");
    for (int i = 0; i < attr_count; i++) {
        if (setxattr(test_file, test_attrs[i][0], test_attrs[i][1], 
                     strlen(test_attrs[i][1]), 0) == 0) {
            printf("  ✓ %s = %s\n", test_attrs[i][0], test_attrs[i][1]);
        } else {
            printf("  ✗ %s 设置失败: %s\n", test_attrs[i][0], strerror(errno));
        }
    }
    
    // 列出扩展属性名称
    print_xattr_names(test_file);
    
    // 清理测试文件
    unlink(test_file);
    
    return 0;
}

示例2：符号链接扩展属性演示链接到标题

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <attr/xattr.h>
#include <errno.h>
#include <string.h>
#include <fcntl.h>

void compare_link_xattr_functions(const char *symlink_name) {
    printf("=== 符号链接扩展属性比较 ===\n");
    
    printf("测试符号链接: %s\n", symlink_name);
    
    // 使用 listxattr（跟随符号链接）
    printf("\n使用 listxattr (跟随符号链接):\n");
    ssize_t list_size = listxattr(symlink_name, NULL, 0);
    if (list_size != -1) {
        if (list_size == 0) {
            printf("  目标文件没有扩展属性\n");
        } else {
            char *buffer = malloc(list_size);
            if (buffer) {
                listxattr(symlink_name, buffer, list_size);
                char *current = buffer;
                while (current < buffer + list_size) {
                    printf("  %s\n", current);
                    current += strlen(current) + 1;
                }
                free(buffer);
            }
        }
    } else {
        printf("  获取失败: %s\n", strerror(errno));
    }
    
    // 使用 llistxattr（不跟随符号链接）
    printf("\n使用 llistxattr (不跟随符号链接):\n");
    list_size = llistxattr(symlink_name, NULL, 0);
    if (list_size != -1) {
        if (list_size == 0) {
            printf("  符号链接本身没有扩展属性\n");
        } else {
            char *buffer = malloc(list_size);
            if (buffer) {
                llistxattr(symlink_name, buffer, list_size);
                char *current = buffer;
                while (current < buffer + list_size) {
                    printf("  %s\n", current);
                    current += strlen(current) + 1;
                }
                free(buffer);
            }
        }
    } else {
        printf("  获取失败: %s\n", strerror(errno));
    }
}

int main() {
    const char *target_file = "target.txt";
    const char *symlink_name = "symlink_to_target";
    
    printf("=== listxattr vs llistxattr 演示 ===\n");
    
    // 创建目标文件
    int fd = open(target_file, O_CREAT | O_WRONLY | O_TRUNC, 0644);
    if (fd == -1) {
        perror("创建目标文件失败");
        exit(EXIT_FAILURE);
    }
    
    const char *content = "Target file content\n";
    write(fd, content, strlen(content));
    close(fd);
    
    printf("创建目标文件: %s\n", target_file);
    
    // 为目标文件设置扩展属性
    if (setxattr(target_file, "user.target_attr", "target_value", 12, 0) == 0) {
        printf("✓ 为目标文件设置扩展属性: user.target_attr\n");
    }
    
    // 创建符号链接
    if (symlink(target_file, symlink_name) == 0) {
        printf("✓ 创建符号链接: %s -> %s\n", symlink_name, target_file);
    } else {
        perror("创建符号链接失败");
        unlink(target_file);
        exit(EXIT_FAILURE);
    }
    
    // 为符号链接本身设置扩展属性
    if (lsetxattr(symlink_name, "user.symlink_attr", "symlink_value", 13, 0) == 0) {
        printf("✓ 为符号链接设置扩展属性: user.symlink_attr\n");
    }
    
    // 比较两种函数的行为
    compare_link_xattr_functions(symlink_name);
    
    // 清理测试文件
    unlink(symlink_name);
    unlink(target_file);
    
    return 0;
}

示例3：错误处理和边界情况链接到标题

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <attr/xattr.h>
#include <errno.h>
#include <string.h>

void test_listxattr_errors(const char *path, const char *description) {
    printf("\n测试 %s:\n", description);
    printf("  路径: %s\n", path);
    
    // 测试获取列表大小
    ssize_t list_size = listxattr(path, NULL, 0);
    if (list_size == -1) {
        printf("  获取列表大小失败: %s\n", strerror(errno));
        switch (errno) {
            case ENOENT:
                printf("    原因: 文件不存在\n");
                break;
            case EACCES:
                printf("    原因: 权限不足\n");
                break;
            case ENAMETOOLONG:
                printf("    原因: 路径名过长\n");
                break;
            case ELOOP:
                printf("    原因: 符号链接层级过深\n");
                break;
            case ENOTSUP:
                printf("    原因: 文件系统不支持扩展属性\n");
                break;
            case EFAULT:
                printf("    原因: 路径指针无效\n");
                break;
            default:
                printf("    原因: 其他错误\n");
                break;
        }
        return;
    }
    
    printf("  列表大小: %zd 字节\n", list_size);
    
    if (list_size == 0) {
        printf("  文件没有扩展属性\n");
        return;
    }
    
    // 测试缓冲区不足的情况
    size_t small_buffer_size = 10;
    char small_buffer[10];
    
    ssize_t result = listxattr(path, small_buffer, small_buffer_size);
    if (result == -1) {
        if (errno == ERANGE) {
            printf("  缓冲区大小不足 (ERANGE)，实际需要 %zd 字节\n", list_size);
        } else {
            printf("  其他错误: %s\n", strerror(errno));
        }
    } else {
        printf("  意外成功，获取了 %zd 字节\n", result);
    }
    
    // 测试正常获取
    char *buffer = malloc(list_size);
    if (buffer) {
        result = listxattr(path, buffer, list_size);
        if (result != -1) {
            printf("  成功获取 %zd 字节的属性列表\n", result);
            
            // 显示属性名称
            char *current = buffer;
            int count = 0;
            while (current < buffer + result) {
                printf("    属性 %d: %s\n", ++count, current);
                current += strlen(current) + 1;
            }
        } else {
            printf("  获取属性列表失败: %s\n", strerror(errno));
        }
        free(buffer);
    }
}

int main() {
    printf("=== listxattr 错误处理测试 ===\n");
    
    // 创建测试文件
    const char *test_file = "error_test.txt";
    int fd = open(test_file, O_CREAT | O_WRONLY | O_TRUNC, 0644);
    if (fd != -1) {
        write(fd, "test", 4);
        close(fd);
        printf("创建测试文件: %s\n", test_file);
    }
    
    // 测试正常情况
    test_listxattr_errors(test_file, "正常文件");
    
    // 测试各种错误情况
    test_listxattr_errors("nonexistent_file.txt", "不存在的文件");
    test_listxattr_errors("", "空路径");
    test_listxattr_errors("/etc/passwd", "系统文件");
    
    // 创建长路径名测试
    char long_path[1024];
    memset(long_path, 'a', sizeof(long_path) - 1);
    long_path[1023] = '\0';
    test_listxattr_errors(long_path, "过长路径名");
    
    // 测试缓冲区大小处理
    printf("\n=== 缓冲区大小测试 ===\n");
    ssize_t size = listxattr(test_file, NULL, 0);
    if (size != -1) {
        printf("文件属性列表实际大小: %zd 字节\n", size);
        
        // 测试不同大小的缓冲区
        for (size_t test_size = 0; test_size <= (size_t)size + 10; test_size += 5) {
            char *test_buffer = malloc(test_size);
            if (test_buffer) {
                ssize_t result = listxattr(test_file, test_buffer, test_size);
                printf("  缓冲区大小 %2zu: ", test_size);
                if (result == -1) {
                    if (errno == ERANGE) {
                        printf("ERANGE (缓冲区不足)\n");
                    } else {
                        printf("错误: %s\n", strerror(errno));
                    }
                } else {
                    printf("成功获取 %zd 字节\n", result);
                }
                free(test_buffer);
            }
        }
    }
    
    // 清理测试文件
    unlink(test_file);
    
    return 0;
}

示例4：扩展属性管理工具链接到标题

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <attr/xattr.h>
#include <errno.h>
#include <string.h>
#include <dirent.h>

typedef struct {
    char name[256];
    size_t value_size;
    char *value;
} xattr_info_t;

int get_all_xattrs(const char *filename, xattr_info_t **attrs, int *count) {
    // 获取属性名称列表大小
    ssize_t list_size = listxattr(filename, NULL, 0);
    if (list_size == -1) {
        return -1;
    }
    
    if (list_size == 0) {
        *count = 0;
        *attrs = NULL;
        return 0;
    }
    
    // 分配内存存储属性名称列表
    char *list_buffer = malloc(list_size);
    if (list_buffer == NULL) {
        return -1;
    }
    
    // 获取属性名称列表
    if (listxattr(filename, list_buffer, list_size) == -1) {
        free(list_buffer);
        return -1;
    }
    
    // 计算属性数量
    int attr_count = 0;
    char *current = list_buffer;
    while (current < list_buffer + list_size) {
        attr_count++;
        current += strlen(current) + 1;
    }
    
    // 分配属性信息数组
    xattr_info_t *attr_array = malloc(attr_count * sizeof(xattr_info_t));
    if (attr_array == NULL) {
        free(list_buffer);
        return -1;
    }
    
    // 获取每个属性的详细信息
    int valid_attrs = 0;
    current = list_buffer;
    while (current < list_buffer + list_size) {
        // 获取属性值大小
        ssize_t value_size = getxattr(filename, current, NULL, 0);
        if (value_size != -1) {
            // 存储属性信息
            strncpy(attr_array[valid_attrs].name, current, sizeof(attr_array[valid_attrs].name) - 1);
            attr_array[valid_attrs].name[sizeof(attr_array[valid_attrs].name) - 1] = '\0';
            attr_array[valid_attrs].value_size = value_size;
            
            // 获取属性值
            attr_array[valid_attrs].value = malloc(value_size + 1);
            if (attr_array[valid_attrs].value != NULL) {
                if (getxattr(filename, current, attr_array[valid_attrs].value, value_size) != -1) {
                    // 如果是字符串，添加终止符
                    if (value_size > 0 && memchr(attr_array[valid_attrs].value, '\0', value_size) == NULL) {
                        attr_array[valid_attrs].value[value_size] = '\0';
                    }
                    valid_attrs++;
                } else {
                    free(attr_array[valid_attrs].value);
                    attr_array[valid_attrs].value = NULL;
                }
            }
        }
        current += strlen(current) + 1;
    }
    
    free(list_buffer);
    *attrs = attr_array;
    *count = valid_attrs;
    return 0;
}

void print_xattr_details(const char *filename) {
    printf("=== 文件 '%s' 的扩展属性详情 ===\n", filename);
    
    xattr_info_t *attrs;
    int count;
    
    if (get_all_xattrs(filename, &attrs, &count) == -1) {
        printf("获取扩展属性信息失败: %s\n", strerror(errno));
        return;
    }
    
    if (count == 0) {
        printf("文件没有扩展属性\n");
        return;
    }
    
    printf("找到 %d 个扩展属性:\n", count);
    printf("%-30s %-10s %s\n", "属性名称", "大小", "值");
    printf("%-30s %-10s %s\n", "--------", "----", "---");
    
    for (int i = 0; i < count; i++) {
        printf("%-30s %-10zu ", attrs[i].name, attrs[i].value_size);
        
        // 显示值（如果是可打印字符）
        int is_printable = 1;
        if (attrs[i].value && attrs[i].value_size > 0) {
            for (size_t j = 0; j < attrs[i].value_size && j < 50; j++) {
                if (attrs[i].value[j] < 32 || attrs[i].value[j] > 126) {
                    if (attrs[i].value[j] != '\n' && attrs[i].value[j] != '\t') {
                        is_printable = 0;
                        break;
                    }
                }
            }
            
            if (is_printable && attrs[i].value_size < 50) {
                printf("%s", attrs[i].value);
            } else {
                printf("(二进制数据或长文本)");
            }
        } else {
            printf("(空值)");
        }
        printf("\n");
        
        // 释放内存
        if (attrs[i].value) {
            free(attrs[i].value);
        }
    }
    
    free(attrs);
}

void scan_directory_xattrs(const char *directory) {
    printf("=== 目录 '%s' 的扩展属性扫描 ===\n", directory);
    
    DIR *dir = opendir(directory);
    if (!dir) {
        printf("无法打开目录: %s\n", strerror(errno));
        return;
    }
    
    struct dirent *entry;
    char filepath[512];
    int files_with_xattrs = 0;
    int total_xattrs = 0;
    
    while ((entry = readdir(dir)) != NULL) {
        // 跳过 . 和 ..
        if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0) {
            continue;
        }
        
        snprintf(filepath, sizeof(filepath), "%s/%s", directory, entry->d_name);
        
        // 获取扩展属性列表大小
        ssize_t list_size = listxattr(filepath, NULL, 0);
        if (list_size > 0) {
            files_with_xattrs++;
            total_xattrs += list_size;  // 这里简化处理
            
            printf("文件 '%s' 有扩展属性\n", entry->d_name);
            
            // 获取实际属性数量
            char *buffer = malloc(list_size);
            if (buffer) {
                if (listxattr(filepath, buffer, list_size) != -1) {
                    int attr_count = 0;
                    char *current = buffer;
                    while (current < buffer + list_size) {
                        attr_count++;
                        current += strlen(current) + 1;
                    }
                    printf("  属性数量: %d\n", attr_count);
                    total_xattrs = attr_count;  // 更新为实际数量
                }
                free(buffer);
            }
        }
    }
    
    closedir(dir);
    
    printf("\n扫描结果:\n");
    printf("  包含扩展属性的文件数: %d\n", files_with_xattrs);
    printf("  扩展属性总数: %d\n", total_xattrs);
}

void interactive_xattr_browser() {
    char filename[256];
    int choice;
    
    while (1) {
        printf("\n=== 扩展属性浏览器 ===\n");
        printf("1. 查看文件扩展属性\n");
        printf("2. 扫描目录扩展属性\n");
        printf("3. 比较符号链接属性\n");
        printf("0. 退出\n");
        printf("请选择操作: ");
        
        if (scanf("%d", &choice) != 1) {
            printf("输入无效\n");
            while (getchar() != '\n');  // 清空输入缓冲区
            continue;
        }
        
        switch (choice) {
            case 1:
                printf("输入文件名: ");
                scanf("%255s", filename);
                print_xattr_details(filename);
                break;
                
            case 2:
                printf("输入目录名: ");
                scanf("%255s", filename);
                scan_directory_xattrs(filename);
                break;
                
            case 3: {
                printf("输入符号链接名: ");
                scanf("%255s", filename);
                
                printf("符号链接属性 (llistxattr):\n");
                ssize_t size = llistxattr(filename, NULL, 0);
                if (size > 0) {
                    char *buffer = malloc(size);
                    if (buffer) {
                        llistxattr(filename, buffer, size);
                        char *current = buffer;
                        while (current < buffer + size) {
                            printf("  %s\n", current);
                            current += strlen(current) + 1;
                        }
                        free(buffer);
                    }
                } else if (size == 0) {
                    printf("  没有扩展属性\n");
                } else {
                    printf("  获取失败: %s\n", strerror(errno));
                }
                
                printf("目标文件属性 (listxattr):\n");
                size = listxattr(filename, NULL, 0);
                if (size > 0) {
                    char *buffer = malloc(size);
                    if (buffer) {
                        listxattr(filename, buffer, size);
                        char *current = buffer;
                        while (current < buffer + size) {
                            printf("  %s\n", current);
                            current += strlen(current) + 1;
                        }
                        free(buffer);
                    }
                } else if (size == 0) {
                    printf("  没有扩展属性\n");
                } else {
                    printf("  获取失败: %s\n", strerror(errno));
                }
                break;
            }
            
            case 0:
                printf("退出扩展属性浏览器\n");
                return;
                
            default:
                printf("无效选择\n");
                break;
        }
    }
}

int main() {
    printf("=== 扩展属性管理工具 ===\n");
    
    // 检查系统是否支持扩展属性
    if (listxattr(".", NULL, 0) == -1 && errno == ENOTSUP) {
        printf("错误: 当前文件系统不支持扩展属性\n");
        return 1;
    }
    
    printf("✓ 系统支持扩展属性\n");
    
    // 显示系统信息
    printf("系统信息:\n");
    system("df -T . | tail -1");
    
    // 启动交互式浏览器
    char choice;
    printf("\n是否启动交互式扩展属性浏览器? (y/N): ");
    if (scanf(" %c", &choice) == 1 && (choice == 'y' || choice == 'Y')) {
        interactive_xattr_browser();
    }
    
    return 0;
}

9. 扩展属性命名空间说明链接到标题

// Linux 扩展属性支持的命名空间:

// 1. user.* - 用户命名空间
// 普通用户可读写自己文件的属性
// 示例: "user.my_attribute"

// 2. trusted.* - 受信任命名空间
// 只有特权进程可以访问
// 示例: "trusted.admin_note"

// 3. system.* - 系统命名空间
// 系统内部使用
// 示例: "system.posix_acl_access"

// 4. security.* - 安全命名空间
// 安全相关属性
// 示例: "security.selinux", "security.capability"

10. 实际应用场景链接到标题

场景1：备份工具元数据存储链接到标题

void store_backup_metadata(const char *filename, const char *backup_info) {
    // 存储备份时间戳
    char timestamp[32];
    time_t now = time(NULL);
    snprintf(timestamp, sizeof(timestamp), "%ld", (long)now);
    setxattr(filename, "user.backup_timestamp", timestamp, strlen(timestamp), 0);
    
    // 存储备份源信息
    setxattr(filename, "user.backup_source", backup_info, strlen(backup_info), 0);
}

场景2：访问控制列表链接到标题

void check_file_acl(const char *filename) {
    ssize_t size = listxattr(filename, NULL, 0);
    if (size > 0) {
        char *buffer = malloc(size);
        if (buffer) {
            listxattr(filename, buffer, size);
            char *current = buffer;
            while (current < buffer + size) {
                if (strncmp(current, "system.posix_acl_", 17) == 0) {
                    printf("文件具有 ACL 控制: %s\n", current);
                }
                current += strlen(current) + 1;
            }
            free(buffer);
        }
    }
}

场景3：安全标签验证链接到标题

int verify_security_context(const char *filename) {
    ssize_t size = listxattr(filename, NULL, 0);
    if (size > 0) {
        char *buffer = malloc(size);
        if (buffer) {
            listxattr(filename, buffer, size);
            char *current = buffer;
            int has_security_attrs = 0;
            while (current < buffer + size) {
                if (strncmp(current, "security.", 9) == 0) {
                    has_security_attrs = 1;
                    break;
                }
                current += strlen(current) + 1;
            }
            free(buffer);
            return has_security_attrs;
        }
    }
    return 0;
}

11. 注意事项链接到标题

使用 listxattr 和 llistxattr 时需要注意：

文件系统支持: 不是所有文件系统都支持扩展属性
权限要求: 不同命名空间需要不同的权限
缓冲区管理: 正确处理缓冲区大小和内存分配
符号链接处理: 理解 listxattr 和 llistxattr 的区别
字符编码: 属性名称和值可以是任意二进制数据
性能考虑: 频繁调用可能影响性能

12. 与相关函数的配合使用链接到标题

// 完整的扩展属性操作示例
void complete_xattr_operations(const char *filename) {
    // 1. 列出所有属性名称
    ssize_t list_size = listxattr(filename, NULL, 0);
    
    // 2. 获取特定属性值
    ssize_t value_size = getxattr(filename, "user.test", NULL, 0);
    
    // 3. 设置属性值
    setxattr(filename, "user.new_attr", "value", 5, 0);
    
    // 4. 删除属性
    removexattr(filename, "user.old_attr");
}

13. 系统配置检查链接到标题

# 检查文件系统对扩展属性的支持
mount | grep -E "(ext|btrfs|xfs)" | grep -v tmpfs

# 查看文件的扩展属性
getfattr -d filename

# 递归查看目录的扩展属性
getfattr -d -R directory/

# 检查特定文件系统的扩展属性支持
tune2fs -l /dev/sdX1 | grep "features"

总结链接到标题

listxattr 和 llistxattr 是操作文件扩展属性的重要函数：

关键特性:

灵活接口: 支持先查询大小再获取值的两阶段操作
命名空间支持: 支持多种属性命名空间
符号链接处理: 提供不同的符号链接处理方式
错误处理: 提供详细的错误信息

主要应用:

备份和归档工具的元数据存储
访问控制列表和安全标签管理
文件系统管理和监控工具
应用程序的自定义元数据存储

使用要点:

理解不同函数对符号链接的处理方式
正确管理缓冲区大小和内存分配
注意不同命名空间的权限要求
配合其他扩展属性函数使用效果更佳

正确使用这些函数可以充分发挥 Linux 文件系统扩展属性的功能，实现更丰富的文件元数据管理和安全控制。

96. listxattr - 列出文件的扩展属性名称 链接到标题

1. 函数介绍 链接到标题

2. 函数原型 链接到标题

97. llistxattr - 列出符号链接的扩展属性名称 链接到标题

1. 函数介绍 链接到标题

2. 函数原型 链接到标题

3. 功能对比 链接到标题

4. 参数说明 链接到标题

5. 返回值 链接到标题

6. 常见 errno 错误码 链接到标题

7. 相似函数，或关联函数 链接到标题

8. 示例代码 链接到标题

示例1：基本使用 - 获取扩展属性名称列表 链接到标题

示例2：符号链接扩展属性演示 链接到标题

示例3：错误处理和边界情况 链接到标题

示例4：扩展属性管理工具 链接到标题

9. 扩展属性命名空间说明 链接到标题

10. 实际应用场景 链接到标题

场景1：备份工具元数据存储 链接到标题

场景2：访问控制列表 链接到标题

场景3：安全标签验证 链接到标题

11. 注意事项 链接到标题

12. 与相关函数的配合使用 链接到标题

13. 系统配置检查 链接到标题

总结 链接到标题

96. listxattr - 列出文件的扩展属性名称链接到标题

1. 函数介绍链接到标题

2. 函数原型链接到标题

97. llistxattr - 列出符号链接的扩展属性名称链接到标题

1. 函数介绍链接到标题

2. 函数原型链接到标题

3. 功能对比链接到标题

4. 参数说明链接到标题

5. 返回值链接到标题

6. 常见 errno 错误码链接到标题

7. 相似函数，或关联函数链接到标题

8. 示例代码链接到标题

示例1：基本使用 - 获取扩展属性名称列表链接到标题

示例2：符号链接扩展属性演示链接到标题

示例3：错误处理和边界情况链接到标题

示例4：扩展属性管理工具链接到标题

9. 扩展属性命名空间说明链接到标题

10. 实际应用场景链接到标题

场景1：备份工具元数据存储链接到标题

场景2：访问控制列表链接到标题

场景3：安全标签验证链接到标题

11. 注意事项链接到标题

12. 与相关函数的配合使用链接到标题

13. 系统配置检查链接到标题

总结链接到标题