256101c95b
(UTC) rather than the archaic (GMT) in comments. Except where the comments are making fun of people doing this (and pedants who insist on the new terms).
308 lines
9.9 KiB
C
308 lines
9.9 KiB
C
/*-
|
|
* Copyright (c) 2006 Poul-Henning Kamp
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*
|
|
* $FreeBSD$
|
|
*
|
|
* Convert MS-DOS FAT format timestamps to and from unix timespecs
|
|
*
|
|
* FAT filestamps originally consisted of two 16 bit integers, encoded like
|
|
* this:
|
|
*
|
|
* yyyyyyymmmmddddd (year - 1980, month, day)
|
|
*
|
|
* hhhhhmmmmmmsssss (hour, minutes, seconds divided by two)
|
|
*
|
|
* Subsequently even Microsoft realized that files could be accessed in less
|
|
* than two seconds and a byte was added containing:
|
|
*
|
|
* sfffffff (second mod two, 100ths of second)
|
|
*
|
|
* FAT timestamps are in the local timezone, with no indication of which
|
|
* timezone much less if daylight savings time applies.
|
|
*
|
|
* Later on again, in Windows NT, timestamps were defined relative to GMT.
|
|
*
|
|
* Purists will point out that UTC replaced GMT for such uses around
|
|
* half a century ago, already then. Ironically "NT" was an abbreviation of
|
|
* "New Technology". Anyway...
|
|
*
|
|
* The 'utc' argument determines if the resulting FATTIME timestamp
|
|
* should be on the UTC or local timezone calendar.
|
|
*
|
|
* The conversion functions below cut time into four-year leap-year
|
|
* cycles rather than single years and uses table lookups inside those
|
|
* cycles to get the months and years sorted out.
|
|
*
|
|
* Obviously we cannot calculate the correct table index going from
|
|
* a posix seconds count to Y/M/D, but we can get pretty close by
|
|
* dividing the daycount by 32 (giving a too low index), and then
|
|
* adjusting upwards a couple of steps if necessary.
|
|
*
|
|
* FAT timestamps have 7 bits for the year and starts at 1980, so
|
|
* they can represent up to 2107 which means that the non-leap-year
|
|
* 2100 must be handled.
|
|
*
|
|
* XXX: As long as time_t is 32 bits this is not relevant or easily
|
|
* XXX: testable. Revisit when time_t grows bigger.
|
|
* XXX: grepfodder: 64 bit time_t, y2100, y2.1k, 2100, leap year
|
|
*
|
|
*/
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/types.h>
|
|
#include <sys/time.h>
|
|
#include <sys/clock.h>
|
|
|
|
#define DAY (24 * 60 * 60) /* Length of day in seconds */
|
|
#define YEAR 365 /* Length of normal year */
|
|
#define LYC (4 * YEAR + 1) /* Length of 4 year leap-year cycle */
|
|
#define T1980 (10 * 365 + 2) /* Days from 1970 to 1980 */
|
|
|
|
/* End of month is N days from start of (normal) year */
|
|
#define JAN 31
|
|
#define FEB (JAN + 28)
|
|
#define MAR (FEB + 31)
|
|
#define APR (MAR + 30)
|
|
#define MAY (APR + 31)
|
|
#define JUN (MAY + 30)
|
|
#define JUL (JUN + 31)
|
|
#define AUG (JUL + 31)
|
|
#define SEP (AUG + 30)
|
|
#define OCT (SEP + 31)
|
|
#define NOV (OCT + 30)
|
|
#define DEC (NOV + 31)
|
|
|
|
/* Table of months in a 4 year leap-year cycle */
|
|
|
|
#define ENC(y,m) (((y) << 9) | ((m) << 5))
|
|
|
|
static const struct {
|
|
uint16_t days; /* month start in days relative to cycle */
|
|
uint16_t coded; /* encoded year + month information */
|
|
} mtab[48] = {
|
|
{ 0 + 0 * YEAR, ENC(0, 1) },
|
|
|
|
{ JAN + 0 * YEAR, ENC(0, 2) }, { FEB + 0 * YEAR + 1, ENC(0, 3) },
|
|
{ MAR + 0 * YEAR + 1, ENC(0, 4) }, { APR + 0 * YEAR + 1, ENC(0, 5) },
|
|
{ MAY + 0 * YEAR + 1, ENC(0, 6) }, { JUN + 0 * YEAR + 1, ENC(0, 7) },
|
|
{ JUL + 0 * YEAR + 1, ENC(0, 8) }, { AUG + 0 * YEAR + 1, ENC(0, 9) },
|
|
{ SEP + 0 * YEAR + 1, ENC(0, 10) }, { OCT + 0 * YEAR + 1, ENC(0, 11) },
|
|
{ NOV + 0 * YEAR + 1, ENC(0, 12) }, { DEC + 0 * YEAR + 1, ENC(1, 1) },
|
|
|
|
{ JAN + 1 * YEAR + 1, ENC(1, 2) }, { FEB + 1 * YEAR + 1, ENC(1, 3) },
|
|
{ MAR + 1 * YEAR + 1, ENC(1, 4) }, { APR + 1 * YEAR + 1, ENC(1, 5) },
|
|
{ MAY + 1 * YEAR + 1, ENC(1, 6) }, { JUN + 1 * YEAR + 1, ENC(1, 7) },
|
|
{ JUL + 1 * YEAR + 1, ENC(1, 8) }, { AUG + 1 * YEAR + 1, ENC(1, 9) },
|
|
{ SEP + 1 * YEAR + 1, ENC(1, 10) }, { OCT + 1 * YEAR + 1, ENC(1, 11) },
|
|
{ NOV + 1 * YEAR + 1, ENC(1, 12) }, { DEC + 1 * YEAR + 1, ENC(2, 1) },
|
|
|
|
{ JAN + 2 * YEAR + 1, ENC(2, 2) }, { FEB + 2 * YEAR + 1, ENC(2, 3) },
|
|
{ MAR + 2 * YEAR + 1, ENC(2, 4) }, { APR + 2 * YEAR + 1, ENC(2, 5) },
|
|
{ MAY + 2 * YEAR + 1, ENC(2, 6) }, { JUN + 2 * YEAR + 1, ENC(2, 7) },
|
|
{ JUL + 2 * YEAR + 1, ENC(2, 8) }, { AUG + 2 * YEAR + 1, ENC(2, 9) },
|
|
{ SEP + 2 * YEAR + 1, ENC(2, 10) }, { OCT + 2 * YEAR + 1, ENC(2, 11) },
|
|
{ NOV + 2 * YEAR + 1, ENC(2, 12) }, { DEC + 2 * YEAR + 1, ENC(3, 1) },
|
|
|
|
{ JAN + 3 * YEAR + 1, ENC(3, 2) }, { FEB + 3 * YEAR + 1, ENC(3, 3) },
|
|
{ MAR + 3 * YEAR + 1, ENC(3, 4) }, { APR + 3 * YEAR + 1, ENC(3, 5) },
|
|
{ MAY + 3 * YEAR + 1, ENC(3, 6) }, { JUN + 3 * YEAR + 1, ENC(3, 7) },
|
|
{ JUL + 3 * YEAR + 1, ENC(3, 8) }, { AUG + 3 * YEAR + 1, ENC(3, 9) },
|
|
{ SEP + 3 * YEAR + 1, ENC(3, 10) }, { OCT + 3 * YEAR + 1, ENC(3, 11) },
|
|
{ NOV + 3 * YEAR + 1, ENC(3, 12) }
|
|
};
|
|
|
|
|
|
void
|
|
timespec2fattime(struct timespec *tsp, int utc, uint16_t *ddp, uint16_t *dtp, uint8_t *dhp)
|
|
{
|
|
time_t t1;
|
|
unsigned t2, l, m;
|
|
|
|
t1 = tsp->tv_sec;
|
|
if (!utc)
|
|
t1 -= utc_offset();
|
|
|
|
if (dhp != NULL)
|
|
*dhp = (tsp->tv_sec & 1) * 100 + tsp->tv_nsec / 10000000;
|
|
if (dtp != NULL) {
|
|
*dtp = (t1 / 2) % 30;
|
|
*dtp |= ((t1 / 60) % 60) << 5;
|
|
*dtp |= ((t1 / 3600) % 24) << 11;
|
|
}
|
|
if (ddp != NULL) {
|
|
t2 = t1 / DAY;
|
|
if (t2 < T1980) {
|
|
/* Impossible date, truncate to 1980-01-01 */
|
|
*ddp = 0x0021;
|
|
} else {
|
|
t2 -= T1980;
|
|
|
|
/*
|
|
* 2100 is not a leap year.
|
|
* XXX: a 32 bit time_t can not get us here.
|
|
*/
|
|
if (t2 >= ((2100 - 1980) / 4 * LYC + FEB))
|
|
t2++;
|
|
|
|
/* Account for full leapyear cycles */
|
|
l = t2 / LYC;
|
|
*ddp = (l * 4) << 9;
|
|
t2 -= l * LYC;
|
|
|
|
/* Find approximate table entry */
|
|
m = t2 / 32;
|
|
|
|
/* Find correct table entry */
|
|
while (m < 47 && mtab[m + 1].days <= t2)
|
|
m++;
|
|
|
|
/* Get year + month from the table */
|
|
*ddp += mtab[m].coded;
|
|
|
|
/* And apply the day in the month */
|
|
t2 -= mtab[m].days - 1;
|
|
*ddp |= t2;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Table indexed by the bottom two bits of year + four bits of the month
|
|
* from the FAT timestamp, returning number of days into 4 year long
|
|
* leap-year cycle
|
|
*/
|
|
|
|
#define DCOD(m, y, l) ((m) + YEAR * (y) + (l))
|
|
static const uint16_t daytab[64] = {
|
|
0, DCOD( 0, 0, 0), DCOD(JAN, 0, 0), DCOD(FEB, 0, 1),
|
|
DCOD(MAR, 0, 1), DCOD(APR, 0, 1), DCOD(MAY, 0, 1), DCOD(JUN, 0, 1),
|
|
DCOD(JUL, 0, 1), DCOD(AUG, 0, 1), DCOD(SEP, 0, 1), DCOD(OCT, 0, 1),
|
|
DCOD(NOV, 0, 1), DCOD(DEC, 0, 1), 0, 0,
|
|
0, DCOD( 0, 1, 1), DCOD(JAN, 1, 1), DCOD(FEB, 1, 1),
|
|
DCOD(MAR, 1, 1), DCOD(APR, 1, 1), DCOD(MAY, 1, 1), DCOD(JUN, 1, 1),
|
|
DCOD(JUL, 1, 1), DCOD(AUG, 1, 1), DCOD(SEP, 1, 1), DCOD(OCT, 1, 1),
|
|
DCOD(NOV, 1, 1), DCOD(DEC, 1, 1), 0, 0,
|
|
0, DCOD( 0, 2, 1), DCOD(JAN, 2, 1), DCOD(FEB, 2, 1),
|
|
DCOD(MAR, 2, 1), DCOD(APR, 2, 1), DCOD(MAY, 2, 1), DCOD(JUN, 2, 1),
|
|
DCOD(JUL, 2, 1), DCOD(AUG, 2, 1), DCOD(SEP, 2, 1), DCOD(OCT, 2, 1),
|
|
DCOD(NOV, 2, 1), DCOD(DEC, 2, 1), 0, 0,
|
|
0, DCOD( 0, 3, 1), DCOD(JAN, 3, 1), DCOD(FEB, 3, 1),
|
|
DCOD(MAR, 3, 1), DCOD(APR, 3, 1), DCOD(MAY, 3, 1), DCOD(JUN, 3, 1),
|
|
DCOD(JUL, 3, 1), DCOD(AUG, 3, 1), DCOD(SEP, 3, 1), DCOD(OCT, 3, 1),
|
|
DCOD(NOV, 3, 1), DCOD(DEC, 3, 1), 0, 0
|
|
};
|
|
|
|
void
|
|
fattime2timespec(unsigned dd, unsigned dt, unsigned dh, int utc, struct timespec *tsp)
|
|
{
|
|
unsigned day;
|
|
|
|
/* Unpack time fields */
|
|
tsp->tv_sec = (dt & 0x1f) << 1;
|
|
tsp->tv_sec += ((dt & 0x7e0) >> 5) * 60;
|
|
tsp->tv_sec += ((dt & 0xf800) >> 11) * 3600;
|
|
tsp->tv_sec += dh / 100;
|
|
tsp->tv_nsec = (dh % 100) * 10000000;
|
|
|
|
/* Day of month */
|
|
day = (dd & 0x1f) - 1;
|
|
|
|
/* Full leap-year cycles */
|
|
day += LYC * ((dd >> 11) & 0x1f);
|
|
|
|
/* Month offset from leap-year cycle */
|
|
day += daytab[(dd >> 5) & 0x3f];
|
|
|
|
/*
|
|
* 2100 is not a leap year.
|
|
* XXX: a 32 bit time_t can not get us here.
|
|
*/
|
|
if (day >= ((2100 - 1980) / 4 * LYC + FEB))
|
|
day--;
|
|
|
|
/* Align with time_t epoch */
|
|
day += T1980;
|
|
|
|
tsp->tv_sec += DAY * day;
|
|
if (!utc)
|
|
tsp->tv_sec += utc_offset();
|
|
}
|
|
|
|
#ifdef TEST_DRIVER
|
|
|
|
#include <stdio.h>
|
|
#include <unistd.h>
|
|
#include <stdlib.h>
|
|
|
|
int
|
|
main(int argc __unused, char **argv __unused)
|
|
{
|
|
int i;
|
|
struct timespec ts;
|
|
struct tm tm;
|
|
double a;
|
|
uint16_t d, t;
|
|
uint8_t p;
|
|
char buf[100];
|
|
|
|
for (i = 0; i < 10000; i++) {
|
|
do {
|
|
ts.tv_sec = random();
|
|
} while (ts.tv_sec < T1980 * 86400);
|
|
ts.tv_nsec = random() % 1000000000;
|
|
|
|
printf("%10d.%03ld -- ", ts.tv_sec, ts.tv_nsec / 1000000);
|
|
|
|
gmtime_r(&ts.tv_sec, &tm);
|
|
strftime(buf, sizeof buf, "%Y %m %d %H %M %S", &tm);
|
|
printf("%s -- ", buf);
|
|
|
|
a = ts.tv_sec + ts.tv_nsec * 1e-9;
|
|
d = t = p = 0;
|
|
timet2fattime(&ts, &d, &t, &p);
|
|
printf("%04x %04x %02x -- ", d, t, p);
|
|
printf("%3d %02d %02d %02d %02d %02d -- ",
|
|
((d >> 9) & 0x7f) + 1980,
|
|
(d >> 5) & 0x0f,
|
|
(d >> 0) & 0x1f,
|
|
(t >> 11) & 0x1f,
|
|
(t >> 5) & 0x3f,
|
|
((t >> 0) & 0x1f) * 2);
|
|
|
|
ts.tv_sec = ts.tv_nsec = 0;
|
|
fattime2timet(d, t, p, &ts);
|
|
printf("%10d.%03ld == ", ts.tv_sec, ts.tv_nsec / 1000000);
|
|
gmtime_r(&ts.tv_sec, &tm);
|
|
strftime(buf, sizeof buf, "%Y %m %d %H %M %S", &tm);
|
|
printf("%s -- ", buf);
|
|
a -= ts.tv_sec + ts.tv_nsec * 1e-9;
|
|
printf("%.3f", a);
|
|
printf("\n");
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
#endif /* TEST_DRIVER */
|