{-# LANGUAGE ForeignFunctionInterface #-}

module Network.Mosquitto.LowLevel.Functions where

import           Foreign.C
import           Foreign.C.String
import           Foreign.Ptr
import           Network.Mosquitto.LowLevel.Types
-- | Function: mosquitto_lib_version
--
-- Can be used to obtain version information for the mosquitto library.
-- This allows the application to compare the library version against the
-- version it was compiled against by using the LIBMOSQUITTO_MAJOR,
-- LIBMOSQUITTO_MINOR and LIBMOSQUITTO_REVISION defines.
--
-- Parameters:
--  major -    an integer pointer. If not NULL, the major version of the
--             library will be returned in this variable.
--  minor -    an integer pointer. If not NULL, the minor version of the
--             library will be returned in this variable.
--  revision - an integer pointer. If not NULL, the revision of the library will
--             be returned in this variable.
--
-- Returns:
-- LIBMOSQUITTO_VERSION_NUMBER, which is a unique number based on the major,
-- minor and revision values.
-- See Also:
-- <mosquitto_lib_cleanup>, <mosquitto_lib_init>
--
-- libmosq_EXPORT int mosquitto_lib_version(intmajor, intminor, intrevision);
foreign import ccall unsafe "mosquitto.h mosquitto_lib_version" c_lib_version :: Ptr CInt -> Ptr CInt -> Ptr CInt -> IO CInt

-- | Function: mosquitto_lib_init
--
-- Must be called before any other mosquitto functions.
--
-- This function isnot* thread safe.
--
-- Returns:
-- MOSQ_ERR_SUCCESS - always
--
-- See Also:
-- <mosquitto_lib_cleanup>, <mosquitto_lib_version>
--
-- libmosq_EXPORT int mosquitto_lib_init(void);
foreign import ccall safe "mosquitto.h mosquitto_lib_init" c_mosquitto_lib_init :: IO CInt

-- | Function: mosquitto_lib_cleanup
--
-- Call to free resources associated with the library.
--
-- Returns:
-- MOSQ_ERR_SUCCESS - always
--
-- See Also:
-- <mosquitto_lib_init>, <mosquitto_lib_version>
--
-- libmosq_EXPORT int mosquitto_lib_cleanup(void);
foreign import ccall unsafe "mosquitto.h mosquitto_lib_cleanup" c_lib_cleanup :: IO CInt

-- | Function: mosquitto_new
--
-- Create a new mosquitto client instance.
--
-- Parameters:
-- id -            String to use as the client id. If NULL, a random client id
--                 will be generated. If id is NULL, clean_session must be true.
-- clean_session - set to true to instruct the broker to clean all messages
--                  and subscriptions on disconnect, false to instruct it to
--                  keep them. See the man page mqtt(7) for more details.
--                  Note that a client will never discard its own outgoing
--                  messages on disconnect. Calling <mosquitto_connect> or
--                  <mosquitto_reconnect> will cause the messages to be resent.
--                  Use <mosquitto_reinitialise> to reset a client to its
--                  original state.
--                  Must be set to true if the id parameter is NULL.
-- obj -           A user pointer that will be passed as an argument to any
--                  callbacks that are specified.
--
-- Returns:
-- Pointer to a struct mosquitto on success.
-- NULL on failure. Interrogate errno to determine the cause for the failure:
--      - ENOMEM on out of memory.
--      - EINVAL on invalid input parameters.
--
-- See Also:
-- <mosquitto_reinitialise>, <mosquitto_destroy>, <mosquitto_user_data_set>
--
-- libmosq_EXPORT struct mosquittomosquitto_new(const charid, bool clean_session, voidobj);
foreign import ccall unsafe "mosquitto.h mosquitto_new" c_new :: CString -> Bool -> Ptr () -> IO (Ptr Mosquitto)

-- | Function: mosquitto_destroy
--
-- Use to free memory associated with a mosquitto client instance.
--
-- Parameters:
-- mosq - a struct mosquitto pointer to free.
--
-- See Also:
-- <mosquitto_new>, <mosquitto_reinitialise>
--
-- libmosq_EXPORT void mosquitto_destroy(struct mosquittomosq);
foreign import ccall unsafe "mosquitto.h mosquitto_destroy" c_destroy :: Ptr Mosquitto -> IO ()

-- | Function: mosquitto_reinitialise
--
-- This function allows an existing mosquitto client to be reused. Call on a
-- mosquitto instance to close any open network connections, free memory
-- and reinitialise the client with the new parameters. The end result is the
-- same as the output of <mosquitto_new>.
--
-- Parameters:
-- mosq -          a valid mosquitto instance.
-- id -            string to use as the client id. If NULL, a random client id
--                 will be generated. If id is NULL, clean_session must be true.
-- clean_session - set to true to instruct the broker to clean all messages
--                  and subscriptions on disconnect, false to instruct it to
--                  keep them. See the man page mqtt(7) for more details.
--                  Must be set to true if the id parameter is NULL.
-- obj -           A user pointer that will be passed as an argument to any
--                  callbacks that are specified.
--
-- Returns:
-- MOSQ_ERR_SUCCESS - on success.
-- MOSQ_ERR_INVAL -   if the input parameters were invalid.
-- MOSQ_ERR_NOMEM -   if an out of memory condition occurred.
--
-- See Also:
-- <mosquitto_new>, <mosquitto_destroy>
--
-- libmosq_EXPORT int mosquitto_reinitialise(struct mosquittomosq, const charid, bool clean_session, voidobj);
foreign import ccall unsafe "mosquitto.h mosquitto_reinitialise" c_mosquitto_reinitialise :: Ptr Mosquitto -> CString -> Bool -> Ptr () -> IO CInt

-- | Function: mosquitto_will_set
--
-- Configure will information for a mosquitto instance. By default, clients do
-- not have a will.  This must be called before calling <mosquitto_connect>.
--
-- Parameters:
-- mosq -       a valid mosquitto instance.
-- topic -      the topic on which to publish the will.
-- payloadlen - the size of the payload (bytes). Valid values are between 0 and
--               268,435,455.
-- payload -    pointer to the data to send. If payloadlen > 0 this must be a
--               valid memory location.
-- qos -        integer value 0, 1 or 2 indicating the Quality of Service to be
--               used for the will.
-- retain -     set to true to make the will a retained message.
--
-- Returns:
-- MOSQ_ERR_SUCCESS -      on success.
-- MOSQ_ERR_INVAL -        if the input parameters were invalid.
-- MOSQ_ERR_NOMEM -        if an out of memory condition occurred.
-- MOSQ_ERR_PAYLOAD_SIZE - if payloadlen is too large.
--
-- libmosq_EXPORT int mosquitto_will_set(struct mosquittomosq, const chartopic, int payloadlen, const voidpayload, int qos, bool retain);
foreign import ccall unsafe "mosquitto.h mosquitto_will_set" c_mosquitto_will_set :: Ptr Mosquitto -> CString -> CInt -> Ptr () -> CInt -> Bool -> IO CInt

-- | Function: mosquitto_will_clear
--
-- Remove a previously configured will. This must be called before calling
-- <mosquitto_connect>.
--
-- Parameters:
-- mosq - a valid mosquitto instance.
--
-- Returns:
-- MOSQ_ERR_SUCCESS - on success.
-- MOSQ_ERR_INVAL -   if the input parameters were invalid.
--
-- libmosq_EXPORT int mosquitto_will_clear(struct mosquittomosq);
foreign import ccall unsafe "mosquitto.h mosquitto_will_clear" c_mosquitto_will_clear :: Ptr Mosquitto -> IO CInt

-- | Function: mosquitto_username_pw_set
--
-- Configure username and password for a mosquitton instance. This is only
-- supported by brokers that implement the MQTT spec v3.1. By default, no
-- username or password will be sent.
-- If username is NULL, the password argument is ignored.
-- This must be called before calling mosquitto_connect().
--
-- This is must be called before calling <mosquitto_connect>.
--
-- Parameters:
-- mosq -     a valid mosquitto instance.
-- username - the username to send as a string, or NULL to disable
--             authentication.
-- password - the password to send as a string. Set to NULL when username is
--            valid in order to send just a username.
--
-- Returns:
-- MOSQ_ERR_SUCCESS - on success.
-- MOSQ_ERR_INVAL -   if the input parameters were invalid.
-- MOSQ_ERR_NOMEM -   if an out of memory condition occurred.
--
-- libmosq_EXPORT int mosquitto_username_pw_set(struct mosquittomosq, const charusername, const charpassword);
foreign import ccall unsafe "mosquitto.h mosquitto_username_pw_set" c_mosquitto_username_pw_set :: Ptr Mosquitto -> CString -> CString -> IO CInt

-- | Function: mosquitto_connect
--
-- Connect to an MQTT broker.
--
-- Parameters:
-- mosq -      a valid mosquitto instance.
-- host -      the hostname or ip address of the broker to connect to.
-- port -      the network port to connect to. Usually 1883.
-- keepalive - the number of seconds after which the broker should send a PING
--              message to the client if no other messages have been exchanged
--              in that time.
--
-- Returns:
-- MOSQ_ERR_SUCCESS - on success.
-- MOSQ_ERR_INVAL -   if the input parameters were invalid.
-- MOSQ_ERR_ERRNO -   if a system call returned an error. The variable errno
--                     contains the error code, even on Windows.
--                     Use strerror_r() where available or FormatMessage() on
--                     Windows.
--
-- See Also:
-- <mosquitto_connect_bind>, <mosquitto_connect_async>, <mosquitto_reconnect>, <mosquitto_disconnect>, <mosquitto_tls_set>
--
-- libmosq_EXPORT int mosquitto_connect(struct mosquittomosq, const charhost, int port, int keepalive);
foreign import ccall unsafe "mosquitto.h mosquitto_connect" c_mosquitto_connect :: Ptr Mosquitto -> CString -> CInt -> CInt -> IO CInt

-- | Function: mosquitto_connect_bind
--
-- Connect to an MQTT broker. This extends the functionality of
-- <mosquitto_connect> by adding the bind_address parameter. Use this function
-- if you need to restrict network communication over a particular interface.
--
-- Parameters:
-- mosq -         a valid mosquitto instance.
-- host -         the hostname or ip address of the broker to connect to.
-- port -         the network port to connect to. Usually 1883.
-- keepalive -    the number of seconds after which the broker should send a PING
--                 message to the client if no other messages have been exchanged
--                 in that time.
--  bind_address - the hostname or ip address of the local network interface to
--                 bind to.
--
-- Returns:
-- MOSQ_ERR_SUCCESS - on success.
-- MOSQ_ERR_INVAL -   if the input parameters were invalid.
-- MOSQ_ERR_ERRNO -   if a system call returned an error. The variable errno
--                     contains the error code, even on Windows.
--                     Use strerror_r() where available or FormatMessage() on
--                     Windows.
--
-- See Also:
-- <mosquitto_connect>, <mosquitto_connect_async>, <mosquitto_connect_bind_async>
--
-- libmosq_EXPORT int mosquitto_connect_bind(struct mosquittomosq, const charhost, int port, int keepalive, const charbind_address);
foreign import ccall unsafe "mosquitto.h mosquitto_connect_bind" c_mosquitto_connect_bind :: Ptr Mosquitto -> CString -> CInt -> CInt -> CString -> IO CInt

-- | Function: mosquitto_connect_async
--
-- Connect to an MQTT broker. This is a non-blocking call. If you use
-- <mosquitto_connect_async> your client must use the threaded interface
-- <mosquitto_loop_start>. If you need to use <mosquitto_loop>, you must use
-- <mosquitto_connect> to connect the client.
--
-- May be called before or after <mosquitto_loop_start>.
--
-- Parameters:
-- mosq -      a valid mosquitto instance.
-- host -      the hostname or ip address of the broker to connect to.
-- port -      the network port to connect to. Usually 1883.
-- keepalive - the number of seconds after which the broker should send a PING
--              message to the client if no other messages have been exchanged
--              in that time.
--
-- Returns:
-- MOSQ_ERR_SUCCESS - on success.
-- MOSQ_ERR_INVAL -   if the input parameters were invalid.
-- MOSQ_ERR_ERRNO -   if a system call returned an error. The variable errno
--                     contains the error code, even on Windows.
--                     Use strerror_r() where available or FormatMessage() on
--                     Windows.
--
-- See Also:
-- <mosquitto_connect_bind_async>, <mosquitto_connect>, <mosquitto_reconnect>, <mosquitto_disconnect>, <mosquitto_tls_set>
--
-- libmosq_EXPORT int mosquitto_connect_async(struct mosquittomosq, const charhost, int port, int keepalive);
foreign import ccall unsafe "mosquitto.h mosquitto_connect_async" c_mosquitto_connect_async :: Ptr Mosquitto -> CString -> CInt -> CInt -> IO CInt

-- | Function: mosquitto_connect_bind_async
--
-- Connect to an MQTT broker. This is a non-blocking call. If you use
-- <mosquitto_connect_bind_async> your client must use the threaded interface
-- <mosquitto_loop_start>. If you need to use <mosquitto_loop>, you must use
-- <mosquitto_connect> to connect the client.
--
-- This extends the functionality of <mosquitto_connect_async> by adding the
-- bind_address parameter. Use this function if you need to restrict network
-- communication over a particular interface.
--
-- May be called before or after <mosquitto_loop_start>.
--
-- Parameters:
-- mosq -         a valid mosquitto instance.
-- host -         the hostname or ip address of the broker to connect to.
-- port -         the network port to connect to. Usually 1883.
-- keepalive -    the number of seconds after which the broker should send a PING
--                 message to the client if no other messages have been exchanged
--                 in that time.
--  bind_address - the hostname or ip address of the local network interface to
--                 bind to.
--
-- Returns:
-- MOSQ_ERR_SUCCESS - on success.
-- MOSQ_ERR_INVAL -   if the input parameters were invalid.
-- MOSQ_ERR_ERRNO -   if a system call returned an error. The variable errno
--                     contains the error code, even on Windows.
--                     Use strerror_r() where available or FormatMessage() on
--                     Windows.
--
-- See Also:
-- <mosquitto_connect_async>, <mosquitto_connect>, <mosquitto_connect_bind>
--
-- libmosq_EXPORT int mosquitto_connect_bind_async(struct mosquittomosq, const charhost, int port, int keepalive, const charbind_address);
foreign import ccall unsafe "mosquitto.h mosquitto_connect_bind_async" c_mosquitto_connect_bind_async :: Ptr Mosquitto -> CString -> CInt -> CInt -> CString -> IO CInt

-- | Function: mosquitto_connect_srv
--
-- Connect to an MQTT broker. This is a non-blocking call. If you use
-- <mosquitto_connect_async> your client must use the threaded interface
-- <mosquitto_loop_start>. If you need to use <mosquitto_loop>, you must use
-- <mosquitto_connect> to connect the client.
--
-- This extends the functionality of <mosquitto_connect_async> by adding the
-- bind_address parameter. Use this function if you need to restrict network
-- communication over a particular interface.
--
-- May be called before or after <mosquitto_loop_start>.
--
-- Parameters:
-- mosq -         a valid mosquitto instance.
-- host -         the hostname or ip address of the broker to connect to.
-- keepalive -    the number of seconds after which the broker should send a PING
--                 message to the client if no other messages have been exchanged
--                 in that time.
--  bind_address - the hostname or ip address of the local network interface to
--                 bind to.
--
-- Returns:
-- MOSQ_ERR_SUCCESS - on success.
-- MOSQ_ERR_INVAL -   if the input parameters were invalid.
-- MOSQ_ERR_ERRNO -   if a system call returned an error. The variable errno
--                     contains the error code, even on Windows.
--                     Use strerror_r() where available or FormatMessage() on
--                     Windows.
--
-- See Also:
-- <mosquitto_connect_async>, <mosquitto_connect>, <mosquitto_connect_bind>
--
-- libmosq_EXPORT int mosquitto_connect_srv(struct mosquittomosq, const charhost, int keepalive, const charbind_address);
foreign import ccall unsafe "mosquitto.h mosquitto_connect_srv" c_mosquitto_connect_srv :: Ptr Mosquitto -> CString -> CInt -> CString -> IO CInt

-- | Function: mosquitto_reconnect
--
-- Reconnect to a broker.
--
-- This function provides an easy way of reconnecting to a broker after a
-- connection has been lost. It uses the values that were provided in the
-- <mosquitto_connect> call. It must not be called before
-- <mosquitto_connect>.
--
-- Parameters:
-- mosq - a valid mosquitto instance.
--
-- Returns:
-- MOSQ_ERR_SUCCESS - on success.
-- MOSQ_ERR_INVAL -   if the input parameters were invalid.
-- MOSQ_ERR_NOMEM -   if an out of memory condition occurred.
--
-- Returns:
-- MOSQ_ERR_SUCCESS - on success.
-- MOSQ_ERR_INVAL -   if the input parameters were invalid.
-- MOSQ_ERR_ERRNO -   if a system call returned an error. The variable errno
--                     contains the error code, even on Windows.
--                     Use strerror_r() where available or FormatMessage() on
--                     Windows.
--
-- See Also:
-- <mosquitto_connect>, <mosquitto_disconnect>, <mosquitto_reconnect_async>
--
-- libmosq_EXPORT int mosquitto_reconnect(struct mosquittomosq);
foreign import ccall unsafe "mosquitto.h mosquitto_reconnect" c_mosquitto_reconnect :: Ptr Mosquitto -> IO CInt

-- | Function: mosquitto_reconnect_async
--
-- Reconnect to a broker. Non blocking version of <mosquitto_reconnect>.
--
-- This function provides an easy way of reconnecting to a broker after a
-- connection has been lost. It uses the values that were provided in the
-- <mosquitto_connect> or <mosquitto_connect_async> calls. It must not be
-- called before <mosquitto_connect>.
--
-- Parameters:
-- mosq - a valid mosquitto instance.
--
-- Returns:
-- MOSQ_ERR_SUCCESS - on success.
-- MOSQ_ERR_INVAL -   if the input parameters were invalid.
-- MOSQ_ERR_NOMEM -   if an out of memory condition occurred.
--
-- Returns:
-- MOSQ_ERR_SUCCESS - on success.
-- MOSQ_ERR_INVAL -   if the input parameters were invalid.
-- MOSQ_ERR_ERRNO -   if a system call returned an error. The variable errno
--                     contains the error code, even on Windows.
--                     Use strerror_r() where available or FormatMessage() on
--                     Windows.
--
-- See Also:
-- <mosquitto_connect>, <mosquitto_disconnect>
--
-- libmosq_EXPORT int mosquitto_reconnect_async(struct mosquittomosq);
foreign import ccall unsafe "mosquitto.h mosquitto_reconnect_async" c_mosquitto_reconnect_async :: Ptr Mosquitto -> IO CInt

-- | Function: mosquitto_disconnect
--
-- Disconnect from the broker.
--
-- Parameters:
-- mosq - a valid mosquitto instance.
--
-- Returns:
-- MOSQ_ERR_SUCCESS - on success.
-- MOSQ_ERR_INVAL -   if the input parameters were invalid.
-- MOSQ_ERR_NO_CONN -  if the client isn't connected to a broker.
--
-- libmosq_EXPORT int mosquitto_disconnect(struct mosquittomosq);


-- | Function: mosquitto_publish
--
-- Publish a message on a given topic.
--
-- Parameters:
-- mosq -       a valid mosquitto instance.
-- mid -        pointer to an int. If not NULL, the function will set this
--               to the message id of this particular message. This can be then
--               used with the publish callback to determine when the message
--               has been sent.
--               Note that although the MQTT protocol doesn't use message ids
--               for messages with QoS=0, libmosquitto assigns them message ids
--               so they can be tracked with this parameter.
--  topic -      null terminated string of the topic to publish to.
-- payloadlen - the size of the payload (bytes). Valid values are between 0 and
--               268,435,455.
-- payload -    pointer to the data to send. If payloadlen > 0 this must be a
--               valid memory location.
-- qos -        integer value 0, 1 or 2 indicating the Quality of Service to be
--               used for the message.
-- retain -     set to true to make the message retained.
--
-- Returns:
-- MOSQ_ERR_SUCCESS -      on success.
-- MOSQ_ERR_INVAL -        if the input parameters were invalid.
-- MOSQ_ERR_NOMEM -        if an out of memory condition occurred.
-- MOSQ_ERR_NO_CONN -      if the client isn't connected to a broker.
-- MOSQ_ERR_PROTOCOL -     if there is a protocol error communicating with the
--                          broker.
-- MOSQ_ERR_PAYLOAD_SIZE - if payloadlen is too large.
--
-- See Also:
-- <mosquitto_max_inflight_messages_set>
--
-- libmosq_EXPORT int mosquitto_publish(struct mosquittomosq, intmid, const chartopic, int payloadlen, const voidpayload, int qos, bool retain);
foreign import ccall unsafe "mosquitto.h mosquitto_publish" c_mosquitto_publish :: Ptr Mosquitto -> Ptr CInt -> CString -> CInt -> Ptr () -> CInt -> Bool -> IO CInt

-- | Function: mosquitto_subscribe
--
-- Subscribe to a topic.
--
-- Parameters:
-- mosq - a valid mosquitto instance.
-- mid -  a pointer to an int. If not NULL, the function will set this to
--        the message id of this particular message. This can be then used
--        with the subscribe callback to determine when the message has been
--        sent.
-- sub -  the subscription pattern.
-- qos -  the requested Quality of Service for this subscription.
--
-- Returns:
-- MOSQ_ERR_SUCCESS - on success.
-- MOSQ_ERR_INVAL -   if the input parameters were invalid.
-- MOSQ_ERR_NOMEM -   if an out of memory condition occurred.
-- MOSQ_ERR_NO_CONN - if the client isn't connected to a broker.
--
-- libmosq_EXPORT int mosquitto_subscribe(struct mosquittomosq, intmid, const charsub, int qos);
foreign import ccall unsafe "mosquitto.h mosquitto_subscribe" c_mosquitto_subscribe :: Ptr Mosquitto -> Ptr CInt -> CString -> CInt -> IO CInt


-- | Function: mosquitto_unsubscribe
--
-- Unsubscribe from a topic.
--
-- Parameters:
-- mosq - a valid mosquitto instance.
-- mid -  a pointer to an int. If not NULL, the function will set this to
--        the message id of this particular message. This can be then used
--        with the unsubscribe callback to determine when the message has been
--        sent.
-- sub -  the unsubscription pattern.
--
-- Returns:
-- MOSQ_ERR_SUCCESS - on success.
-- MOSQ_ERR_INVAL -   if the input parameters were invalid.
-- MOSQ_ERR_NOMEM -   if an out of memory condition occurred.
-- MOSQ_ERR_NO_CONN - if the client isn't connected to a broker.
--
-- libmosq_EXPORT int mosquitto_unsubscribe(struct mosquittomosq, intmid, const charsub);
foreign import ccall unsafe "mosquitto.h mosquitto_unsubscribe" c_mosquitto_unsubscribe :: Ptr Mosquitto -> Ptr CInt -> CString -> IO CInt

-- | Function: mosquitto_message_copy
--
-- Copy the contents of a mosquitto message to another message.
-- Useful for preserving a message received in the on_message() callback.
--
-- Parameters:
-- dst - a pointer to a valid mosquitto_message struct to copy to.
-- src - a pointer to a valid mosquitto_message struct to copy from.
--
-- Returns:
-- MOSQ_ERR_SUCCESS - on success.
-- MOSQ_ERR_INVAL -   if the input parameters were invalid.
-- MOSQ_ERR_NOMEM -   if an out of memory condition occurred.
--
-- See Also:
-- <mosquitto_message_free>
--
-- libmosq_EXPORT int mosquitto_message_copy(struct mosquitto_messagedst, const struct mosquitto_messagesrc);
foreign import ccall unsafe "mosquitto.h mosquitto_message_copy" c_mosquitto_message_copy :: Ptr MosquittoMessage -> Ptr MosquittoMessage -> IO CInt

-- | Function: mosquitto_message_free
--
-- Completely free a mosquitto_message struct.
--
-- Parameters:
-- message - pointer to a mosquitto_message pointer to free.
--
-- See Also:
-- <mosquitto_message_copy>
--
-- libmosq_EXPORT void mosquitto_message_free(struct mosquitto_message*message);
foreign import ccall unsafe "mosquitto.h mosquitto_message_free" c_mosquitto_message_free :: Ptr MosquittoMessage -> IO ()

-- | Function: mosquitto_loop
--
-- The main network loop for the client. You must call this frequently in order
-- to keep communications between the client and broker working. If incoming
-- data is present it will then be processed. Outgoing commands, from e.g.
-- <mosquitto_publish>, are normally sent immediately that their function is
-- called, but this is not always possible. <mosquitto_loop> will also attempt
-- to send any remaining outgoing messages, which also includes commands that
-- are part of the flow for messages with QoS>0.
--
-- An alternative approach is to use <mosquitto_loop_start> to run the client
-- loop in its own thread.
--
-- This calls select() to monitor the client network socket. If you want to
-- integrate mosquitto client operation with your own select() call, use
-- <mosquitto_socket>, <mosquitto_loop_read>, <mosquitto_loop_write> and
-- <mosquitto_loop_misc>.
--
-- Threads:
--
-- Parameters:
-- mosq -        a valid mosquitto instance.
-- timeout -     Maximum number of milliseconds to wait for network activity
--               in the select() call before timing out. Set to 0 for instant
--               return.  Set negative to use the default of 1000ms.
-- max_packets - this parameter is currently unused and should be set to 1 for
--               future compatibility.
--
-- Returns:
-- MOSQ_ERR_SUCCESS -   on success.
-- MOSQ_ERR_INVAL -     if the input parameters were invalid.
-- MOSQ_ERR_NOMEM -     if an out of memory condition occurred.
-- MOSQ_ERR_NO_CONN -   if the client isn't connected to a broker.
--  MOSQ_ERR_CONN_LOST - if the connection to the broker was lost.
-- MOSQ_ERR_PROTOCOL -  if there is a protocol error communicating with the
--                       broker.
-- MOSQ_ERR_ERRNO -     if a system call returned an error. The variable errno
--                       contains the error code, even on Windows.
--                       Use strerror_r() where available or FormatMessage() on
--                       Windows.
-- See Also:
-- <mosquitto_loop_forever>, <mosquitto_loop_start>, <mosquitto_loop_stop>
--
-- libmosq_EXPORT int mosquitto_loop(struct mosquittomosq, int timeout, int max_packets);
foreign import ccall unsafe "mosquitto.h mosquitto_loop" c_mosquitto_loop :: Ptr MosquittoMessage -> CInt -> CInt -> IO CInt

-- | Function: mosquitto_loop_forever
--
-- This function call loop() for you in an infinite blocking loop. It is useful
-- for the case where you only want to run the MQTT client loop in your
-- program.
--
-- It handles reconnecting in case server connection is lost. If you call
-- mosquitto_disconnect() in a callback it will return.
--
-- Parameters:
--  mosq - a valid mosquitto instance.
-- timeout -     Maximum number of milliseconds to wait for network activity
--               in the select() call before timing out. Set to 0 for instant
--               return.  Set negative to use the default of 1000ms.
-- max_packets - this parameter is currently unused and should be set to 1 for
--               future compatibility.
--
-- Returns:
-- MOSQ_ERR_SUCCESS -   on success.
-- MOSQ_ERR_INVAL -     if the input parameters were invalid.
-- MOSQ_ERR_NOMEM -     if an out of memory condition occurred.
-- MOSQ_ERR_NO_CONN -   if the client isn't connected to a broker.
--  MOSQ_ERR_CONN_LOST - if the connection to the broker was lost.
-- MOSQ_ERR_PROTOCOL -  if there is a protocol error communicating with the
--                       broker.
-- MOSQ_ERR_ERRNO -     if a system call returned an error. The variable errno
--                       contains the error code, even on Windows.
--                       Use strerror_r() where available or FormatMessage() on
--                       Windows.
--
-- See Also:
-- <mosquitto_loop>, <mosquitto_loop_start>
--
-- libmosq_EXPORT int mosquitto_loop_forever(struct mosquittomosq, int timeout, int max_packets);
foreign import ccall unsafe "mosquitto.h mosquitto_loop_forever" c_mosquitto_loop_forever :: Ptr MosquittoMessage -> CInt -> CInt -> IO CInt

-- | Function: mosquitto_loop_start
--
-- This is part of the threaded client interface. Call this once to start a new
-- thread to process network traffic. This provides an alternative to
-- repeatedly calling <mosquitto_loop> yourself.
--
-- Parameters:
--  mosq - a valid mosquitto instance.
--
-- Returns:
-- MOSQ_ERR_SUCCESS -       on success.
-- MOSQ_ERR_INVAL -         if the input parameters were invalid.
-- MOSQ_ERR_NOT_SUPPORTED - if thread support is not available.
--
-- See Also:
-- <mosquitto_connect_async>, <mosquitto_loop>, <mosquitto_loop_forever>, <mosquitto_loop_stop>
--
-- libmosq_EXPORT int mosquitto_loop_start(struct mosquittomosq);
foreign import ccall unsafe "mosquitto.h mosquitto_loop_start" c_mosquitto_loop_start :: Ptr MosquittoMessage -> IO CInt

-- | Function: mosquitto_loop_stop
--
-- This is part of the threaded client interface. Call this once to stop the
-- network thread previously created with <mosquitto_loop_start>. This call
-- will block until the network thread finishes. For the network thread to end,
-- you must have previously called <mosquitto_disconnect> or have set the force
-- parameter to true.
--
-- Parameters:
--  mosq - a valid mosquitto instance.
-- force - set to true to force thread cancellation. If false,
--         <mosquitto_disconnect> must have already been called.
--
-- Returns:
-- MOSQ_ERR_SUCCESS -       on success.
-- MOSQ_ERR_INVAL -         if the input parameters were invalid.
-- MOSQ_ERR_NOT_SUPPORTED - if thread support is not available.
--
-- See Also:
-- <mosquitto_loop>, <mosquitto_loop_start>
--
-- libmosq_EXPORT int mosquitto_loop_stop(struct mosquittomosq, bool force);
foreign import ccall unsafe "mosquitto.h mosquitto_loop_stop" c_mosquitto_loop_stop :: Ptr Mosquitto -> Bool -> IO CInt

-- | Function: mosquitto_socket
--
-- Return the socket handle for a mosquitto instance. Useful if you want to
-- include a mosquitto client in your own select() calls.
--
-- Parameters:
-- mosq - a valid mosquitto instance.
--
-- Returns:
-- The socket for the mosquitto client or -1 on failure.
--
-- libmosq_EXPORT int mosquitto_socket(struct mosquittomosq);
foreign import ccall unsafe "mosquitto.h mosquitto_socket" c_mosquitto_socket :: Ptr MosquittoMessage -> IO CInt

-- | Function: mosquitto_loop_read
--
-- Carry out network read operations.
-- This should only be used if you are not using mosquitto_loop() and are
-- monitoring the client network socket for activity yourself.
--
-- Parameters:
-- mosq -        a valid mosquitto instance.
-- max_packets - this parameter is currently unused and should be set to 1 for
--               future compatibility.
--
-- Returns:
-- MOSQ_ERR_SUCCESS -   on success.
-- MOSQ_ERR_INVAL -     if the input parameters were invalid.
-- MOSQ_ERR_NOMEM -     if an out of memory condition occurred.
-- MOSQ_ERR_NO_CONN -   if the client isn't connected to a broker.
--  MOSQ_ERR_CONN_LOST - if the connection to the broker was lost.
-- MOSQ_ERR_PROTOCOL -  if there is a protocol error communicating with the
--                       broker.
-- MOSQ_ERR_ERRNO -     if a system call returned an error. The variable errno
--                       contains the error code, even on Windows.
--                       Use strerror_r() where available or FormatMessage() on
--                       Windows.
--
-- See Also:
-- <mosquitto_socket>, <mosquitto_loop_write>, <mosquitto_loop_misc>
--
-- libmosq_EXPORT int mosquitto_loop_read(struct mosquittomosq, int max_packets);
foreign import ccall unsafe "mosquitto.h mosquitto_loop_read" c_mosquitto_loop_read :: Ptr Mosquitto -> CInt -> IO CInt

-- | Function: mosquitto_loop_write
--
-- Carry out network write operations.
-- This should only be used if you are not using mosquitto_loop() and are
-- monitoring the client network socket for activity yourself.
--
-- Parameters:
-- mosq -        a valid mosquitto instance.
-- max_packets - this parameter is currently unused and should be set to 1 for
--               future compatibility.
--
-- Returns:
-- MOSQ_ERR_SUCCESS -   on success.
-- MOSQ_ERR_INVAL -     if the input parameters were invalid.
-- MOSQ_ERR_NOMEM -     if an out of memory condition occurred.
-- MOSQ_ERR_NO_CONN -   if the client isn't connected to a broker.
--  MOSQ_ERR_CONN_LOST - if the connection to the broker was lost.
-- MOSQ_ERR_PROTOCOL -  if there is a protocol error communicating with the
--                       broker.
-- MOSQ_ERR_ERRNO -     if a system call returned an error. The variable errno
--                       contains the error code, even on Windows.
--                       Use strerror_r() where available or FormatMessage() on
--                       Windows.
--
-- See Also:
-- <mosquitto_socket>, <mosquitto_loop_read>, <mosquitto_loop_misc>, <mosquitto_want_write>
--
-- libmosq_EXPORT int mosquitto_loop_write(struct mosquittomosq, int max_packets);
foreign import ccall unsafe "mosquitto.h mosquitto_loop_write" c_mosquitto_loop_write :: Ptr Mosquitto -> CInt -> IO CInt

-- | Function: mosquitto_loop_misc
--
-- Carry out miscellaneous operations required as part of the network loop.
-- This should only be used if you are not using mosquitto_loop() and are
-- monitoring the client network socket for activity yourself.
--
-- This function deals with handling PINGs and checking whether messages need
-- to be retried, so should be called fairly frequently.
--
-- Parameters:
-- mosq - a valid mosquitto instance.
--
-- Returns:
-- MOSQ_ERR_SUCCESS -   on success.
-- MOSQ_ERR_INVAL -     if the input parameters were invalid.
-- MOSQ_ERR_NO_CONN -   if the client isn't connected to a broker.
--
-- See Also:
-- <mosquitto_socket>, <mosquitto_loop_read>, <mosquitto_loop_write>
--
-- libmosq_EXPORT int mosquitto_loop_misc(struct mosquittomosq);
foreign import ccall unsafe "mosquitto.h mosquitto_loop_misc" c_mosquitto_loop_misc :: Ptr Mosquitto -> IO CInt

-- | Function: mosquitto_want_write
--
-- Returns true if there is data ready to be written on the socket.
--
-- Parameters:
-- mosq - a valid mosquitto instance.
--
-- See Also:
-- <mosquitto_socket>, <mosquitto_loop_read>, <mosquitto_loop_write>
--
-- libmosq_EXPORT bool mosquitto_want_write(struct mosquittomosq);
foreign import ccall unsafe "mosquitto.h mosquitto_want_write" c_mosquitto_want_write :: Ptr Mosquitto -> IO Bool

-- | Function: mosquitto_threaded_set
--
-- Used to tell the library that your application is using threads, but not
-- using <mosquitto_loop_start>. The library operates slightly differently when
-- not in threaded mode in order to simplify its operation. If you are managing
-- your own threads and do not use this function you will experience crashes
-- due to race conditions.
--
-- When using <mosquitto_loop_start>, this is set automatically.
--
-- Parameters:
--  mosq -     a valid mosquitto instance.
--  threaded - true if your application is using threads, false otherwise.
--
-- libmosq_EXPORT int mosquitto_threaded_set(struct mosquittomosq, bool threaded);
foreign import ccall unsafe "mosquitto.h mosquitto_threaded_set" c_mosquitto_threaded_set :: Ptr Mosquitto -> Bool -> IO CInt


-- | Function: mosquitto_opts_set
--
-- Used to set options for the client.
--
-- Parameters:
-- mosq -   a valid mosquitto instance.
-- option - the option to set.
-- value -  the option specific value.
--
-- Options:
-- MOSQ_OPT_PROTOCOL_VERSION - value must be an int, set to either
--                             MQTT_PROTOCOL_V31 or MQTT_PROTOCOL_V311. Must
--                             be set before the client connects. Defaults to
--                             MQTT_PROTOCOL_V31.
--
-- libmosq_EXPORT int mosquitto_opts_set(struct mosquittomosq, enum mosq_opt_t option, voidvalue);
foreign import ccall unsafe "mosquitto.h mosquitto_opts_set" c_mosquitto_opts_set :: Ptr Mosquitto -> CInt -> Ptr () -> IO CInt


-- | Function: mosquitto_tls_set
--
-- Configure the client for certificate based SSL/TLS support. Must be called
-- before <mosquitto_connect>.
--
-- Cannot be used in conjunction with <mosquitto_tls_psk_set>.
--
-- Define the Certificate Authority certificates to be trusted (ie. the server
-- certificate must be signed with one of these certificates) using cafile.
--
-- If the server you are connecting to requires clients to provide a
-- certificate, define certfile and keyfile with your client certificate and
-- private key. If your private key is encrypted, provide a password callback
-- function or you will have to enter the password at the command line.
--
-- Parameters:
--  mosq -        a valid mosquitto instance.
--  cafile -      path to a file containing the PEM encoded trusted CA
--                certificate files. Either cafile or capath must not be NULL.
--  capath -      path to a directory containing the PEM encoded trusted CA
--                certificate files. See mosquitto.conf for more details on
--                configuring this directory. Either cafile or capath must not
--                be NULL.
--  certfile -    path to a file containing the PEM encoded certificate file
--                for this client. If NULL, keyfile must also be NULL and no
--                client certificate will be used.
--  keyfile -     path to a file containing the PEM encoded private key for
--                this client. If NULL, certfile must also be NULL and no
--                client certificate will be used.
--  pw_callback - if keyfile is encrypted, set pw_callback to allow your client
--                to pass the correct password for decryption. If set to NULL,
--                the password must be entered on the command line.
--                Your callback must write the password into "buf", which is
--                "size" bytes long. The return value must be the length of the
--                password. "userdata" will be set to the calling mosquitto
--                instance.
--
-- Returns:
-- MOSQ_ERR_SUCCESS - on success.
-- MOSQ_ERR_INVAL -   if the input parameters were invalid.
-- MOSQ_ERR_NOMEM -   if an out of memory condition occurred.
--
-- See Also:
-- <mosquitto_tls_opts_set>, <mosquitto_tls_psk_set>, <mosquitto_tls_insecure_set>
--
-- libmosq_EXPORT int mosquitto_tls_set(struct mosquittomosq,
type PWCallback = FunPtr (CString -> CInt -> CInt -> Ptr () -> IO CInt)
foreign import ccall unsafe "mosquitto.h mosquitto_tls_set" c_mosquitto_tls_set :: Ptr Mosquitto -> CString -> CString -> CString -> CString -> PWCallback -> IO CInt




-- | Function: mosquitto_tls_insecure_set
--
-- Configure verification of the server hostname in the server certificate. If
-- value is set to true, it is impossible to guarantee that the host you are
-- connecting to is not impersonating your server. This can be useful in
-- initial server testing, but makes it possible for a malicious third party to
-- impersonate your server through DNS spoofing, for example.
-- Do not use this function in a real system. Setting value to true makes the
-- connection encryption pointless.
-- Must be called before <mosquitto_connect>.
--
-- Parameters:
--  mosq -  a valid mosquitto instance.
--  value - if set to false, the default, certificate hostname checking is
--          performed. If set to true, no hostname checking is performed and
--          the connection is insecure.
--
-- Returns:
-- MOSQ_ERR_SUCCESS - on success.
-- MOSQ_ERR_INVAL -   if the input parameters were invalid.
--
-- See Also:
-- <mosquitto_tls_set>
--
-- libmosq_EXPORT int mosquitto_tls_insecure_set(struct mosquittomosq, bool value);
foreign import ccall unsafe "mosquitto.h mosquitto_tls_insecure_set" c_mosquitto_tls_insecure_set :: Ptr Mosquitto -> Bool -> IO CInt

-- | Function: mosquitto_tls_opts_set
--
-- Set advanced SSL/TLS options. Must be called before <mosquitto_connect>.
--
-- Parameters:
--  mosq -        a valid mosquitto instance.
-- cert_reqs -   an integer defining the verification requirements the client
--               will impose on the server. This can be one of:
--              SSL_VERIFY_NONE (0): the server will not be verified in any way.
--              SSL_VERIFY_PEER (1): the server certificate will be verified
--                 and the connection aborted if the verification fails.
--               The default and recommended value is SSL_VERIFY_PEER. Using
--               SSL_VERIFY_NONE provides no security.
-- tls_version - the version of the SSL/TLS protocol to use as a string. If NULL,
--               the default value is used. The default value and the
--               available values depend on the version of openssl that the
--               library was compiled against. For openssl >= 1.0.1, the
--               available options are tlsv1.2, tlsv1.1 and tlsv1, with tlv1.2
--               as the default. For openssl < 1.0.1, only tlsv1 is available.
-- ciphers -     a string describing the ciphers available for use. See the
--               "openssl ciphers" tool for more information. If NULL, the
--               default ciphers will be used.
--
-- Returns:
-- MOSQ_ERR_SUCCESS - on success.
-- MOSQ_ERR_INVAL -   if the input parameters were invalid.
-- MOSQ_ERR_NOMEM -   if an out of memory condition occurred.
--
-- See Also:
-- <mosquitto_tls_set>
--
-- libmosq_EXPORT int mosquitto_tls_opts_set(struct mosquittomosq, int cert_reqs, const chartls_version, const charciphers);
foreign import ccall unsafe "mosquitto.h mosquitto_tls_opts_set" c_mosquitto_tls_opts_set :: Ptr Mosquitto -> CInt -> CString -> CString -> IO CInt

-- | Function: mosquitto_tls_psk_set
--
-- Configure the client for pre-shared-key based TLS support. Must be called
-- before <mosquitto_connect>.
--
-- Cannot be used in conjunction with <mosquitto_tls_set>.
--
-- Parameters:
--  mosq -     a valid mosquitto instance.
--  psk -      the pre-shared-key in hex format with no leading "0x".
--  identity - the identity of this client. May be used as the username
--             depending on the server settings.
-- ciphers -  a string describing the PSK ciphers available for use. See the
--            "openssl ciphers" tool for more information. If NULL, the
--            default ciphers will be used.
--
-- Returns:
-- MOSQ_ERR_SUCCESS - on success.
-- MOSQ_ERR_INVAL -   if the input parameters were invalid.
-- MOSQ_ERR_NOMEM -   if an out of memory condition occurred.
--
-- See Also:
-- <mosquitto_tls_set>
--
-- libmosq_EXPORT int mosquitto_tls_psk_set(struct mosquittomosq, const charpsk, const charidentity, const charciphers);
foreign import ccall unsafe "mosquitto.h mosquitto_tls_psk_set" c_mosquitto_tls_psk_set :: Ptr Mosquitto -> CString -> CString -> CString -> IO CInt

-- | Function: mosquitto_connect_callback_set
--
-- Set the connect callback. This is called when the broker sends a CONNACK
-- message in response to a connection.
--
-- Parameters:
--  mosq -       a valid mosquitto instance.
--  on_connect - a callback function in the following form:
--               void callback(struct mosquittomosq, voidobj, int rc)
--
-- Callback Parameters:
--  mosq - the mosquitto instance making the callback.
--  obj - the user data provided in <mosquitto_new>
--  rc -  the return code of the connection response, one of:
--
-- * 0 - success
-- * 1 - connection refused (unacceptable protocol version)
-- * 2 - connection refused (identifier rejected)
-- * 3 - connection refused (broker unavailable)
-- * 4-255 - reserved for future use
--
-- libmosq_EXPORT void mosquitto_connect_callback_set(struct mosquittomosq, void (*on_connect)(struct mosquitto, void, int));
type ConnectCallback = FunPtr (Ptr Mosquitto -> Ptr () -> CInt -> IO ())
foreign import ccall unsafe "mosquitto.h mosquitto_connect_callback_set" c_mosquitto_connect_callback_set :: Ptr Mosquitto -> ConnectCallback -> IO ()

-- | Function: mosquitto_disconnect_callback_set
--
-- Set the disconnect callback. This is called when the broker has received the
-- DISCONNECT command and has disconnected the client.
--
-- Parameters:
--  mosq -          a valid mosquitto instance.
--  on_disconnect - a callback function in the following form:
--                  void callback(struct mosquittomosq, voidobj)
--
-- Callback Parameters:
--  mosq - the mosquitto instance making the callback.
--  obj -  the user data provided in <mosquitto_new>
--  rc -   integer value indicating the reason for the disconnect. A value of 0
--         means the client has called <mosquitto_disconnect>. Any other value
--         indicates that the disconnect is unexpected.
--
-- libmosq_EXPORT void mosquitto_disconnect_callback_set(struct mosquittomosq, void (*on_disconnect)(struct mosquitto, void, int));
type DisconnectCallback = FunPtr (Ptr Mosquitto -> Ptr () -> CInt -> IO ())
foreign import ccall unsafe "mosquitto.h mosquitto_disconnect_callback_set" c_mosquitto_disconnect_callback_set :: Ptr Mosquitto -> DisconnectCallback -> IO ()

-- | Function: mosquitto_publish_callback_set
--
-- Set the publish callback. This is called when a message initiated with
-- <mosquitto_publish> has been sent to the broker successfully.
--
-- Parameters:
--  mosq -       a valid mosquitto instance.
--  on_publish - a callback function in the following form:
--               void callback(struct mosquittomosq, voidobj, int mid)
--
-- Callback Parameters:
--  mosq - the mosquitto instance making the callback.
--  obj -  the user data provided in <mosquitto_new>
--  mid -  the message id of the sent message.
--
-- libmosq_EXPORT void mosquitto_publish_callback_set(struct mosquittomosq, void (*on_publish)(struct mosquitto, void, int));
type PublishCallback = FunPtr (Ptr Mosquitto -> Ptr () -> CInt -> IO ())
foreign import ccall unsafe "mosquitto.h mosquitto_publish_callback_set" c_mosquitto_publish_callback_set :: Ptr Mosquitto -> PublishCallback -> IO ()

-- | Function: mosquitto_message_callback_set
--
-- Set the message callback. This is called when a message is received from the
-- broker.
--
-- Parameters:
--  mosq -       a valid mosquitto instance.
--  on_message - a callback function in the following form:
--               void callback(struct mosquittomosq, voidobj, const struct mosquitto_messagemessage)
--
-- Callback Parameters:
--  mosq -    the mosquitto instance making the callback.
--  obj -     the user data provided in <mosquitto_new>
--  message - the message data. This variable and associated memory will be
--            freed by the library after the callback completes. The client
--            should make copies of any of the data it requires.
--
-- See Also:
-- <mosquitto_message_copy>
--
-- libmosq_EXPORT void mosquitto_message_callback_set(struct mosquittomosq, void (*on_message)(struct mosquitto, void, const struct mosquitto_message));
type MessageCallback = FunPtr (Ptr Mosquitto -> Ptr () -> Ptr MosquittoMessage -> IO ())
foreign import ccall unsafe "mosquitto.h mosquitto_message_callback_set" c_mosquitto_message_callback_set :: Ptr Mosquitto -> MessageCallback -> IO ()

-- | Function: mosquitto_subscribe_callback_set
--
-- Set the subscribe callback. This is called when the broker responds to a
-- subscription request.
--
-- Parameters:
--  mosq -         a valid mosquitto instance.
--  on_subscribe - a callback function in the following form:
--                 void callback(struct mosquittomosq, voidobj, int mid, int qos_count, const intgranted_qos)
--
-- Callback Parameters:
--  mosq -        the mosquitto instance making the callback.
--  obj -         the user data provided in <mosquitto_new>
--  mid -         the message id of the subscribe message.
--  qos_count -   the number of granted subscriptions (size of granted_qos).
--  granted_qos - an array of integers indicating the granted QoS for each of
--                the subscriptions.
--
-- libmosq_EXPORT void mosquitto_subscribe_callback_set(struct mosquittomosq, void (*on_subscribe)(struct mosquitto, void, int, int, const int));
type SubscribeCallback = FunPtr (Ptr Mosquitto -> Ptr () -> CInt -> CInt -> Ptr CInt -> IO ())
foreign import ccall unsafe "mosquitto.h mosquitto_subscribe_callback_set" c_mosquitto_subscribe_callback_set :: Ptr Mosquitto -> SubscribeCallback -> IO ()

-- | Function: mosquitto_unsubscribe_callback_set
--
-- Set the unsubscribe callback. This is called when the broker responds to a
-- unsubscription request.
--
-- Parameters:
--  mosq -           a valid mosquitto instance.
--  on_unsubscribe - a callback function in the following form:
--                   void callback(struct mosquittomosq, voidobj, int mid)
--
-- Callback Parameters:
--  mosq - the mosquitto instance making the callback.
--  obj -  the user data provided in <mosquitto_new>
--  mid -  the message id of the unsubscribe message.
--
-- libmosq_EXPORT void mosquitto_unsubscribe_callback_set(struct mosquittomosq, void (*on_unsubscribe)(struct mosquitto, void, int));
type UnsubscribeCallback = FunPtr (Ptr Mosquitto -> Ptr () -> CInt -> IO ())
foreign import ccall unsafe "mosquitto.h mosquitto_unsubscribe_callback_set" c_mosquitto_unsubscribe_callback_set :: Ptr Mosquitto -> UnsubscribeCallback -> IO ()

-- | Function: mosquitto_log_callback_set
--
-- Set the logging callback. This should be used if you want event logging
-- information from the client library.
--
--  mosq -   a valid mosquitto instance.
--  on_log - a callback function in the following form:
--           void callback(struct mosquittomosq, voidobj, int level, const charstr)
--
-- Callback Parameters:
--  mosq -  the mosquitto instance making the callback.
--  obj -   the user data provided in <mosquitto_new>
--  level - the log message level from the values:
--         MOSQ_LOG_INFO
--         MOSQ_LOG_NOTICE
--         MOSQ_LOG_WARNING
--         MOSQ_LOG_ERR
--         MOSQ_LOG_DEBUG
-- str -   the message string.
--
-- libmosq_EXPORT void mosquitto_log_callback_set(struct mosquittomosq, void (*on_log)(struct mosquitto, void, int, const char));
type LogCallback = FunPtr (Ptr Mosquitto -> Ptr () -> CInt -> CString -> IO ())
foreign import ccall unsafe "mosquitto.h mosquitto_log_callback_set" c_mosquitto_log_callback_set :: Ptr Mosquitto -> LogCallback -> IO ()

-- | Function: mosquitto_reconnect_delay_set
--
-- Control the behaviour of the client when it has unexpectedly disconnected in
-- <mosquitto_loop_forever> or after <mosquitto_loop_start>. The default
-- behaviour if this function is not used is to repeatedly attempt to reconnect
-- with a delay of 1 second until the connection succeeds.
--
-- Use reconnect_delay parameter to change the delay between successive
-- reconnection attempts. You may also enable exponential backoff of the time
-- between reconnections by setting reconnect_exponential_backoff to true and
-- set an upper bound on the delay with reconnect_delay_max.
--
-- Example 1:
-- delay=2, delay_max=10, exponential_backoff=False
-- Delays would be: 2, 4, 6, 8, 10, 10, ...
--
-- Example 2:
-- delay=3, delay_max=30, exponential_backoff=True
-- Delays would be: 3, 6, 12, 24, 30, 30, ...
--
-- Parameters:
--  mosq -                          a valid mosquitto instance.
--  reconnect_delay -               the number of seconds to wait between
--                                  reconnects.
--  reconnect_delay_max -           the maximum number of seconds to wait
--                                  between reconnects.
--  reconnect_exponential_backoff - use exponential backoff between
--                                  reconnect attempts. Set to true to enable
--                                  exponential backoff.
--
-- Returns:
-- MOSQ_ERR_SUCCESS - on success.
-- MOSQ_ERR_INVAL -   if the input parameters were invalid.
--
-- libmosq_EXPORT int mosquitto_reconnect_delay_set(struct mosquittomosq, unsigned int reconnect_delay, unsigned int reconnect_delay_max, bool reconnect_exponential_backoff);
foreign import ccall unsafe "mosquitto.h mosquitto_reconnect_delay_set" c_mosquitto_reconnect_delay_set :: Ptr Mosquitto -> CUInt -> CUInt -> Bool -> IO CInt

-- | Function: mosquitto_max_inflight_messages_set
--
-- Set the number of QoS 1 and 2 messages that can be "in flight" at one time.
-- An in flight message is part way through its delivery flow. Attempts to send
-- further messages with <mosquitto_publish> will result in the messages being
-- queued until the number of in flight messages reduces.
--
-- A higher number here results in greater message throughput, but if set
-- higher than the maximum in flight messages on the broker may lead to
-- delays in the messages being acknowledged.
--
-- Set to 0 for no maximum.
--
-- Parameters:
--  mosq -                  a valid mosquitto instance.
--  max_inflight_messages - the maximum number of inflight messages. Defaults
--                          to 20.
--
-- Returns:
-- MOSQ_ERR_SUCCESS - on success.
-- MOSQ_ERR_INVAL -   if the input parameters were invalid.
--
-- libmosq_EXPORT int mosquitto_max_inflight_messages_set(struct mosquittomosq, unsigned int max_inflight_messages);
foreign import ccall unsafe "mosquitto.h mosquitto_max_inflight_messages_set" c_mosquitto_max_inflight_messages_set :: Ptr Mosquitto -> CUInt -> IO CInt

-- | Function: mosquitto_message_retry_set
--
-- Set the number of seconds to wait before retrying messages. This applies to
-- publish messages with QoS>0. May be called at any time.
--
-- Parameters:
--  mosq -          a valid mosquitto instance.
--  message_retry - the number of seconds to wait for a response before
--                  retrying. Defaults to 20.
--
-- libmosq_EXPORT void mosquitto_message_retry_set(struct mosquittomosq, unsigned int message_retry);
foreign import ccall unsafe "mosquitto.h mosquitto_message_retry_set" c_mosquitto_message_retry_set :: Ptr Mosquitto -> CUInt -> IO ()

-- | Function: mosquitto_user_data_set
--
-- When <mosquitto_new> is called, the pointer given as the "obj" parameter
-- will be passed to the callbacks as user data. The <mosquitto_user_data_set>
-- function allows this obj parameter to be updated at any time. This function
-- will not modify the memory pointed to by the current user data pointer. If
-- it is dynamically allocated memory you must free it yourself.
--
-- Parameters:
--  mosq - a valid mosquitto instance.
-- obj -  A user pointer that will be passed as an argument to any callbacks
--        that are specified.
--
-- libmosq_EXPORT void mosquitto_user_data_set(struct mosquittomosq, voidobj);
foreign import ccall unsafe "mosquitto.h mosquitto_user_data_set" c_mosquitto_user_data_set :: Ptr Mosquitto -> Ptr () -> IO ()


--  =============================================================================
-- |
-- Section: Utility functions
--
-- =============================================================================
--
--

-- | Function: mosquitto_strerror
--
-- Call to obtain a const string description of a mosquitto error number.
--
-- Parameters:
-- mosq_errno - a mosquitto error number.
--
-- Returns:
-- A constant string describing the error.
--
-- libmosq_EXPORT const charmosquitto_strerror(int mosq_errno);


-- | Function: mosquitto_connack_string
--
-- Call to obtain a const string description of an MQTT connection result.
--
-- Parameters:
-- connack_code - an MQTT connection result.
--
-- Returns:
-- A constant string describing the result.
--
-- libmosq_EXPORT const charmosquitto_connack_string(int connack_code);


-- | Function: mosquitto_sub_topic_tokenise
--
-- Tokenise a topic or subscription string into an array of strings
-- representing the topic hierarchy.
--
-- For example:
--
-- subtopic: "a/deep/topic/hierarchy"
--
-- Would result in:
--
-- topics[0] = "a"
-- topics[1] = "deep"
-- topics[2] = "topic"
-- topics[3] = "hierarchy"
--
-- and:
--
-- subtopic: "/a/deep/topic/hierarchy/"
--
-- Would result in:
--
-- topics[0] = NULL
-- topics[1] = "a"
-- topics[2] = "deep"
-- topics[3] = "topic"
-- topics[4] = "hierarchy"
--
-- Parameters:
-- subtopic - the subscription/topic to tokenise
-- topics -   a pointer to store the array of strings
-- count -    an int pointer to store the number of items in the topics array.
--
-- Returns:
-- MOSQ_ERR_SUCCESS - on success
-- MOSQ_ERR_NOMEM -   if an out of memory condition occurred.
--
-- Example:
--
-- > char*topics;
-- > int topic_count;
-- > int i;
-- >
-- > mosquitto_sub_topic_tokenise("$SYS/broker/uptime", &topics, &topic_count);
-- >
-- > for(i=0; i<token_count; i++){
-- >     printf("%d: %s\n", i, topics[i]);
-- > }
--
-- See Also:
-- <mosquitto_sub_topic_tokens_free>
--
-- libmosq_EXPORT int mosquitto_sub_topic_tokenise(const charsubtopic, char**topics, intcount);


-- | Function: mosquitto_sub_topic_tokens_free
--
-- Free memory that was allocated in <mosquitto_sub_topic_tokenise>.
--
-- Parameters:
-- topics - pointer to string array.
-- count - count of items in string array.
--
-- Returns:
-- MOSQ_ERR_SUCCESS - on success
-- MOSQ_ERR_INVAL -   if the input parameters were invalid.
--
-- See Also:
-- <mosquitto_sub_topic_tokenise>
--
-- libmosq_EXPORT int mosquitto_sub_topic_tokens_free(char**topics, int count);


-- | Function: mosquitto_topic_matches_sub
--
-- Check whether a topic matches a subscription.
--
-- For example:
--
-- foo/bar would match the subscription foo/# or +/bar
-- non/matching would not match the subscription non/+/+
--
-- Parameters:
-- sub - subscription string to check topic against.
-- topic - topic to check.
-- result - bool pointer to hold result. Will be set to true if the topic
--          matches the subscription.
--
-- Returns:
-- MOSQ_ERR_SUCCESS - on success
-- MOSQ_ERR_INVAL -   if the input parameters were invalid.
-- MOSQ_ERR_NOMEM -   if an out of memory condition occurred.
--
-- libmosq_EXPORT int mosquitto_topic_matches_sub(const charsub, const chartopic, boolresult);


-- | Function: mosquitto_pub_topic_check
--
-- Check whether a topic to be used for publishing is valid.
--
-- This searches for + or # in a topic and checks its length.
--
-- This check is already carried out in <mosquitto_publish> and
-- <mosquitto_will_set>, there is no need to call it directly before them. It
-- may be useful if you wish to check the validity of a topic in advance of
-- making a connection for example.
--
-- Parameters:
--   topic - the topic to check
--
-- Returns:
--   MOSQ_ERR_SUCCESS - for a valid topic
--   MOSQ_ERR_INVAL - if the topic contains a + or a #, or if it is too long.
--
-- See Also:
--   <mosquitto_sub_topic_check>
--
-- libmosq_EXPORT int mosquitto_pub_topic_check(const chartopic);


-- | Function: mosquitto_sub_topic_check
--
-- Check whether a topic to be used for subscribing is valid.
--
-- This searches for + or # in a topic and checks that they aren't in invalid
-- positions, such as with foo/#/bar, foo/+bar or foo/bar#, and checks its
-- length.
--
-- This check is already carried out in <mosquitto_subscribe> and
-- <mosquitto_unsubscribe>, there is no need to call it directly before them.
-- It may be useful if you wish to check the validity of a topic in advance of
-- making a connection for example.
--
-- Parameters:
--   topic - the topic to check
--
-- Returns:
--   MOSQ_ERR_SUCCESS - for a valid topic
--   MOSQ_ERR_INVAL - if the topic contains a + or a # that is in an invalid
--                    position, or if it is too long.
--
-- See Also:
--   <mosquitto_sub_topic_check>
--
-- libmosq_EXPORT int mosquitto_sub_topic_check(const chartopic);