/*
 * coreSNTP v1.2.0
 * Copyright (C) 2021 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
 *
 * SPDX-License-Identifier: MIT
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of
 * this software and associated documentation files (the "Software"), to deal in
 * the Software without restriction, including without limitation the rights to
 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 * the Software, and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

/**
 * @file core_sntp_serializer.h
 * @brief API for serializing SNTP request packets and, and de-serializing SNTP
 * response packets.
 * This API layer adheres to the SNTPv4 specification defined in
 * [RFC 4330](https://tools.ietf.org/html/rfc4330).
 */

#ifndef CORE_SNTP_SERIALIZER_H_
#define CORE_SNTP_SERIALIZER_H_

/* Standard include. */
#include <stdint.h>
#include <stddef.h>

/* *INDENT-OFF* */
#ifdef __cplusplus
    extern "C" {
#endif
/* *INDENT-ON* */

/**
 * @ingroup sntp_constants
 * @brief The base packet size of request and response of the (S)NTP protocol.
 * @note This is the packet size without any authentication headers for security
 * mechanism. If the application uses a security mechanism for communicating with
 * an (S)NTP server, it can add authentication data after the SNTP packet is
 * serialized with the @ref Sntp_SerializeRequest API function.
 */
#define SNTP_PACKET_BASE_SIZE                         ( 48U )

/**
 * @ingroup sntp_constants
 * @brief Number of SNTP timestamp fractions in 1 microsecond.
 *
 * The fraction's part of an SNTP timestamp is 32-bits wide, thereby, giving a
 * resolution of 2^(-32) seconds ~ 232 picoseconds.
 *
 * @note The application can use this value to convert microseconds part of system
 * time into SNTP timestamp fractions. For example, if the microseconds
 * part of system time is n microseconds, the fractions value to be used for the
 * SNTP timestamp part will be n * SNTP_FRACTION_VALUE_PER_MICROSECOND.
 */
#define SNTP_FRACTION_VALUE_PER_MICROSECOND           ( 4295U )

/**
 * @ingroup sntp_constants
 * @brief The seconds part of SNTP time at the UNIX epoch time, which represents
 * an offset of 70 years (in seconds) between SNTP epoch and UNIX epoch time.
 * SNTP uses 1st Jan 1900 UTC as the epoch time, whereas UNIX standard uses
 * 1st Jan 1970 UTC as the epoch time, thereby, causing an offset of 70 years
 * between them.
 *
 *  Difference of 70 years = ((70 * 365) + 17 leap days) * 24 * 3600 seconds
 *
 * @note If your system follows UNIX time, the application can use this value to
 * convert seconds part of a system time to seconds part of the equivalent SNTP
 * time. For example, if the seconds part of system time is n seconds, the seconds
 * value to be used for the SNTP timestamp will be n + SNTP_TO_UNIX_OFFSET_SECS.
 */
#define SNTP_TIME_AT_UNIX_EPOCH_SECS                  ( 2208988800U )

/**
 * @ingroup sntp_constants
 * @brief The seconds value of SNTP timestamp for the largest UNIX time when
 * using signed 32-bit integer for seconds.
 * The largest time representable with a 32-bit signed integer in UNIX time
 * is 19 Jan 2038 3h 14m 7s UTC. However, as the SNTP time overflows at
 * 7 Feb 2036 6h 28m 16s UTC, therefore, the SNTP time for the largest UNIX time
 * represents the time duration between the 2 timestamps.
 *
 * SNTP Time at Largest       Time Duration in the range
 * Signed 32-bit UNIX time =  [7 Feb 2036 6:28:16, 19 Jan 2038 3:14:07]
 */
#define SNTP_TIME_AT_LARGEST_UNIX_TIME_SECS           ( 61505151U )

/**
 * @ingroup sntp_constants
 * @brief The UNIX time (in seconds) at the smallest SNTP time in era 1,
 * i.e. UNIX time at 7 Feb 2036 6:28:16 UTC/
 *
 * Time Duration = 7 Feb 6:28:16 UTC (SNTP Era 1 Epoch) -
 *                 1 Jan 1970 0:0:0 UTC (UNIX epoch)
 *               = 66 years, 37 days, 6 hours, 28 minutes and 16 seconds
 *               = ((66 * 365) + 16 leap days) * 24 * 3600) + (6 * 3600)
 *                 + (28 * 60) + 16
 */
#define UNIX_TIME_SECS_AT_SNTP_ERA_1_SMALLEST_TIME    ( 2085978496U )

/**
 * @ingroup sntp_constants
 * @brief The fixed-length of any Kiss-o'-Death message ASCII code sent
 * in an SNTP server response.
 * @note An SNTP server sends a Kiss-o'-Death message to reject a time request
 * from the client. For more information on the Kiss-o'-Death codes, refer to the
 * [SNTPv4 specification Section 8](https://tools.ietf.org/html/rfc4330#section-8).
 */
#define SNTP_KISS_OF_DEATH_CODE_LENGTH                ( 4U )

/**
 * @ingroup sntp_constants
 * @brief The value for the #SntpResponseData_t.rejectedResponseCode member
 * when that the server response packet does not contain a Kiss-o'-Death
 * message, and therefore, does not have a "kiss code".
 * The server sends a "kiss-code" only when it rejects an SNTP request
 * with a Kiss-o'-Death message.
 */
#define SNTP_KISS_OF_DEATH_CODE_NONE                  ( 0U )

/**
 * @ingroup sntp_enum_types
 * @brief Enumeration of status codes that can be returned
 * by the coreSNTP Library API.
 */
typedef enum SntpStatus
{
    /**
     * @brief Successful operation of an SNTP API.
     */
    SntpSuccess,

    /**
     * @brief Invalid parameter passed to an API function.
     */
    SntpErrorBadParameter,

    /**
     * @brief Server sent a Kiss-o'-Death message to reject the request for time.
     * This status can be returned by the @ref Sntp_ReceiveTimeResponse API.
     */
    SntpRejectedResponse,

    /**
     * @brief Server sent a Kiss-o'-Death message with non-retryable code (i.e. DENY or RSTR).
     */
    SntpRejectedResponseChangeServer,

    /**
     * @brief Server sent a Kiss-o'-Death message with a RATE code, which means that
     * client should back-off before retrying.
     */
    SntpRejectedResponseRetryWithBackoff,

    /**
     * @brief Server sent a Kiss-o'-Death message with a code, specific to the server.
     * Application can inspect the ASCII kiss-code from @ref Sntp_DeserializeResponse API.
     */
    SntpRejectedResponseOtherCode,

    /**
     * @brief Application provided insufficient buffer space for serializing
     * or de-serializing an SNTP packet.
     * The minimum size of an SNTP packet is #SNTP_PACKET_BASE_SIZE
     * bytes. */
    SntpErrorBufferTooSmall,

    /**
     * @brief Server response failed validation checks for expected data in SNTP packet.
     */
    SntpInvalidResponse,

    /**
     * @brief Poll interval value is under 1 second which cannot be calculated
     *  by @ref Sntp_CalculatePollInterval.
     */
    SntpZeroPollInterval,

    /**
     * @brief SNTP timestamp cannot be converted to UNIX time as time does not lie
     * in time range supported by Sntp_ConvertToUnixTime.
     */
    SntpErrorTimeNotSupported,

    /**
     * @brief The user-defined DNS resolution interface, @ref SntpResolveDns_t, failed to resolve
     * address for a time server. This status is returned by the @ref Sntp_SendTimeRequest API.
     */
    SntpErrorDnsFailure,

    /**
     * @brief Networking operation of sending or receiving SNTP packet through the user-defined UDP
     * transport interface, @ref UdpTransportInterface_t, failed.
     * This status is returned by either of @ref Sntp_SendTimeRequest OR @ref Sntp_ReceiveTimeResponse
     * APIs.
     */
    SntpErrorNetworkFailure,

    /**
     * @brief Time server is not authenticated from the authentication data in its response.
     * This status can be returned by the user-supplied definition of the
     * @ref SntpValidateServerAuth_t authentication interface.
     */
    SntpServerNotAuthenticated,

    /**
     * @brief Failure from the user-supplied authentication interface, @ref SntpAuthenticationInterface_t,
     * in either generating authentication data for SNTP request OR validating the authentication
     * data in SNTP response from server.
     */
    SntpErrorAuthFailure,

    /**
     * @brief A timeout occurred in sending time request packet over the network to a server through the
     * @ref Sntp_SendTimeRequest API.
     */
    SntpErrorSendTimeout,

    /**
     * @brief A timeout has occurred in receiving server response with the @ref Sntp_ReceiveTimeResponse
     * API.
     */
    SntpErrorResponseTimeout,

    /**
     * @brief No SNTP packet for server response is received from the network by the
     * @ref Sntp_ReceiveTimeResponse API.
     */
    SntpNoResponseReceived,

    /**
     * @brief The SNTP context passed to @ref Sntp_SendTimeRequest or @ref Sntp_ReceiveTimeResponse APIs is
     * is uninitialized.
     */
    SntpErrorContextNotInitialized
} SntpStatus_t;

/**
 * @ingroup sntp_enum_types
 * @brief Enumeration for leap second information that an SNTP server can
 * send its response to a time request. An SNTP server sends information about
 * whether there is an upcoming leap second adjustment in the last day of the
 * current month.
 *
 * @note A leap second is an adjustment made in atomic clock time because Earth's rotation
 * can be inconsistent. Leap seconds are usually incorporated as an extra second insertion
 * or second deletion in the last minute before midnight i.e. in the minute of 23h:59m UTC
 * on the last day of June or December. For more information on leap seconds, refer to
 * https://www.nist.gov/pml/time-and-frequency-division/leap-seconds-faqs.
 */
typedef enum SntpLeapSecondInfo
{
    NoLeapSecond = 0x00,              /** <@brief There is no upcoming leap second adjustment. */
    LastMinuteHas61Seconds = 0x01,    /** <@brief A leap second should be inserted in the last minute before midnight. */
    LastMinuteHas59Seconds = 0x02,    /** <@brief A leap second should be deleted from the last minute before midnight. */
    AlarmServerNotSynchronized = 0x03 /** <@brief An alarm condition meaning that server's time is not synchronized
                                       * to an upstream NTP (or SNTP) server. */
} SntpLeapSecondInfo_t;

/**
 * @ingroup sntp_struct_types
 * @brief Structure representing an SNTP timestamp.
 *
 * @note The SNTP timestamp uses 1st January 1900 0h 0m 0s Coordinated Universal Time (UTC)
 * as the primary epoch i.e. the timestamp represents current time as the amount of time since
 * the epoch time.
 * Refer to the [SNTPv4 specification](https://tools.ietf.org/html/rfc4330#section-3) for more
 * information of the SNTP timestamp format.
 */
typedef struct SntpTimestamp
{
    uint32_t seconds;   /**< @brief Number of seconds since epoch time. */
    uint32_t fractions; /**< @brief The fractions part of the SNTP timestamp with resolution
                         *   of 2^(-32) ~ 232 picoseconds. */
} SntpTimestamp_t;

/**
 * @ingroup sntp_struct_types
 * @brief Structure representing data parsed from an SNTP response from server
 * as well as data of arithmetic calculations derived from the response.
 */
typedef struct SntpResponse
{
    /**
     * @brief The timestamp sent by the server.
     */
    SntpTimestamp_t serverTime;

    /**
     * @brief The information of an upcoming leap second in the
     * server response.
     */
    SntpLeapSecondInfo_t leapSecondType;

    /**
     * @brief If a server responded with Kiss-o'-Death message to reject
     * time request, this is the fixed length ASCII code sequence for the
     * rejection.
     *
     * The Kiss-o'-Death code is always #SNTP_KISS_OF_DEATH_CODE_LENGTH
     * bytes long.
     *
     * @note If the server does not send a Kiss-o'-Death message in its
     * response, this value will be #SNTP_KISS_OF_DEATH_CODE_NONE.
     */
    uint32_t rejectedResponseCode;

    /**
     * @brief The offset (in milliseconds) of the system clock relative to the server time
     * calculated from timestamps in the client SNTP request and server SNTP response packets.
     * If the the system time is BEHIND the server time, then the clock-offset value is > 0.
     * If the system time is AHEAD of the server time, then the clock-offset value is < 0.
     *
     * @note This information can be used to synchronize the system clock with a "slew",
     * "step" OR combination of the two clock correction methodologies depending on the degree
     *  of system clock drift (represented by the clock-offset) and the application's
     * tolerance for system clock error.
     *
     * @note The library calculates the clock-offset value using the On-Wire
     * protocol suggested by the NTPv4 specification. For more information,
     * refer to https://tools.ietf.org/html/rfc5905#section-8.
     *
     * @note The library ASSUMES that the server and client systems are within
     * ~68 years of each other clock, whether in the same NTP era or across adjacent
     * NTP eras. Thus, the client and system times MUST be within ~68 years (or
     * 2^31 seconds exactly) of each other for correct calculation of clock-offset.
     *
     * @note When the server and client times are exactly 2^31 (or INT32_MAX + 1 )
     * seconds apart, the library ASSUMES that the server time is ahead of the client
     * time, and return the clock-offset value of INT32_MAX.
     */
    int64_t clockOffsetMs;
} SntpResponseData_t;


/**
 * @brief Serializes an SNTP request packet to use for querying a
 * time server.
 *
 * This function will fill only #SNTP_PACKET_BASE_SIZE bytes of data in the
 * passed buffer.
 *
 * @param[in, out] pRequestTime The current time of the system, expressed as time
 * since the SNTP epoch (i.e. 0h of 1st Jan 1900 ). This time will be serialized
 * in the SNTP request packet. The function will use this parameter to return the
 * timestamp serialized in the SNTP request. To protect against attacks spoofing
 * server responses, the timestamp MUST NOT be zero in value.
 * @param[in] randomNumber A random number (generated by a True Random Generator)
 * for use in the SNTP request packet to protect against replay attacks as suggested
 * by SNTPv4 specification. For more information, refer to
 * [RFC 4330 Section 3](https://tools.ietf.org/html/rfc4330#section-3).
 * @param[out] pBuffer The buffer that will be populated with the serialized
 * SNTP request packet.
 * @param[in] bufferSize The size of the @p pBuffer buffer. It should be at least
 * #SNTP_PACKET_BASE_SIZE bytes in size.
 *
 * @note It is recommended to use a True Random Generator (TRNG) to generate
 * the random number.
 * @note The application MUST save the @p pRequestTime value for de-serializing
 * the server response with @ref Sntp_DeserializeResponse API.
 *
 * @return This function returns one of the following:
 * - #SntpSuccess when serialization operation is successful.
 * - #SntpErrorBadParameter if an invalid parameter is passed.
 * - #SntpErrorBufferTooSmall if the buffer does not have the minimum size
 * for serializing an SNTP request packet.
 */
/* @[define_sntp_serializerequest] */
SntpStatus_t Sntp_SerializeRequest( SntpTimestamp_t * pRequestTime,
                                    uint32_t randomNumber,
                                    void * pBuffer,
                                    size_t bufferSize );
/* @[define_sntp_serializerequest] */

/**
 * @brief De-serializes an SNTP packet received from a server as a response
 * to a SNTP request.
 *
 * This function will parse only the #SNTP_PACKET_BASE_SIZE bytes of data
 * in the passed buffer.
 *
 * @note If the server has sent a Kiss-o'-Death message to reject the associated
 * time request, the API function will return the appropriate return code and,
 * also, provide the ASCII code (of fixed length, #SNTP_KISS_OF_DEATH_CODE_LENGTH bytes)
 * in the #SntpResponseData_t.rejectedResponseCode member of @p pParsedResponse parameter,
 * parsed from the response packet.
 * The application SHOULD respect the server rejection and take appropriate action
 * based on the rejection code.
 * If the server response represents an accepted SNTP client request, then the API
 * function will set the #SntpResponseData_t.rejectedResponseCode member of
 * @p pParsedResponse parameter to #SNTP_KISS_OF_DEATH_CODE_NONE.
 *
 * @note If the server has positively responded with its clock time, then this API
 * function will calculate the clock-offset. For the clock-offset to be correctly
 * calculated, the system clock MUST be within ~68 years (or 2^31 seconds) of the server
 * time mentioned. This function supports clock-offset calculation when server and client
 * timestamps are in adjacent NTP eras, with one system is in NTP era 0 (i.e. before 7 Feb 2036
 * 6h:28m:14s UTC) and another system in NTP era 1 (on or after 7 Feb 2036 6h:28m:14s UTC).
 *
 * @note In the special case when the server and client times are exactly 2^31 seconds apart,
 * the library ASSUMES that the server time is ahead of the client time, and returns the
 * positive clock-offset value of INT32_MAX seconds.
 *
 * @param[in] pRequestTime The system time used in the SNTP request packet
 * that is associated with the server response. This MUST be the same as the
 * time returned by the @ref Sntp_SerializeRequest API. To protect against attacks
 * spoofing server responses, this timestamp MUST NOT be zero in value.
 * @param[in] pResponseRxTime The time of the system, expressed as time since the
 * SNTP epoch (i.e. 0h of 1st Jan 1900 ), at receiving SNTP response from server.
 * This time will be used to calculate system clock offset relative to server.
 * @param[in] pResponseBuffer The buffer containing the SNTP response from the
 * server.
 * @param[in] bufferSize The size of the @p pResponseBuffer containing the SNTP
 * response. It MUST be at least #SNTP_PACKET_BASE_SIZE bytes
 * long for a valid SNTP response.
 * @param[out] pParsedResponse The information parsed from the SNTP response packet.
 * If possible to calculate without overflow, it also contains the system clock
 * offset relative to the server time.
 *
 * @return This function returns one of the following:
 * - #SntpSuccess if the de-serialization operation is successful.
 * - #SntpErrorBadParameter if an invalid parameter is passed.
 * - #SntpErrorBufferTooSmall if the buffer does not have the minimum size
 * required for a valid SNTP response packet.
 * - #SntpInvalidResponse if the response fails sanity checks expected in an
 * SNTP response.
 * - #SntpRejectedResponseChangeServer if the server rejected with a code
 * indicating that client cannot be retry requests to it.
 * - #SntpRejectedResponseRetryWithBackoff if the server rejected with a code
 * indicating that client should back-off before retrying request.
 * - #SntpRejectedResponseOtherCode if the server rejected with a code that
 * application can inspect in the @p pParsedResponse parameter.
 */
/* @[define_sntp_deserializeresponse] */
SntpStatus_t Sntp_DeserializeResponse( const SntpTimestamp_t * pRequestTime,
                                       const SntpTimestamp_t * pResponseRxTime,
                                       const void * pResponseBuffer,
                                       size_t bufferSize,
                                       SntpResponseData_t * pParsedResponse );
/* @[define_sntp_deserializeresponse] */

/**
 * @brief Utility to calculate the poll interval of sending periodic time queries
 * to servers to achieve a desired system clock accuracy for a given
 * frequency tolerance of the system clock.
 *
 * For example, from the SNTPv4 specification, "if the frequency tolerance
 * is 200 parts per million (PPM) and the required accuracy is one minute,
 * the maximum timeout is about 3.5 days". In this example, the system
 * clock frequency tolerance is 200 PPM and the desired accuracy is
 * 60000 milliseconds (or 1 minute) for which this API function
 * will return the maximum poll interval value as 2^18 seconds (or ~3 days).
 *
 * @note The poll interval returned is a power of 2, which is the
 * standard way to represent the value. According to the SNTPv4 specification
 * Best Practices, an SNTP client SHOULD NOT have a poll interval less than 15 seconds.
 * https://tools.ietf.org/html/rfc4330#section-10. This API function DOES NOT
 * support poll interval calculation less than 1 second.
 *
 * @param[in] clockFreqTolerance The frequency tolerance of system clock
 * in parts per million (PPM) units. This parameter MUST be non-zero.
 * @param[in] desiredAccuracy The acceptable maximum drift, in milliseconds,
 * for the system clock. The maximum value (0xFFFF) represents ~1 minute of
 * desired clock accuracy. This parameter MUST be non-zero.
 * @param[out] pPollInterval This is filled with the poll interval, in seconds
 * calculated as the closest power of 2 value that will achieve either the
 * exact desired or higher clock accuracy @p desiredAccuracy, for the given clock
 * frequency tolerance, @p clockFreqTolerance.
 *
 * @return Returns one of the following:
 *  - #SntpSuccess if calculation is successful.
 *  - #SntpErrorBadParameter for an invalid parameter passed to the function.
 *  - #SntpZeroPollInterval if calculated poll interval is less than 1 second.
 */
/* @[define_sntp_calculatepollinterval] */
SntpStatus_t Sntp_CalculatePollInterval( uint16_t clockFreqTolerance,
                                         uint16_t desiredAccuracy,
                                         uint32_t * pPollInterval );
/* @[define_sntp_calculatepollinterval] */


/**
 * @brief Utility to convert SNTP timestamp (that uses 1st Jan 1900 as the epoch) to
 * UNIX timestamp (that uses 1st Jan 1970 as the epoch).
 *
 * @note This function can ONLY handle conversions of SNTP timestamps that lie in the
 * range from 1st Jan 1970 0h 0m 0s, the UNIX epoch time, to 19th Jan 2038 3h 14m 7s,
 * the maximum UNIX time that can be represented in a signed 32 bit integer. (The
 * limitation is to support systems that use signed 32-bit integer to represent the
 * seconds part of the UNIX time.)
 *
 * @note This function supports overflow of the SNTP timestamp (from the 7 Feb 2036
 * 6h 28m 16s time, i.e. SNTP era 1) by treating the timestamps with seconds part
 * in the range [0, 61,505,152] seconds where the upper limit represents the UNIX
 * overflow time (i.e. 19 Jan 2038 3h 14m 7s) for systems that use signed 32-bit
 * integer to represent time.
 *
 * @param[in] pSntpTime The SNTP timestamp to convert to UNIX time.
 * @param[out] pUnixTimeSecs This will be filled with the seconds part of the
 * UNIX time equivalent of the SNTP time, @p pSntpTime.
 * @param[out] pUnixTimeMicrosecs This will be filled with the microseconds part
 * of the UNIX time equivalent of the SNTP time, @p pSntpTime.
 *
 * @return Returns one of the following:
 *  - #SntpSuccess if conversion to UNIX time is successful
 *  - #SntpErrorBadParameter if any of the passed parameters are NULL.
 *  - #SntpErrorTimeNotSupported if the passed SNTP time does not lie in the
 * supported time range.
 */
/* @[define_sntp_converttounixtime] */
SntpStatus_t Sntp_ConvertToUnixTime( const SntpTimestamp_t * pSntpTime,
                                     uint32_t * pUnixTimeSecs,
                                     uint32_t * pUnixTimeMicrosecs );
/* @[define_sntp_converttounixtime] */

/* *INDENT-OFF* */
#ifdef __cplusplus
    }
#endif
/* *INDENT-ON* */

#endif /* ifndef CORE_SNTP_SERIALIZER_H_ */