Go to main content

man pages section 3: Basic Library Functions

Exit Print View

Updated: Thursday, June 13, 2019
 
 

timegm(3C)

Name

mktime, timegm, timelocal - converts atmstructure to a calendar time

Synopsis

#include <time.h>
time_t mktime(struct tm *timeptr);
time_t timegm(struct tm *timeptr);
time_t timelocal(struct tm *timeptr);

Description

The mktime(), timegm(), and timelocal() functions convert the time represented by the tm structure pointed to by timeptr into a calendar time (the number of seconds since 00:00:00 UTC, January 1, 1970).

The tm structure contains the following members:

int  tm_sec;     /* seconds after the minute [0, 60]  */
int  tm_min;     /* minutes after the hour [0, 59] */
int  tm_hour;    /* hour since midnight [0, 23] */
int  tm_mday;    /* day of the month [1, 31] */
int  tm_mon;     /* months since January [0, 11] */
int  tm_year;    /* years since 1900 */
int  tm_wday;    /* days since Sunday [0, 6] */
int  tm_yday;    /* days since January 1 [0, 365] */
int  tm_isdst;   /* flag for daylight savings time */

In addition to computing the calendar time, mktime(), timegm(), and timelocal() normalize the supplied tm structure. The original values of the tm_wday and tm_yday components of the structure are ignored, and the original values of the other components are not restricted to the ranges indicated in the definition of the structure. On successful completion, the values of the tm_wday and tm_yday components are set appropriately, and the other components are set to represent the specified calendar time, but with their values forced to be within the appropriate ranges. The final value of tm_mday is not set until tm_mon and tm_year are determined.

Calendar time in a 32-bit application cannot represent values before 20:45:52 UTC, December 13, 1901 or after 03:14:07 UTC, January 19, 2038. As the tm_year member is a signed integer, calendar time in a 64-bit application cannot represent years before 2147483649 BC or after 2147485546 AD. Portable applications should not try to create dates before 00:00:00 UTC, January 1, 1970 or after 00:00:00 UTC, January 1, 2038. Where practical 64-bit applications should limit themselves to dates in the range 00:00:00 UTC, January 1, 1970 to 00:00:00 UTC, December 31, 9999.

The original values of the components may be either greater than or less than the specified range. For example, a tm_hour of −1 means 1 hour before midnight, tm_mday of 0 means the day preceding the current month, and tm_mon of −2 means 2 months before January of tm_year.

If tm_isdst is positive, mktime() assumes the original values to be in the alternate timezone. If it turns out that the alternate timezone is not valid for the computed calendar time, then the components are adjusted to the main timezone. Likewise, if tm_isdst is zero, the original values are assumed to be in the main timezone and are converted to the alternate timezone if the main timezone is not valid. If tm_isdst is negative, mktime() attempts to determine whether the alternate timezone is in effect for the specified time. timelocal() is equivalent to mktime() with a negative tm_isdst value.

Local timezone information is used as if mktime() or timelocal() had called tzset(). See ctime(3C).

The function timegm() performs the inverse conversion to gmtime() and ignores the local timezone information. The original values are assumed to be in the UTC timezone. See ctime(3C).

Return Values

If the calendar time can be represented in an object of type time_t, then mktime(), timegm(), and timelocal() return the specified calendar time without changing errno. If the calendar time cannot be represented, the functions return the value (time_t)\(mi1) and set errno to indicate the error.

Errors

The mktime(), timegm(), and timelocal() functions will fail if:

EOVERFLOW

The date represented by the input tm struct cannot be represented in a time_t. Note that the errno setting may change if future revisions to the standards specify a different value.

Usage

The mktime() and timelocal() functions are MT-Safe in multithreaded applications, as long as no user-defined function directly modifies one of the following variables: timezone, altzone, daylight, and tzname. See ctime(3C). The timegm() function is MT-Safe in multithreaded applications.

Note that −1 can be a valid return value for the time that is one second before the Epoch. The user should clear errno before calling mktime(). If mktime() then returns −1, the user should check errno to determine whether or not an error actually occurred.

The mktime(), timegm(), and timelocal() functions assume Gregorian dates. Times before the adoption of the Gregorian calendar will not match historical records.

Examples

Example 1 Sample code using mktime().

What day of the week is July 4, 2001?

#include <stdio.h>
#include <time.h>
static char *const wday[ ] = {
        "Sunday", "Monday", "Tuesday", "Wednesday",
        "Thursday", "Friday", "Saturday", "-unknown-"
};
struct tm time_str;
/* . . .*/
time_str.tm_year	= 2001 - 1900;
time_str.tm_mon = 7 - 1;
time_str.tm_mday = 4;
time_str.tm_hour = 0;
time_str.tm_min = 0;
time_str.tm_sec = 1;
time_str.tm_isdst = −1;
if (mktime(&time_str)== −1)
        time_str.tm_wday=7;
printf("%s\n", wday[time_str.tm_wday]);

Attributes

See attributes(7) for descriptions of the following attributes:

ATTRIBUTE TYPE
ATTRIBUTE VALUE
Interface Stability
Committed
MT-Level
MT-Safe with exceptions
Standard

See Also

ctime(3C), getenv(3C), attributes(7), standards(7)