1
2
3
#include <sys/time.h>
int gettimeofday(struct timeval *tv, struct timezone *tz);
//Returns 0 on success, or –1 on error

1
2
3
4
struct timeval {
 time_t tv_sec; /* Seconds since 00:00:00, 1 Jan 1970 UTC */
 suseconds_t tv_usec; /* Additional microseconds (long int) */
};

1
2
3
#include <time.h>
time_t time(time_t *timep);
//Returns number of seconds since the Epoch,or (time_t) –1 on error

1
t = time(NULL);

1
2
3
4
#include <time.h>
char *ctime(const time_t *timep);
//Returns pointer to statically allocated string terminated
//by newline and  on success, or NULL on error

1
2
3
4
5
#include <time.h>
struct tm *gmtime(const time_t *timep);
struct tm *localtime(const time_t *timep);
//Both return a pointer to a statically allocated broken-down
//time structure on success, or NULL on error

1
2
3
4
5
6
7
8
9
10
11
12
13
14
struct tm {
 int tm_sec; /* Seconds (0-60) */
 int tm_min; /* Minutes (0-59) */
 int tm_hour; /* Hours (0-23) */
 int tm_mday; /* Day of the month (1-31) */
 int tm_mon; /* Month (0-11) */
 int tm_year; /* Year since 1900 */
 int tm_wday; /* Day of the week (Sunday = 0)*/
 int tm_yday; /* Day in the year (0-365; 1 Jan = 0)*/
 int tm_isdst; /* Daylight saving time flag
 > 0: DST is in effect;
 = 0: DST is not effect;
 < 0: DST information not available */
};

1
2
3
4
#include <time.h>
time_t mktime(struct tm *timeptr);
//Returns seconds since the Epoch corresponding to timeptr
//on success, or (time_t) –1 on error

1
2
3
4
#include <time.h>
char *asctime(const struct tm *timeptr);
//Returns pointer to statically allocated string terminated by
//newline and  on success, or NULL on error

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
#include <locale.h>
#include <time.h>
#include <sys/time.h>
#include "tlpi_hdr.h"

#define SECONDS_IN_TROPICAL_YEAR (365.24219 * 24 * 60 * 60)
int
main(int argc, char *argv[])
{
    time_t t;
    struct tm *gmp, *locp;
    struct tm gm, loc;
    struct timeval tv;

    t = time(NULL);
    printf("Seconds since the Epoch (1 Jan 1970): %ld", (long) t);
    printf(" (about %6.3f years)n", t / SECONDS_IN_TROPICAL_YEAR);

    if (gettimeofday(&tv, NULL) == -1)
        errExit("gettimeofday");
    printf("  gettimeofday() returned %ld secs, %ld microsecsn",
            (long) tv.tv_sec, (long) tv.tv_usec);

    gmp = gmtime(&t);
    if (gmp == NULL)
        errExit("gmtime");

    gm = *gmp;          /* Save local copy, since *gmp may be modified
                           by asctime() or gmtime() */
    printf("Broken down by gmtime():n");
    printf("  year=%d mon=%d mday=%d hour=%d min=%d sec=%d ", gm.tm_year,
            gm.tm_mon, gm.tm_mday, gm.tm_hour, gm.tm_min, gm.tm_sec);
    printf("wday=%d yday=%d isdst=%dn", gm.tm_wday, gm.tm_yday, gm.tm_isdst);

    locp = localtime(&t);
    if (locp == NULL)
        errExit("localtime");

    loc = *locp;        /* Save local copy */

    printf("Broken down by localtime():n");
    printf("  year=%d mon=%d mday=%d hour=%d min=%d sec=%d ",
            loc.tm_year, loc.tm_mon, loc.tm_mday,
            loc.tm_hour, loc.tm_min, loc.tm_sec);
    printf("wday=%d yday=%d isdst=%dnn",
            loc.tm_wday, loc.tm_yday, loc.tm_isdst);

    printf("asctime() formats the gmtime() value as: %s", asctime(&gm));
    printf("ctime() formats the time() value as:     %s", ctime(&t));

    printf("mktime() of gmtime() value:    %ld secsn", (long) mktime(&gm));
    printf("mktime() of localtime() value: %ld secsn", (long) mktime(&loc));

    exit(EXIT_SUCCESS);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
pi@raspberrypi:~/sysprog/learn_tlpi/build $ date
Mon 15 Aug 2022 11:06:07 AM CEST
pi@raspberrypi:~/sysprog/learn_tlpi/build $ ./out
Seconds since the Epoch (1 Jan 1970): 1660554369 (about 52.621 years)
  gettimeofday() returned 1660554369 secs, 907771 microsecs
Broken down by gmtime():
  year=122 mon=7 mday=15 hour=9 min=6 sec=9 wday=1 yday=226 isdst=0
Broken down by localtime():
  year=122 mon=7 mday=15 hour=11 min=6 sec=9 wday=1 yday=226 isdst=1

asctime() formats the gmtime() value as: Mon Aug 15 09:06:09 2022
ctime() formats the time() value as:     Mon Aug 15 11:06:09 2022
mktime() of gmtime() value:    1660550769 secs
mktime() of localtime() value: 1660554369 secs

1
2
3
4
5
#include <time.h>
size_t strftime(char *outstr, size_t maxsize, const char *format,
 const struct tm *timeptr);
//Returns number of bytes placed in outstr (excluding
//terminating null byte) on success, or 0 on error

1
2
3
#include "curr_time.h"
char *currTime(const char *format);
//Returns pointer to statically allocated string, or NULL on error

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
#include <time.h>
#include "curr_time.h"          /* Declares function defined here */

#define BUF_SIZE 1000
/* Return a string containing the current time formatted according to
   the specification in 'format' (see strftime(3) for specifiers).
   If 'format' is NULL, we use "%c" as a specifier (which gives the'
   date and time as for ctime(3), but without the trailing newline).
   Returns NULL on error. */

char *
currTime(const char *format)
{
    static char buf[BUF_SIZE];  /* Nonreentrant */
    time_t t;
    size_t s;
    struct tm *tm;

    t = time(NULL);
    tm = localtime(&t);
    if (tm == NULL)
        return NULL;

    s = strftime(buf, BUF_SIZE, (format != NULL) ? format : "%c", tm);

    return (s == 0) ? NULL : buf;
}

1
2
3
4
5
6
7
8
9
10
/* curr_time.h

   Header file for curr_time.c.
*/
#ifndef CURR_TIME_H
#define CURR_TIME_H             /* Prevent accidental double inclusion */

char *currTime(const char *fmt);

#endif

1
2
3
4
5
#define _XOPEN_SOURCE
#include <time.h>
char *strptime(const char *str, const char *format, struct tm *timeptr);
//Returns pointer to next unprocessed character in
//str on success, or NULL on error

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
/* strtime.c

   Demonstrate the use of strptime() and strftime().

   Calls strptime() using the given "format" to process the "input-date+time".
   The conversion is then reversed by calling strftime() with the given
   "out-format" (or a default format if this argument is omitted).
*/
#if ! defined(__sun)
#ifndef _XOPEN_SOURCE
#define _XOPEN_SOURCE
#endif
#endif
#include <time.h>
#include <locale.h>
#include "tlpi_hdr.h"

#define SBUF_SIZE 1000
int
main(int argc, char *argv[])
{
    struct tm tm;
    char sbuf[SBUF_SIZE];
    char *ofmt;

    if (argc < 3 || strcmp(argv[1], "--help") == 0)
        usageErr("%s input-date-time in-format [out-format]n", argv[0]);

    if (setlocale(LC_ALL, "") == NULL)
        errExit("setlocale");   /* Use locale settings in conversions */

    memset(&tm, 0, sizeof(struct tm));          /* Initialize 'tm' */
    if (strptime(argv[1], argv[2], &tm) == NULL)
        fatal("strptime");

    tm.tm_isdst = -1;           /* Not set by strptime(); tells mktime()
                                   to determine if DST is in effect */
    printf("calendar time (seconds since Epoch): %ldn", (long) mktime(&tm));

    ofmt = (argc > 3) ? argv[3] : "%H:%M:%S %A, %d %B %Y %Z";
    if (strftime(sbuf, SBUF_SIZE, ofmt, &tm) == 0)
        fatal("strftime returned 0");
    printf("strftime() yields: %sn", sbuf);

    exit(EXIT_SUCCESS);
}

1
2
3
4
5
6
7
pi@raspberrypi:~/sysprog/learn_tlpi/build $ ./out  "9:39:46pm 1 Feb 2011" "%I:%M:%S%p %d %b %Y"
calendar time (seconds since Epoch): 1296592786
strftime() yields: 21:39:46 Tuesday, 01 February 2011 CET
pi@raspberrypi:~/sysprog/learn_tlpi/build $ ./out "9:39:46pm 1 Feb 2011" "%I:%M:%S%p %d %b %Y" "%F %T"
calendar time (seconds since Epoch): 1296592786
strftime() yields: 2011-02-01 21:39:46

1
2
3
4
5
6
7
8
9
10
11
12
13
14
pi@raspberrypi:/usr/share/zoneinfo $ ls
Africa      Cuba     GMT+0        Japan              Pacific     Turkey
America     EET      GMT-0        Kwajalein          Poland      UCT
Antarctica  Egypt    GMT0         leap-seconds.list  Portugal    Universal
Arctic      Eire     Greenwich    Libya              posix       US
Asia        EST      Hongkong     localtime          posixrules  UTC
Atlantic    EST5EDT  HST          MET                PRC         WET
Australia   Etc      Iceland      Mexico             PST8PDT     W-SU
Brazil      Europe   Indian       MST                right       zone1970.tab
Canada      Factory  Iran         MST7MDT            ROC         zone.tab
CET         GB       iso3166.tab  Navajo             ROK         Zulu
Chile       GB-Eire  Israel       NZ                 Singapore
CST6CDT     GMT      Jamaica      NZ-CHAT            SystemV

1
2
3
4
char *tzname[2]; /* Name of timezone and alternate (DST) timezone */
int daylight; /* Nonzero if there is an alternate (DST) timezone */
long timezone; /* Seconds difference between UTC and local
 standard time */

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
#include <time.h>
#include <locale.h>
#include "tlpi_hdr.h"

#define BUF_SIZE 200
int
main(int argc, char *argv[])
{
    time_t t;
    struct tm *loc;
    char buf[BUF_SIZE];

    if (setlocale(LC_ALL, "") == NULL)
        errExit("setlocale");   /* Use locale settings in conversions */

    t = time(NULL);

    printf("ctime() of time() value is:  %s", ctime(&t));

    loc = localtime(&t);
    if (loc == NULL)
        errExit("localtime");

    printf("asctime() of local time is:  %s", asctime(loc));

    if (strftime(buf, BUF_SIZE, "%A, %d %B %Y, %H:%M:%S %Z", loc) == 0)
        fatal("strftime returned 0");
    printf("strftime() of local time is: %sn", buf);

    exit(EXIT_SUCCESS);
}

1
2
3
4
5
6
7
8
9
pi@raspberrypi:/usr/share/zoneinfo/Pacific $ ls
Apia          Enderbury    Guam        Marquesas  Palau         Samoa      Yap
Auckland      Fakaofo      Honolulu    Midway     Pitcairn      Tahiti
Bougainville  Fiji         Johnston    Nauru      Pohnpei       Tarawa
Chatham       Funafuti     Kiritimati  Niue       Ponape        Tongatapu
Chuuk         Galapagos    Kosrae      Norfolk    Port_Moresby  Truk
Easter        Gambier      Kwajalein   Noumea     Rarotonga     Wake
Efate         Guadalcanal  Majuro      Pago_Pago  Saipan        Wallis

1
2
3
4
5
6
7
8
9
pi@raspberrypi:~/sysprog/learn_tlpi/build $ ./out 
ctime() of time() value is:  Mon Aug 15 18:14:53 2022
asctime() of local time is:  Mon Aug 15 18:14:53 2022
strftime() of local time is: Monday, 15 August 2022, 18:14:53 CEST
pi@raspberrypi:~/sysprog/learn_tlpi/build $ TZ=":Pacific/Auckland" ./out
ctime() of time() value is:  Tue Aug 16 04:15:41 2022
asctime() of local time is:  Tue Aug 16 04:15:41 2022
strftime() of local time is: Tuesday, 16 August 2022, 04:15:41 NZST

1
2
std offset [ dst [ offset ][ , start-date [ /time ] , end-date [ /time ]]]

1
2
3
4
5
TZ="CET-1:00:00CEST-2:00:00,M3.5.0,M10.5.0"
     ^     ^    ^     ^        ^       ^
     |     |    |     |        |       |
    std offset dst  offset start-date  end-date  

1
2
TZ=":Europe/Berlin"

1
2
language[_territory[.codeset]][@modifier]

1
2
3
4
5
 zh_CN
bn_IN     en_NZ        hr     kw_GB     nso           szl       zh_Hant
bo        en@quot      ht     kw@kkcor  nv            ta        zh_HK
br        en@shaw      hu     kw@uccor  oc            te        zh_TW

1
2
3
4
#include <locale.h>
char *setlocale(int category, const char *locale);
//Returns pointer to a (usually statically allocated) string identifying
//the new or current locale on success, or NULL on error

1
2
setlocale(LC_ALL, "");

1
2
3
4
5
6
7
8
9
10
11
12
13
14
$ LANG=de_DE ./show_time German locale
ctime() of time() value is: Tue Feb 1 12:23:39 2011
asctime() of local time is: Tue Feb 1 12:23:39 2011
strftime() of local time is: Dienstag, 01 Februar 2011, 12:23:39 CET

$ LANG=de_DE LC_TIME=it_IT ./show_time German and Italian locales
ctime() of time() value is: Tue Feb 1 12:24:03 2011
asctime() of local time is: Tue Feb 1 12:24:03 2011
strftime() of local time is: martedì, 01 febbraio 2011, 12:24:03 CET

$ LC_ALL=fr_FR LC_TIME=en_US ./show_time French and US locales
ctime() of time() value is: Tue Feb 1 12:25:38 2011
asctime() of local time is: Tue Feb 1 12:25:38 2011
strftime() of local time is: mardi, 01 février 2011, 12:25:38 CET

1
2
3
4
#define _BSD_SOURCE
#include <sys/time.h>
int settimeofday(const struct timeval *tv, const struct timezone *tz);
//Returns 0 on success, or –1 on error

1
2
3
4
#define _BSD_SOURCE
#include <sys/time.h>
int adjtime(struct timeval *delta, struct timeval *olddelta);
//Returns 0 on success, or –1 on error

1
2
3
4
#include <sys/times.h>
clock_t times(struct tms *buf);
//Returns number of clock ticks (sysconf(_SC_CLK_TCK)) since
//“arbitrary” time in past on success, or (clock_t) –1 on error

1
2
3
4
5
6
struct tms {
 clock_t tms_utime; /* User CPU time used by caller */
 clock_t tms_stime; /* System CPU time used by caller */ 
 clock_t tms_cutime; /* User CPU time of all (waited for) children */
 clock_t tms_cstime; /* System CPU time of all (waited for) children */
};

1
2
3
4
#include <time.h>
clock_t clock(void);
//Returns total CPU time used by calling process measured in
//CLOCKS_PER_SEC, or (clock_t) –1 on error

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
#include <sys/times.h>
#include <time.h>
#include "tlpi_hdr.h"
static void             /* Display 'msg' and process times */
displayProcessTimes(const char *msg)
{
    struct tms t;
    clock_t clockTime;
    static long clockTicks = 0;

    if (msg != NULL)
        printf("%s", msg);

    if (clockTicks == 0) {      /* Fetch clock ticks on first call */
        clockTicks = sysconf(_SC_CLK_TCK);
        if (clockTicks == -1)
            errExit("sysconf");
    }

    clockTime = clock();
    if (clockTime == -1)
        errExit("clock");

    printf("        clock() returns: %ld clocks-per-sec (%.2f secs)n",
            (long) clockTime, (double) clockTime / CLOCKS_PER_SEC);

    if (times(&t) == -1)
        errExit("times");
    printf("        times() yields: user CPU=%.2f; system CPU: %.2fn",
            (double) t.tms_utime / clockTicks,
            (double) t.tms_stime / clockTicks);
}
int
main(int argc, char *argv[])
{
    int numCalls, j;

    printf("CLOCKS_PER_SEC=%ld  sysconf(_SC_CLK_TCK)=%ldnn",
            (long) CLOCKS_PER_SEC, sysconf(_SC_CLK_TCK));

    displayProcessTimes("At program start:n");

    numCalls = (argc > 1) ? getInt(argv[1], GN_GT_0, "num-calls") : 100000000;
    for (j = 0; j < numCalls; j++)
        (void) getppid();

    displayProcessTimes("After getppid() loop:n");

    exit(EXIT_SUCCESS);
}

1
2
3
4
5
6
7
8
9
10
pi@raspberrypi:~/sysprog/learn_tlpi/build $ ./out 10000000
CLOCKS_PER_SEC=1000000  sysconf(_SC_CLK_TCK)=100

At program start:
        clock() returns: 5722 clocks-per-sec (0.01 secs)
        times() yields: user CPU=0.00; system CPU: 0.00
After getppid() loop:
        clock() returns: 3360682 clocks-per-sec (3.36 secs)
        times() yields: user CPU=1.22; system CPU: 2.14