我正在尝试运行以下代码（一个简单的备份程序），但由于某种原因，无法解析字段tv_sec。 我尝试了所有想到的东西 - 但没有帮助。 我想强调一下，我已阅读本网站中的其他相关问题，并尝试添加以下内容：
#include <sys/time.h>
但是 - 再次 - 它没有用。
你能帮帮我吗？谢谢大家！
我决定将整个程序附加到任何cas中 - 以便在需要时可以查看整个图片。 代码（有问题的行在注释//＆lt;＆gt; //下）：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <utime.h>
#include <dirent.h>
#include <libgen.h>
#define MIN(X,Y) ((X) < (Y) ? (X) : (Y))
// The header of each backed-up file
typedef struct {
char name[100];
char mode[8];
char uid[8];
char gid[8];
char size[12];
char mtime[12];
char typeflag;
} bkp_header;
// Function declarations
int backup(char *src, char *dest);
int restore(char *src);
int backup_abstract(char *src, int out_file);
int backup_file(char *name, struct stat buf, int out_file);
int backup_dir(char *name, struct stat buf, int out_file);
int backup_symlink(char *name, struct stat buf, int out_file);
int restore_file(bkp_header *file_header, int bkp_file);
int restore_dir(bkp_header *file_header, int bkp_file);
int restore_symlink(bkp_header *file_header, int bkp_file);
int restore_metadata(bkp_header *file_header);
bkp_header* get_file_header(char *name, struct stat buf, char type);
int write_header_to_file(char *name, struct stat buf, int out_file, char type);
char* backup_dir_name;
// Main
int main(int argc, char *argv[]) {
int result = 1;
if (argc < 3) {
fprintf(stderr, "Invalid parameters\n");
}
else {
// Backup
if (strncmp(argv[1], "-c", 2) == 0) {
if (argc < 4) {
fprintf(stderr, "Please insert the path you want to backup\n");
}
else {
result = backup(argv[3], argv[2]);
}
}
// Restore
else if (strncmp(argv[1], "-x", 2) == 0) {
result = restore(argv[2]);
}
else {
fprintf(stderr, "Invalid operation\n");
}
}
exit(result);
}
// Takes a 'src' path and runs a backup to the 'dest' path
int backup(char *src, char *dest) {
// Create the backup file
int out_file = open(dest, O_TRUNC | O_CREAT | O_WRONLY);
if (out_file < 0) {
fprintf(stdout, "Failed opening file for writing.");
return -1;
}
// Get the root backup directory
char *src_dup = strdup(src);
backup_dir_name = dirname(src_dup);
// Run the backup based on the type
int result = backup_abstract(src, out_file);
close(out_file);
return result;
}
// Backup something - a file, a folder or a symbolic link
int backup_abstract(char *src, int out_file) {
// Get the 'src' lstat
struct stat buf;
if (lstat(src, &buf) < 0) {
fprintf(stderr, "lstat error");
return -1;
}
if (S_ISDIR(buf.st_mode)) {
return backup_dir(src, buf, out_file);
}
else if (S_ISREG(buf.st_mode)) {
return backup_file(src, buf, out_file);
}
#ifdef S_ISLNK
else if (S_ISLNK(buf.st_mode)) {
return backup_symlink(src, buf, out_file);
}
#endif
else {
fprintf(stderr, "Can only backup a regular file, a directory, or a symlink\n");
}
return -1;
}
// Backup a single file
int backup_file(char *name, struct stat buf, int out_file) {
if (write_header_to_file(name, buf, out_file, 'r') < 0) {
return -1;
}
// Copy the file right after the header in 8K chunks
int in_file = open(name, O_RDONLY);
if (in_file < 0) {
fprintf(stdout, "Failed opening file for reading.");
return -1;
}
char read_buf[8192];
while (1) {
ssize_t result = read(in_file, read_buf, sizeof(read_buf));
if (result < 0) {
fprintf(stdout, "Failed reading from file.");
return -1;
}
if (result == 0) {
break; /* EOF */
}
if (write(out_file, read_buf, (int)result) != (int)result) {
fprintf(stdout, "Failed writing to file.");
return -1;
}
}
close(in_file);
return 0;
}
// Backup a directory
int backup_dir(char *name, struct stat buf, int out_file) {
if (write_header_to_file(name, buf, out_file, 'd') < 0) {
return -1;
}
// Backup the contents of this directory
DIR *dir;
struct dirent *ent;
if ((dir = opendir(name)) == NULL) {
fprintf(stdout, "Failed opening directory for reading.");
return -1;
}
while ((ent = readdir(dir)) != NULL) {
if (strcmp(ent->d_name, ".") && strcmp(ent->d_name, "..")) {
char full_path[100];
strcpy(full_path, name);
strcat(full_path, "/");
strcat(full_path, ent->d_name);
if (backup_abstract(full_path, out_file) != 0) {
return -1;
}
}
}
closedir(dir);
return 0;
}
// Backup a symbolic link
int backup_symlink(char *name, struct stat buf, int out_file) {
if (write_header_to_file(name, buf, out_file, 'l') < 0) {
return -1;
}
char *link_target = malloc(buf.st_size + 1);
if (link_target == NULL) {
fprintf(stdout, "Failed allocating memory.");
return -1;
}
ssize_t link = readlink(name, link_target, buf.st_size + 1);
if (link < 0) {
fprintf(stderr, "lstat error");
return -1;
}
link_target[buf.st_size] = '\0';
if (write(out_file, link_target, buf.st_size) != buf.st_size) {
fprintf(stdout, "Failed writing to file.");
return -1;
}
free(link_target);
return 0;
}
// Get the backup header for a file
bkp_header* get_file_header(char *name, struct stat buf, char type) {
bkp_header *file_header = (bkp_header*)malloc(sizeof(bkp_header));
int abs_path_start = strncmp(name, backup_dir_name, strlen(backup_dir_name));
if (abs_path_start != 0) {
fprintf(stdout, "Warning: Failed converting backup path to relative.");
}
else {
name = &name[strlen(backup_dir_name)+1];
}
sprintf(file_header->name, name);
sprintf(file_header->mode, "%d", buf.st_mode);
sprintf(file_header->uid, "%d", buf.st_uid);
sprintf(file_header->gid, "%d", buf.st_gid);
sprintf(file_header->size, "%d", (int)buf.st_size);
//<<PROBLEM!!!>>//
sprintf(file_header->mtime, "%d", (int)buf.st_mtim.tv_sec);
file_header->typeflag = type;
return file_header;
}
// Create and write the header to the output file
int write_header_to_file(char *name, struct stat buf, int out_file, char type) {
bkp_header *file_header = get_file_header(name, buf, type);
if (write(out_file, file_header, sizeof(bkp_header)) != sizeof(bkp_header)) {
fprintf(stdout, "Failed writing to file.");
return -1;
}
return 0;
}
// Takes a 'src' backup file path and extracts it to the current working dir
int restore(char *src) {
// Read the backup file
int bkp_file = open(src, O_RDONLY);
if (bkp_file < 0) {
fprintf(stdout, "Failed opening backup file for reading.");
return -1;
}
while (1) {
// Read the header
char header_buf[sizeof(bkp_header)];
ssize_t h_result = read(bkp_file, header_buf, sizeof(header_buf));
if (h_result < 0) {
fprintf(stdout, "Failed reading from backup file.");
return -1;
}
if (h_result == 0) {
break; /* EOF */
}
bkp_header *file_header = header_buf;
// Restore the file/dir/symbolic-link
if (file_header->typeflag == 'r') {
if (restore_file(file_header, bkp_file) < 0) {
return -1;
}
}
else if (file_header->typeflag == 'd') {
if (restore_dir(file_header, bkp_file) < 0) {
return -1;
}
}
else if (file_header->typeflag == 'l') {
if (restore_symlink(file_header, bkp_file) < 0) {
return -1;
}
}
else {
fprintf(stdout, "Failed restoring, unknown file type found.");
return -1;
}
}
close(bkp_file);
return 0;
}
// Restore a single file based on the header and the raw bkp_file
int restore_file(bkp_header *file_header, int bkp_file) {
// Make sure the output file does not exist
int out_file;
out_file = open(file_header->name, O_RDONLY);
if (out_file != -1) {
close(out_file);
fprintf(stdout, "Failed restoring, file %s already exists.", file_header->name);
return -1;
}
// Create and open it for writing
out_file = open(file_header->name, O_WRONLY | O_CREAT);
if (out_file < 0) {
fprintf(stdout, "Failed opening backed-up file path for writing.");
return -1;
}
// Restore the file's meta data
if (restore_metadata(file_header) != 0) {
fprintf(stdout, "Failed restoring backed-up file meta data.");
return -1;
}
// Read the content of the file in 8K chunks, and write them to disk
int file_size = atoi(file_header->size);
while (file_size) {
// Read a chunk from the backup file
char file_buf[8192];
ssize_t f_result = read(bkp_file, file_buf, MIN(sizeof(file_buf), file_size));
if (f_result < 0) {
fprintf(stdout, "Failed reading from backup file.");
return -1;
}
if (f_result == 0) {
break; /* EOF */
}
// Write this chunk to the disc
if (write(out_file, file_buf, (int)f_result) != (int)f_result) {
fprintf(stdout, "Failed writing file to disc.");
return -1;
}
file_size -= f_result;
}
close(out_file);
return 0;
}
// Restore a directory based on the header and the raw bkp_file
int restore_dir(bkp_header *file_header, int bkp_file) {
// Create this folder on the disc
if (mkdir(file_header->name, atoi(file_header->mode)) != 0) {
fprintf(stdout, "Failed creating directory.");
return -1;
}
// Restore the directory's meta data
if (restore_metadata(file_header) != 0) {
fprintf(stdout, "Failed restoring backed-up directory's meta data.");
return -1;
}
return 0;
}
// Restore a symbolic link (not the target file) based on the header and the raw bkp_file
int restore_symlink(bkp_header *file_header, int bkp_file) {
// Make sure the output file does not exist
int out_file;
out_file = open(file_header->name, O_RDONLY);
if (out_file != -1) {
close(out_file);
fprintf(stdout, "Failed restoring, symlink %s already exists.", file_header->name);
return -1;
}
int path_size = atoi(file_header->size);
char *file_buf = malloc(sizeof(char)*path_size);
if (file_buf == NULL) {
fprintf(stdout, "Failed allocating memory.");
return -1;
}
// Read the content of the file, get the link target
ssize_t f_result = read(bkp_file, file_buf, path_size);
if (f_result < 0) {
fprintf(stdout, "Failed reading from backup file.");
return -1;
}
// Create this symbolic link on the disc
if (symlink(file_buf, file_header->name) != 0) {
fprintf(stdout, "Failed creating symlink.");
return -1;
}
// Restore the link's meta data
if (restore_metadata(file_header) != 0) {
fprintf(stdout, "Failed restoring backed-up link meta data.");
return -1;
}
return 0;
}
// Set the original UID, GID, permissions and modification time
int restore_metadata(bkp_header *file_header) {
if (lchown(file_header->name, atoi(file_header->uid), atoi(file_header->gid)) != 0) {
fprintf(stdout, "chown error");
return -1;
}
if (file_header->typeflag != 'l') {
// No lchmod in my glibc, not restoring mode for symlinks
if (chmod(file_header->name, atoi(file_header->mode)) != 0) {
fprintf(stdout, "chmod error");
return -1;
}
struct utimbuf ubuf;
ubuf.modtime = atoi(file_header->mtime);
if (utime(file_header->name, &ubuf) != 0) {
fprintf(stdout, "utime error");
return -1;
}
}
return 0;
}
答案 0 :(得分：1)
buf具有struct stat类型，其中存在st_mtime类型time_t字段。 time_t通常被定义为算术类型而不是结构化类型，它没有字段。