settimeofday系统调用及示例

settimeofday 函数详解

  1. 函数介绍

settimeofday 是Linux系统调用，settimeofday系统调用及示例，用于设置系统的日期和时间。它允许特权进程修改系统时钟，是系统管理和时间同步的重要工具。这个函数通常由系统管理员或时间同步服务（如NTP）使用。

  1. 函数原型
1
2
3
#include <sys/time.h>
int settimeofday(const struct timeval *tv, const struct timezone *tz);

  1. 功能

settimeofday 设置系统的当前日期和时间。它可以精确到微秒级别，用于系统时钟校准和时间同步。

  1. 参数

  • *const struct timeval tv: 指向时间值结构的指针（NULL表示不设置时间）

  • *const struct timezone tz: 指向时区结构的指针（通常为NULL，已被废弃）

  1. 返回值

  • 成功: 返回0

  • 失败: 返回-1，并设置errno

  1. 相似函数，或关联函数

  • gettimeofday: 获取当前时间

  • clock_settime: 更现代的时间设置函数

  • adjtime: 逐步调整系统时间

  • ntp_adjtime: NTP时间调整

  1. 示例代码

示例1：基础settimeofday使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
#include <sys/time.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <time.h>
#include <unistd.h>

/**
 * 显示当前系统时间
 */
void show_current_time() {
    struct timeval tv;
    struct tm *tm_info;
    char time_str&#91;64];
    
    if (gettimeofday(&tv, NULL) == 0) {
        tm_info = localtime(&tv.tv_sec);
        strftime(time_str, sizeof(time_str), "%Y-%m-%d %H:%M:%S", tm_info);
        printf("当前系统时间: %s.%06ld\n", time_str, tv.tv_usec);
    } else {
        printf("获取当前时间失败: %s\n", strerror(errno));
    }
}

/**
 * 演示基础settimeofday使用方法
 */
int demo_settimeofday_basic() {
    struct timeval current_time, new_time;
    struct timezone tz = {0, 0};
    time_t original_time;
    int result;
    
    printf("=== 基础settimeofday使用示例 ===\n");
    
    // 显示原始时间
    printf("1. 原始系统时间:\n");
    show_current_time();
    
    // 获取当前时间作为参考
    if (gettimeofday(&current_time, NULL) != 0) {
        printf("获取当前时间失败: %s\n", strerror(errno));
        return -1;
    }
    
    original_time = current_time.tv_sec;
    
    // 设置新的时间（当前时间+10秒）
    new_time.tv_sec = current_time.tv_sec + 10;
    new_time.tv_usec = current_time.tv_usec;
    
    printf("\n2. 尝试设置新时间:\n");
    printf("   目标时间: %ld.%06ld\n", new_time.tv_sec, new_time.tv_usec);
    
    // 尝试设置时间（需要root权限）
    result = settimeofday(&new_time, &tz);
    if (result == 0) {
        printf("   ✓ 成功设置系统时间\n");
        
        // 验证设置结果
        printf("   设置后的时间:\n");
        show_current_time();
        
        // 恢复原始时间
        printf("\n3. 恢复原始时间:\n");
        struct timeval restore_time;
        restore_time.tv_sec = original_time;
        restore_time.tv_usec = current_time.tv_usec;
        
        result = settimeofday(&restore_time, &tz);
        if (result == 0) {
            printf("   ✓ 成功恢复原始时间\n");
            show_current_time();
        } else {
            printf("   ✗ 恢复原始时间失败: %s\n", strerror(errno));
            if (errno == EPERM) {
                printf("   原因：需要root权限\n");
            }
        }
    } else {
        printf("   ✗ 设置系统时间失败: %s\n", strerror(errno));
        if (errno == EPERM) {
            printf("   原因：需要root权限来设置系统时间\n");
        } else if (errno == EINVAL) {
            printf("   原因：时间值无效\n");
        }
        
        printf("   注意：普通用户通常无法修改系统时间\n");
    }
    
    return 0;
}

int main() {
    return demo_settimeofday_basic();
}

示例2：时间同步模拟

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
#include <sys/time.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <time.h>
#include <unistd.h>

/**
 * 时间同步服务模拟
 */
typedef struct {
    time_t reference_time;
    int sync_interval;
    int max_adjustment;
} time_sync_service_t;

/**
 * 初始化时间同步服务
 */
int init_time_sync_service(time_sync_service_t *service) {
    struct timeval tv;
    
    if (gettimeofday(&tv, NULL) != 0) {
        printf("获取当前时间失败\n");
        return -1;
    }
    
    service->reference_time = tv.tv_sec;
    service->sync_interval = 60;  // 60秒同步间隔
    service->max_adjustment = 30; // 最大调整30秒
    
    printf("时间同步服务初始化完成\n");
    printf("  参考时间: %ld\n", service->reference_time);
    printf("  同步间隔: %d 秒\n", service->sync_interval);
    printf("  最大调整: %d 秒\n", service->max_adjustment);
    
    return 0;
}

/**
 * 计算时间差
 */
long calculate_time_difference(time_t current_time, time_t reference_time) {
    return current_time - reference_time;
}

/**
 * 模拟时间同步
 */
int simulate_time_synchronization(time_sync_service_t *service) {
    struct timeval current_time, adjusted_time;
    struct timezone tz = {0, 0};
    long time_diff;
    int result;
    
    printf("=== 时间同步模拟 ===\n");
    
    // 获取当前时间
    if (gettimeofday(&current_time, NULL) != 0) {
        printf("获取当前时间失败: %s\n", strerror(errno));
        return -1;
    }
    
    printf("当前系统时间: %ld.%06ld\n", current_time.tv_sec, current_time.tv_usec);
    
    // 计算时间差
    time_diff = calculate_time_difference(current_time.tv_sec, service->reference_time);
    printf("与参考时间差: %ld 秒\n", time_diff);
    
    // 检查是否需要调整
    if (labs(time_diff) > service->max_adjustment) {
        printf("时间偏差过大，需要调整\n");
        
        // 计算调整后的时间
        adjusted_time.tv_sec = service->reference_time;
        adjusted_time.tv_usec = current_time.tv_usec;
        
        printf("调整目标时间: %ld.%06ld\n", adjusted_time.tv_sec, adjusted_time.tv_usec);
        
        // 尝试设置时间
        result = settimeofday(&adjusted_time, &tz);
        if (result == 0) {
            printf("✓ 时间同步成功\n");
            show_current_time();
        } else {
            printf("✗ 时间同步失败: %s\n", strerror(errno));
            if (errno == EPERM) {
                printf("  需要root权限来调整系统时间\n");
            }
            return -1;
        }
    } else {
        printf("时间偏差在可接受范围内，无需调整\n");
    }
    
    return 0;
}

/**
 * 演示时间同步
 */
int demo_time_synchronization() {
    time_sync_service_t service = {0};
    
    printf("=== 时间同步演示 ===\n");
    
    // 检查权限
    uid_t uid = getuid();
    printf("当前用户ID: %d\n", uid);
    if (uid == 0) {
        printf("✓ 具有root权限，可以设置系统时间\n");
    } else {
        printf("✗ 没有root权限，时间设置操作将失败\n");
    }
    
    // 显示当前时间
    printf("\n1. 当前系统时间:\n");
    show_current_time();
    
    // 初始化时间同步服务
    if (init_time_sync_service(&service) != 0) {
        printf("初始化时间同步服务失败\n");
        return -1;
    }
    
    // 模拟时间同步
    printf("\n2. 模拟时间同步:\n");
    if (simulate_time_synchronization(&service) != 0) {
        printf("时间同步模拟失败\n");
    }
    
    // 显示同步后的时间
    printf("\n3. 同步后的时间:\n");
    show_current_time();
    
    return 0;
}

// 辅助函数声明
void show_current_time();

int main() {
    return demo_time_synchronization();
}

示例3：逐步时间调整

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
#include <sys/time.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <time.h>
#include <unistd.h>

/**
 * 逐步时间调整
 */
int gradual_time_adjustment(time_t target_time, int adjustment_steps) {
    struct timeval current_time, target_tv;
    struct timezone tz = {0, 0};
    time_t current_sec, step_size;
    int result;
    
    printf("=== 逐步时间调整 ===\n");
    printf("目标时间: %ld\n", target_time);
    printf("调整步数: %d\n", adjustment_steps);
    
    // 获取当前时间
    if (gettimeofday(&current_time, NULL) != 0) {
        printf("获取当前时间失败: %s\n", strerror(errno));
        return -1;
    }
    
    current_sec = current_time.tv_sec;
    printf("当前时间: %ld\n", current_sec);
    
    // 计算步长
    step_size = (target_time - current_sec) / adjustment_steps;
    if (step_size == 0) {
        step_size = (target_time > current_sec) ? 1 : -1;
    }
    
    printf("每步调整: %ld 秒\n", step_size);
    
    // 逐步调整时间
    for (int i = 0; i < adjustment_steps; i++) {
        time_t next_time = current_sec + (i + 1) * step_size;
        
        // 确保不超过目标时间
        if ((step_size > 0 && next_time > target_time) ||
            (step_size < 0 && next_time < target_time)) {
            next_time = target_time;
        }
        
        target_tv.tv_sec = next_time;
        target_tv.tv_usec = current_time.tv_usec;
        
        printf("第 %d 步: 设置时间 %ld\n", i + 1, next_time);
        
        result = settimeofday(&target_tv, &tz);
        if (result == 0) {
            printf("  ✓ 设置成功\n");
            show_current_time();
        } else {
            printf("  ✗ 设置失败: %s\n", strerror(errno));
            if (errno == EPERM) {
                printf("  需要root权限\n");
                break;
            }
        }
        
        // 短暂延迟
        sleep(1);
    }
    
    return 0;
}

/**
 * 时间跳跃检测
 */
int detect_time_jumps() {
    struct timeval prev_time, current_time;
    long time_diff;
    static int first_call = 1;
    
    if (gettimeofday(&current_time, NULL) != 0) {
        printf("获取时间失败: %s\n", strerror(errno));
        return -1;
    }
    
    if (first_call) {
        prev_time = current_time;
        first_call = 0;
        return 0;
    }
    
    time_diff = current_time.tv_sec - prev_time.tv_sec;
    
    if (labs(time_diff) > 5) {  // 超过5秒的时间跳跃
        printf("⚠ 检测到时间跳跃: %ld 秒\n", time_diff);
        printf("  之前时间: %ld.%06ld\n", prev_time.tv_sec, prev_time.tv_usec);
        printf("  当前时间: %ld.%06ld\n", current_time.tv_sec, current_time.tv_usec);
    }
    
    prev_time = current_time;
    return 0;
}

/**
 * 演示逐步时间调整
 */
int demo_gradual_adjustment() {
    struct timeval current_time;
    time_t target_time;
    uid_t uid = getuid();
    
    printf("=== 逐步时间调整演示 ===\n");
    
    // 检查权限
    printf("用户权限检查:\n");
    printf("  当前用户ID: %d\n", uid);
    if (uid == 0) {
        printf("  ✓ 具有root权限\n");
    } else {
        printf("  ✗ 没有root权限，时间设置将失败\n");
    }
    
    // 显示当前时间
    printf("\n当前系统时间:\n");
    show_current_time();
    
    // 获取当前时间
    if (gettimeofday(&current_time, NULL) != 0) {
        printf("获取当前时间失败\n");
        return -1;
    }
    
    // 设置目标时间为当前时间+30秒
    target_time = current_time.tv_sec + 30;
    printf("\n目标时间: %ld (当前时间+30秒)\n", target_time);
    
    // 演示逐步调整
    printf("\n执行逐步时间调整:\n");
    if (gradual_time_adjustment(target_time, 5) != 0) {
        printf("逐步时间调整失败\n");
    }
    
    // 演示时间跳跃检测
    printf("\n时间跳跃检测演示:\n");
    for (int i = 0; i < 10; i++) {
        detect_time_jumps();
        sleep(1);
    }
    
    return 0;
}

// 辅助函数声明
void show_current_time();

int main() {
    return demo_gradual_adjustment();
}

示例4：NTP时间同步模拟

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
#include <sys/time.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <time.h>
#include <unistd.h>
#include <math.h>

/**
 * NTP时间同步模拟
 */
typedef struct {
    time_t server_time;
    double offset;
    double delay;
    int stratum;
    char server_name&#91;64];
} ntp_server_info_t;

/**
 * 模拟NTP服务器响应
 */
int simulate_ntp_server_response(ntp_server_info_t *server) {
    struct timeval tv;
    
    // 模拟NTP服务器信息
    strcpy(server->server_name, "ntp.example.com");
    server->stratum = 2;  // 二级时间服务器
    server->delay = 0.05 + (rand() / (double)RAND_MAX) * 0.1;  // 50-150ms延迟
    
    // 获取当前时间作为服务器时间
    if (gettimeofday(&tv, NULL) != 0) {
        return -1;
    }
    
    server->server_time = tv.tv_sec;
    // 模拟时钟偏移（-1到1秒）
    server->offset = (rand() / (double)RAND_MAX) * 2.0 - 1.0;
    
    return 0;
}

/**
 * 计算时间同步质量
 */
double calculate_sync_quality(ntp_server_info_t *server) {
    // 简单的质量计算：基于stratum和offset
    double quality = 1.0;
    
    // stratum越高，质量越低
    quality -= (server->stratum - 1) * 0.1;
    
    // offset越大，质量越低
    quality -= fabs(server->offset) * 0.5;
    
    // delay越大，质量越低
    quality -= server->delay * 2.0;
    
    return (quality > 0) ? quality : 0.0;
}

/**
 * NTP时间同步
 */
int ntp_time_synchronization(ntp_server_info_t *server) {
    struct timeval current_time, sync_time;
    struct timezone tz = {0, 0};
    double quality;
    int result;
    
    printf("=== NTP时间同步 ===\n");
    printf("服务器: %s\n", server->server_name);
    printf("层级: %d\n", server->stratum);
    printf("服务器时间: %ld\n", server->server_time);
    printf("时钟偏移: %.3f 秒\n", server->offset);
    printf("网络延迟: %.3f 秒\n", server->delay);
    
    // 计算同步质量
    quality = calculate_sync_quality(server);
    printf("同步质量: %.2f\n", quality);
    
    if (quality < 0.5) {
        printf("同步质量过低，跳过同步\n");
        return -1;
    }
    
    // 获取当前时间
    if (gettimeofday(&current_time, NULL) != 0) {
        printf("获取当前时间失败: %s\n", strerror(errno));
        return -1;
    }
    
    printf("同步前时间: %ld.%06ld\n", current_time.tv_sec, current_time.tv_usec);
    
    // 计算同步后的时间
    sync_time.tv_sec = server->server_time;
    sync_time.tv_usec = current_time.tv_usec;
    
    // 应用偏移调整
    if (server->offset > 0) {
        sync_time.tv_sec += (time_t)server->offset;
        sync_time.tv_usec += (suseconds_t)((server->offset - (time_t)server->offset) * 1000000);
    } else {
        sync_time.tv_sec += (time_t)server->offset;
        sync_time.tv_usec += (suseconds_t)((server->offset - (time_t)server->offset) * 1000000);
    }
    
    // 确保微秒在有效范围内
    if (sync_time.tv_usec >= 1000000) {
        sync_time.tv_sec += 1;
        sync_time.tv_usec -= 1000000;
    } else if (sync_time.tv_usec < 0) {
        sync_time.tv_sec -= 1;
        sync_time.tv_usec += 1000000;
    }
    
    printf("同步目标时间: %ld.%06ld\n", sync_time.tv_sec, sync_time.tv_usec);
    
    // 执行时间同步
    result = settimeofday(&sync_time, &tz);
    if (result == 0) {
        printf("✓ NTP时间同步成功\n");
        show_current_time();
    } else {
        printf("✗ NTP时间同步失败: %s\n", strerror(errno));
        if (errno == EPERM) {
            printf("  需要root权限来设置系统时间\n");
        }
        return -1;
    }
    
    return 0;
}

/**
 * 演示NTP时间同步
 */
int demo_ntp_synchronization() {
    ntp_server_info_t servers&#91;3];
    double best_quality = 0.0;
    int best_server = -1;
    
    printf("=== NTP时间同步演示 ===\n");
    
    // 检查权限
    uid_t uid = getuid();
    printf("权限检查: ");
    if (uid == 0) {
        printf("✓ 具有root权限\n");
    } else {
        printf("✗ 没有root权限，时间设置将失败\n");
    }
    
    // 显示当前时间
    printf("\n当前系统时间:\n");
    show_current_time();
    
    // 模拟多个NTP服务器
    printf("\n查询NTP服务器:\n");
    srand(time(NULL));
    
    for (int i = 0; i < 3; i++) {
        if (simulate_ntp_server_response(&servers&#91;i]) == 0) {
            double quality = calculate_sync_quality(&servers&#91;i]);
            printf("服务器 %d: %s (质量: %.2f)\n", 
                   i + 1, servers&#91;i].server_name, quality);
            
            if (quality > best_quality) {
                best_quality = quality;
                best_server = i;
            }
        }
    }
    
    // 选择最佳服务器进行同步
    if (best_server >= 0) {
        printf("\n选择最佳服务器进行同步:\n");
        printf("  服务器: %s\n", servers&#91;best_server].server_name);
        printf("  质量: %.2f\n", best_quality);
        
        if (ntp_time_synchronization(&servers&#91;best_server]) != 0) {
            printf("NTP时间同步失败\n");
        }
    } else {
        printf("\n没有找到合适的NTP服务器\n");
    }
    
    // 显示同步后的时间
    printf("\n同步后的时间:\n");
    show_current_time();
    
    return 0;
}

// 辅助函数声明
void show_current_time();

int main() {
    return demo_ntp_synchronization();
}

示例5：时间管理工具

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
#include <sys/time.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <time.h>
#include <unistd.h>
#include <getopt.h>

/**
 * 时间管理工具配置
 */
typedef struct {
    int set_time;
    time_t target_time;
    int show_time;
    int sync_time;
    char time_string&#91;64];
    int verbose;
} time_tool_config_t;

/**
 * 显示帮助信息
 */
void show_help(const char *program_name) {
    printf("用法: %s &#91;选项]\n", program_name);
    printf("\n选项:\n");
    printf("  -s, --set TIME     设置系统时间 (格式: YYYY-MM-DD HH:MM:SS)\n");
    printf("  -g, --get          显示当前系统时间\n");
    printf("  -S, --sync         同步时间\n");
    printf("  -v, --verbose      详细输出\n");
    printf("  -h, --help         显示此帮助信息\n");
    printf("\n示例:\n");
    printf("  %s -g              # 显示当前时间\n", program_name);
    printf("  %s -s \"2023-12-25 10:30:00\"  # 设置时间\n", program_name);
    printf("  %s -v -g           # 详细显示当前时间\n", program_name);
}

/**
 * 解析时间字符串
 */
int parse_time_string(const char *time_str, time_t *result) {
    struct tm tm_time = {0};
    char *endptr;
    
    // 尝试解析 ISO 格式时间: YYYY-MM-DD HH:MM:SS
    if (strptime(time_str, "%Y-%m-%d %H:%M:%S", &tm_time) != NULL) {
        *result = mktime(&tm_time);
        if (*result == -1) {
            printf("时间转换失败\n");
            return -1;
        }
        return 0;
    }
    
    // 尝试解析 Unix 时间戳
    *result = strtol(time_str, &endptr, 10);
    if (*endptr == '\0' && *result > 0) {
        return 0;
    }
    
    printf("无法解析时间字符串: %s\n", time_str);
    printf("支持的格式:\n");
    printf("  YYYY-MM-DD HH:MM:SS\n");
    printf("  Unix时间戳\n");
    return -1;
}

/**
 * 详细显示时间信息
 */
void show_detailed_time() {
    struct timeval tv;
    struct tm *tm_info;
    char time_str&#91;128];
    
    if (gettimeofday(&tv, NULL) == 0) {
        // 显示多种时间格式
        tm_info = localtime(&tv.tv_sec);
        
        // 标准格式
        strftime(time_str, sizeof(time_str), "%Y-%m-%d %H:%M:%S", tm_info);
        printf("标准时间: %s.%06ld\n", time_str, tv.tv_usec);
        
        // Unix时间戳
        printf("Unix时间戳: %ld.%06ld\n", tv.tv_sec, tv.tv_usec);
        
        // UTC时间
        tm_info = gmtime(&tv.tv_sec);
        strftime(time_str, sizeof(time_str), "%Y-%m-%d %H:%M:%S UTC", tm_info);
        printf("UTC时间: %s\n", time_str);
        
        // 星期和年份信息
        strftime(time_str, sizeof(time_str), "%A, %B %d, %Y", localtime(&tv.tv_sec));
        printf("详细日期: %s\n", time_str);
        
    } else {
        printf("获取时间失败: %s\n", strerror(errno));
    }
}

/**
 * 设置系统时间
 */
int set_system_time(time_t target_time) {
    struct timeval tv;
    struct timezone tz = {0, 0};
    int result;
    
    printf("设置系统时间为: %ld\n", target_time);
    
    tv.tv_sec = target_time;
    tv.tv_usec = 0;
    
    result = settimeofday(&tv, &tz);
    if (result == 0) {
        printf("✓ 系统时间设置成功\n");
        show_current_time();
        return 0;
    } else {
        printf("✗ 系统时间设置失败: %s\n", strerror(errno));
        if (errno == EPERM) {
            printf("  需要root权限来设置系统时间\n");
        }
        return -1;
    }
}

/**
 * 演示时间管理工具
 */
int demo_time_management_tool() {
    time_tool_config_t config = {0};
    uid_t uid = getuid();
    
    printf("=== 时间管理工具演示 ===\n");
    
    // 显示工具信息
    printf("工具功能:\n");
    printf("  1. 显示系统时间\n");
    printf("  2. 设置系统时间\n");
    printf("  3. 时间同步\n");
    printf("  4. 详细时间信息\n");
    
    // 权限检查
    printf("\n权限检查:\n");
    printf("  当前用户ID: %d\n", uid);
    if (uid == 0) {
        printf("  ✓ 具有root权限，可以设置系统时间\n");
    } else {
        printf("  ✗ 没有root权限，时间设置功能将受限\n");
    }
    
    // 演示显示时间功能
    printf("\n1. 显示当前时间:\n");
    show_current_time();
    
    printf("\n2. 详细时间信息:\n");
    show_detailed_time();
    
    // 演示时间设置功能
    printf("\n3. 时间设置功能演示:\n");
    
    // 获取当前时间
    struct timeval current_time;
    if (gettimeofday(&current_time, NULL) == 0) {
        time_t future_time = current_time.tv_sec + 60;  // 1分钟后
        
        printf("  尝试设置时间为1分钟后: %ld\n", future_time);
        
        if (uid == 0) {
            // 有权限时尝试设置
            if (set_system_time(future_time) == 0) {
                printf("  ✓ 时间设置成功\n");
                
                // 恢复原始时间
                printf("  恢复原始时间: %ld\n", current_time.tv_sec);
                set_system_time(current_time.tv_sec);
            }
        } else {
            // 无权限时模拟设置
            struct timeval future_tv;
            future_tv.tv_sec = future_time;
            future_tv.tv_usec = current_time.tv_usec;
            
            int result = settimeofday(&future_tv, NULL);
            if (result != 0) {
                printf("  ✗ 时间设置失败 (预期): %s\n", strerror(errno));
                printf("  需要root权限才能设置系统时间\n");
            }
        }
    }
    
    // 演示时间格式解析
    printf("\n4. 时间格式解析演示:\n");
    const char *time_formats&#91;] = {
        "2023-12-25 10:30:00",
        "1703498200",  // Unix时间戳
        NULL
    };
    
    for (int i = 0; time_formats&#91;i]; i++) {
        time_t parsed_time;
        printf("  解析时间字符串: %s\n", time_formats&#91;i]);
        if (parse_time_string(time_formats&#91;i], &parsed_time) == 0) {
            printf("  ✓ 解析成功: %ld\n", parsed_time);
        } else {
            printf("  ✗ 解析失败\n");
        }
    }
    
    // 显示工具使用建议
    printf("\n=== 工具使用建议 ===\n");
    printf("1. 时间设置需要root权限\n");
    printf("2. 建议使用NTP服务进行时间同步\n");
    printf("3. 避免频繁手动调整系统时间\n");
    printf("4. 记录时间变更操作日志\n");
    printf("5. 使用逐步调整避免时间跳跃\n");
    
    return 0;
}

// 辅助函数声明
void show_current_time();

int main() {
    return demo_time_management_tool();
}

settimeofday 使用注意事项

系统要求：

内核版本: 支持settimeofday的Linux内核

权限要求: 需要CAP_SYS_TIME能力或root权限

架构支持: 支持所有主流架构

参数限制：

时间有效性: tv参数必须指向有效的timeval结构

时区参数: tz参数通常应为NULL（已被废弃）

时间范围: 时间值应在有效范围内

错误处理：

EPERM: 权限不足（需要CAP_SYS_TIME或root权限）

EINVAL: 时间值无效

EFAULT: 指针参数指向无效内存

安全考虑：

权限提升: 不当使用可能导致安全风险

系统稳定性: 频繁的时间调整可能影响系统稳定性

应用程序影响: 时间跳跃可能影响依赖时间的应用程序

最佳实践：

权限检查: 执行前检查是否具有足够权限

时间验证: 验证时间值的有效性和合理性

错误处理: 妥善处理各种错误情况

日志记录: 记录时间变更操作

逐步调整: 避免大的时间跳跃，使用逐步调整

时间结构体说明

struct timeval：

1
2
3
4
5
struct timeval {
    time_t tv_sec;      // 秒数
    suseconds_t tv_usec; // 微秒数
};

struct timezone（已废弃）：

1
2
3
4
5
struct timezone {
    int tz_minuteswest; // 西偏分钟数
    int tz_dsttime;     // 夏令时标志
};

相关函数对比

1. settimeofday vs clock_settime：

1
2
3
4
5
6
// settimeofday（传统接口）
settimeofday(&tv, NULL);

// clock_settime（现代接口）
clock_settime(CLOCK_REALTIME, &timespec);

2. settimeofday vs adjtime：

1
2
3
4
5
6
// settimeofday：直接设置时间
settimeofday(&tv, NULL);

// adjtime：逐步调整时间
adjtime(&delta, NULL);

常见使用场景

1. 系统管理：

1
2
3
// 系统启动时设置初始时间
settimeofday(&initial_time, NULL);

2. NTP客户端：

1
2
3
// 时间同步服务设置系统时间
settimeofday(&ntp_time, NULL);

3. 测试环境：

1
2
3
// 测试时模拟特定时间点
settimeofday(&test_time, NULL);

时间同步策略

1. 突然跳跃 vs 逐步调整：

  • 突然跳跃: 使用settimeofday直接设置

  • 逐步调整: 使用adjtime逐步调整

2. 同步频率：

  • 高精度: 每分钟同步

  • 普通: 每小时同步

  • 低精度: 每天同步

总结

settimeofday 是Linux系统中重要的时间管理函数，提供了：

精确时间控制: 可以精确到微秒级别设置系统时间

灵活接口: 支持多种时间格式和设置方式

权限管理: 通过权限控制保证系统安全

标准兼容: 符合POSIX标准

通过合理使用 settimeofday，可以实现精确的时间管理和同步。在实际应用中，需要注意权限要求、错误处理和系统稳定性等关键问题。建议在生产环境中使用专业的NTP服务进行时间同步，避免手动频繁调整系统时间。

https://www.calcguide.tech/2025/08/26/linux开源软件路线图/

相关阅读

settimeofday系统调用及示例
https://blog.calcguide.tech/2025-08-11-settimeofday系统调用及示例/
作者
CalcGuide
发布于
2025年8月11日
许可协议