将本地时间与Binance合约服务器时间同步

1. 安装libcurl开发库

sudo yum install libcurl-devel

2. 创建一个C语言程序，例如sync_time.c：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/time.h>
#include <curl/curl.h>

#define URL "https://www.binance.com/fapi/v1/time"

typedef struct {
    char *memory;
    size_t size;
} MemoryStruct;

static size_t WriteMemoryCallback(void *contents, size_t size, size_t nmemb, void *userp) {
    size_t realsize = size * nmemb;
    MemoryStruct *mem = (MemoryStruct *)userp;

    char *ptr = realloc(mem->memory, mem->size + realsize + 1);
    if (ptr == NULL) {
        printf("Not enough memory (realloc returned NULL)\n");
        return 0;
    }

    mem->memory = ptr;
    memcpy(&(mem->memory[mem->size]), contents, realsize);
    mem->size += realsize;
    mem->memory[mem->size] = 0;

    return realsize;
}

long long get_binance_time(long long *network_delay) {
    CURL *curl;
    CURLcode res;
    struct timeval start, end;

    MemoryStruct chunk;
    chunk.memory = malloc(1);
    chunk.size = 0;

    curl_global_init(CURL_GLOBAL_ALL);
    curl = curl_easy_init();
    if (curl) {
        gettimeofday(&start, NULL);

        curl_easy_setopt(curl, CURLOPT_URL, URL);
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&chunk);

        res = curl_easy_perform(curl);
        gettimeofday(&end, NULL);

        if (res != CURLE_OK) {
            fprintf(stderr, "curl_easy_perform() failed: %s\n", curl_easy_strerror(res));
        } else {
            // Calculate round-trip time in milliseconds
            long round_trip_time = (end.tv_sec - start.tv_sec) * 1000 + (end.tv_usec - start.tv_usec) / 1000;
            *network_delay = round_trip_time / 2;

            // Parse JSON response
            long long server_time = 0;
            sscanf(chunk.memory, "{\"serverTime\":%lld}", &server_time);

            free(chunk.memory);
            curl_easy_cleanup(curl);
            curl_global_cleanup();
            return server_time;
        }
    }
    free(chunk.memory);
    curl_global_cleanup();
    return -1;
}

void print_time(const char *label, struct timeval tv) {
    printf("%s: %ld.%06ld\n", label, tv.tv_sec, tv.tv_usec);
}

long long timeval_to_millis(struct timeval tv) {
    return tv.tv_sec * 1000LL + tv.tv_usec / 1000;
}

int main(void) {
    struct timeval local_before, local_after, sync_before, sync_after;
    long long network_delay = 0;
    long long binance_time = get_binance_time(&network_delay);

    if (binance_time != -1) {
        // Record local time before setting
        gettimeofday(&local_before, NULL);
        print_time("Local time before sync", local_before);

        printf("Binance time: %lld\n", binance_time);
        printf("Network delay: %lld ms\n", network_delay);

        // Adjust for network delay
        binance_time += network_delay;
        printf("Adjusted Binance time: %lld\n", binance_time);

        // Set system time
        struct timeval tv;
        tv.tv_sec = binance_time / 1000;
        tv.tv_usec = (binance_time % 1000) * 1000;
        settimeofday(&tv, NULL);

        // Record local time after setting
        gettimeofday(&local_after, NULL);
        print_time("Local time after sync", local_after);

        // Verification: similar to Python logic
        long long local_before_ms = timeval_to_millis(local_before);
        long long local_after_ms = timeval_to_millis(local_after);

        // Fetch server time again
        long long final_server_time = get_binance_time(&network_delay);

        // Record local time after fetching server time again
        gettimeofday(&sync_after, NULL);

        // Print the final verification times
        long long sync_after_ms = timeval_to_millis(sync_after);

        printf("\nVerification:\n");
        printf("local_time1: %lld\n", local_after_ms);
        printf("server_time: %lld\n", final_server_time);
        printf("local_time2: %lld\n", sync_after_ms);
        printf("双向延迟: %lld ms\n", sync_after_ms - local_after_ms);
        printf("单向延迟: %lld ms\n", (sync_after_ms - local_after_ms) / 2);
        printf("server_time - local_time1: %lld ms\n", final_server_time - local_after_ms);
        printf("local_time2 - server_time: %lld ms\n", sync_after_ms - final_server_time);
    } else {
        printf("Failed to get Binance time.\n");
    }
    return 0;
}

3. 编译并执行

gcc -o sync_time sync_time.c -lcurl
sudo ./sync_time

4. 可以用Python再次检查

import time
import requests

local_time1 = time.time() * 1000
server_time = requests.get("https://www.binance.com/fapi/v1/time").json()['serverTime']
local_time2 = time.time() * 1000
print(f"local_time1: {local_time1}\n"
      f"server_time: {server_time}\n"
      f"local_time2: {local_time2}\n"
      f"双向延迟: {local_time2 - local_time1}ms\n"
      f"单向延迟: {(local_time2 - local_time1) / 2}\n"
      f"server_time - local_time1: {server_time - local_time1}ms\n"
      f"local_time2 - server_time: {local_time2 - server_time}ms")