/* * Copyright (c) 2006 Ondrej Palkovsky * Copyright (c) 2011 Petr Koupy * Copyright (c) 2011 Jiri Zarevucky * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - 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. * - The name of the author may not be used to endorse or promote products * derived from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 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. */ /** @addtogroup libc * @{ */ /** @file */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #define ASCTIME_BUF_LEN 27 #define HOURS_PER_DAY 24 #define MINS_PER_HOUR 60 #define SECS_PER_MIN 60 #define NSECS_PER_SEC 1000000000ll #define MINS_PER_DAY (MINS_PER_HOUR * HOURS_PER_DAY) #define SECS_PER_HOUR (SECS_PER_MIN * MINS_PER_HOUR) #define SECS_PER_DAY (SECS_PER_HOUR * HOURS_PER_DAY) /** Pointer to kernel shared variables with time */ struct { volatile sysarg_t seconds1; volatile sysarg_t useconds; volatile sysarg_t seconds2; } *ktime = NULL; static async_sess_t *clock_conn = NULL; /** * Get CPU time used since the process invocation. * * @return Consumed microseconds by this process or -1 if not available. */ clock_t clock(void) { static_assert(CLOCKS_PER_SEC == 1000000, ""); size_t count; stats_cpu_t *cpu_stats = stats_get_cpus(&count); if (!cpu_stats) return (clock_t) -1; if (!cpu_stats->frequency_mhz) { free(cpu_stats); return (clock_t) -1; } clock_t total_usecs = -1; if (cpu_stats) { stats_task_t *task_stats = stats_get_task(task_get_id()); if (task_stats) { total_usecs = (clock_t) (task_stats->kcycles + task_stats->ucycles) / cpu_stats->frequency_mhz; free(task_stats); } free(cpu_stats); } return total_usecs; } /** Check whether the year is a leap year. * * @param year Year since 1900 (e.g. for 1970, the value is 70). * * @return true if year is a leap year, false otherwise * */ static bool is_leap_year(time_t year) { year += 1900; if (year % 400 == 0) return true; if (year % 100 == 0) return false; if (year % 4 == 0) return true; return false; } /** How many days there are in the given month * * Return how many days there are in the given month of the given year. * Note that year is only taken into account if month is February. * * @param year Year since 1900 (can be negative). * @param mon Month of the year. 0 for January, 11 for December. * * @return Number of days in the specified month. * */ static int days_in_month(time_t year, time_t mon) { assert(mon >= 0); assert(mon <= 11); static int month_days[] = { 31, 0, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }; if (mon == 1) { /* February */ year += 1900; return is_leap_year(year) ? 29 : 28; } return month_days[mon]; } /** Which day of that year it is. * * For specified year, month and day of month, return which day of that year * it is. * * For example, given date 2011-01-03, the corresponding expression is: * day_of_year(111, 0, 3) == 2 * * @param year Year (year 1900 = 0, can be negative). * @param mon Month (January = 0). * @param mday Day of month (First day is 1). * * @return Day of year (First day is 0). * */ static int day_of_year(time_t year, time_t mon, time_t mday) { static int mdays[] = { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 }; static int leap_mdays[] = { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335 }; return (is_leap_year(year) ? leap_mdays[mon] : mdays[mon]) + mday - 1; } /** Integer division that rounds to negative infinity. * * Used by some functions in this module. * * @param op1 Dividend. * @param op2 Divisor. * * @return Rounded quotient. * */ static time_t floor_div(time_t op1, time_t op2) { if ((op1 >= 0) || (op1 % op2 == 0)) return op1 / op2; return op1 / op2 - 1; } /** Modulo that rounds to negative infinity. * * Used by some functions in this module. * * @param op1 Dividend. * @param op2 Divisor. * * @return Remainder. * */ static time_t floor_mod(time_t op1, time_t op2) { time_t div = floor_div(op1, op2); /* * (a / b) * b + a % b == a * Thus: a % b == a - (a / b) * b */ time_t result = op1 - div * op2; /* Some paranoid checking to ensure there is mistake here. */ assert(result >= 0); assert(result < op2); assert(div * op2 + result == op1); return result; } /** Number of days since the Epoch. * * Epoch is 1970-01-01, which is also equal to day 0. * * @param year Year (year 1900 = 0, may be negative). * @param mon Month (January = 0). * @param mday Day of month (first day = 1). * * @return Number of days since the Epoch. * */ static time_t days_since_epoch(time_t year, time_t mon, time_t mday) { return (year - 70) * 365 + floor_div(year - 69, 4) - floor_div(year - 1, 100) + floor_div(year + 299, 400) + day_of_year(year, mon, mday); } /** Seconds since the Epoch. * * See also days_since_epoch(). * * @param tm Normalized broken-down time. * * @return Number of seconds since the epoch, not counting leap seconds. * */ static time_t secs_since_epoch(const struct tm *tm) { return days_since_epoch(tm->tm_year, tm->tm_mon, tm->tm_mday) * SECS_PER_DAY + tm->tm_hour * SECS_PER_HOUR + tm->tm_min * SECS_PER_MIN + tm->tm_sec; } /** Which day of week the specified date is. * * @param year Year (year 1900 = 0). * @param mon Month (January = 0). * @param mday Day of month (first = 1). * * @return Day of week (Sunday = 0). * */ static time_t day_of_week(time_t year, time_t mon, time_t mday) { /* 1970-01-01 is Thursday */ return floor_mod(days_since_epoch(year, mon, mday) + 4, 7); } /** Normalize the broken-down time. * * Optionally add specified amount of seconds. * * @param tm Broken-down time to normalize. * @param ts Timespec to add. * * @return 0 on success, -1 on overflow * */ static int normalize_tm_ts(struct tm *tm, const struct timespec *ts) { // TODO: DST correction /* Set initial values. */ time_t nsec = tm->tm_nsec + ts->tv_nsec; time_t sec = tm->tm_sec + ts->tv_sec; time_t min = tm->tm_min; time_t hour = tm->tm_hour; time_t day = tm->tm_mday - 1; time_t mon = tm->tm_mon; time_t year = tm->tm_year; /* Adjust time. */ sec += floor_div(nsec, NSECS_PER_SEC); nsec = floor_mod(nsec, NSECS_PER_SEC); min += floor_div(sec, SECS_PER_MIN); sec = floor_mod(sec, SECS_PER_MIN); hour += floor_div(min, MINS_PER_HOUR); min = floor_mod(min, MINS_PER_HOUR); day += floor_div(hour, HOURS_PER_DAY); hour = floor_mod(hour, HOURS_PER_DAY); /* Adjust month. */ year += floor_div(mon, 12); mon = floor_mod(mon, 12); /* Now the difficult part - days of month. */ /* First, deal with whole cycles of 400 years = 146097 days. */ year += floor_div(day, 146097) * 400; day = floor_mod(day, 146097); /* Then, go in one year steps. */ if (mon <= 1) { /* January and February. */ while (day > 365) { day -= is_leap_year(year) ? 366 : 365; year++; } } else { /* Rest of the year. */ while (day > 365) { day -= is_leap_year(year + 1) ? 366 : 365; year++; } } /* Finally, finish it off month per month. */ while (day >= days_in_month(year, mon)) { day -= days_in_month(year, mon); mon++; if (mon >= 12) { mon -= 12; year++; } } /* Calculate the remaining two fields. */ tm->tm_yday = day_of_year(year, mon, day + 1); tm->tm_wday = day_of_week(year, mon, day + 1); /* And put the values back to the struct. */ tm->tm_nsec = (int) nsec; tm->tm_sec = (int) sec; tm->tm_min = (int) min; tm->tm_hour = (int) hour; tm->tm_mday = (int) day + 1; tm->tm_mon = (int) mon; /* Casts to work around POSIX brain-damage. */ if (year > ((int) INT_MAX) || year < ((int) INT_MIN)) { tm->tm_year = (year < 0) ? ((int) INT_MIN) : ((int) INT_MAX); return -1; } tm->tm_year = (int) year; return 0; } static int normalize_tm_time(struct tm *tm, time_t time) { struct timespec ts = { .tv_sec = time, .tv_nsec = 0 }; return normalize_tm_ts(tm, &ts); } /** Which day the week-based year starts on. * * Relative to the first calendar day. E.g. if the year starts * on December 31st, the return value is -1. * * @param Year since 1900. * * @return Offset of week-based year relative to calendar year. * */ static int wbyear_offset(int year) { int start_wday = day_of_week(year, 0, 1); return floor_mod(4 - start_wday, 7) - 3; } /** Week-based year of the specified time. * * @param tm Normalized broken-down time. * * @return Week-based year. * */ static int wbyear(const struct tm *tm) { int day = tm->tm_yday - wbyear_offset(tm->tm_year); if (day < 0) { /* Last week of previous year. */ return tm->tm_year - 1; } if (day > 364 + is_leap_year(tm->tm_year)) { /* First week of next year. */ return tm->tm_year + 1; } /* All the other days are in the calendar year. */ return tm->tm_year; } /** Week number of the year (assuming weeks start on Sunday). * * The first Sunday of January is the first day of week 1; * days in the new year before this are in week 0. * * @param tm Normalized broken-down time. * * @return The week number (0 - 53). * */ static int sun_week_number(const struct tm *tm) { int first_day = (7 - day_of_week(tm->tm_year, 0, 1)) % 7; return (tm->tm_yday - first_day + 7) / 7; } /** Week number of the year (assuming weeks start on Monday). * * If the week containing January 1st has four or more days * in the new year, then it is considered week 1. Otherwise, * it is the last week of the previous year, and the next week * is week 1. Both January 4th and the first Thursday * of January are always in week 1. * * @param tm Normalized broken-down time. * * @return The week number (1 - 53). * */ static int iso_week_number(const struct tm *tm) { int day = tm->tm_yday - wbyear_offset(tm->tm_year); if (day < 0) { /* Last week of previous year. */ return 53; } if (day > 364 + is_leap_year(tm->tm_year)) { /* First week of next year. */ return 1; } /* All the other days give correct answer. */ return (day / 7 + 1); } /** Week number of the year (assuming weeks start on Monday). * * The first Monday of January is the first day of week 1; * days in the new year before this are in week 0. * * @param tm Normalized broken-down time. * * @return The week number (0 - 53). * */ static int mon_week_number(const struct tm *tm) { int first_day = (1 - day_of_week(tm->tm_year, 0, 1)) % 7; return (tm->tm_yday - first_day + 7) / 7; } static void ts_normalize(struct timespec *ts) { while (ts->tv_nsec >= NSECS_PER_SEC) { ts->tv_sec++; ts->tv_nsec -= NSECS_PER_SEC; } while (ts->tv_nsec < 0) { ts->tv_sec--; ts->tv_nsec += NSECS_PER_SEC; } } /** Add nanoseconds to given timespec. * * @param ts Destination timespec. * @param nsecs Number of nanoseconds to add. * */ void ts_add_diff(struct timespec *ts, nsec_t nsecs) { ts->tv_sec += nsecs / NSECS_PER_SEC; ts->tv_nsec += nsecs % NSECS_PER_SEC; ts_normalize(ts); } /** Add two timespecs. * * @param ts1 First timespec. * @param ts2 Second timespec. */ void ts_add(struct timespec *ts1, const struct timespec *ts2) { ts1->tv_sec += ts2->tv_sec; ts1->tv_nsec += ts2->tv_nsec; ts_normalize(ts1); } /** Subtract two timespecs. * * @param ts1 First timespec. * @param ts2 Second timespec. * * @return Difference between ts1 and ts2 (ts1 - ts2) in nanoseconds. * */ nsec_t ts_sub_diff(const struct timespec *ts1, const struct timespec *ts2) { return (nsec_t) (ts1->tv_nsec - ts2->tv_nsec) + SEC2NSEC((ts1->tv_sec - ts2->tv_sec)); } /** Subtract two timespecs. * * @param ts1 First timespec. * @param ts2 Second timespec. * */ void ts_sub(struct timespec *ts1, const struct timespec *ts2) { ts1->tv_sec -= ts2->tv_sec; ts1->tv_nsec -= ts2->tv_nsec; ts_normalize(ts1); } /** Decide if one timespec is greater than the other. * * @param ts1 First timespec. * @param ts2 Second timespec. * * @return True if ts1 is greater than ts2. * @return False otherwise. * */ bool ts_gt(const struct timespec *ts1, const struct timespec *ts2) { if (ts1->tv_sec > ts2->tv_sec) return true; if ((ts1->tv_sec == ts2->tv_sec) && (ts1->tv_nsec > ts2->tv_nsec)) return true; return false; } /** Decide if one timespec is greater than or equal to the other. * * @param ts1 First timespec. * @param ts2 Second timespec. * * @return True if ts1 is greater than or equal to ts2. * @return False otherwise. * */ bool ts_gteq(const struct timespec *ts1, const struct timespec *ts2) { if (ts1->tv_sec > ts2->tv_sec) return true; if ((ts1->tv_sec == ts2->tv_sec) && (ts1->tv_nsec >= ts2->tv_nsec)) return true; return false; } /** Get real time from a RTC service. * * @param[out] ts Timespec to hold time read from the RTC service (if * available). If no such service exists, the returned time * corresponds to system uptime. */ void getrealtime(struct timespec *ts) { if (clock_conn == NULL) { category_id_t cat_id; errno_t rc = loc_category_get_id("clock", &cat_id, IPC_FLAG_BLOCKING); if (rc != EOK) goto fallback; service_id_t *svc_ids; size_t svc_cnt; rc = loc_category_get_svcs(cat_id, &svc_ids, &svc_cnt); if (rc != EOK) goto fallback; if (svc_cnt == 0) goto fallback; char *svc_name; rc = loc_service_get_name(svc_ids[0], &svc_name); free(svc_ids); if (rc != EOK) goto fallback; service_id_t svc_id; rc = loc_service_get_id(svc_name, &svc_id, 0); free(svc_name); if (rc != EOK) goto fallback; clock_conn = loc_service_connect(svc_id, INTERFACE_DDF, IPC_FLAG_BLOCKING); if (!clock_conn) goto fallback; } struct tm time; errno_t rc = clock_dev_time_get(clock_conn, &time); if (rc != EOK) goto fallback; ts->tv_nsec = time.tm_nsec; ts->tv_sec = mktime(&time); return; fallback: getuptime(ts); } /** Get system uptime. * * @param[out] ts Timespec to hold time current uptime. * * The time variables are memory mapped (read-only) from kernel which * updates them periodically. * * As it is impossible to read 2 values atomically, we use a trick: * First we read the seconds, then we read the microseconds, then we * read the seconds again. If a second elapsed in the meantime, set * the microseconds to zero. * * This assures that the values returned by two subsequent calls * to getuptime() are monotonous. * */ void getuptime(struct timespec *ts) { if (ktime == NULL) { uintptr_t faddr; errno_t rc = sysinfo_get_value("clock.faddr", &faddr); if (rc != EOK) { errno = rc; goto fallback; } void *addr = AS_AREA_ANY; rc = physmem_map(faddr, 1, AS_AREA_READ | AS_AREA_CACHEABLE, &addr); if (rc != EOK) { as_area_destroy(addr); errno = rc; goto fallback; } ktime = addr; } sysarg_t s2 = ktime->seconds2; read_barrier(); ts->tv_nsec = USEC2NSEC(ktime->useconds); read_barrier(); sysarg_t s1 = ktime->seconds1; if (s1 != s2) { ts->tv_sec = max(s1, s2); ts->tv_nsec = 0; } else ts->tv_sec = s1; return; fallback: ts->tv_sec = 0; ts->tv_nsec = 0; } time_t time(time_t *tloc) { struct timespec ts; getrealtime(&ts); if (tloc) *tloc = ts.tv_sec; return ts.tv_sec; } void udelay(sysarg_t time) { (void) __SYSCALL1(SYS_THREAD_UDELAY, (sysarg_t) time); } /** Get time from broken-down time. * * First normalize the provided broken-down time * (moves all values to their proper bounds) and * then try to calculate the appropriate time_t * representation. * * @param tm Broken-down time. * * @return time_t representation of the time. * @return Undefined value on overflow. * */ time_t mktime(struct tm *tm) { // TODO: take DST flag into account // TODO: detect overflow normalize_tm_time(tm, 0); return secs_since_epoch(tm); } /* * FIXME: This requires POSIX-correct snprintf. * Otherwise it won't work with non-ASCII chars. */ #define APPEND(...) \ { \ consumed = snprintf(ptr, remaining, __VA_ARGS__); \ if (consumed >= remaining) \ return 0; \ \ ptr += consumed; \ remaining -= consumed; \ } #define RECURSE(fmt) \ { \ consumed = strftime(ptr, remaining, fmt, tm); \ if (consumed == 0) \ return 0; \ \ ptr += consumed; \ remaining -= consumed; \ } #define TO_12H(hour) \ (((hour) > 12) ? ((hour) - 12) : \ (((hour) == 0) ? 12 : (hour))) /** Convert time and date to a string. * * @param s Buffer to write string to. * @param maxsize Size of the buffer. * @param format Format of the output. * @param tm Broken-down time to format. * * @return Number of bytes written. * */ size_t strftime(char *restrict s, size_t maxsize, const char *restrict format, const struct tm *restrict tm) { assert(s != NULL); assert(format != NULL); assert(tm != NULL); // TODO: use locale static const char *wday_abbr[] = { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" }; static const char *wday[] = { "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" }; static const char *mon_abbr[] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" }; static const char *mon[] = { "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December" }; if (maxsize < 1) return 0; char *ptr = s; size_t consumed; size_t remaining = maxsize; while (*format != '\0') { if (*format != '%') { APPEND("%c", *format); format++; continue; } format++; if ((*format == '0') || (*format == '+')) { // TODO: padding format++; } while (isdigit(*format)) { // TODO: padding format++; } if ((*format == 'O') || (*format == 'E')) { // TODO: locale's alternative format format++; } switch (*format) { case 'a': APPEND("%s", wday_abbr[tm->tm_wday]); break; case 'A': APPEND("%s", wday[tm->tm_wday]); break; case 'b': APPEND("%s", mon_abbr[tm->tm_mon]); break; case 'B': APPEND("%s", mon[tm->tm_mon]); break; case 'c': // TODO: locale-specific datetime format RECURSE("%Y-%m-%d %H:%M:%S"); break; case 'C': APPEND("%02d", (1900 + tm->tm_year) / 100); break; case 'd': APPEND("%02d", tm->tm_mday); break; case 'D': RECURSE("%m/%d/%y"); break; case 'e': APPEND("%2d", tm->tm_mday); break; case 'F': RECURSE("%+4Y-%m-%d"); break; case 'g': APPEND("%02d", wbyear(tm) % 100); break; case 'G': APPEND("%d", wbyear(tm)); break; case 'h': RECURSE("%b"); break; case 'H': APPEND("%02d", tm->tm_hour); break; case 'I': APPEND("%02d", TO_12H(tm->tm_hour)); break; case 'j': APPEND("%03d", tm->tm_yday); break; case 'k': APPEND("%2d", tm->tm_hour); break; case 'l': APPEND("%2d", TO_12H(tm->tm_hour)); break; case 'm': APPEND("%02d", tm->tm_mon); break; case 'M': APPEND("%02d", tm->tm_min); break; case 'n': APPEND("\n"); break; case 'p': APPEND("%s", tm->tm_hour < 12 ? "AM" : "PM"); break; case 'P': APPEND("%s", tm->tm_hour < 12 ? "am" : "PM"); break; case 'r': RECURSE("%I:%M:%S %p"); break; case 'R': RECURSE("%H:%M"); break; case 's': APPEND("%lld", secs_since_epoch(tm)); break; case 'S': APPEND("%02d", tm->tm_sec); break; case 't': APPEND("\t"); break; case 'T': RECURSE("%H:%M:%S"); break; case 'u': APPEND("%d", (tm->tm_wday == 0) ? 7 : tm->tm_wday); break; case 'U': APPEND("%02d", sun_week_number(tm)); break; case 'V': APPEND("%02d", iso_week_number(tm)); break; case 'w': APPEND("%d", tm->tm_wday); break; case 'W': APPEND("%02d", mon_week_number(tm)); break; case 'x': // TODO: locale-specific date format RECURSE("%Y-%m-%d"); break; case 'X': // TODO: locale-specific time format RECURSE("%H:%M:%S"); break; case 'y': APPEND("%02d", tm->tm_year % 100); break; case 'Y': APPEND("%d", 1900 + tm->tm_year); break; case 'z': // TODO: timezone break; case 'Z': // TODO: timezone break; case '%': APPEND("%%"); break; default: /* Invalid specifier, print verbatim. */ while (*format != '%') format--; APPEND("%%"); break; } format++; } return maxsize - remaining; } /** Convert a time value to a broken-down UTC time/ * * @param time Time to convert * @param result Structure to store the result to * * @return EOK or an error code * */ errno_t time_utc2tm(const time_t time, struct tm *restrict result) { assert(result != NULL); /* Set result to epoch. */ result->tm_nsec = 0; result->tm_sec = 0; result->tm_min = 0; result->tm_hour = 0; result->tm_mday = 1; result->tm_mon = 0; result->tm_year = 70; /* 1970 */ if (normalize_tm_time(result, time) == -1) return EOVERFLOW; return EOK; } /** Convert a time value to a NULL-terminated string. * * The format is "Wed Jun 30 21:49:08 1993\n" expressed in UTC. * * @param time Time to convert. * @param buf Buffer to store the string to, must be at least * ASCTIME_BUF_LEN bytes long. * * @return EOK or an error code. * */ errno_t time_utc2str(const time_t time, char *restrict buf) { struct tm tm; errno_t ret = time_utc2tm(time, &tm); if (ret != EOK) return ret; time_tm2str(&tm, buf); return EOK; } /** Convert broken-down time to a NULL-terminated string. * * The format is "Sun Jan 1 00:00:00 1970\n". (Obsolete) * * @param timeptr Broken-down time structure. * @param buf Buffer to store string to, must be at least * ASCTIME_BUF_LEN bytes long. * */ void time_tm2str(const struct tm *restrict timeptr, char *restrict buf) { assert(timeptr != NULL); assert(buf != NULL); static const char *wday[] = { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" }; static const char *mon[] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" }; snprintf(buf, ASCTIME_BUF_LEN, "%s %s %2d %02d:%02d:%02d %d\n", wday[timeptr->tm_wday], mon[timeptr->tm_mon], timeptr->tm_mday, timeptr->tm_hour, timeptr->tm_min, timeptr->tm_sec, 1900 + timeptr->tm_year); } /** Converts a time value to a broken-down local time. * * Time is expressed relative to the user's specified timezone. * * @param tv Timeval to convert. * @param result Structure to store the result to. * * @return EOK on success or an error code. * */ errno_t time_ts2tm(const struct timespec *ts, struct tm *restrict result) { // TODO: Deal with timezones. // Currently assumes system and all times are in UTC /* Set result to epoch. */ result->tm_nsec = 0; result->tm_sec = 0; result->tm_min = 0; result->tm_hour = 0; result->tm_mday = 1; result->tm_mon = 0; result->tm_year = 70; /* 1970 */ if (normalize_tm_ts(result, ts) == -1) return EOVERFLOW; return EOK; } /** Converts a time value to a broken-down local time. * * Time is expressed relative to the user's specified timezone. * * @param timer Time to convert. * @param result Structure to store the result to. * * @return EOK on success or an error code. * */ errno_t time_local2tm(const time_t time, struct tm *restrict result) { struct timespec ts = { .tv_sec = time, .tv_nsec = 0 }; return time_ts2tm(&ts, result); } /** Convert the calendar time to a NULL-terminated string. * * The format is "Wed Jun 30 21:49:08 1993\n" expressed relative to the * user's specified timezone. * * @param timer Time to convert. * @param buf Buffer to store the string to. Must be at least * ASCTIME_BUF_LEN bytes long. * * @return EOK on success or an error code. * */ errno_t time_local2str(const time_t time, char *buf) { struct tm loctime; errno_t ret = time_local2tm(time, &loctime); if (ret != EOK) return ret; time_tm2str(&loctime, buf); return EOK; } /** Calculate the difference between two times, in seconds. * * @param time1 First time. * @param time0 Second time. * * @return Time difference in seconds. * */ double difftime(time_t time1, time_t time0) { return (double) (time1 - time0); } /** @} */