489 lines
14 KiB
C
489 lines
14 KiB
C
#include <c_File.h>
|
|
#ifdef _WIN32
|
|
#include <windows.h>
|
|
#include <io.h> // 提供 _get_osfhandle
|
|
#include <direct.h>
|
|
#include <dirent.h>
|
|
#define C_ACCESS(path) _access(path, 0)
|
|
#define C_MAKE_DIR(path) _mkdir(path) // Windows 下创建目录
|
|
#define sys_rmdir(path) _rmdir(path)
|
|
#define PATH_SEP '\\'
|
|
#else
|
|
#include <unistd.h> // 提供 fsync
|
|
#include <sys/stat.h>
|
|
#include <sys/types.h>
|
|
#define C_ACCESS(path) access(path, F_OK)
|
|
#define C_MAKE_DIR(path) mkdir(path, 0755)
|
|
#define sys_rmdir(path) rmdir(path)
|
|
#define PATH_SEP '/'
|
|
#endif
|
|
|
|
/* ------------------------------------------------------------------------------------------------------------------ */
|
|
/* */
|
|
|
|
|
|
#if defined(C_PLATFORM_IS_64BIT)
|
|
|
|
// 跨平台 64 位 fseek 封装
|
|
C_STATIC_FORCE_INLINE
|
|
int fn_fseek(FILE* fp, long long offset, int whence) {
|
|
#ifdef _WIN32
|
|
return _fseeki64(fp, (__int64)offset, whence);
|
|
#else
|
|
// 在定义了 _FILE_OFFSET_BITS=64 的情况下，fseeko 接收 64 位的 off_t
|
|
return fseeko(fp, (off_t)offset, whence);
|
|
#endif
|
|
}
|
|
|
|
// 跨平台 64 位 ftell 封装
|
|
C_STATIC_FORCE_INLINE
|
|
long long fn_tell(FILE* fp) {
|
|
#ifdef _WIN32
|
|
return (long long)_ftelli64(fp);
|
|
#else
|
|
return (long long)ftello(fp);
|
|
#endif
|
|
}
|
|
|
|
#elif defined(C_PLATFORM_IS_32BIT)
|
|
|
|
C_STATIC_FORCE_INLINE
|
|
int fn_fseek(FILE* fp, long long offset, int whence) {
|
|
return fseek(fp, (long)offset, whence);
|
|
}
|
|
|
|
C_STATIC_FORCE_INLINE
|
|
long long fn_tell(FILE* fp) {
|
|
return (long long)ftell(fp);
|
|
}
|
|
|
|
#endif
|
|
|
|
/* ------------------------------------------------------------------------------------------------------------------ */
|
|
/* */
|
|
|
|
|
|
c_err_t c_File_Open(c_File_t* file, const char* fileName, const char* mode) {
|
|
if (!file || !fileName || !mode) {
|
|
return C_ERR_FAIL;
|
|
}
|
|
|
|
file->fp = fopen(fileName, mode);
|
|
if (!file->fp) {
|
|
return C_ERR_FAIL;
|
|
}
|
|
|
|
return C_ERR_OK;
|
|
}
|
|
|
|
void c_File_Close(c_File_t* file) {
|
|
if (file && file->fp) {
|
|
fclose(file->fp);
|
|
file->fp = NULL;
|
|
}
|
|
}
|
|
|
|
c_err_t c_File_Read(c_File_t* file, void* buffer, c_size_t buffer_size, c_size_t *read_size) {
|
|
if (!file || !file->fp || !buffer || buffer_size == 0) {
|
|
if (read_size) *read_size = 0;
|
|
return C_ERR_FAIL;
|
|
}
|
|
|
|
// 从文件流中读取 1 字节 * buffer_size
|
|
size_t bytes_read = fread(buffer, 1, (size_t)buffer_size, file->fp);
|
|
|
|
if (read_size) {
|
|
*read_size = (c_size_t)bytes_read;
|
|
}
|
|
|
|
// 如果读取数量小于请求数量，需检查是出错还是到达文件末尾
|
|
if (bytes_read < (size_t)buffer_size) {
|
|
if (ferror(file->fp)) {
|
|
return C_ERR_FAIL; // 发生读取错误
|
|
}
|
|
}
|
|
|
|
return C_ERR_OK;
|
|
}
|
|
|
|
c_err_t c_File_Readline(c_File_t* file, void* buffer, c_size_t buffer_size, c_size_t *read_size) {
|
|
if (!file || !file->fp || !buffer || buffer_size == 0) {
|
|
if (read_size) *read_size = 0;
|
|
return C_ERR_FAIL;
|
|
}
|
|
|
|
// fgets 会自动在末尾加上 '\0'，并且最多读取 buffer_size - 1 个字符
|
|
char* result = fgets((char*)buffer, (int)buffer_size, file->fp);
|
|
|
|
if (!result) {
|
|
if (read_size) *read_size = 0;
|
|
return C_ERR_FAIL; // 读取失败或到达文件末尾
|
|
}
|
|
|
|
if (read_size) {
|
|
*read_size = (c_size_t)strlen((char*)buffer);
|
|
}
|
|
|
|
return C_ERR_OK;
|
|
}
|
|
|
|
c_err_t c_File_Write(c_File_t* file, void* buffer, c_size_t buffer_size, c_size_t *write_size) {
|
|
if (!file || !file->fp || !buffer || buffer_size == 0) {
|
|
if (write_size) *write_size = 0;
|
|
return C_ERR_FAIL;
|
|
}
|
|
|
|
size_t bytes_written = fwrite(buffer, 1, (size_t)buffer_size, file->fp);
|
|
|
|
if (write_size) {
|
|
*write_size = (c_size_t)bytes_written;
|
|
}
|
|
|
|
// 如果实际写入字节数不等于预期，说明写入失败（如磁盘满）
|
|
if (bytes_written < (size_t)buffer_size) {
|
|
return C_ERR_FAIL;
|
|
}
|
|
|
|
return C_ERR_OK;
|
|
}
|
|
|
|
c_err_t c_File_Seek(c_File_t* file, long long position) {
|
|
if (!file || !file->fp) {
|
|
return C_ERR_PARAM;
|
|
}
|
|
const int result = fseek(file->fp, (long)position, SEEK_SET);
|
|
return (result == 0) ? C_ERR_OK : C_ERR_FAIL;
|
|
}
|
|
|
|
long long c_File_Size(c_File_t* file) {
|
|
if (!file || !file->fp) {
|
|
return 0;
|
|
}
|
|
|
|
// 1. 保存当前文件指针的位置
|
|
long long current_pos = fn_tell(file->fp);
|
|
if (current_pos == -1LL) return 0;
|
|
|
|
// 2. 将文件指针移到末尾
|
|
if (fn_fseek(file->fp, 0, SEEK_END) != C_ERR_OK) return 0;
|
|
|
|
// 3. 获取末尾位置即为文件大小
|
|
long long size = fn_tell(file->fp);
|
|
|
|
// 4. 恢复原先的文件指针位置
|
|
fn_fseek(file->fp, current_pos, SEEK_SET);
|
|
|
|
return (long long)((size < 0) ? 0 : size);
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------------------------------------------------ */
|
|
/* */
|
|
|
|
c_err_t c_File_Flush(c_File_t* file) {
|
|
if (!file || !file->fp) {
|
|
return C_ERR_FAIL;
|
|
}
|
|
|
|
// Step 1: 先刷新 C 库自带的软件层缓冲区（将数据推入 OS 内核队列）
|
|
if (fflush(file->fp) != 0) {
|
|
return C_ERR_FAIL;
|
|
}
|
|
|
|
// Step 2: 获取底层文件描述符，强行驱动硬件刷盘
|
|
#ifdef _WIN32
|
|
// 从 C 语言的 FILE* 提取 Windows 系统的文件句柄 HANDLE
|
|
int fd = _fileno(file->fp);
|
|
if (fd < 0) return C_ERR_FAIL;
|
|
|
|
HANDLE hFile = (HANDLE)_get_osfhandle(fd);
|
|
if (hFile == INVALID_HANDLE_VALUE) return C_ERR_FAIL;
|
|
|
|
// 强行驱动机械硬盘/SSD硬件将内核缓存写入物理介质
|
|
if (!FlushFileBuffers(hFile)) {
|
|
return C_ERR_FAIL;
|
|
}
|
|
#else
|
|
// Linux / macOS 平台直接提取文件描述符
|
|
int fd = fileno(file->fp);
|
|
if (fd < 0) return C_ERR_FAIL;
|
|
|
|
// 触发 POSIX 的 fsync 系统调用，阻塞直到硬件写入完毕
|
|
if (fsync(fd) != 0) {
|
|
return C_ERR_FAIL;
|
|
}
|
|
#endif
|
|
|
|
return C_ERR_OK;
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------------------------------------------------ */
|
|
/* */
|
|
|
|
c_bool_t c_File_IsExist(const char* fileName) {
|
|
if (!fileName) {
|
|
return C_FALSE;
|
|
}
|
|
|
|
// 参数 0 代表 F_OK，即只检查文件是否存在
|
|
// C_ACCESS 返回 0 表示文件存在且可访问，返回 -1 表示不存在或无权限
|
|
if (C_ACCESS(fileName) == F_OK) {
|
|
return C_TRUE;
|
|
}
|
|
|
|
return C_FALSE;
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------------------------------------------------ */
|
|
/* */
|
|
|
|
c_err_t c_File_MkDirs(const char* path) {
|
|
if (path == NULL || strlen(path) == 0) {
|
|
return C_ERR_PARAM;
|
|
}
|
|
|
|
char temp_path[512];
|
|
snprintf(temp_path, sizeof(temp_path), "%s", path);
|
|
size_t len = strlen(temp_path);
|
|
|
|
// 统一将 Windows 的 '\\' 转换为 '/' 方便逐级切分
|
|
for (int i = 0; i < len; i++) {
|
|
if (temp_path[i] == '\\') {
|
|
temp_path[i] = '/';
|
|
}
|
|
}
|
|
|
|
// 确保路径以 '/' 结尾，方便循环逻辑处理
|
|
if (temp_path[len - 1] != '/') {
|
|
if (len + 1 < sizeof(temp_path)) {
|
|
temp_path[len] = '/';
|
|
temp_path[len + 1] = '\0';
|
|
len++;
|
|
} else {
|
|
return C_ERR_FAIL; // 路径超长
|
|
}
|
|
}
|
|
|
|
// 逐级探测并创建目录
|
|
for (int i = 0; i < len; i++) {
|
|
// 每当遇到路径分隔符 '/' 时，尝试截断并创建当前层级目录
|
|
if (temp_path[i] == '/' && i > 0) {
|
|
temp_path[i] = '\0'; // 临时截断字符串
|
|
|
|
// 检查当前级目录是否存在，不存在则创建
|
|
if (C_ACCESS(temp_path) != 0) {
|
|
if (C_MAKE_DIR(temp_path) != 0) {
|
|
return C_ERR_FAIL; // 创建失败
|
|
}
|
|
}
|
|
|
|
temp_path[i] = '/'; // 恢复分隔符
|
|
}
|
|
}
|
|
|
|
return C_SUCCESS;
|
|
}
|
|
|
|
c_err_t c_File_Rmdir(const char* path) {
|
|
if (!path || path[0] == '\0') {
|
|
return C_ERR_PARAM;
|
|
}
|
|
|
|
// 调用操作系统底层移除目录的 API
|
|
int result = sys_rmdir(path);
|
|
|
|
if (result == 0) {
|
|
return C_ERR_OK; // 删除成功
|
|
} else {
|
|
// 删除失败（可能是由于目录不存在、无权限、或者目录非空）
|
|
return C_ERR_FAIL;
|
|
}
|
|
}
|
|
|
|
c_err_t c_File_Rmdirs(const char* path) {
|
|
if (!path || path[0] == '\0') {
|
|
return C_ERR_PARAM;
|
|
}
|
|
|
|
c_err_t status = C_ERR_OK;
|
|
|
|
#if defined(_WIN32) || defined(_WIN64)
|
|
// ==========================================
|
|
// Windows 平台的递归删除实现
|
|
// ==========================================
|
|
char search_path[MAX_PATH];
|
|
// Windows 检索目录需要追加 "\\*"
|
|
snprintf(search_path, sizeof(search_path), "%s\\*", path);
|
|
|
|
WIN32_FIND_DATAA find_data;
|
|
HANDLE h_find = FindFirstFileA(search_path, &find_data);
|
|
|
|
if (h_find == INVALID_HANDLE_VALUE) {
|
|
// 如果目录根本不存在，或者无法打开，尝试直接当做文件 remove 移除（处理符号链接等边界）
|
|
return remove(path) == 0 ? C_ERR_OK : C_ERR_FAIL;
|
|
}
|
|
|
|
do {
|
|
// 排除 Windows 的特殊目录 "." 和 ".."
|
|
if (strcmp(find_data.cFileName, ".") == 0 || strcmp(find_data.cFileName, "..") == 0) {
|
|
continue;
|
|
}
|
|
|
|
// 拼接子项的完整路径
|
|
char sub_path[MAX_PATH];
|
|
snprintf(sub_path, sizeof(sub_path), "%s\\%s", path, find_data.cFileName);
|
|
|
|
if (find_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
|
|
// 如果子项是目录，递归调用
|
|
status = c_File_Rmdirs(sub_path);
|
|
} else {
|
|
// 如果子项是普通文件，取消只读属性（防止因只读导致删除失败），然后将其删除
|
|
SetFileAttributesA(sub_path, FILE_ATTRIBUTE_NORMAL);
|
|
status = (DeleteFileA(sub_path) != 0) ? C_ERR_OK : C_ERR_FAIL;
|
|
}
|
|
|
|
if (status != C_ERR_OK) {
|
|
break;
|
|
}
|
|
} while (FindNextFileA(h_find, &find_data));
|
|
|
|
FindClose(h_find);
|
|
|
|
#else
|
|
// ==========================================
|
|
// Linux / macOS (POSIX) 平台的递归删除实现
|
|
// ==========================================
|
|
DIR* dir = opendir(path);
|
|
if (!dir) {
|
|
// 无法打开作为目录处理，尝试按普通文件物理删除
|
|
return remove(path) == 0 ? C_ERR_OK : C_ERR_FAIL;
|
|
}
|
|
|
|
struct dirent* entry;
|
|
while ((entry = readdir(dir)) != NULL) {
|
|
// 排除 Linux 的特殊目录 "." 和 ".."
|
|
if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0) {
|
|
continue;
|
|
}
|
|
|
|
// 拼接子项的完整路径
|
|
char sub_path[1024];
|
|
snprintf(sub_path, sizeof(sub_path), "%s/%s", path, entry->d_name);
|
|
|
|
struct stat statbuf;
|
|
if (stat(sub_path, &statbuf) == 0) {
|
|
if (S_ISDIR(statbuf.st_mode)) {
|
|
// 如果子项是目录，递归调用
|
|
status = c_File_Rmdirs(sub_path);
|
|
} else {
|
|
// 如果子项是文件，执行普通删除
|
|
status = (remove(sub_path) == 0) ? C_ERR_OK : C_ERR_FAIL;
|
|
}
|
|
}
|
|
|
|
if (status != C_ERR_OK) {
|
|
break;
|
|
}
|
|
}
|
|
closedir(dir);
|
|
#endif
|
|
|
|
// ==========================================
|
|
// 公共收尾：清空了内部所有子项后，最后删除外层空壳目录
|
|
// ==========================================
|
|
if (status == C_ERR_OK) {
|
|
if (sys_rmdir(path) != 0) {
|
|
status = C_ERR_FAIL;
|
|
}
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
c_err_t c_File_Delete(const char* fileName) {
|
|
if (!fileName || fileName[0] == '\0') {
|
|
return C_ERR_PARAM;
|
|
}
|
|
|
|
// 标准 C 库的 remove 能够直接删除文件（在某些平台上也能删除空目录）
|
|
int result = remove(fileName);
|
|
|
|
if (result == 0) {
|
|
return C_ERR_OK; // 删除成功
|
|
} else {
|
|
// 删除失败（文件不存在、或无权限、或文件正被某些操作系统强锁占用）
|
|
return C_ERR_FAIL;
|
|
}
|
|
}
|
|
|
|
#define COPY_BUFFER_SIZE 4096
|
|
|
|
c_err_t c_File_Copy(const char* srcPath, const char* destPath) {
|
|
if (!srcPath || srcPath[0] == '\0' || !destPath || destPath[0] == '\0') {
|
|
return C_ERR_PARAM;
|
|
}
|
|
|
|
FILE* src = fopen(srcPath, "rb");
|
|
if (!src) return C_ERR_NOTFOUND;
|
|
|
|
FILE* dest = fopen(destPath, "wb");
|
|
if (!dest) {
|
|
fclose(src);
|
|
return C_ERR_FAIL;
|
|
}
|
|
|
|
char* buffer = (char*)malloc(COPY_BUFFER_SIZE);
|
|
if (!buffer) {
|
|
fclose(src);
|
|
fclose(dest);
|
|
return C_ERR_FAIL;
|
|
}
|
|
|
|
c_err_t status = C_ERR_OK;
|
|
size_t bytes_read;
|
|
|
|
// 循环读写块，避免一次性读入大文件撑爆堆内存
|
|
while ((bytes_read = fread(buffer, 1, COPY_BUFFER_SIZE, src)) > 0) {
|
|
size_t bytes_written = fwrite(buffer, 1, bytes_read, dest);
|
|
if (bytes_written < bytes_read) {
|
|
status = C_ERR_FAIL; // 磁盘空间不足或写入错误
|
|
break;
|
|
}
|
|
}
|
|
|
|
free(buffer);
|
|
fclose(src);
|
|
fclose(dest);
|
|
|
|
// 如果中途失败，清理掉生成的不完整目标文件
|
|
if (status != C_ERR_OK) {
|
|
remove(destPath);
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
c_err_t c_File_Move(const char* oldPath, const char* newPath) {
|
|
if (!oldPath || oldPath[0] == '\0' || !newPath || newPath[0] == '\0') {
|
|
return C_ERR_PARAM;
|
|
}
|
|
|
|
// 1. 尝试使用操作系统原生的轻量级重命名/移动
|
|
if (rename(oldPath, newPath) == 0) {
|
|
return C_ERR_OK;
|
|
}
|
|
|
|
// 2. 跨分区保底策略：如果因为跨文件系统挂载点导致 rename 失败，则执行 复制 + 删除
|
|
c_err_t copy_err = c_File_Copy(oldPath, newPath);
|
|
if (copy_err == C_ERR_OK) {
|
|
if (remove(oldPath) == 0) {
|
|
return C_ERR_OK;
|
|
} else {
|
|
// 如果删原文件失败，为了数据安全，把新拷过去的文件也撤销，避免数据状态不一致
|
|
remove(newPath);
|
|
return C_ERR_FAIL;
|
|
}
|
|
}
|
|
|
|
return C_ERR_FAIL;
|
|
}
|