barentp 1.3.0

An NTP client library for use with and without the standard library.
Documentation 
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

#[test]
#[ignore]
pub fn compare_to_system_time() {
    let ntp_server =
        std::env::var("NTP_TEST_SERVER").unwrap_or_else(|_| "pool.ntp.org".to_string());
    println!("Using NTP server: {}", ntp_server);

    // Lookup the IP address of the NTP server using dns_lookup:
    let ips = dns_lookup::lookup_host(&ntp_server).expect("failed to lookup host");
    assert!(!ips.is_empty(), "no IP addresses found for {}", ntp_server);
    let ip = ips[0];
    println!("Using NTP server IP address: {}", ip);

    let addr = std::net::SocketAddr::new(ip, 123);
    println!("Using NTP server socket address: {}", addr);

    // Create a UDP socket, bind it to an available IP and port, then connect it to the NTP server:
    let socket = std::net::UdpSocket::bind("0.0.0.0:0").expect("could not found to UDP socket");

    socket
        .set_read_timeout(Some(std::time::Duration::from_secs(5)))
        .expect("failed to set socket read timeout");

    socket
        .set_write_timeout(Some(std::time::Duration::from_secs(5)))
        .expect("failed to set socket write timeout");

    socket
        .connect(addr)
        .expect("failed to connect UDP socket to NTP server");

    // Get a timestamp from the NTP server:
    println!("Fetching timestamp from NTP server...");
    let timestamp = barentp::sntp_get_transmit_timestamp(&socket).expect("failed to get timestamp");

    let datetime_ntp = chrono::DateTime::<chrono::Utc>::from(timestamp);
    let datetime_sys = chrono::Utc::now();

    println!("NTP timestamp: {}", datetime_ntp);
    println!("System timestamp: {}", datetime_sys);

    let diff_time_delta = (datetime_ntp - datetime_sys).abs();
    let diff_duration = diff_time_delta
        .to_std()
        .expect("failed to convert to std duration");
    println!("Difference: {diff_duration:?}");

    assert!(
        diff_duration < std::time::Duration::from_secs(5),
        "difference between NTP and system time is too large"
    );
}

#[test]
fn test_first_timestamp_msb_set_micros() {
    let timestamp = barentp::Timestamp::new(0x80000000, 0);
    let actual_utc = timestamp.utc_micros();

    // First timestamp with MSB set:
    //     Saturday, January 20, 1968 | 03:14:08 AM UTC
    let expected = chrono::NaiveDateTime::new(
        chrono::NaiveDate::from_ymd_opt(1968, 1, 20).unwrap(),
        chrono::NaiveTime::from_hms_opt(3, 14, 8).unwrap(),
    );
    let expected_utc = expected.and_utc().timestamp_micros();

    assert_eq!(actual_utc, expected_utc);
}

#[test]
fn test_first_timestamp_msb_clear_micros() {
    let timestamp = barentp::Timestamp::new(0, 0);
    let actual_utc = timestamp.utc_micros();

    // First timestamp with MSB clear:
    //     Thursday, February 07, 2036 | 06:28:16 AM UTC
    let expected = chrono::NaiveDateTime::new(
        chrono::NaiveDate::from_ymd_opt(2036, 2, 7).unwrap(),
        chrono::NaiveTime::from_hms_opt(6, 28, 16).unwrap(),
    );
    let expected_utc = expected.and_utc().timestamp_micros();

    assert_eq!(actual_utc, expected_utc);
}

#[test]
fn test_first_timestamp_msb_set_millis() {
    let timestamp = barentp::Timestamp::new(0x80000000, 0);
    let actual_utc = timestamp.utc_millis();

    // First timestamp with MSB set:
    //     Saturday, January 20, 1968 | 03:14:08 AM UTC
    let expected = chrono::NaiveDateTime::new(
        chrono::NaiveDate::from_ymd_opt(1968, 1, 20).unwrap(),
        chrono::NaiveTime::from_hms_opt(3, 14, 8).unwrap(),
    );
    let expected_utc = expected.and_utc().timestamp_millis();

    assert_eq!(actual_utc, expected_utc);
}

#[test]
fn test_first_timestamp_msb_clear_millis() {
    let timestamp = barentp::Timestamp::new(0, 0);
    let actual_utc = timestamp.utc_millis();

    // First timestamp with MSB clear:
    //     Thursday, February 07, 2036 | 06:28:16 AM UTC
    let expected = chrono::NaiveDateTime::new(
        chrono::NaiveDate::from_ymd_opt(2036, 2, 7).unwrap(),
        chrono::NaiveTime::from_hms_opt(6, 28, 16).unwrap(),
    );
    let expected_utc = expected.and_utc().timestamp_millis();

    assert_eq!(actual_utc, expected_utc);
}

#[test]
fn test_first_timestamp_msb_set_seconds() {
    let timestamp = barentp::Timestamp::new(0x80000000, 0);
    let actual_utc = timestamp.utc_seconds();

    // First timestamp with MSB set:
    //     Saturday, January 20, 1968 | 03:14:08 AM UTC
    let expected = chrono::NaiveDateTime::new(
        chrono::NaiveDate::from_ymd_opt(1968, 1, 20).unwrap(),
        chrono::NaiveTime::from_hms_opt(3, 14, 8).unwrap(),
    );
    let expected_utc = expected.and_utc().timestamp();

    assert_eq!(actual_utc, expected_utc);
}

#[test]
fn test_first_timestamp_msb_clear_seconds() {
    let timestamp = barentp::Timestamp::new(0, 0);
    let actual_utc = timestamp.utc_seconds();

    // First timestamp with MSB clear:
    //     Thursday, February 07, 2036 | 06:28:16 AM UTC
    let expected = chrono::NaiveDateTime::new(
        chrono::NaiveDate::from_ymd_opt(2036, 2, 7).unwrap(),
        chrono::NaiveTime::from_hms_opt(6, 28, 16).unwrap(),
    );
    let expected_utc = expected.and_utc().timestamp();

    assert_eq!(actual_utc, expected_utc);
}