#pragma once
/*
 * Copyright (c) 2016 MariaDB Corporation Ab
 *
 * Use of this software is governed by the Business Source License included
 * in the LICENSE.TXT file and at www.mariadb.com/bsl.
 *
 * Change Date: 2019-07-01
 *
 * On the date above, in accordance with the Business Source License, use
 * of this software will be governed by version 2 or later of the General
 * Public License.
 */

/**
 * @file config.h The configuration handling elements
 *
 * @verbatim
 * Revision History
 *
 * Date         Who                     Description
 * 21/06/13     Mark Riddoch            Initial implementation
 * 07/05/14     Massimiliano Pinto      Added version_string to global configuration
 * 23/05/14     Massimiliano Pinto      Added id to global configuration
 * 17/10/14     Mark Riddoch            Added poll tuning configuration parameters
 * 05/03/15     Massimiliano Pinto      Added sysname, release, sha1_mac to gateway struct
 *
 * @endverbatim
 */

#include <maxscale/cdefs.h>
#include <limits.h>
#include <sys/utsname.h>
#include <openssl/sha.h>
#include <maxscale/gw_ssl.h>
#include <maxscale/modinfo.h>

MXS_BEGIN_DECLS

#define DEFAULT_NBPOLLS         3       /**< Default number of non block polls before we block */
#define DEFAULT_POLLSLEEP       1000    /**< Default poll wait time (milliseconds) */
#define _RELEASE_STR_LENGTH     256     /**< release len */
#define DEFAULT_NTHREADS        1 /**< Default number of polling threads */
/**
 * Maximum length for configuration parameter value.
 */
enum
{
    MAX_PARAM_LEN = 256
};

/** TODO: Remove this from the core and move it inside readwritesplit */
typedef enum
{
    TYPE_UNDEFINED = 0,
    TYPE_MASTER,
    TYPE_ALL
} target_t;

enum
{
    MAX_RLAG_NOT_AVAILABLE = -1,
    MAX_RLAG_UNDEFINED = -2
};

#define PARAM_IS_TYPE(p,t) ((p) & (t))

/**
 * The config parameter
 */
typedef struct config_parameter
{
    char                    *name;          /**< The name of the parameter */
    char                    *value;         /**< The value of the parameter */
    struct config_parameter *next;          /**< Next pointer in the linked list */
} CONFIG_PARAMETER;

/**
 * The config context structure, used to build the configuration
 * data during the parse process
 */
typedef struct config_context
{
    char                  *object;     /**< The name of the object being configured */
    CONFIG_PARAMETER      *parameters; /**< The list of parameter values */
    void                  *element;    /**< The element created from the data */
    bool                   was_persisted; /**< True if this object was persisted */
    struct config_context *next;       /**< Next pointer in the linked list */
} CONFIG_CONTEXT;

/**
 * The gateway global configuration data
 */
typedef struct
{
    bool          config_check;                        /**< Only check config */
    int           n_threads;                           /**< Number of polling threads */
    char          *version_string;                     /**< The version string of embedded db library */
    char          release_string[_RELEASE_STR_LENGTH]; /**< The release name string of the system */
    char          sysname[_UTSNAME_SYSNAME_LENGTH];    /**< The OS name of the system */
    uint8_t       mac_sha1[SHA_DIGEST_LENGTH];         /**< The SHA1 digest of an interface MAC address */
    unsigned long id;                                  /**< MaxScale ID */
    unsigned int  n_nbpoll;                            /**< Tune number of non-blocking polls */
    unsigned int  pollsleep;                           /**< Wait time in blocking polls */
    int           syslog;                              /**< Log to syslog */
    int           maxlog;                              /**< Log to MaxScale's own logs */
    int           log_to_shm;                          /**< Write log-file to shared memory */
    unsigned int  auth_conn_timeout;                   /**< Connection timeout for the user authentication */
    unsigned int  auth_read_timeout;                   /**< Read timeout for the user authentication */
    unsigned int  auth_write_timeout;                  /**< Write timeout for the user authentication */
    bool          skip_permission_checks;              /**< Skip service and monitor permission checks */
    char          qc_name[PATH_MAX];                   /**< The name of the query classifier to load */
    char*         qc_args;                             /**< Arguments for the query classifier */
} GATEWAY_CONF;


/**
 * @brief Creates an empty configuration context
 *
 * @param section Context name
 * @return New context or NULL on memory allocation failure
 */
CONFIG_CONTEXT* config_context_create(const char *section);

/**
 * @brief Free a configuration context
 *
 * @param context The context to free
 */
void config_context_free(CONFIG_CONTEXT *context);

/**
 * @brief Get a configuration parameter
 *
 * @param params List of parameters
 * @param name Name of parameter to get
 * @return The parameter or NULL if the parameter was not found
 */
CONFIG_PARAMETER* config_get_param(CONFIG_PARAMETER* params, const char* name);

/**
 * @brief Add a parameter to a configuration context
 *
 * @param obj Context where the parameter should be added
 * @param key Key to add
 * @param value Value for the key
 * @return True on success, false on memory allocation error
 */
bool config_add_param(CONFIG_CONTEXT* obj, const char* key, const char* value);

/**
 * @brief Append to an existing parameter
 *
 * @param obj Configuration context
 * @param key Parameter name
 * @param value Value to append to the parameter
 * @return True on success, false on memory allocation error
 */
bool config_append_param(CONFIG_CONTEXT* obj, const char* key, const char* value);

/**
 * @brief Check if all SSL parameters are defined
 *
 * Helper function to check whether all of the required SSL parameters are defined
 * in the configuration context. The checked parameters are 'ssl', 'ssl_key',
 * 'ssl_cert' and 'ssl_ca_cert'. The 'ssl' parameter must also have a value of
 * 'required'.
 *
 * @param obj Configuration context
 * @return True if all required parameters are present
 */
bool config_have_required_ssl_params(CONFIG_CONTEXT *obj);

/**
 * @brief Helper function for checking SSL parameters
 *
 * @param key Parameter name
 * @return True if the parameter is an SSL parameter
 */
bool config_is_ssl_parameter(const char *key);

/**
 * @brief Construct an SSL structure
 *
 * The SSL structure is used by both listeners and servers.
 *
 * TODO: Rename to something like @c config_construct_ssl
 *
 * @param obj Configuration context
 * @param require_cert Whether certificates are required
 * @param error_count Pointer to an int which is incremented for each error
 * @return New SSL_LISTENER structure or NULL on error
 */
SSL_LISTENER *make_ssl_structure(CONFIG_CONTEXT *obj, bool require_cert, int *error_count);

/**
 * @brief Check if a configuration parameter is valid
 *
 * If a module has declared parameters and parameters were given to the module,
 * the given parameters are compared to the expected ones. This function also
 * does preliminary type checking for various basic values as well as enumerations.
 *
 * @param params Module parameters
 * @param key Parameter key
 * @param value Parameter value
 * @param context Configuration context or NULL for no context (uses runtime checks)
 *
 * @return True if the configuration parameter is valid
 */
bool config_param_is_valid(const MXS_MODULE_PARAM *params, const char *key,
                           const char *value, const CONFIG_CONTEXT *context);

/**
 * @brief Get a boolean value
 *
 * The existence of the parameter should be checked with config_get_param() before
 * calling this function to determine whether the return value represents an existing
 * value or a missing value.
 *
 * @param params List of configuration parameters
 * @param key Parameter name
 *
 * @return The value as a boolean or false if none was found
 */
bool config_get_bool(const CONFIG_PARAMETER *params, const char *key);

/**
 * @brief Get an integer value
 *
 * This is used for both MXS_MODULE_PARAM_INT and MXS_MODULE_PARAM_COUNT.
 *
 * @param params List of configuration parameters
 * @param key Parameter name
 *
 * @return The integer value of the parameter or 0 if no parameter was found
 */
int config_get_integer(const CONFIG_PARAMETER *params, const char *key);

/**
 * @brief Get a size in bytes
 *
 * The value can have either one of the IEC binary prefixes or SI prefixes as
 * a suffix. For example, the value 1Ki will be converted to 1024 bytes whereas
 * 1k will be converted to 1000 bytes. Supported SI suffix values are k, m, g and t
 * in both lower and upper case. Supported IEC binary suffix values are
 * Ki, Mi, Gi and Ti both in upper and lower case.
 *
 * @param params List of configuration parameters
 * @param key Parameter name
 *
 * @return Number of bytes or 0 if no parameter was found
 */
uint64_t config_get_size(const CONFIG_PARAMETER *params, const char *key);

/**
 * @brief Get a string value
 *
 * @param params List of configuration parameters
 * @param key Parameter name
 *
 * @return The raw string value or an empty string if no parameter was found
 */
const char* config_get_string(const CONFIG_PARAMETER *params, const char *key);

/**
 * @brief Get a enumeration value
 *
 * @param params List of configuration parameters
 * @param key Parameter name
 * @param values All possible enumeration values
 *
 * @return The enumeration value converted to an int or -1 if the parameter was not found
 *
 * @note The enumeration values should not use -1 so that an undefined parameter is
 * detected. If -1 is used, config_get_param() should be used to detect whether
 * the parameter exists
 */
int config_get_enum(const CONFIG_PARAMETER *params, const char *key, const MXS_ENUM_VALUE *values);

/**
 * @brief Get a service value
 *
 * @param params List of configuration parameters
 * @param key Parameter name
 *
 * @return Pointer to configured service
 */
struct service* config_get_service(const CONFIG_PARAMETER *params, const char *key);

/**
 * @brief Get a server value
 *
 * @param params List of configuration parameters
 * @param key Parameter name
 *
 * @return Pointer to configured server
 */
struct server* config_get_server(const CONFIG_PARAMETER *params, const char *key);

/**
 * @brief Get copy of parameter value if it is defined
 *
 * If a parameter with the name of @c key is defined in @c params, a copy of the
 * value of that parameter is returned. The caller must free the returned string.
 *
 * @param params List of configuration parameters
 * @param key Parameter name
 *
 * @return Pointer to copy of value or NULL if the parameter was not found
 *
 * @note The use of this function should be avoided after startup as the function
 * will abort the process if memory allocation fails.
 */
char* config_copy_string(const CONFIG_PARAMETER *params, const char *key);

/**
 * @brief Convert string truth value
 *
 * Used for truth values with @c 1, @c yes or @c true for a boolean true value and @c 0, @c no
 * or @c false for a boolean false value.
 *
 * @param str String to convert to a truth value
 *
 * @return 1 if @c value is true, 0 if value is false and -1 if the value is not
 * a valid truth value
 */
int config_truth_value(const char *value);

/** TODO: Add new capability that allows skipping of permission checks */
bool                is_internal_service(const char *router);

/***************************************************************************************
 * TODO: Move the following functions to a header that's internal to the MaxScale core *
 ***************************************************************************************/

/**
 * @brief Generate default module parameters
 *
 * Adds any default parameters to @c ctx that aren't already in it.
 *
 * @param ctx    Configuration context where the parameters are added
 * @param params Module parameters
 */
void config_add_defaults(CONFIG_CONTEXT *ctx, const MXS_MODULE_PARAM *params);

char*               config_clean_string_list(const char* str);
CONFIG_PARAMETER*   config_clone_param(const CONFIG_PARAMETER* param);
void                config_enable_feedback_task(void);
void                config_disable_feedback_task(void);
GATEWAY_CONF*       config_get_global_options();
bool                config_load(const char *);
unsigned int        config_nbpolls();
unsigned int        config_pollsleep();
bool                config_reload();
int                 config_threadcount();
void                config_parameter_free(CONFIG_PARAMETER* p1);

MXS_END_DECLS