/*
** Zabbix
** Copyright (C) 2001-2022 Zabbix SIA
**
** This program is free software; you can redistribute it and/or modify
** it under the terms of the GNU General Public License as published by
** the Free Software Foundation; either version 2 of the License, or
** (at your option) any later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with this program; if not, write to the Free Software
** Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
**/
#include "common.h"
#include "zbxmockdata.h"
/* output formats */
#define ZBX_MOCK_FORMAT_DATE "%04d-%02d-%02d"
#define ZBX_MOCK_FORMAT_TIME "%02d:%02d:%02d"
#define ZBX_MOCK_FORMAT_DATETIME ZBX_MOCK_FORMAT_DATE " " ZBX_MOCK_FORMAT_TIME
#define ZBX_MOCK_FORMAT_NS ".%09d"
#define ZBX_MOCK_FORMAT_TZ "%c%02d:%02d"
#define ZBX_MOCK_TZ_MAX 7
#define ZBX_MOCK_TIME_DATE 0x0001
#define ZBX_MOCK_TIME_TIME 0x0002
#define ZBX_MOCK_TIME_NS 0x0004
#define ZBX_MOCK_TIME_TZ 0x0008
/******************************************************************************
* *
* Function: ts_get_component_end *
* *
* Purpose: finds the next character after numeric time component *
* *
* Parameters: text - [IN] the text *
* *
* Return value: text after the time component *
* *
* Comments: If the first character is not a digit the source text is *
* returned. *
* *
******************************************************************************/
static const char *ts_get_component_end(const char *text)
{
while (0 != isdigit(*text))
text++;
return text;
}
/******************************************************************************
* *
* Function: ts_get_date *
* *
* Purpose: parses year, month and day from date component having *
* YYYY-MM-DD format *
* *
* Parameters: text - [IN] the text *
* year - [OUT] the year *
* month - [OUT] the month *
* day - [OUT] the day *
* pnext - [OUT] text after date component *
* *
* Return value: ZBX_MOCK_SUCCESS - the date was parsed successfully *
* ZBX_MOCK_NOT_A_TIMESTAMP - invalid date format *
* *
* Comments: The year, month, day limits are not validated. *
* *
******************************************************************************/
static zbx_mock_error_t ts_get_date(const char *text, int *year, int *month, int *day, const char **pnext)
{
const char *year_end, *month_end, *day_end;
int value_year, value_month, value_day;
year_end = ts_get_component_end(text);
if (year_end - text != 4 || '-' != *year_end)
return ZBX_MOCK_NOT_A_TIMESTAMP;
month_end = ts_get_component_end(year_end + 1);
if (2 > month_end - year_end || 3 < month_end - year_end || '-' != *month_end)
return ZBX_MOCK_NOT_A_TIMESTAMP;
day_end = ts_get_component_end(month_end + 1);
if (2 > day_end - month_end || 3 < day_end - month_end)
return ZBX_MOCK_NOT_A_TIMESTAMP;
value_year = atoi(text);
if (1970 > value_year || 2038 < value_year)
return ZBX_MOCK_NOT_A_TIMESTAMP;
value_month = atoi(year_end + 1);
if (12 < value_month)
return ZBX_MOCK_NOT_A_TIMESTAMP;
value_day = atoi(month_end + 1);
if (value_day > zbx_day_in_month(value_year, value_month))
return ZBX_MOCK_NOT_A_TIMESTAMP;
*pnext = day_end;
*year = value_year;
*month = value_month;
*day = value_day;
return ZBX_MOCK_SUCCESS;
}
/******************************************************************************
* *
* Function: ts_get_time *
* *
* Purpose: parses hours, minutes and seconds from time component having *
* HH:MM:SS format *
* *
* Parameters: text - [IN] the text *
* hours - [OUT] the hours *
* minutes - [OUT] the minutes *
* seconds - [OUT] the seconds *
* pnext - [OUT] text after time component *
* *
* Return value: ZBX_MOCK_SUCCESS - the time was parsed successfully *
* ZBX_MOCK_NOT_A_TIMESTAMP - invalid time format *
* *
* Comments: The hours, minutes and seconds limits are not validated. *
* *
******************************************************************************/
static zbx_mock_error_t ts_get_time(const char *text, int *hours, int *minutes, int *seconds, const char **pnext)
{
const char *hours_end, *minutes_end, *seconds_end;
int value_hours, value_minutes, value_seconds;
hours_end = ts_get_component_end(text);
if (hours_end == text || ':' != *hours_end)
return ZBX_MOCK_NOT_A_TIMESTAMP;
minutes_end = ts_get_component_end(hours_end + 1);
if (minutes_end - hours_end != 3 || ':' != *minutes_end)
return ZBX_MOCK_NOT_A_TIMESTAMP;
seconds_end = ts_get_component_end(minutes_end + 1);
if (seconds_end - minutes_end != 3)
return ZBX_MOCK_NOT_A_TIMESTAMP;
value_hours = atoi(text);
if (24 <= value_hours)
return ZBX_MOCK_NOT_A_TIMESTAMP;
value_minutes = atoi(hours_end + 1);
if (60 <= value_minutes)
return ZBX_MOCK_NOT_A_TIMESTAMP;
value_seconds = atoi(minutes_end + 1);
if (60 <= value_seconds)
return ZBX_MOCK_NOT_A_TIMESTAMP;
*pnext = seconds_end;
*hours = value_hours;
*minutes = value_minutes;
*seconds = value_seconds;
return ZBX_MOCK_SUCCESS;
}
/******************************************************************************
* *
* Function: ts_get_ns *
* *
* Purpose: parses nanoseconds from time component having .NNNNNNNNN format *
* *
* Parameters: text - [IN] the text *
* ns - [OUT] nanoseconds *
* pnext - [OUT] text after time component *
* *
* Return value: ZBX_MOCK_SUCCESS - the nanoseconds was parsed successfully *
* ZBX_MOCK_NOT_A_TIMESTAMP - invalid time format *
* *
* Comments: The nanoseconds limits are not validated. *
* *
******************************************************************************/
static zbx_mock_error_t ts_get_ns(const char *text, int *ns, const char **pnext)
{
const char *ns_end;
int pad;
ns_end = ts_get_component_end(text + 1);
if (ns_end == text + 1 || 10 < ns_end - text)
return ZBX_MOCK_NOT_A_TIMESTAMP;
*pnext = ns_end;
*ns = atoi(text + 1);
pad = 9 - (ns_end - text);
while (0 <= pad--)
*ns *= 10;
return ZBX_MOCK_SUCCESS;
}
/******************************************************************************
* *
* Function: ts_get_tz *
* *
* Purpose: parses timezone offset seconds from timezone component having *
* (+|-)HH[:MM] format *
* *
* Parameters: text - [IN] the text *
* sec - [OUT] timezone offset seconds *
* pnext - [OUT] text after timezone component *
* *
* Return value: ZBX_MOCK_SUCCESS - the timezone was parsed successfully *
* ZBX_MOCK_NOT_A_TIMESTAMP - invalid time format *
* *
* Comments: The timezone offset limits are not validated. *
* *
******************************************************************************/
static zbx_mock_error_t ts_get_tz(const char *text, int *sec, const char **pnext)
{
const char *tz_end;
int hours = 0, minutes = 0;
tz_end = ts_get_component_end(text + 1);
if (tz_end == text + 1)
return ZBX_MOCK_NOT_A_TIMESTAMP;
hours = atoi(text + 1);
if (':' == *tz_end)
{
minutes = atoi(tz_end + 1);
tz_end = ts_get_component_end(tz_end + 1);
if (tz_end == text + 1)
return ZBX_MOCK_NOT_A_TIMESTAMP;
}
*pnext = tz_end;
*sec = hours * SEC_PER_HOUR + minutes * SEC_PER_MIN;
if ('-' == *text)
*sec = -*sec;
return ZBX_MOCK_SUCCESS;
}
/******************************************************************************
* *
* Function: is_leap_year *
* *
* Return value: SUCCEED - year is a leap year *
* FAIL - year is not a leap year *
* *
******************************************************************************/
static int is_leap_year(int year)
{
return 0 == year % 4 && (0 != year % 100 || 0 == year % 400) ? SUCCEED : FAIL;
}
/******************************************************************************
* *
* Function: zbx_time_to_localtime *
* *
* Purpose: converts timestamp to a broken-down time representation and *
* timezone offset (in seconds). *
* *
* Parameters: timestamp - [IN] the number of seconds since Epoch *
* local - [OUT] broken-down time representation *
* tz_offset - [OUT] timezone offset in seconds *
* *
* Return value: ZBX_MOCK_SUCCESS - the time was converted successfully *
* ZBX_MOCK_INTERNAL_ERROR - invalid timestamp was specified *
* *
******************************************************************************/
static zbx_mock_error_t zbx_time_to_localtime(time_t timestamp, struct tm *local, int *tz_offset)
{
struct tm tm_utc, tm_local;
if (NULL == gmtime_r(×tamp, &tm_utc))
return ZBX_MOCK_INTERNAL_ERROR;
if (NULL == localtime_r(×tamp, &tm_local))
return ZBX_MOCK_INTERNAL_ERROR;
*tz_offset = (tm_local.tm_yday - tm_utc.tm_yday) * SEC_PER_DAY +
(tm_local.tm_hour - tm_utc.tm_hour) * SEC_PER_HOUR +
(tm_local.tm_min - tm_utc.tm_min) * SEC_PER_MIN;
while (tm_local.tm_year > tm_utc.tm_year)
*tz_offset += (SUCCEED == is_leap_year(tm_utc.tm_year++) ? SEC_PER_YEAR + SEC_PER_DAY : SEC_PER_YEAR);
while (tm_local.tm_year < tm_utc.tm_year)
*tz_offset -= (SUCCEED == is_leap_year(--tm_utc.tm_year) ? SEC_PER_YEAR + SEC_PER_DAY : SEC_PER_YEAR);
*local = tm_local;
return ZBX_MOCK_SUCCESS;
}
/******************************************************************************
* *
* Function: zbx_tz_format *
* *
* Purpose: formats timezone to +hh:mm format *
* *
* Parameters: buffer - [OUT] the output buffer *
* size - [IN] the output buffer size *
* tz_sec - [IN] the timezone offset in seconds *
* *
******************************************************************************/
static void zbx_tz_format(char *buffer, size_t size, int tz_sec)
{
int tz_hour, tz_min;
char tz_sign;
if (0 > tz_sec)
{
tz_sec = -tz_sec;
tz_sign = '-';
}
else
tz_sign = '+';
tz_hour = tz_sec / 60;
tz_min = tz_hour % 60;
tz_hour /= 60;
zbx_snprintf(buffer, size, ZBX_MOCK_FORMAT_TZ, tz_sign, tz_hour, tz_min);
}
typedef enum
{
ZBX_TOKEN_START,
ZBX_TOKEN_DELIM,
ZBX_TOKEN_COMPONENT
}
zbx_mock_time_parser_state_t;
/******************************************************************************
* *
* Function: zbx_strtime_to_timespec *
* *
* Purpose: converts YAML space separated timestamp having *
* YYYY-MM-DD hh:mm:ss.nnnnnnnnn TZ format to zabbix timespec *
* *
* Parameters: strtime - [IN] the YAML space separated timestamp *
* ts - [OUT] zabbix timespec *
* *
* Return value: ZBX_MOCK_SUCCESS - the timestamp was converted successfully *
* ZBX_MOCK_NOT_A_TIMESTAMP - invalid timestamp format *
* *
* Comments: Timestamp consists of 4 components - date, time, nanoseconds and *
* timezone. Any of those components can be omitted except timezone *
* component requires date component to be present. Absent *
* components are treated as zero values. So for example 10:00:00 *
* is equal to 1970-01-01 10:00:00.000000000 +00:00 and parsing it *
* would result in timespec with 36000 seconds and 0 nanoseconds. *
* *
******************************************************************************/
zbx_mock_error_t zbx_strtime_to_timespec(const char *strtime, zbx_timespec_t *ts)
{
int sec, ns, tz, components = 0;
const char *ptr, *pnext;
struct tm tm;
zbx_mock_error_t err;
zbx_mock_time_parser_state_t state = ZBX_TOKEN_START;
for (ptr = strtime; '\0' != *ptr;)
{
if ('.' == *ptr)
{
if (ZBX_TOKEN_DELIM == state)
return ZBX_MOCK_NOT_A_TIMESTAMP;
if (ZBX_MOCK_TIME_NS < components)
return ZBX_MOCK_NOT_A_TIMESTAMP;
if (ZBX_MOCK_SUCCESS != (err = ts_get_ns(ptr, &ns, &ptr)))
return err;
components |= ZBX_MOCK_TIME_NS;
state = ZBX_TOKEN_COMPONENT;
continue;
}
if ('Z' == *ptr)
{
if (ZBX_TOKEN_DELIM == state)
return ZBX_MOCK_NOT_A_TIMESTAMP;
if (0 != (components & ZBX_MOCK_TIME_TZ) || 0 == (components & ZBX_MOCK_TIME_DATE))
return ZBX_MOCK_NOT_A_TIMESTAMP;
tz = 0;
ptr++;
components |= ZBX_MOCK_TIME_TZ;
state = ZBX_TOKEN_COMPONENT;
continue;
}
if (' ' == *ptr || '\t' == *ptr)
{
state = ZBX_TOKEN_DELIM;
ptr++;
continue;
}
if (ZBX_TOKEN_COMPONENT == state)
return ZBX_MOCK_NOT_A_TIMESTAMP;
state = ZBX_TOKEN_COMPONENT;
if ('-' == *ptr || '+' == *ptr)
{
if (0 != (components & ZBX_MOCK_TIME_TZ) || 0 == (components & ZBX_MOCK_TIME_DATE))
return ZBX_MOCK_NOT_A_TIMESTAMP;
if (ZBX_MOCK_SUCCESS != (err = ts_get_tz(ptr, &tz, &ptr)))
return err;
components |= ZBX_MOCK_TIME_TZ;
continue;
}
pnext = ts_get_component_end(ptr);
if (ptr == pnext)
return ZBX_MOCK_NOT_A_TIMESTAMP;
if ('-' == *pnext)
{
if (ZBX_MOCK_TIME_DATE < components)
return ZBX_MOCK_NOT_A_TIMESTAMP;
if (ZBX_MOCK_SUCCESS != (err = ts_get_date(ptr, &tm.tm_year, &tm.tm_mon, &tm.tm_mday, &ptr)))
return err;
components |= ZBX_MOCK_TIME_DATE;
tm.tm_year -= 1900;
tm.tm_mon--;
continue;
}
if (':' == *pnext)
{
if (ZBX_MOCK_TIME_TIME < components)
return ZBX_MOCK_NOT_A_TIMESTAMP;
if (ZBX_MOCK_SUCCESS != (err = ts_get_time(ptr, &tm.tm_hour, &tm.tm_min, &tm.tm_sec, &ptr)))
return err;
components |= ZBX_MOCK_TIME_TIME;
continue;
}
return ZBX_MOCK_NOT_A_TIMESTAMP;
}
if (0 != (components & (ZBX_MOCK_TIME_DATE | ZBX_MOCK_TIME_TIME)))
{
if (0 == (components & ZBX_MOCK_TIME_DATE))
{
tm.tm_year = 70;
tm.tm_mon = 0;
tm.tm_mday = 1;
}
if (0 == (components & ZBX_MOCK_TIME_TIME))
{
tm.tm_hour = 0;
tm.tm_min = 0;
tm.tm_sec = 0;
}
if (0 > (sec = timegm(&tm)))
return ZBX_MOCK_NOT_A_TIMESTAMP;
if (0 != (components & ZBX_MOCK_TIME_TZ))
sec -= tz;
}
else
sec = 0;
if (0 == (components & ZBX_MOCK_TIME_NS))
ns = 0;
ts->sec = sec;
ts->ns = ns;
return ZBX_MOCK_SUCCESS;
}
/******************************************************************************
* *
* Function: zbx_time_to_strtime *
* *
* Purpose: converts time to YAML space separated timestamp in *
* YYYY-MM-DD hh:mm:ss TZ format *
* *
* Parameters: timestamp - [IN] the time (seconds since Epoch) *
* buffer - [OUT] the output buffer *
* size - [OUT] the size of output buffer *
* *
* Return value: ZBX_MOCK_SUCCESS - the time was converted successfully *
* ZBX_MOCK_NOT_ENOUGH_MEMORY - the output buffer size is too *
* small *
* ZBX_MOCK_INTERNAL_ERROR - invalid timestamp specified *
* *
* Comments: The time is converted by using current timezone settings. *
* *
******************************************************************************/
zbx_mock_error_t zbx_time_to_strtime(time_t timestamp, char *buffer, size_t size)
{
struct tm tm;
int tz_sec;
char tz_buf[ZBX_MOCK_TZ_MAX];
zbx_mock_error_t err;
/* max timestamp length minus nanosecond component */
if (size < ZBX_MOCK_TIMESTAMP_MAX_LEN - 10)
return ZBX_MOCK_NOT_ENOUGH_MEMORY;
if (ZBX_MOCK_SUCCESS != (err = zbx_time_to_localtime(timestamp, &tm, &tz_sec)))
return err;
zbx_tz_format(tz_buf, sizeof(tz_buf), tz_sec);
zbx_snprintf(buffer, size, ZBX_MOCK_FORMAT_DATETIME " %s",
tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
tm.tm_hour, tm.tm_min, tm.tm_sec, tz_buf);
return ZBX_MOCK_SUCCESS;
}
/******************************************************************************
* *
* Function: zbx_timespec_to_strtime *
* *
* Purpose: converts timespec (seconds + nanoseconds) to YAML space separated *
* timestamp in YYYY-MM-DD hh:mm:ss.nnnnnnnnn TZ format *
* *
* Parameters: ts - [IN] the zabbix timespec (seconds + nanoseconds) *
* buffer - [OUT] the output buffer *
* size - [OUT] the size of output buffer *
* *
* Return value: ZBX_MOCK_SUCCESS - the time was converted successfully *
* ZBX_MOCK_NOT_ENOUGH_MEMORY - the output buffer size is too *
* small *
* ZBX_MOCK_INTERNAL_ERROR - invalid timestamp specified *
* *
* Comments: The time is converted by using current timezone settings. *
* *
******************************************************************************/
zbx_mock_error_t zbx_timespec_to_strtime(const zbx_timespec_t *ts, char *buffer, size_t size)
{
struct tm tm;
int tz_sec;
char tz_buf[ZBX_MOCK_TZ_MAX + 1];
zbx_mock_error_t err;
if (size < ZBX_MOCK_TIMESTAMP_MAX_LEN)
return ZBX_MOCK_NOT_ENOUGH_MEMORY;
if (ZBX_MOCK_SUCCESS != (err = zbx_time_to_localtime(ts->sec, &tm, &tz_sec)))
return err;
zbx_tz_format(tz_buf, sizeof(tz_buf), tz_sec);
zbx_snprintf(buffer, size, ZBX_MOCK_FORMAT_DATETIME ZBX_MOCK_FORMAT_NS " %s",
tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
tm.tm_hour, tm.tm_min, tm.tm_sec, ts->ns, tz_buf);
return ZBX_MOCK_SUCCESS;
}