1// musl as a whole is licensed under the following standard MIT license:
2//
3// ----------------------------------------------------------------------
4// Copyright © 2005-2020 Rich Felker, et al.
5//
6// Permission is hereby granted, free of charge, to any person obtaining
7// a copy of this software and associated documentation files (the
8// "Software"), to deal in the Software without restriction, including
9// without limitation the rights to use, copy, modify, merge, publish,
10// distribute, sublicense, and/or sell copies of the Software, and to
11// permit persons to whom the Software is furnished to do so, subject to
12// the following conditions:
13//
14// The above copyright notice and this permission notice shall be
15// included in all copies or substantial portions of the Software.
16//
17// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
18// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
19// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
20// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
21// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
22// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
23// SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
24// ----------------------------------------------------------------------
25//
26// Authors/contributors include:
27//
28// A. Wilcox
29// Ada Worcester
30// Alex Dowad
31// Alex Suykov
32// Alexander Monakov
33// Andre McCurdy
34// Andrew Kelley
35// Anthony G. Basile
36// Aric Belsito
37// Arvid Picciani
38// Bartosz Brachaczek
39// Benjamin Peterson
40// Bobby Bingham
41// Boris Brezillon
42// Brent Cook
43// Chris Spiegel
44// Clément Vasseur
45// Daniel Micay
46// Daniel Sabogal
47// Daurnimator
48// David Carlier
49// David Edelsohn
50// Denys Vlasenko
51// Dmitry Ivanov
52// Dmitry V. Levin
53// Drew DeVault
54// Emil Renner Berthing
55// Fangrui Song
56// Felix Fietkau
57// Felix Janda
58// Gianluca Anzolin
59// Hauke Mehrtens
60// He X
61// Hiltjo Posthuma
62// Isaac Dunham
63// Jaydeep Patil
64// Jens Gustedt
65// Jeremy Huntwork
66// Jo-Philipp Wich
67// Joakim Sindholt
68// John Spencer
69// Julien Ramseier
70// Justin Cormack
71// Kaarle Ritvanen
72// Khem Raj
73// Kylie McClain
74// Leah Neukirchen
75// Luca Barbato
76// Luka Perkov
77// M Farkas-Dyck (Strake)
78// Mahesh Bodapati
79// Markus Wichmann
80// Masanori Ogino
81// Michael Clark
82// Michael Forney
83// Mikhail Kremnyov
84// Natanael Copa
85// Nicholas J. Kain
86// orc
87// Pascal Cuoq
88// Patrick Oppenlander
89// Petr Hosek
90// Petr Skocik
91// Pierre Carrier
92// Reini Urban
93// Rich Felker
94// Richard Pennington
95// Ryan Fairfax
96// Samuel Holland
97// Segev Finer
98// Shiz
99// sin
100// Solar Designer
101// Stefan Kristiansson
102// Stefan O'Rear
103// Szabolcs Nagy
104// Timo Teräs
105// Trutz Behn
106// Valentin Ochs
107// Will Dietz
108// William Haddon
109// William Pitcock
110//
111// Portions of this software are derived from third-party works licensed
112// under terms compatible with the above MIT license:
113//
114// The TRE regular expression implementation (src/regex/reg* and
115// src/regex/tre*) is Copyright © 2001-2008 Ville Laurikari and licensed
116// under a 2-clause BSD license (license text in the source files). The
117// included version has been heavily modified by Rich Felker in 2012, in
118// the interests of size, simplicity, and namespace cleanliness.
119//
120// Much of the math library code (src/math/* and src/complex/*) is
121// Copyright © 1993,2004 Sun Microsystems or
122// Copyright © 2003-2011 David Schultz or
123// Copyright © 2003-2009 Steven G. Kargl or
124// Copyright © 2003-2009 Bruce D. Evans or
125// Copyright © 2008 Stephen L. Moshier or
126// Copyright © 2017-2018 Arm Limited
127// and labelled as such in comments in the individual source files. All
128// have been licensed under extremely permissive terms.
129//
130// The ARM memcpy code (src/string/arm/memcpy.S) is Copyright © 2008
131// The Android Open Source Project and is licensed under a two-clause BSD
132// license. It was taken from Bionic libc, used on Android.
133//
134// The AArch64 memcpy and memset code (src/string/aarch64/*) are
135// Copyright © 1999-2019, Arm Limited.
136//
137// The implementation of DES for crypt (src/crypt/crypt_des.c) is
138// Copyright © 1994 David Burren. It is licensed under a BSD license.
139//
140// The implementation of blowfish crypt (src/crypt/crypt_blowfish.c) was
141// originally written by Solar Designer and placed into the public
142// domain. The code also comes with a fallback permissive license for use
143// in jurisdictions that may not recognize the public domain.
144//
145// The smoothsort implementation (src/stdlib/qsort.c) is Copyright © 2011
146// Valentin Ochs and is licensed under an MIT-style license.
147//
148// The x86_64 port was written by Nicholas J. Kain and is licensed under
149// the standard MIT terms.
150//
151// The mips and microblaze ports were originally written by Richard
152// Pennington for use in the ellcc project. The original code was adapted
153// by Rich Felker for build system and code conventions during upstream
154// integration. It is licensed under the standard MIT terms.
155//
156// The mips64 port was contributed by Imagination Technologies and is
157// licensed under the standard MIT terms.
158//
159// The powerpc port was also originally written by Richard Pennington,
160// and later supplemented and integrated by John Spencer. It is licensed
161// under the standard MIT terms.
162//
163// All other files which have no copyright comments are original works
164// produced specifically for use as part of this library, written either
165// by Rich Felker, the main author of the library, or by one or more
166// contibutors listed above. Details on authorship of individual files
167// can be found in the git version control history of the project. The
168// omission of copyright and license comments in each file is in the
169// interest of source tree size.
170//
171// In addition, permission is hereby granted for all public header files
172// (include/* and arch/*/bits/*) and crt files intended to be linked into
173// applications (crt/*, ldso/dlstart.c, and arch/*/crt_arch.h) to omit
174// the copyright notice and permission notice otherwise required by the
175// license, and to use these files without any requirement of
176// attribution. These files include substantial contributions from:
177//
178// Bobby Bingham
179// John Spencer
180// Nicholas J. Kain
181// Rich Felker
182// Richard Pennington
183// Stefan Kristiansson
184// Szabolcs Nagy
185//
186// all of whom have explicitly granted such permission.
187//
188// This file previously contained text expressing a belief that most of
189// the files covered by the above exception were sufficiently trivial not
190// to be subject to copyright, resulting in confusion over whether it
191// negated the permissions granted in the license. In the spirit of
192// permissive licensing, and of not having licensing issues being an
193// obstacle to adoption, that text has been removed.
194
195
196use std::fmt;
197
198/// A date/time type which exists primarily to convert `SystemTime` timestamps into an ISO 8601
199/// formatted string.
200///
201/// Yes, this exists. Before you have a heart attack, understand that the meat of this is musl's
202/// [`__secs_to_tm`][1] converted to Rust via [c2rust][2] and then cleaned up by hand as part of
203/// the [kudu-rs project][3], [released under MIT][4].
204///
205/// [1] http://git.musl-libc.org/cgit/musl/tree/src/time/__secs_to_tm.c
206/// [2] https://c2rust.com/
207/// [3] https://github.com/danburkert/kudu-rs/blob/c9660067e5f4c1a54143f169b5eeb49446f82e54/src/timestamp.rs#L5-L18
208/// [4] https://github.com/tokio-rs/tracing/issues/1644#issuecomment-963888244
209///
210/// All existing `strftime`-like APIs I found were unable to handle the full range of timestamps representable
211/// by `SystemTime`, including `strftime` itself, since tm.tm_year is an int.
212#[derive(Debug, Clone, Copy, PartialEq, Eq)]
213pub(crate) struct DateTime {
214 year: i64,
215 month: u8,
216 day: u8,
217 hour: u8,
218 minute: u8,
219 second: u8,
220 nanos: u32,
221}
222
223impl fmt::Display for DateTime {
224 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
225 if self.year > 9999 {
226 write!(f, "+{}", self.year)?;
227 } else if self.year < 0 {
228 write!(f, "{:05}", self.year)?;
229 } else {
230 write!(f, "{:04}", self.year)?;
231 }
232
233 write!(
234 f,
235 "-{:02}-{:02}T{:02}:{:02}:{:02}.{:06}Z",
236 self.month,
237 self.day,
238 self.hour,
239 self.minute,
240 self.second,
241 self.nanos / 1_000
242 )
243 }
244}
245
246impl From<std::time::SystemTime> for DateTime {
247 fn from(timestamp: std::time::SystemTime) -> DateTime {
248 let (t, nanos) = match timestamp.duration_since(std::time::UNIX_EPOCH) {
249 Ok(duration) => {
250 debug_assert!(duration.as_secs() <= std::i64::MAX as u64);
251 (duration.as_secs() as i64, duration.subsec_nanos())
252 }
253 Err(error) => {
254 let duration = error.duration();
255 debug_assert!(duration.as_secs() <= std::i64::MAX as u64);
256 let (secs, nanos) = (duration.as_secs() as i64, duration.subsec_nanos());
257 if nanos == 0 {
258 (-secs, 0)
259 } else {
260 (-secs - 1, 1_000_000_000 - nanos)
261 }
262 }
263 };
264
265 // 2000-03-01 (mod 400 year, immediately after feb29
266 const LEAPOCH: i64 = 946_684_800 + 86400 * (31 + 29);
267 const DAYS_PER_400Y: i32 = 365 * 400 + 97;
268 const DAYS_PER_100Y: i32 = 365 * 100 + 24;
269 const DAYS_PER_4Y: i32 = 365 * 4 + 1;
270 static DAYS_IN_MONTH: [i8; 12] = [31, 30, 31, 30, 31, 31, 30, 31, 30, 31, 31, 29];
271
272 // Note(dcb): this bit is rearranged slightly to avoid integer overflow.
273 let mut days: i64 = (t / 86_400) - (LEAPOCH / 86_400);
274 let mut remsecs: i32 = (t % 86_400) as i32;
275 if remsecs < 0i32 {
276 remsecs += 86_400;
277 days -= 1
278 }
279
280 let mut qc_cycles: i32 = (days / i64::from(DAYS_PER_400Y)) as i32;
281 let mut remdays: i32 = (days % i64::from(DAYS_PER_400Y)) as i32;
282 if remdays < 0 {
283 remdays += DAYS_PER_400Y;
284 qc_cycles -= 1;
285 }
286
287 let mut c_cycles: i32 = remdays / DAYS_PER_100Y;
288 if c_cycles == 4 {
289 c_cycles -= 1;
290 }
291 remdays -= c_cycles * DAYS_PER_100Y;
292
293 let mut q_cycles: i32 = remdays / DAYS_PER_4Y;
294 if q_cycles == 25 {
295 q_cycles -= 1;
296 }
297 remdays -= q_cycles * DAYS_PER_4Y;
298
299 let mut remyears: i32 = remdays / 365;
300 if remyears == 4 {
301 remyears -= 1;
302 }
303 remdays -= remyears * 365;
304
305 let mut years: i64 = i64::from(remyears)
306 + 4 * i64::from(q_cycles)
307 + 100 * i64::from(c_cycles)
308 + 400 * i64::from(qc_cycles);
309
310 let mut months: i32 = 0;
311 while i32::from(DAYS_IN_MONTH[months as usize]) <= remdays {
312 remdays -= i32::from(DAYS_IN_MONTH[months as usize]);
313 months += 1
314 }
315
316 if months >= 10 {
317 months -= 12;
318 years += 1;
319 }
320
321 DateTime {
322 year: years + 2000,
323 month: (months + 3) as u8,
324 day: (remdays + 1) as u8,
325 hour: (remsecs / 3600) as u8,
326 minute: (remsecs / 60 % 60) as u8,
327 second: (remsecs % 60) as u8,
328 nanos,
329 }
330 }
331}
332
333#[cfg(test)]
334mod tests {
335 use std::i32;
336 use std::time::{Duration, UNIX_EPOCH};
337
338 use super::*;
339
340 #[test]
341 fn test_datetime() {
342 let case = |expected: &str, secs: i64, micros: u32| {
343 let timestamp = if secs >= 0 {
344 UNIX_EPOCH + Duration::new(secs as u64, micros * 1_000)
345 } else {
346 (UNIX_EPOCH - Duration::new(!secs as u64 + 1, 0)) + Duration::new(0, micros * 1_000)
347 };
348 assert_eq!(
349 expected,
350 format!("{}", DateTime::from(timestamp)),
351 "secs: {}, micros: {}",
352 secs,
353 micros
354 )
355 };
356
357 // Mostly generated with:
358 // - date -jur <secs> +"%Y-%m-%dT%H:%M:%S.000000Z"
359 // - http://unixtimestamp.50x.eu/
360
361 case("1970-01-01T00:00:00.000000Z", 0, 0);
362
363 case("1970-01-01T00:00:00.000001Z", 0, 1);
364 case("1970-01-01T00:00:00.500000Z", 0, 500_000);
365 case("1970-01-01T00:00:01.000001Z", 1, 1);
366 case("1970-01-01T00:01:01.000001Z", 60 + 1, 1);
367 case("1970-01-01T01:01:01.000001Z", 60 * 60 + 60 + 1, 1);
368 case(
369 "1970-01-02T01:01:01.000001Z",
370 24 * 60 * 60 + 60 * 60 + 60 + 1,
371 1,
372 );
373
374 case("1969-12-31T23:59:59.000000Z", -1, 0);
375 case("1969-12-31T23:59:59.000001Z", -1, 1);
376 case("1969-12-31T23:59:59.500000Z", -1, 500_000);
377 case("1969-12-31T23:58:59.000001Z", -60 - 1, 1);
378 case("1969-12-31T22:58:59.000001Z", -60 * 60 - 60 - 1, 1);
379 case(
380 "1969-12-30T22:58:59.000001Z",
381 -24 * 60 * 60 - 60 * 60 - 60 - 1,
382 1,
383 );
384
385 case("2038-01-19T03:14:07.000000Z", std::i32::MAX as i64, 0);
386 case("2038-01-19T03:14:08.000000Z", std::i32::MAX as i64 + 1, 0);
387 case("1901-12-13T20:45:52.000000Z", i32::MIN as i64, 0);
388 case("1901-12-13T20:45:51.000000Z", i32::MIN as i64 - 1, 0);
389
390 // Skipping these tests on windows as std::time::SysteTime range is low
391 // on Windows compared with that of Unix which can cause the following
392 // high date value tests to panic
393 #[cfg(not(target_os = "windows"))]
394 {
395 case("+292277026596-12-04T15:30:07.000000Z", std::i64::MAX, 0);
396 case("+292277026596-12-04T15:30:06.000000Z", std::i64::MAX - 1, 0);
397 case("-292277022657-01-27T08:29:53.000000Z", i64::MIN + 1, 0);
398 }
399
400 case("1900-01-01T00:00:00.000000Z", -2208988800, 0);
401 case("1899-12-31T23:59:59.000000Z", -2208988801, 0);
402 case("0000-01-01T00:00:00.000000Z", -62167219200, 0);
403 case("-0001-12-31T23:59:59.000000Z", -62167219201, 0);
404
405 case("1234-05-06T07:08:09.000000Z", -23215049511, 0);
406 case("-1234-05-06T07:08:09.000000Z", -101097651111, 0);
407 case("2345-06-07T08:09:01.000000Z", 11847456541, 0);
408 case("-2345-06-07T08:09:01.000000Z", -136154620259, 0);
409 }
410}
411