Timestamp

Data Structures
struct	_timestamp
	The timestamp structure (unix epoch time). More...

Typedefs
typedef struct _timestamp	amxc_ts_t
	The timestamp structure (unix epoch time). More...

Functions
int	amxc_ts_now (amxc_ts_t *tsp)
	Takes current time as unix epoch time. More...
int	amxc_ts_parse (amxc_ts_t *tsp, const char *str, size_t len)
	Transforms the given string in to unix epoch time. More...
size_t	amxc_ts_format (const amxc_ts_t *tsp, char *dst, size_t len)
	Transforms unix epoch time to a string. More...
size_t	amxc_ts_format_precision (const amxc_ts_t *tsp, char *dst, size_t len, int precision)
	Transforms unix epoch time to a string. More...
int	amxc_ts_compare (const amxc_ts_t *tsp1, const amxc_ts_t *tsp2)
	Checks if tsp1 comes after tsp2. More...
bool	amxc_ts_is_valid (const amxc_ts_t *tsp)
	Checks if a timestamp is valid. More...
int	amxc_ts_to_tm_utc (const amxc_ts_t *tsp, struct tm *tmp)
	Converts timestamp in unix epoch time to a struct tm type in UTC time. More...
int	amxc_ts_to_tm_local (const amxc_ts_t *tsp, struct tm *tmp)
	Converts timestamp in unix epoch time to a struct tm type in local time. More...
int	amxc_ts_to_local (amxc_ts_t *tsp)
	Adds the local time offset to the timestamp structure. More...
int	amxc_ts_from_tm (amxc_ts_t *const tsp, struct tm *tmp)
	Converts a broken down time in a struct tm to a timestamp structure. More...

Detailed Description

Typedef Documentation

amxc_ts_t

typedef struct _timestamp amxc_ts_t

The timestamp structure (unix epoch time).

Function Documentation

amxc_ts_compare()

int amxc_ts_compare	(	const amxc_ts_t *	tsp1,
		const amxc_ts_t *	tsp2
	)

Checks if tsp1 comes after tsp2.

Parameters

tsp1	a pointer to a timestamp structure
tsp2	a pointer to a timestamp structure

Returns

0 if input is invalid 1 if tsp1 comes after tsp2 -1 if tsp2 comes after tsp1

Definition at line 506 of file amxc_timestamp.c.

                                                                  {
    when_null(tsp1, exit);
    when_null(tsp2, exit);
 
    if(tsp1->sec < tsp2->sec) {
        return -1;
    }
    if(tsp1->sec > tsp2->sec) {
        return 1;
    }
    if(tsp1->nsec < tsp2->nsec) {
        return -1;
    }
    if(tsp1->nsec > tsp2->nsec) {
        return 1;
    }
 
exit:
    return 0;
}

amxc_ts_format()

size_t amxc_ts_format	(	const amxc_ts_t *	tsp,
		char *	dst,
		size_t	len
	)

Transforms unix epoch time to a string.

Transforms unix epoch time to string in RFC3339 compatible format.

Use amxc_ts_format_precision to specify the precision.

Note

The length of the provided string buffer must be at least 21 bytes. The buffer length must be 36 bytes to be able to store nanoseconds and time zone offset. The buffer must be pre-allocated.

Parameters

tsp	a pointer to a timestamp structure
dst	a pointer to a string
len	size of the string buffer

Returns

length of string dst

Definition at line 461 of file amxc_timestamp.c.

                                  {
    size_t retval = 0;
    uint32_t f;
    int precision;
 
    when_null(tsp, exit);
    when_null(dst, exit);
    when_true(!amxc_ts_is_valid(tsp), exit);
 
    f = tsp->nsec;
    if(f == 0) {
        precision = 0;
    } else {
        if((f % 1000000) == 0) {
            precision = 3;
        } else if((f % 1000) == 0) {
            precision = 6;
        } else {
            precision = 9;
        }
    }
    retval = timestamp_format_internal(dst, len, tsp, precision);
 
exit:
    return retval;
}

amxc_ts_format_precision()

size_t amxc_ts_format_precision	(	const amxc_ts_t *	tsp,
		char *	dst,
		size_t	len,
		int	precision
	)

Transforms unix epoch time to a string.

Transforms unix epoch time to string in RFC3339 compatible format.

Note

The length of the provided string buffer must be at least 21 bytes. The buffer length must be 36 bytes to be able to store nanoseconds and time zone offset. The buffer must be pre-allocated.

Parameters

tsp	a pointer to a timestamp structure
dst	a pointer to a string storing the UTC time
len	size of the string buffer
precision	number of digits used to express nanoseconds

Returns

length of string dst

Definition at line 490 of file amxc_timestamp.c.

                                               {
    int retval = 0;
 
    when_null(tsp, exit);
    when_null(dst, exit);
 
    when_true(!amxc_ts_is_valid(tsp) || precision < 0 || precision > 9, exit);
    retval = timestamp_format_internal(dst, len, tsp, precision);
 
exit:
    return retval;
}

amxc_ts_from_tm()

int amxc_ts_from_tm	(	amxc_ts_t *const	tsp,
		struct tm *	tmp
	)

Converts a broken down time in a struct tm to a timestamp structure.

Using this function a timestamp structure is initialized using a struct tm as input.

Note

As struct tm doesn't contain timezone information, the offset will be set to 0.

Parameters

tsp	a pointer to a timestamp structure
tmp	pointer to struct tm, containing the broken down time.

Returns

-1 if an error occurs 0 if the action succeeded

Definition at line 574 of file amxc_timestamp.c.

                                                          {
    int rv = -1;
    time_t epoch = 0;
 
    when_null(tsp, exit);
    when_null(tmp, exit);
 
    epoch = mktime(tmp);
    when_true(epoch == -1, exit);
 
    tsp->sec = epoch;
    tsp->nsec = 0;
    tsp->offset = 0;
 
    rv = 0;
 
exit:
    return rv;
}

amxc_ts_is_valid()

bool amxc_ts_is_valid

(

const amxc_ts_t *

tsp

)

Checks if a timestamp is valid.

Parameters

tsp	a pointer to a timestamp structure

Returns

true if the timestamp is valid false if the timestamp is invalid

Definition at line 527 of file amxc_timestamp.c.

                                            {
    bool retval = false;
    int64_t sec = 0;
    when_null(tsp, exit);
 
    sec = tsp->sec + tsp->offset * 60;
    if((sec < MIN_SEC) || (sec > MAX_SEC) ||
       ( tsp->nsec < 0) || ( tsp->nsec > 999999999) ||
       ( tsp->offset < -1439) || ( tsp->offset > 1439)) {
        goto exit;
    }
 
    retval = true;
 
exit:
    return retval;
}

amxc_ts_now()

int amxc_ts_now

(

amxc_ts_t *

tsp

)

Takes current time as unix epoch time.

Fills the given amxc_ts_t structure with the current time in seconds from the unix epoch time.

Parameters

tsp	a pointer to the timestamp structure

Returns

-1 if an error occurred. 0 on success.

Definition at line 301 of file amxc_timestamp.c.

                                {
    int retval = -1;
    struct timespec ts = {0, 0};
 
    when_null(tsp, exit);
    retval = clock_gettime(CLOCK_REALTIME, &ts);
    tsp->sec = ts.tv_sec;
    tsp->nsec = ts.tv_nsec;
 
    if(retval != 0) {
        tsp->sec = MIN_SEC;
    }
    tsp->offset = 0;
 
exit:
    return retval ? -1 : 0;
}

amxc_ts_parse()

int amxc_ts_parse	(	amxc_ts_t *	tsp,
		const char *	str,
		size_t	len
	)

Transforms the given string in to unix epoch time.

Transforms the time stored in a string in https://tools.ietf.org/html/rfc3339 format into unix epoch time stored as a struct.

Parameters

tsp	a pointer to a timestamp structure
str	string containing time in RFC3339 format
len	length of the string

Returns

-1 if an error occurred. 0 on success.

Definition at line 369 of file amxc_timestamp.c.

                              {
    int retval = -1;
    const unsigned char* cur, * end;
    unsigned char ch;
    uint16_t year, month, day, hour, min, sec;
    uint32_t rdn, sod, nsec;
    int16_t offset;
 
    when_null(tsp, exit);
    when_null(str, exit);
    when_true(len < 20, exit);
    /*
     *           1
     * 01234567890123456789
     * 2013-12-31T23:59:59Z
     */
    cur = (const unsigned char*) str;
    when_true(cur[4] != '-' || cur[7] != '-' ||
              cur[13] != ':' || cur[16] != ':', exit);
 
    ch = cur[10];
    when_true(!(ch == 'T' || ch == ' ' || ch == 't'), exit);
    when_failed(amxc_ts_parse_date(cur, &year, &month, &day), exit);
    when_failed(amxc_ts_parse_time(cur, &hour, &min, &sec), exit);
    when_true(day > 28 && day > month_days(year, month), exit);
 
    if(month < 3) {
        year--;
    }
 
    rdn = (1461 * year) / 4 - year / 100 + year / 400 + DayOffset[month] + day - 306;
    sod = hour * 3600 + min * 60 + sec;
    end = cur + len;
    cur = cur + 19;
    offset = nsec = 0;
 
    ch = *cur++;
    if(ch == '.') {
        const unsigned char* start;
        size_t ndigits;
 
        start = cur;
        for(; cur < end; cur++) {
            const unsigned char digit = *cur - '0';
            if(digit > 9) {
                break;
            }
            nsec = nsec * 10 + digit;
        }
 
        ndigits = cur - start;
        when_true(ndigits < 1 || ndigits > 9, exit);
 
        nsec *= Pow10[9 - ndigits];
 
        when_true(cur == end, exit);
 
        ch = *cur++;
    }
 
    if(!((ch == 'Z') || (ch == 'z'))) {
        when_failed(amxc_ts_parse_offset(cur - 1, end, &offset), exit);
        cur += 5;
    }
 
    when_true(cur != end, exit);
 
    tsp->sec = ((int64_t) rdn - 719163) * 86400 + sod - offset * 60;
    tsp->nsec = nsec;
    tsp->offset = offset;
 
    retval = 0;
 
exit:
    return retval;
}

amxc_ts_to_local()

int amxc_ts_to_local

(

amxc_ts_t *

tsp

)

Adds the local time offset to the timestamp structure.

Parameters

tsp	a pointer to a timestamp structure

Returns

-1 if an error occurs 0 if the action succeeded

Definition at line 553 of file amxc_timestamp.c.

                                     {
    int retval = -1;
    time_t rawtime = time(NULL);
    struct tm* ptm = gmtime(&rawtime);
    time_t gmt = 0;
 
    when_null(ptm, exit);
    when_null(tsp, exit);
 
    gmt = mktime(ptm);
    ptm = localtime(&rawtime);
 
    when_null(ptm, exit);
 
    tsp->offset = (rawtime - gmt + (ptm->tm_isdst ? 3600 : 0)) / 60;
    retval = 0;
 
exit:
    return retval;
}

amxc_ts_to_tm_local()

int amxc_ts_to_tm_local	(	const amxc_ts_t *	tsp,
		struct tm *	tmp
	)

Converts timestamp in unix epoch time to a struct tm type in local time.

Parameters

tsp	a pointer to a timestamp structure
tmp	a pointer to a struct tm type

Returns

-1 if an error occurs 0 if the action succeeded

Definition at line 549 of file amxc_timestamp.c.

                                                              {
    return timestamp_to_tm(tsp, tmp, true);
}

amxc_ts_to_tm_utc()

int amxc_ts_to_tm_utc	(	const amxc_ts_t *	tsp,
		struct tm *	tmp
	)

Converts timestamp in unix epoch time to a struct tm type in UTC time.

Parameters

tsp	a pointer to a timestamp structure
tmp	a pointer to a struct tm type

Returns

-1 if an error occurs 0 if the action succeeded

Definition at line 545 of file amxc_timestamp.c.

                                                            {
    return timestamp_to_tm(tsp, tmp, false);
}