diff --git a/.travis.yml b/.travis.yml
index 997c2d48..da3d6a2b 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -5,9 +5,6 @@ sudo: required
 
 dist: bionic # ubuntu 18.04
 
-#os:
- # - linux
-
 compiler:
 - gcc
 - clang
@@ -48,6 +45,17 @@ install:
     brew update;
     brew install cmake pkg-config openssl boost libsodium readline protobuf ncurses;
     export OPENSSL_ROOT_DIR=`brew --prefix openssl`;
+    git clone https://github.com/eclipse/paho.mqtt.c.git;
+    cd paho.mqtt.c;
+    git checkout v1.3.1;
+    mkdir build && cd build;
+    cmake -DPAHO_BUILD_STATIC=TRUE -DPAHO_WITH_SSL=TRUE ..;
+    sudo make install;
+    sudo mkdir /usr/local/include/mqtt/;
+    sudo chmod 755 /usr/local/include/mqtt/;
+    sudo cp ${TRAVIS_BUILD_DIR}/src/mqtt/src/mqtt/* /usr/local/include/mqtt/;
+    sudo chmod 644 /usr/local/include/mqtt/*;
+    cd ${TRAVIS_BUILD_DIR};
   else
     sudo apt-get update -qq;
     sudo apt install -y g++ cmake libboost-all-dev openssl libssl1.0-dev libreadline-dev pkg-config libprotobuf-dev protobuf-compiler libncurses5-dev autoconf;
@@ -60,15 +68,27 @@ install:
     make -j2;
     sudo make install;
     cd ../;
+    git clone https://github.com/eclipse/paho.mqtt.c.git;
+    cd paho.mqtt.c;
+    git checkout v1.3.1;
+    mkdir build && cd build;
+    cmake -DPAHO_BUILD_STATIC=TRUE -DPAHO_WITH_SSL=TRUE ..;
+    sudo make install;
+    sudo cp -r  ${TRAVIS_BUILD_DIR}/src/mqtt/src/mqtt/ /usr/local/include/;
+    sudo chmod 755 /usr/local/include/mqtt;
+    cd /usr/local/include/mqtt;
+    sudo chmod 644 *;
+    cd -;
+    cd ../..;
   fi
 
 before_script:
 - ulimit -c unlimited -S       # enable core dumps
 
 script:
-- ./INSTALL.sh 
+- ./INSTALL.sh
 - ./build/test/test_big
 - ./build/test/test_ctsdb
 - if [ "$TRAVIS_OS_NAME" == "linux" ]; then
-    cppcheck --error-exitcode=1 --std=c++11 --enable=warning,performance,portability -i libsodium-1.0.18 -i src/leveldb -i build -i src/snappy -i src/crypto -i src/jsonrpc/json -i src/xengine/docker -i script -i test . ;
+    cppcheck -j2 --error-exitcode=1 --std=c++11 --enable=warning,performance,portability -i libsodium-1.0.18 -i src/leveldb -i build -i src/snappy -i src/crypto -i src/jsonrpc/json -i src/xengine/docker -i script -i test -i paho.mqtt.c -i src/mqtt . ;
   fi
diff --git a/CMakeLists.txt b/CMakeLists.txt
index aaaee1d7..c90060e5 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -38,7 +38,7 @@ elseif(UNIX)
     set(CMAKE_CXX_EXTENSIONS OFF)
     
 else()
-    message(FATAL_ERROR "Unsupported plantform")
+    message(FATAL_ERROR "Unsupported platform")
 endif()
 
 # build type
@@ -57,7 +57,7 @@ endif()
 if(UNIX AND NOT CYGWIN)
     string(APPEND CMAKE_CXX_FLAGS " -Wall -Wextra -Werror -Wno-char-subscripts -Wno-unused-parameter -Wno-sign-compare -Wno-reorder -Wno-unused-local-typedefs -Wno-implicit-fallthrough -Wno-overloaded-virtual -Wno-strict-aliasing")
     if (APPLE)
-        string(APPEND CMAKE_CXX_FLAGS " -fvisibility-inlines-hidden -fvisibility=hidden")
+        string(APPEND CMAKE_CXX_FLAGS " -Wno-missing-field-initializers -fvisibility-inlines-hidden -fvisibility=hidden")
     endif()
 endif()
 
diff --git a/INSTALL.sh b/INSTALL.sh
index 74188ede..147e2d78 100755
--- a/INSTALL.sh
+++ b/INSTALL.sh
@@ -12,24 +12,25 @@ fi
 cd build
 
 # cmake
-flagdebug=""
+flag=""
 if [[ "$1" = "debug" || "$2" = "debug" ]]
 then
-    flagdebug="-DCMAKE_BUILD_TYPE=Debug"
+    flag="-DCMAKE_BUILD_TYPE=Debug"
 else
-    flagdebug="-DCMAKE_BUILD_TYPE=Release"
+    flag="-DCMAKE_BUILD_TYPE=Release"
 fi
 
-flagtestnet=""
 if [[ "$1" = "testnet" || "$2" = "testnet" ]]
 then
-    flagtestnet="-DTESTNET=on"
+    flag+=" -DTESTNET=on"
 else
-    flagtestnet="-DTESTNET=off"
+    flag+=" -DTESTNET=off"
 fi
 
-cmake .. $flagdebug $flagtestnet
-if [ $? -ne 0 ]; then 
+flag+=" -DPAHO_BUILD_STATIC=TRUE -DPAHO_BUILD_SHARED=FALSE"
+
+cmake .. $flag
+if [ $? -ne 0 ]; then
     cd $origin_path
     exit 1 
 fi 
diff --git a/doc/auto_rpc.md b/doc/auto_rpc.md
index b4d66762..0e7f77b7 100755
--- a/doc/auto_rpc.md
+++ b/doc/auto_rpc.md
@@ -30,11 +30,11 @@ CBasicConfig* CreateConfig(const std::string& cmd)
 {
 	if (cmd == "help")
 	{
-		return new mode_impl::CCombinConfig<CHelpConfig, T...>;
+		return new mode_impl::CCombineConfig<CHelpConfig, T...>;
 	}
 	else if (cmd == "stop")
 	{
-		return new mode_impl::CCombinConfig<CStopConfig, T...>;
+		return new mode_impl::CCombineConfig<CStopConfig, T...>;
 	}
     ...
 }
diff --git a/doc/config-sample/bigbang.conf b/doc/config-sample/bigbang.conf
index 8ab242b1..f9408abb 100644
--- a/doc/config-sample/bigbang.conf
+++ b/doc/config-sample/bigbang.conf
@@ -1,177 +1,192 @@
-##
-## bigbang.conf configuration file. Lines beginning with # are comments.
-##
-
-
-# Network-related options:
-
-
-# Note that if you use testnet, particularly with the options
-# addnode, connect, port, rpcport or rpchost, you will also
-# want to read "[Sections]" further down.
-
-# Run on the test network instead of the real bigbang network.
-#testnet=false
-#testnet
-# or
-#testnet=true
-
-# Listening mode, Accept IPv4 and IPv6 connections from outside (disabled by default)
-#listen=false
-#listen
-# or
-#listen=true
-
-# Accept IPv4 connections from outside (default: false)
-#listen4=false
-
-# Accept IPv6 connections from outside (default: false)
-#listen6=false
-
-# Port on which to listen for connections (default: 9901, testnet: 9903)
-#port=<port>
-
-# Used in the case of node is being behind a NAT, The form of <ip>:<port> of address of gateway(<ip> can be IPv4 or IPv6, default <port>: 9901, IPv6 format: [ip]:port)
-#gateway=<ip>:<port>
-
-# Maximum number of inbound+outbound connections(125 by default).
-#maxconnections=<n>
-
-# Specify connection timeout (in milliseconds)
-#timeout=<n>
-
-# Add a node to connect to and attempt to keep the connection open(<address> can be IPv4 or IPv6 or domain name, default <port>: 9901, IPv6 format: [ip]:port)
-# Use as many addnode= settings as you like to connect to specific peers
-#addnode=69.164.218.197
-#addnode=10.0.0.2:8333
-
-# Connect only to the specified node(<address> can be IPv4 or IPv6 or domain name, default <port>: 9901, IPv6 format: [ip]:port)
-# Alternatively use as many connect= settings as you like to connect ONLY to specific peers
-#connect=69.164.218.197
-#connect=10.0.0.1:8333
-
-# Trust node address(<address> can be IPv4 or IPv6)
-#confidentAddress=<address>
-
-# DNSeed address list(<address> can be IPv4 or IPv6 or domain name, default <port>: 9906, IPv6 format: [ip]:port)
-#dnseed=<address>:<port>
-
-
-# JSON-RPC options (for controlling a running bigbang process)
-
-
-# rpclisten=true tells bigbang daemon to accept JSON-RPC commands
-#rpclisten=false
-
-# Bind to given address to listen for JSON-RPC connections.
-#rpchost=<addr>
-
-# Listen for JSON-RPC connections on <port> (default: 9902 or testnet: 9904))
-#rpcport=port
-
-# Accept RPC IPv4 connections (default: 0)
-#rpclisten4=false
-
-# Accept RPC IPv6 connections (default: 0)
-#rpclisten6
-
-# <user> name for JSON-RPC connections
-#rpcuser=<user>
-
-# <password> for JSON-RPC connections
-#rpcpassword=<password>
-
-# Use OpenSSL (https) for JSON-RPC connections or not (default false)
-#rpcssl
-
-# Verify SSL or not (default yes)
-#norpcsslverify
-
-# SSL CA file name (default ca.crt)
-#rpccafile=<file.crt>
-
-# Server certificate file (default: server.crt)
-#rpccertfile=<file.crt>
-
-# Server private key (default: server.pem)
-#rpcpkfile=<file.pem>
-
-# Acceptable ciphers (default: TLSv1+HIGH:!SSLv2:!aNULL:!eNULL:!AH:!3DES:@STRENGTH)
-#rpcciphers=<ciphers>
-
-# Enable statistical data or not (default false)
-#statdata
-
-# Enable write RPC log (default true)
-#rpclog
-
-# Connection timeout <time> seconds (default: 120)
-#rpctimeout=<time>
-
-# Set max connections to <num> (default: 5)
-#rpcmaxconnections=<num>
-
-# Allow JSON-RPC connections from specified <ip> address
-#rpcallowip=<ip>
-
-
-# Misc options:
-
-
-# Get bigbang version
-#version
-
-# Add a supported fork
-#addfork=<forkid>
-
-# Add a supported fork group
-#addgroup=<forkid of group leader>
-
-# Set storage check level (default: 0, range=0-3)
-#chklvl=<n>
-
-# Set storage check depth (default: 1440, range=0-n)
-#chkdpth=<n>
-
-# Launch bigbang daemon without wallet functionality
-#nowallet
-
-# Purge database and blockfile
-#purge
-
-# Execute command when the best block changes (%s in cmd is replaced by block hash)
-#blocknotify
-
-# Log file size(M) (default: 10M)
-#logfilesize=<size>
-
-# Log history size(M) (default: 2048M, maximum is 10G in bytes currently)
-#loghistorysize=<size>
-
-
-# Miner options:
-
-
-# mpvss address
-#mpvssaddress=1qsk1j77eqa6ycrsactxtx0cjgppnsvhjvpyr09wjezchcgp3k1t9xsrq
-
-# mpvss key
-#mpvsskey=0efc57e08484eba762aea80c6df7b892a84b73f5a2eb1c16b8957491e34a979c
-
-# Wallet address for miner to spend with POW cryptonight altorithm
-#cryptonightaddress=1nxkdkeggnmj375gam70yns9edyfk49tse4qcrqjebc5p6zdq4wv9dj7r
-
-# POW cryptonight key for mining signature
-#cryptonightkey=9ace832b9770ec013c2eed6a8c97e659fc1a44a82b437cfb76ceae703d0e6c99
-
-
-# Options only for mainnet
-[main]
-#testnet=false
-
-# Options only for testnet
-[test]
-#testnet
-# or
-#testnet=true
-
+##
+## bigbang.conf configuration file. Lines beginning with # are comments.
+##
+
+###################################
+# Network-related options:
+###################################
+
+# Note that if you use testnet, particularly with the options
+# addnode, connect, port, rpcport or rpchost, you will also
+# want to read "[Sections]" further down.
+
+# Run on the test network instead of the real bigbang network.
+#testnet=false
+#testnet
+# or
+#testnet=true
+
+# Listening mode, Accept IPv4 and IPv6 connections from outside (disabled by default)
+#listen=false
+#listen
+# or
+#listen=true
+
+# Accept IPv4 connections from outside (default: false)
+#listen4=false
+
+# Accept IPv6 connections from outside (default: false)
+#listen6=false
+
+# Port on which to listen for connections (default: 9901, testnet: 9903)
+#port=<port>
+
+# Used in the case of node is being behind a NAT, The form of <ip>:<port> of address of gateway(<ip> can be IPv4 or IPv6, default <port>: 9901, IPv6 format: [ip]:port)
+#gateway=<ip>:<port>
+
+# Maximum number of inbound+outbound connections(125 by default).
+#maxconnections=<n>
+
+# Specify connection timeout (in milliseconds)
+#timeout=<n>
+
+# Add a node to connect to and attempt to keep the connection open(<address> can be IPv4 or IPv6 or domain name, default <port>: 9901, IPv6 format: [ip]:port)
+# Use as many addnode= settings as you like to connect to specific peers
+#addnode=69.164.218.197
+#addnode=10.0.0.2:8333
+
+# Connect only to the specified node(<address> can be IPv4 or IPv6 or domain name, default <port>: 9901, IPv6 format: [ip]:port)
+# Alternatively use as many connect= settings as you like to connect ONLY to specific peers
+#connect=69.164.218.197
+#connect=10.0.0.1:8333
+
+# Trust node address(<address> can be IPv4 or IPv6)
+#confidentAddress=<address>
+
+# DNSeed address list(<address> can be IPv4 or IPv6 or domain name, default <port>: 9906, IPv6 format: [ip]:port)
+#dnseed=<address>:<port>
+
+######################################################################
+# JSON-RPC options (for controlling a running bigbang process)
+######################################################################
+
+# rpclisten=true tells bigbang daemon to accept JSON-RPC commands
+#rpclisten=false
+
+# Bind to given address to listen for JSON-RPC connections.
+#rpchost=<addr>
+
+# Listen for JSON-RPC connections on <port> (default: 9902 or testnet: 9904))
+#rpcport=port
+
+# Accept RPC IPv4 connections (default: 0)
+#rpclisten4=false
+
+# Accept RPC IPv6 connections (default: 0)
+#rpclisten6
+
+# <user> name for JSON-RPC connections
+#rpcuser=<user>
+
+# <password> for JSON-RPC connections
+#rpcpassword=<password>
+
+# Use OpenSSL (https) for JSON-RPC connections or not (default false)
+#rpcssl
+
+# Verify SSL or not (default yes)
+#norpcsslverify
+
+# SSL CA file name (default ca.crt)
+#rpccafile=<file.crt>
+
+# Server certificate file (default: server.crt)
+#rpccertfile=<file.crt>
+
+# Server private key (default: server.pem)
+#rpcpkfile=<file.pem>
+
+# Acceptable ciphers (default: TLSv1+HIGH:!SSLv2:!aNULL:!eNULL:!AH:!3DES:@STRENGTH)
+#rpcciphers=<ciphers>
+
+# Enable statistical data or not (default false)
+#statdata
+
+# Enable write RPC log (default true)
+#rpclog
+
+# Connection timeout <time> seconds (default: 120)
+#rpctimeout=<time>
+
+# Set max connections to <num> (default: 5)
+#rpcmaxconnections=<num>
+
+# Allow JSON-RPC connections from specified <ip> address
+#rpcallowip=<ip>
+
+###################################
+# Misc options:
+###################################
+
+# Get bigbang version
+#version
+
+# Add a supported fork
+#addfork=<forkid>
+
+# Add a supported fork group
+#addgroup=<forkid of group leader>
+
+# Set storage check level (default: 0, range=0-3)
+#chklvl=<n>
+
+# Set storage check depth (default: 1440, range=0-n)
+#chkdpth=<n>
+
+# Launch bigbang daemon without wallet functionality
+#nowallet
+
+# Purge database and blockfile
+#purge
+
+# Execute command when the best block changes (%s in cmd is replaced by block hash)
+#blocknotify
+
+# Log file size(M) (default: 10M)
+#logfilesize=<size>
+
+# Log history size(M) (default: 2048M, maximum is 10G in bytes currently)
+#loghistorysize=<size>
+
+###################################
+# Miner options:
+###################################
+
+# mpvss address
+#mpvssaddress=1qsk1j77eqa6ycrsactxtx0cjgppnsvhjvpyr09wjezchcgp3k1t9xsrq
+
+# mpvss key
+#mpvsskey=0efc57e08484eba762aea80c6df7b892a84b73f5a2eb1c16b8957491e34a979c
+
+# Wallet address for miner to spend with POW cryptonight altorithm
+#cryptonightaddress=1nxkdkeggnmj375gam70yns9edyfk49tse4qcrqjebc5p6zdq4wv9dj7r
+
+# POW cryptonight key for mining signature
+#cryptonightkey=9ace832b9770ec013c2eed6a8c97e659fc1a44a82b437cfb76ceae703d0e6c99
+
+###################################
+# super node options:
+###################################
+
+# super node category : 0 - BBCNODE; 1 - FORKNODE; 2 - DPOSNODE, 0 by default
+#catofnode=0
+
+# URI of MQ broker, such as "tcp://localhost:1883"
+#mqbroker="tcp://113.5.221.7:2883"
+
+# client ID of dpos node used to identify in MQTT cluster for fork nodes, "DPOSNODE" by default
+#dposid=BIGBANG_DPOS_NODE
+
+
+
+
+# Options only for mainnet
+[main]
+#testnet=false
+
+# Options only for testnet
+[test]
+#testnet
+# or
+#testnet=true
+
diff --git a/script/auto_protocol.py b/script/auto_protocol.py
index 12e5f39b..d0f2be60 100755
--- a/script/auto_protocol.py
+++ b/script/auto_protocol.py
@@ -1074,20 +1074,20 @@ def CreateConfig_h(w):
     indent = brace_begin(w)
 
     if len(config_class) == 0:
-        w.write(indent + 'return new mode_impl::CCombinConfig<T...>();\n')
+        w.write(indent + 'return new mode_impl::CCombineConfig<T...>();\n')
     else:
         w.write(indent)
         for cmd, name in config_class.items():
             w.write('if (cmd == "' + cmd + '")\n')
             indent = brace_begin(w, indent)
-            w.write(indent + 'return new mode_impl::CCombinConfig<' +
+            w.write(indent + 'return new mode_impl::CCombineConfig<' +
                     name + ', T...>;\n')
             indent = brace_end(w, indent)
             w.write(indent + 'else ')
 
         empty_line(w)
         indent = brace_begin(w, indent)
-        w.write(indent + 'return new mode_impl::CCombinConfig<T...>();\n')
+        w.write(indent + 'return new mode_impl::CCombineConfig<T...>();\n')
         indent = brace_end(w, indent)
 
     brace_end(w, indent)
diff --git a/script/template/options.json b/script/template/options.json
index 6cb796a1..81ecc0fb 100755
--- a/script/template/options.json
+++ b/script/template/options.json
@@ -8,6 +8,38 @@
             "format": "-testnet",
             "desc": "Use the test network"
         },
+        {
+            "name": "nCatOfNode",
+            "type": "int",
+            "opt": "catofnode",
+            "default": 0,
+            "format": "-catofnode=<cat>",
+            "desc": "Identify node category: 0 - BBCNODE; 1 - FORKNODE; 2 - DPOSNODE, 0 by default"
+        },
+        {
+            "name": "strMQBrokerURI",
+            "type": "string",
+            "opt": "mqbroker",
+            "default": "tcp://localhost:1883",
+            "format": "-mqbroker=<protocol>://<ip address or domain name>:<port>",
+            "desc": "Specified URI to which dpos node or fork node can connect through MQTT"
+        },
+        {
+            "name": "strDposNodeID",
+            "type": "string",
+            "opt": "dposid",
+            "default": "DPOSNODE",
+            "format": "-dposid",
+            "desc": "Identification of dpos node used by fork nodes in the same cluster"
+        },
+        {
+            "name": "strTopicPrefix",
+            "type": "string",
+            "opt": "topicprefix",
+            "default": "Cluster0x/",
+            "format": "-topicprefix",
+            "desc": "Prefix of topic for one super node MQ cluster"
+        },
         {
             "name": "fWallet",
             "type": "bool",
diff --git a/script/template/rpc.json b/script/template/rpc.json
index df57b5b2..1a5526b7 100755
--- a/script/template/rpc.json
+++ b/script/template/rpc.json
@@ -874,6 +874,112 @@
         ],
         "error": "{\"code\":-206,\"message\":\"Failed to remove node.\"}"
     },
+    "enrollsupernode": {
+        "type": "command",
+        "name": "EnrollSuperNode",
+        "desc": "Enroll supernode info for MQ communication on both sides of dpos and fork nodes.",
+        "request": {
+            "type": "object",
+            "content": {
+                "clientid" :
+                {
+                    "type": "string",
+                    "desc": "client id for dpos node or fork nodes"
+                },
+                "clientip" :
+                {
+                    "type": "string",
+                    "desc": "client global ip address for dpos node or fork nodes"
+                },
+                "forks" :
+                {
+                    "type" : "array",
+                    "content" : {
+                        "fork" :
+                        {
+                            "type" : "string",
+                            "dest" : "hash of fork produced by super nodes, dpos node gets main chain"
+                        }
+                    }
+                }
+            }
+        },
+        "response": {
+            "type": "string",
+            "name": "result",
+            "desc": "result of adding super node"
+        },
+        "example": [
+            {
+                "request": "enrollsupernode FORKNODE-001 17.1.1.1 '[\"bf0ebca9be985104e88b6a24e54cedbcdd1696a8984c8fdd7bc96917efb5a1ed\",\"575f2041770496489120bb102d9dd55f5e75b0c4aa528d5762b92b59acd6d939\",\"05f07d1e09b60b74538a1e021c98956a7c508fa35f6c3eba01c9ab1f6a871611\"]'",
+                "response": "Add super node successfully."
+            },
+            {
+                "request": "curl -d '{\"id\":3,\"method\":\"enrollsupernode\",\"jsonrpc\":\"2.0\",\"params\":{[\"575f2041770496489120bb102d9dd55f5e75b0c4aa528d5762b92b59acd6d939\",\"6236d780f9f743707d57b3feb19d21c8a867577f5e83c163774222bb7ef8d8cb\",\"7c6a6aba05cec77a998c19649ee1fa0e29c7b5246d0e3a6501ee1d4d81dd73ea\"]}}' http://127.0.0.1:9902",
+                "response": "{\"id\":3,\"jsonrpc\":\"2.0\",\"result\":Add super node successfully.}"
+            }
+        ],
+        "error": [
+            "{\"code\":-32600,\"message\":\"Invalid super node\"}",
+            "{\"code\":-6,\"message\":\"Invalid ip address\"}",
+            "{\"code\":-6,\"message\":\"Failed: IP of fork node must not be 0.0.0.0\"}",
+            "{\"code\":-6,\"message\":\"Failed: IP of dpos node must be 0.0.0.0\"}",
+            "{\"code\":-6,\"message\":\"Invalid fork(s)\"}",
+            "{\"code\":-6,\"message\":\"No fork hash parameter\"}",
+            "{\"code\":-6,\"message\":\"Dpos node must have only main chain to enroll\"}",
+            "{\"code\":-6,\"message\":\"The main fork dpos node enrolls does not match\"}",
+            "{\"code\":-6,\"message\":\"The main fork fork node watches should not be the main fork\"}",
+            "{\"code\":-32603,\"message\":\"Add super node enrollment failed\"}"
+        ]
+    },
+    "listenrollment": {
+        "type": "command",
+        "name": "ListEnrollment",
+        "desc": "List enrollment information for all types of super nodes.",
+        "request": {
+            "type": "object",
+            "content": {}
+        },
+        "response": {
+            "type": "array",
+            "name": "node",
+            "desc": "enrolled nodes previously",
+            "content": {
+                "node": {
+                    "type": "object",
+                    "content": {
+                        "clientid": {
+                            "type": "string",
+                            "desc": "client id for mq either dpos node or fork nodes"
+                        },
+                        "clientip": {
+                            "type": "string",
+                            "desc": "client ip address for fork nodes to engage in p2p communication"
+                        },
+                        "forks": {
+                            "type": "array",
+                            "content": {
+                                "fork": {
+                                    "type": "string",
+                                    "desc": "fork which will be produced by specific fork node"
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        },
+        "example": [
+            {
+                "request": "bigbang-cli listenrollment",
+                "response": "{\"id\":1,\"jsonrpc\":\"2.0\",\"result\":[{\"clientid\":\"DPOSNODE\",\"clientip\":\"0.0.0.0\",\"forks\":[\"00000000b0a9be545f022309e148894d1e1c853ccac3ef04cb6f5e5c70f41a70\"]},{\"clientid\":\"FORKNODE-01\",\"clientip\":\"127.0.0.1\",\"forks\":[\"575f2041770496489120bb102d9dd55f5e75b0c4aa528d5762b92b59acd6d939\",\"6236d780f9f743707d57b3feb19d21c8a867577f5e83c163774222bb7ef8d8cb\",\"7c6a6aba05cec77a998c19649ee1fa0e29c7b5246d0e3a6501ee1d4d81dd73ea\"]},{\"clientid\":\"OUTER-NODE\",\"clientip\":\"127.0.0.1\",\"forks\":[\"575f2041770496489120bb102d9dd55f5e75b0c4aa528d5762b92b59acd6d939\",\"6236d780f9f743707d57b3feb19d21c8a867577f5e83c163774222bb7ef8d8cb\",\"7c6a6aba05cec77a998c19649ee1fa0e29c7b5246d0e3a6501ee1d4d81dd73ea\"]}]}"
+            },
+            {
+                "request": "curl -d '{\"id\":40,\"method\":\"listenrollment\",\"jsonrpc\":\"2.0\",\"params\":{}}' http://127.0.0.1:19902",
+                "response": "{\"id\":40,\"jsonrpc\":\"2.0\",\"result\":[{\"clientid\":\"FORKNODE-001\",\"clientip\":\"17.1.1.1\",\"forks\":[\"bf0ebca9be985104e88b6a24e54cedbcdd1696a8984c8fdd7bc96917efb5a1ed\",\"575f2041770496489120bb102d9dd55f5e75b0c4aa528d5762b92b59acd6d939\",\"05f07d1e09b60b74538a1e021c98956a7c508fa35f6c3eba01c9ab1f6a871611\"]},{\"clientid\":\"OUTER-NODE\",\"clientip\":\"172.16.3.3\",\"forks\":[\"bf0ebca9be985104e88b6a24e54cedbcdd1696a8984c8fdd7bc96917efb5a1ed\"]},{\"clientid\":\"OUTER-NODE\",\"clientip\":\"172.16.6.6\",\"forks\":[\"575f2041770496489120bb102d9dd55f5e75b0c4aa528d5762b92b59acd6d939\"]},{\"clientid\":\"OUTER-NODE\",\"clientip\":\"172.16.9.9\",\"forks\":[\"05f07d1e09b60b74538a1e021c98956a7c508fa35f6c3eba01c9ab1f6a871611\"]}]}"
+            }
+        ]
+    },
     "getforkcount": {
         "type": "command",
         "name": "GetForkCount",
@@ -3083,7 +3189,7 @@
             }
         ],
         "error": [
-            
+
         ]
     },
     "listunspent": {
@@ -3263,7 +3369,11 @@
             }
         ],
         "error": [
-            "{\"code\" : -32603, \"message\" : \"The primary chain is invalid.\"}"
+            "{\"code\" : -32600, \"message\" : \"This fork node has not feature of POW mining.\"}",
+            "{\"code\" : -4, \"message\" : \"Invalid spent address.\"}",
+            "{\"code\" : -4, \"message\" : \"Invalid private key.\"}",
+            "{\"code\" : -4, \"message\" : \"Mining signature private key and spent address cannot be from the same.\"}",
+            "{\"code\" : -4, \"message\" : \"Invalid mint template.\"}"
         ]
     },
     "submitwork": {
@@ -3307,6 +3417,7 @@
             }
         ],
         "error": [
+            "{\"code\" : -32600, \"message\" : \"This fork node has not feature of POW mining.\"}",
             "{\"code\" : -4, \"message\" : \"Invalid spent address\"}",
             "{\"code\" : -4, \"message\" : \"Invalid private key\"}",
             "{\"code\" : -4, \"message\" : \"Invalid mint template\"}",
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 54d6512d..569b040b 100755
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -18,3 +18,4 @@ add_subdirectory(delegate)
 add_subdirectory(leveldb)
 add_subdirectory(snappy)
 add_subdirectory(jsonrpc)
+add_subdirectory(mqtt)
\ No newline at end of file
diff --git a/src/bigbang/CMakeLists.txt b/src/bigbang/CMakeLists.txt
index e7a815f0..874d9ea5 100755
--- a/src/bigbang/CMakeLists.txt
+++ b/src/bigbang/CMakeLists.txt
@@ -46,6 +46,7 @@ set(src
     wallet.cpp          wallet.h
     blockchain.cpp      blockchain.h
     forkmanager.cpp     forkmanager.h
+    mqcluster.cpp       mqcluster.h
     datastat.cpp        datastat.h
     recovery.cpp        recovery.h
     checkrepair.cpp     checkrepair.h
@@ -53,8 +54,8 @@ set(src
     base.h
     struct.h
     param.h
-    storage.h
     version.h
+    mqevent.h
 )
 set(mode_src
     mode/basic_config.cpp   mode/basic_config.h
@@ -80,7 +81,7 @@ set(sources
 add_library(libbigbang ${sources})
 add_executable(bigbang bigbang.cpp)
 
-include_directories(../xengine ../crypto ../common ../storage ../network ../delegate ../mpvss ../jsonrpc ./)
+include_directories(../xengine ../crypto ../common ../storage ../network ../delegate ../mpvss ../jsonrpc ../mqtt/src/mqtt ./)
 include_directories(${CMAKE_CURRENT_BINARY_DIR})
 include_directories(${CMAKE_BINARY_DIR}/src/jsonrpc)
 include_directories(${Protobuf_INCLUDE_DIRS})
@@ -126,6 +127,7 @@ target_link_libraries(libbigbang
     delegate    
     jsonrpc
     common
+    mqtt
 )
 
 # create symbol link
diff --git a/src/bigbang/base.h b/src/bigbang/base.h
index 149b9908..2676db52 100644
--- a/src/bigbang/base.h
+++ b/src/bigbang/base.h
@@ -17,6 +17,7 @@
 #include "destination.h"
 #include "error.h"
 #include "key.h"
+#include "mqdb.h"
 #include "param.h"
 #include "peer.h"
 #include "profile.h"
@@ -117,6 +118,7 @@ class IBlockChain : public xengine::IBase
     virtual bool GetBlock(const uint256& hashBlock, CBlock& block) = 0;
     virtual bool GetBlockEx(const uint256& hashBlock, CBlockEx& block) = 0;
     virtual bool GetOrigin(const uint256& hashFork, CBlock& block) = 0;
+    virtual bool GetBlockMintType(const uint256& hashBlock, uint16& nMintType) = 0;
     virtual bool Exists(const uint256& hashBlock) = 0;
     virtual bool GetTransaction(const uint256& txid, CTransaction& tx) = 0;
     virtual bool GetTransaction(const uint256& txid, CTransaction& tx, uint256& hashFork, int& nHeight) = 0;
@@ -131,6 +133,10 @@ class IBlockChain : public xengine::IBase
     virtual Errno AddNewForkContext(const CTransaction& txFork, CForkContext& ctxt) = 0;
     virtual Errno AddNewBlock(const CBlock& block, CBlockChainUpdate& update) = 0;
     virtual Errno AddNewOrigin(const CBlock& block, CBlockChainUpdate& update) = 0;
+    virtual Errno AddNewSuperNode(const storage::CSuperNode& node) = 0;
+    virtual bool ListSuperNode(std::vector<storage::CSuperNode>& nodes) = 0;
+    virtual bool FetchSuperNode(std::vector<storage::CSuperNode>& nodes, const uint8 mask) = 0;
+    virtual bool AddOuterNodes(const std::vector<storage::CSuperNode>& outers, bool fSuper) = 0;
     virtual bool GetProofOfWorkTarget(const uint256& hashPrev, int nAlgo, int& nBits, int64& nReward) = 0;
     virtual bool GetBlockMintReward(const uint256& hashPrev, int64& nReward) = 0;
     virtual bool GetBlockLocator(const uint256& hashFork, CBlockLocator& locator, uint256& hashDepth, int nIncStep) = 0;
@@ -159,6 +165,7 @@ class IBlockChain : public xengine::IBase
     virtual bool ListDelegatePayment(uint32 height, CBlock& block, std::multimap<int64, CDestination>& mapVotes) = 0;
     virtual uint32 DPoSTimestamp(const uint256& hashPrev) = 0;
     virtual Errno VerifyPowBlock(const CBlock& block, bool& fLongChain) = 0;
+    virtual bool ListActiveFork(std::vector<uint256>& forks) = 0;
     virtual bool CheckForkValidLast(const uint256& hashFork, CBlockChainUpdate& update) = 0;
     virtual bool VerifyForkRefLongChain(const uint256& hashFork, const uint256& hashForkBlock, const uint256& hashPrimaryBlock) = 0;
     virtual bool GetPrimaryHeightBlockTime(const uint256& hashLastBlock, int nHeight, uint256& hashBlock, int64& nTime) = 0;
@@ -214,6 +221,7 @@ class IForkManager : public xengine::IBase
     virtual void ForkUpdate(const CBlockChainUpdate& update, std::vector<uint256>& vActive, std::vector<uint256>& vDeactive) = 0;
     virtual void GetForkList(std::vector<uint256>& vFork) const = 0;
     virtual bool GetSubline(const uint256& hashFork, std::vector<std::pair<int, uint256>>& vSubline) const = 0;
+    virtual bool SetForkFilter(const std::vector<uint256>& vFork = std::vector<uint256>(), const std::vector<uint256>& vGroup = std::vector<uint256>()) = 0;
     virtual bool GetCreatedHeight(const uint256& hashFork, int& nCreatedHeight) const = 0;
     const CForkConfig* ForkConfig()
     {
@@ -333,6 +341,7 @@ class IService : public xengine::IBase
     virtual void GetPeers(std::vector<network::CBbPeerInfo>& vPeerInfo) = 0;
     virtual bool AddNode(const xengine::CNetHost& node) = 0;
     virtual bool RemoveNode(const xengine::CNetHost& node) = 0;
+    virtual bool AddBizForkNodes(const std::vector<uint32>& nodes) = 0;
     /* Blockchain & Tx Pool*/
     virtual int GetForkCount() = 0;
     virtual bool HaveFork(const uint256& hashFork) = 0;
@@ -394,6 +403,9 @@ class IService : public xengine::IBase
     virtual Errno SubmitWork(const std::vector<unsigned char>& vchWorkData, const CTemplateMintPtr& templMint,
                              crypto::CKey& keyMint, uint256& hashBlock)
         = 0;
+    /* Util */
+    virtual bool AddSuperNode(const storage::CSuperNode& node) = 0;
+    virtual bool ListSuperNode(std::vector<storage::CSuperNode>& nodes) = 0;
 };
 
 class IDataStat : public xengine::IIOModule
diff --git a/src/bigbang/blockchain.cpp b/src/bigbang/blockchain.cpp
index ec71d02e..4f278692 100644
--- a/src/bigbang/blockchain.cpp
+++ b/src/bigbang/blockchain.cpp
@@ -95,7 +95,7 @@ bool CBlockChain::HandleInvoke()
     InitCheckPoints();
 
     // Check local block compared to checkpoint
-    if (Config()->nMagicNum == MAINNET_MAGICNUM)
+    /*    if (Config()->nMagicNum == MAINNET_MAGICNUM)
     {
         std::map<uint256, CForkStatus> mapForkStatus;
         GetForkStatus(mapForkStatus);
@@ -109,7 +109,7 @@ bool CBlockChain::HandleInvoke()
                 return false;
             }
         }
-    }
+    }*/
 
     return true;
 }
@@ -322,6 +322,17 @@ bool CBlockChain::GetOrigin(const uint256& hashFork, CBlock& block)
     return cntrBlock.RetrieveOrigin(hashFork, block);
 }
 
+bool CBlockChain::GetBlockMintType(const uint256& hashBlock, uint16& nMintType)
+{
+    CBlockIndex* pIndex = nullptr;
+    if (!cntrBlock.RetrieveIndex(hashBlock, &pIndex))
+    {
+        return false;
+    }
+    nMintType = pIndex->nMintType;
+    return true;
+}
+
 bool CBlockChain::Exists(const uint256& hashBlock)
 {
     return cntrBlock.Exists(hashBlock);
@@ -474,7 +485,7 @@ Errno CBlockChain::AddNewBlock(const CBlock& block, CBlockChainUpdate& update)
     {
         do
         {
-            if (!block.IsPrimary() && pCoreProtocol->IsRefVacantHeight(block.GetBlockHeight()) && pIndexRef
+            if (pCoreProtocol->IsRefVacantHeight(block.GetBlockHeight()) && pIndexRef
                 && !cntrBlock.VerifyRefBlock(pCoreProtocol->GetGenesisBlockHash(), pIndexRef->GetBlockHash()))
             {
                 fGetBranchBlock = false;
@@ -697,7 +708,8 @@ Errno CBlockChain::AddNewOrigin(const CBlock& block, CBlockChainUpdate& update)
     }
     if (block.GetBlockTime() != nTimeRef)
     {
-        Log("Invalid origin block time");
+        Log("Invalid origin block time - block[%ld - %ld] vs. ref[%ld] at height[%d]",
+            block.GetBlockTime(), block.nTimeStamp, nTimeRef, block.GetBlockHeight());
         return ERR_BLOCK_TIMESTAMP_OUT_OF_RANGE;
     }
 
@@ -779,6 +791,45 @@ Errno CBlockChain::AddNewOrigin(const CBlock& block, CBlockChainUpdate& update)
     return OK;
 }
 
+Errno CBlockChain::AddNewSuperNode(const storage::CSuperNode& node)
+{
+    if (!cntrBlock.AddNewSuperNode(node))
+    {
+        return FAILED;
+    }
+    return OK;
+}
+
+bool CBlockChain::ListSuperNode(std::vector<storage::CSuperNode>& nodes)
+{
+    if (!cntrBlock.ListSuperNode(nodes))
+    {
+        return false;
+    }
+
+    return true;
+}
+
+bool CBlockChain::FetchSuperNode(std::vector<storage::CSuperNode>& nodes, const uint8 mask)
+{
+    if (!cntrBlock.FetchSuperNode(nodes, mask))
+    {
+        return false;
+    }
+
+    return true;
+}
+
+bool CBlockChain::AddOuterNodes(const std::vector<storage::CSuperNode>& outers, bool fSuper)
+{
+    if (!cntrBlock.AddOuterNodes(outers, fSuper))
+    {
+        return false;
+    }
+
+    return true;
+}
+
 // uint320 GetBlockTrust() const
 // {
 //     if (IsVacant() && vchProof.empty())
@@ -1193,6 +1244,11 @@ Errno CBlockChain::VerifyPowBlock(const CBlock& block, bool& fLongChain)
     return OK;
 }
 
+bool CBlockChain::ListActiveFork(std::vector<uint256>& forks)
+{
+    return cntrBlock.ListActiveFork(forks);
+}
+
 bool CBlockChain::CheckForkValidLast(const uint256& hashFork, CBlockChainUpdate& update)
 {
     CBlockIndex* pValidLastIndex = cntrBlock.GetForkValidLast(pCoreProtocol->GetGenesisBlockHash(), hashFork, pCoreProtocol->GetRefVacantHeight());
@@ -1787,7 +1843,6 @@ void CBlockChain::InitCheckPoints()
 #ifdef BIGBANG_TESTNET
         vecGenesisCheckPoints.push_back(CCheckPoint(0, pCoreProtocol->GetGenesisBlockHash()));
         InitCheckPoints(pCoreProtocol->GetGenesisBlockHash(), vecGenesisCheckPoints);
-
 #else
         vecGenesisCheckPoints.assign(
             { { 0, uint256("00000000b0a9be545f022309e148894d1e1c853ccac3ef04cb6f5e5c70f41a70") },
diff --git a/src/bigbang/blockchain.h b/src/bigbang/blockchain.h
index 9c7c6217..a0779ec5 100644
--- a/src/bigbang/blockchain.h
+++ b/src/bigbang/blockchain.h
@@ -34,6 +34,7 @@ class CBlockChain : public IBlockChain
     bool GetBlock(const uint256& hashBlock, CBlock& block) override;
     bool GetBlockEx(const uint256& hashBlock, CBlockEx& block) override;
     bool GetOrigin(const uint256& hashFork, CBlock& block) override;
+    bool GetBlockMintType(const uint256& hashBlock, uint16& nMintType) override;
     bool Exists(const uint256& hashBlock) override;
     bool GetTransaction(const uint256& txid, CTransaction& tx) override;
     bool GetTransaction(const uint256& txid, CTransaction& tx, uint256& hashFork, int& nHeight) override;
@@ -47,6 +48,10 @@ class CBlockChain : public IBlockChain
     Errno AddNewForkContext(const CTransaction& txFork, CForkContext& ctxt) override;
     Errno AddNewBlock(const CBlock& block, CBlockChainUpdate& update) override;
     Errno AddNewOrigin(const CBlock& block, CBlockChainUpdate& update) override;
+    Errno AddNewSuperNode(const storage::CSuperNode& node) override;
+    bool ListSuperNode(std::vector<storage::CSuperNode>& nodes) override;
+    bool FetchSuperNode(std::vector<storage::CSuperNode>& nodes, const uint8 mask) override;
+    bool AddOuterNodes(const std::vector<storage::CSuperNode>& outers, bool fSuper) override;
     bool GetProofOfWorkTarget(const uint256& hashPrev, int nAlgo, int& nBits, int64& nReward) override;
     bool GetBlockMintReward(const uint256& hashPrev, int64& nReward) override;
     bool GetBlockLocator(const uint256& hashFork, CBlockLocator& locator, uint256& hashDepth, int nIncStep) override;
@@ -64,6 +69,7 @@ class CBlockChain : public IBlockChain
     bool ListDelegatePayment(uint32 height, CBlock& block, std::multimap<int64, CDestination>& mapVotes) override;
     uint32 DPoSTimestamp(const uint256& hashPrev) override;
     Errno VerifyPowBlock(const CBlock& block, bool& fLongChain) override;
+    bool ListActiveFork(std::vector<uint256>& forks) override;
     bool CheckForkValidLast(const uint256& hashFork, CBlockChainUpdate& update) override;
     bool VerifyForkRefLongChain(const uint256& hashFork, const uint256& hashForkBlock, const uint256& hashPrimaryBlock) override;
     bool GetPrimaryHeightBlockTime(const uint256& hashLastBlock, int nHeight, uint256& hashBlock, int64& nTime) override;
diff --git a/src/bigbang/blockmaker.cpp b/src/bigbang/blockmaker.cpp
index 9ab672ac..0b8eaf9b 100644
--- a/src/bigbang/blockmaker.cpp
+++ b/src/bigbang/blockmaker.cpp
@@ -7,6 +7,7 @@
 #include <thread>
 
 #include "address.h"
+#include "defs.h"
 #include "template/delegate.h"
 #include "template/mint.h"
 #include "template/proof.h"
@@ -62,8 +63,10 @@ bool CBlockMakerProfile::BuildTemplate()
 
 CBlockMaker::CBlockMaker()
   : thrMaker("blockmaker", boost::bind(&CBlockMaker::BlockMakerThreadFunc, this)),
-    thrPow("powmaker", boost::bind(&CBlockMaker::PowThreadFunc, this))
+    thrPow("powmaker", boost::bind(&CBlockMaker::PowThreadFunc, this)),
+    thrBizFork("bizmaker", boost::bind(&CBlockMaker::BizForkThreadFunc, this))
 {
+    nNodeCat = 0;
     pCoreProtocol = nullptr;
     pBlockChain = nullptr;
     pForkManager = nullptr;
@@ -136,7 +139,8 @@ bool CBlockMaker::HandleInitialize()
         }
     }
 
-    if (!MintConfig()->destCryptonight.IsNull() && MintConfig()->keyCryptonight != 0)
+    nNodeCat = dynamic_cast<const CBasicConfig*>(Config())->nCatOfNode;
+    if (!MintConfig()->destCryptonight.IsNull() && MintConfig()->keyCryptonight != 0 && NODE_CAT_FORKNODE != nNodeCat)
     {
         CBlockMakerProfile profile(CM_CRYPTONIGHT, MintConfig()->destCryptonight, MintConfig()->keyCryptonight);
         if (profile.IsValid())
@@ -193,6 +197,14 @@ bool CBlockMaker::HandleInvoke()
     }
 
     fExit = false;
+    if (!mapDelegatedProfile.empty() && NODE_CAT_FORKNODE == nNodeCat)
+    {
+        if (!ThreadDelayStart(thrBizFork))
+        {
+            return false;
+        }
+    }
+
     if (!ThreadDelayStart(thrMaker))
     {
         return false;
@@ -221,6 +233,9 @@ void CBlockMaker::HandleHalt()
     condExit.notify_all();
     condBlock.notify_all();
 
+    thrBizFork.Interrupt();
+    ThreadExit(thrBizFork);
+
     thrMaker.Interrupt();
     ThreadExit(thrMaker);
 
@@ -264,10 +279,12 @@ bool CBlockMaker::HandleEvent(CEventBlockMakerUpdate& eventUpdate)
     {
         boost::unique_lock<boost::mutex> lock(mutex);
 
-        CBlockMakerUpdate& data = eventUpdate.data;
+        const CBlockMakerUpdate& data = eventUpdate.data;
         lastStatus.hashLastBlock = data.hashBlock;
         lastStatus.nLastBlockTime = data.nBlockTime;
         lastStatus.nLastBlockHeight = data.nBlockHeight;
+        lastStatus.nWeight = data.nWeight;
+        lastStatus.nAgreement = data.nAgreement;
         lastStatus.nMintType = data.nMintType;
 
         condBlock.notify_all();
@@ -371,6 +388,7 @@ bool CBlockMaker::DispatchBlock(const CBlock& block)
         }
         Debug("Dispatching block: %s already have, type: %u", block.GetHash().ToString().c_str(), block.nType);
     }
+    Debug("Dispatched block succeeded: %s, type: %u", block.GetHash().ToString().c_str(), block.nType);
     return true;
 }
 
@@ -381,33 +399,33 @@ void CBlockMaker::ProcessDelegatedProofOfStake(const CAgreementBlock& consParam)
     {
         CBlockMakerProfile& profile = (*it).second;
 
-        CBlock block;
-        PrepareBlock(block, consParam.hashPrev, consParam.nPrevTime, consParam.nPrevHeight, consParam.agreement);
-
-        // get block time
-        block.nTimeStamp = pBlockChain->DPoSTimestamp(block.hashPrev);
-        if (block.nTimeStamp == 0)
+        if (NODE_CAT_DPOSNODE == nNodeCat)
         {
-            Error("Get DPoSTimestamp error, hashPrev: %s", block.hashPrev.ToString().c_str());
-            return;
-        }
-
-        // create DPoS primary block
-        if (!CreateDelegatedBlock(block, pCoreProtocol->GetGenesisBlockHash(), profile))
-        {
-            Error("CreateDelegatedBlock error, hashPrev: %s", block.hashPrev.ToString().c_str());
-            return;
-        }
+            Log("before generating primary-dpos...");
+            CBlock block;
+            PrepareBlock(block, consParam.hashPrev, consParam.nPrevTime, consParam.nPrevHeight, consParam.agreement);
 
-        // dispatch DPoS primary block
-        if (DispatchBlock(block))
-        {
-            pDispatcher->SetConsensus(consParam);
+            // get block time
+            block.nTimeStamp = pBlockChain->DPoSTimestamp(block.hashPrev);
+            if (block.nTimeStamp == 0)
+            {
+                Error("Get DPoSTimestamp error, hashPrev: %s", block.hashPrev.ToString().c_str());
+                return;
+            }
 
-            pDispatcher->CheckAllSubForkLastBlock();
+            // create DPoS primary block
+            if (!CreateDelegatedBlock(block, pCoreProtocol->GetGenesisBlockHash(), profile))
+            {
+                Error("CreateDelegatedBlock error, hashPrev: %s", block.hashPrev.ToString().c_str());
+                return;
+            }
 
-            // create sub fork blocks
-            ProcessSubFork(profile, consParam.agreement, block.GetHash(), block.GetBlockTime(), consParam.nPrevHeight, consParam.nPrevMintType);
+            // dispatch DPoS primary block
+            if (DispatchBlock(block))
+            {
+                pDispatcher->SetConsensus(consParam);
+            }
+            Log("...after generated primary-dpos");
         }
     }
 }
@@ -415,28 +433,39 @@ void CBlockMaker::ProcessDelegatedProofOfStake(const CAgreementBlock& consParam)
 void CBlockMaker::ProcessSubFork(const CBlockMakerProfile& profile, const CDelegateAgreement& agreement,
                                  const uint256& hashRefBlock, int64 nRefBlockTime, const int32 nPrevHeight, const uint16 nPrevMintType)
 {
+    pDispatcher->CheckAllSubForkLastBlock();
+
     map<uint256, CForkStatus> mapForkStatus;
     pBlockChain->GetForkStatus(mapForkStatus);
+    Log("subfork: GetForkStatus[%d]", mapForkStatus.size());
 
     // create subsidiary task
     multimap<int64, pair<uint256, CBlock>> mapBlocks;
     for (map<uint256, CForkStatus>::iterator it = mapForkStatus.begin(); it != mapForkStatus.end(); ++it)
     {
-        const uint256& hashFork = it->first;
-        if (hashFork != pCoreProtocol->GetGenesisBlockHash() && pForkManager->IsAllowed(hashFork))
+        Log("subfork: GetForkStatus[%s]", it->first.ToString().c_str());
+        if (it->first != pCoreProtocol->GetGenesisBlockHash())
         {
             CBlock block;
             PreparePiggyback(block, agreement, hashRefBlock, nRefBlockTime, nPrevHeight, it->second, nPrevMintType);
-            mapBlocks.insert(make_pair(nRefBlockTime, make_pair(hashFork, block)));
+            mapBlocks.insert(make_pair(nRefBlockTime, make_pair(it->first, block)));
         }
     }
+    Log("subfork: mapBlocks size[%d]", mapBlocks.size());
+    for (const auto& it : mapBlocks)
+    {
+        Log("subfork: mapBlocks time-fork[%ld][%s]", it.first, it.second.first.ToString().c_str());
+    }
 
+    Log("subfork: before entering while (!mapBlocks.empty())");
     while (!mapBlocks.empty())
     {
         auto it = mapBlocks.begin();
         int64 nSeconds = it->first - GetNetTime();
         const uint256 hashFork = it->second.first;
         CBlock block = it->second.second;
+        Log("subfork: reftime-waittime[%ld]-[%ld] fork[%s] mapBlocks.size[%d]",
+            it->first, nSeconds, hashFork.ToString().c_str(), mapBlocks.size());
         mapBlocks.erase(it);
 
         if (!WaitExit(nSeconds))
@@ -510,24 +539,30 @@ void CBlockMaker::ProcessSubFork(const CBlockMakerProfile& profile, const CDeleg
                     Error("ProcessSubFork GetLastBlock fail, fork: %s", hashFork.ToString().c_str());
                 }
 
-                /*uint256 hashLastBlock;
+/*                uint256 hashLastBlock;
                 int64 nLastTime;
 
-                bool fInWaitTime = (nPrevMintType == CTransaction::TX_STAKE) && (GetNetTime() - nRefBlockTime < WAIT_LAST_EXTENDED_TIME);
+                //                bool fInWaitTime = (nPrevMintType == CTransaction::TX_STAKE) && (GetNetTime() - nRefBlockTime < WAIT_LAST_EXTENDED_TIME);
+                int64 nettime = GetNetTime();
+                bool fInWaitTime = (nPrevMintType == CTransaction::TX_STAKE) && (nettime - nRefBlockTime < WAIT_LAST_EXTENDED_TIME);
+                Log("subfork: nPrevMintType[%d], nettime[%ld] - nRefBlockTime[%ld] = [%d], fInWaitTime[%d]",
+                    nPrevMintType, nettime, nRefBlockTime, nettime - nRefBlockTime, fInWaitTime);
                 if (pBlockChain->GetLastBlockOfHeight(hashFork, nPrevHeight, hashLastBlock, nLastTime)
                     && (!fInWaitTime || (nLastTime + EXTENDED_BLOCK_SPACING == nRefBlockTime)))
                 {
                     // last is PoW or last extended or timeout
                     block.hashPrev = hashLastBlock;
+                    Log("subfork: get last block nLastTime[%ld], hashLastBlock[%s]", nLastTime, hashLastBlock.ToString().c_str());
                 }
                 else if (fInWaitTime)
                 {
-                    // wait the last exteded block for 1s
+                    // wait the last extended block for 1s
                     mapBlocks.insert(make_pair(GetNetTime() + 1, make_pair(hashFork, block)));
+                    Log("subfork: cache one subsidiary block successfully nLastTime[%ld], hashLastBlock[%s]", nLastTime, hashLastBlock.ToString().c_str());
                 }
                 else
                 {
-                    Error("ProcessSubFork get last block error, fork: %s", hashFork.ToString().c_str());
+                    Error("subfork: get last block error, fork[%s]  nLastTime[%ld], hashLastBlock[%s]", hashFork.ToString().c_str(), nLastTime, hashLastBlock.ToString().c_str());
                 }*/
             }
 
@@ -590,6 +625,7 @@ void CBlockMaker::ProcessSubFork(const CBlockMakerProfile& profile, const CDeleg
             mapBlocks.insert(make_pair(extended.nTimeStamp, make_pair(hashFork, extended)));
         }
     }
+    Log("subfork: after leaving while (!mapBlocks.empty())");
 }
 
 bool CBlockMaker::CreateDelegatedBlock(CBlock& block, const uint256& hashFork, const CBlockMakerProfile& profile)
@@ -627,14 +663,19 @@ void CBlockMaker::PreparePiggyback(CBlock& block, const CDelegateAgreement& agre
     block.nType = CBlock::BLOCK_SUBSIDIARY;
     block.nTimeStamp = nRefBlockTime;
     proof.Save(block.vchProof);
-    /*if (status.nLastBlockHeight == nPrevHeight && status.nLastBlockTime < nRefBlockTime)
+    Log("subfork: status.nLastBlockHeight vs. nPrevHeight [%d] - [%d], RefHeight[%d], status.nLastBlockTime vs. nRefBlockTime [%ld] - [%ld]",
+        status.nLastBlockHeight, nPrevHeight, hashRefBlock.Get32(7), status.nLastBlockTime, nRefBlockTime);
+/*    if (status.nLastBlockHeight == nPrevHeight && status.nLastBlockTime < nRefBlockTime)
     {
+        Log("subfork: nPrevMintType[%d], last extended one[%ld], timeout[%ld]",
+            nPrevMintType, nRefBlockTime - status.nLastBlockTime, GetNetTime() - nRefBlockTime);
         // last is PoW or last extended or timeouot
         if (nPrevMintType != CTransaction::TX_STAKE
             || status.nLastBlockTime + EXTENDED_BLOCK_SPACING == nRefBlockTime
             || GetNetTime() - nRefBlockTime >= WAIT_LAST_EXTENDED_TIME)
         {
             block.hashPrev = status.hashLastBlock;
+            Log("subfork: prepared piggyback with prev");
         }
     }*/
 }
@@ -813,6 +854,7 @@ bool CBlockMaker::CreateProofOfWork()
 
 void CBlockMaker::BlockMakerThreadFunc()
 {
+    Log("Entering DPOS block maker thread...");
     uint256 hashCachePrev;
     bool fCachePow = false;
     int64 nWaitTime = 1;
@@ -835,8 +877,10 @@ void CBlockMaker::BlockMakerThreadFunc()
             nWaitTime = consParam.nWaitTime;
             continue;
         }
-        StdDebug("BlockMaker", "BlockMakerThreadFunc: GetNextConsensus success, target height: %d, wait time: %ld, last height: %d, prev block: %s",
-                 consParam.nPrevHeight + 1, consParam.nWaitTime, lastStatus.nLastBlockHeight, consParam.hashPrev.GetHex().c_str());
+        StdDebug("BlockMaker", "BlockMakerThreadFunc: GetNextConsensus success, "
+                               "target height: %d, consensus[%s], wait time: %ld, last height: %d, prev block: %s",
+                 consParam.nPrevHeight + 1, consParam.agreement.IsProofOfWork() ? "POW" : "DPOS",
+                 consParam.nWaitTime, lastStatus.nLastBlockHeight, consParam.hashPrev.GetHex().c_str());
         nWaitTime = consParam.nWaitTime;
 
         if (hashCachePrev != consParam.hashPrev || fCachePow != consParam.agreement.IsProofOfWork())
@@ -866,21 +910,108 @@ void CBlockMaker::BlockMakerThreadFunc()
             break;
         }
     }
-    Log("Block maker exited");
+    Log("...DPOS block maker thread exited normally");
 }
 
 void CBlockMaker::PowThreadFunc()
 {
+    Log("Entering POW block maker thread...");
     if (!WaitExit(5))
     {
-        Log("Pow exited non");
+        Log("...POW block maker thread exited without anything");
         return;
     }
     while (WaitExit(1))
     {
         CreateProofOfWork();
     }
-    Log("Pow exited");
+    Log("...POW block maker thread exited normally");
+}
+
+void CBlockMaker::BizForkThreadFunc()
+{
+    Log("Entering biz fork block maker thread...");
+    int64 nWaitTime = 1;
+    while (!fExit)
+    {
+        if (!WaitUpdateEvent(nWaitTime))
+        {
+            break;
+        }
+
+        try
+        {
+            CForkStatus status;
+            {
+                boost::unique_lock<boost::mutex> lock(mutex);
+                status = lastStatus;
+            }
+            Log("BizMaker: fork status: hashParent[%s], nOriginHeight[%d], hashLastBlock[%s], "
+                "nLastBlockTime[%ld], nLastBlockHeight[%d], nAgreement[%s], nWeight[%d], nMintType[%d]",
+                status.hashParent.ToString().c_str(), status.nOriginHeight, status.hashLastBlock.ToString().c_str(),
+                status.nLastBlockTime, status.nLastBlockHeight, status.nAgreement.ToString().c_str(), status.nWeight,
+                status.nMintType);
+
+            if (CTransaction::TX_STAKE == status.nMintType && status.nAgreement != 0 && status.nWeight > 0)
+            {
+                CBlock block;
+                if (!pBlockChain->GetBlock(status.hashLastBlock, block))
+                {
+                    throw runtime_error("get block from hash[" + status.hashLastBlock.ToString() + "] failed");
+                }
+                const CDestination& miner = block.txMint.sendTo;
+                auto it = mapDelegatedProfile.find(miner);
+                if (it != mapDelegatedProfile.end())
+                {
+                    Log("BizMaker: parent delegate miner found: [%s]", CAddress(miner).ToString().c_str());
+                    uint256 hashLastBlock;
+                    int nLastHeight;
+                    int64 nLastTime;
+                    uint16 nLastMintType;
+                    if (!pBlockChain->GetLastBlock(pCoreProtocol->GetGenesisBlockHash(), hashLastBlock,
+                                                   nLastHeight, nLastTime, nLastMintType))
+                    {
+                        throw runtime_error("get last block failed");
+                    }
+                    if (hashLastBlock != status.hashLastBlock)
+                    {
+                        Log("BizMaker: blocks are mismatched: notify[%s] vs. last[%s]", status.hashLastBlock.ToString().c_str(),
+                            hashLastBlock.ToString().c_str());
+                        {
+                            boost::unique_lock<boost::mutex> lock(mutex);
+                            status = lastStatus;
+                        }
+                        if (hashLastBlock != status.hashLastBlock)
+                        {
+                            continue;
+                        }
+                    }
+                    Log("BizMaker: hashLastBlock[%s], nLastHeight[%d], nLastTime[%ld], nLastMintType[%d]",
+                        hashLastBlock.ToString().c_str(), nLastHeight, nLastTime, nLastMintType);
+
+                    int nPrevHeight = nLastHeight - 1;
+                    uint16 nPrevMintType;
+                    if (!pBlockChain->GetBlockMintType(block.hashPrev, nPrevMintType))
+                    {
+                        throw runtime_error("get previous block mint type failed");
+                    }
+                    CBlockMakerProfile& profile = (*it).second;
+                    CDelegateAgreement agreement;
+                    agreement.nWeight = status.nWeight;
+                    agreement.nAgreement = status.nAgreement;
+                    ProcessSubFork(profile, agreement, hashLastBlock, nLastTime, nPrevHeight, nPrevMintType);
+                    Log("BizMaker: after dealing with subfork");
+                }
+            }
+        }
+        catch (exception& e)
+        {
+            Error("Biz fork block maker error: %s ... abnormally exited biz fork block maker thread",
+                  e.what());
+            return;
+        }
+    }
+    Log("...biz fork block maker thread exited normally");
 }
 
 } // namespace bigbang
diff --git a/src/bigbang/blockmaker.h b/src/bigbang/blockmaker.h
index 4af6b3db..91dfe1a9 100644
--- a/src/bigbang/blockmaker.h
+++ b/src/bigbang/blockmaker.h
@@ -98,10 +98,12 @@ class CBlockMaker : public IBlockMaker, virtual public CBlockMakerEventListener
 private:
     void BlockMakerThreadFunc();
     void PowThreadFunc();
+    void BizForkThreadFunc();
 
 protected:
     xengine::CThread thrMaker;
     xengine::CThread thrPow;
+    xengine::CThread thrBizFork;
     boost::mutex mutex;
     boost::condition_variable condExit;
     boost::condition_variable condBlock;
@@ -110,6 +112,7 @@ class CBlockMaker : public IBlockMaker, virtual public CBlockMakerEventListener
     std::map<int, CBlockMakerHashAlgo*> mapHashAlgo;
     std::map<int, CBlockMakerProfile> mapWorkProfile;
     std::map<CDestination, CBlockMakerProfile> mapDelegatedProfile;
+    int nNodeCat;
     ICoreProtocol* pCoreProtocol;
     IBlockChain* pBlockChain;
     IForkManager* pForkManager;
diff --git a/src/bigbang/consensus.cpp b/src/bigbang/consensus.cpp
index e7639da9..d1f2927a 100644
--- a/src/bigbang/consensus.cpp
+++ b/src/bigbang/consensus.cpp
@@ -557,6 +557,8 @@ bool CConsensus::GetNextConsensus(CAgreementBlock& consParam)
 
     int64 nNextBlockTime = pCoreProtocol->GetNextBlockTimeStamp(nLastMintType, nLastTime, CTransaction::TX_WORK, nLastHeight + 1);
     consParam.nWaitTime = nNextBlockTime - 2 - GetNetTime();
+    Log("timerelative 1: consParam.nWaitTime[%ld] = nNextBlockTime[%ld] - 2 - GetNetTime()[%ld]",
+        consParam.nWaitTime, nNextBlockTime, nNextBlockTime - consParam.nWaitTime - 2);
     if (consParam.nWaitTime >= -60)
     {
         int64 nAgreementWaitTime = GetAgreementWaitTime(nLastHeight + 1);
@@ -567,6 +569,7 @@ bool CConsensus::GetNextConsensus(CAgreementBlock& consParam)
     }
     if (consParam.nWaitTime > 0)
     {
+        Error("GetNextConsensus: nWaitTime > 0 [1]");
         return false;
     }
 
@@ -597,13 +600,18 @@ bool CConsensus::GetNextConsensus(CAgreementBlock& consParam)
         }
         consParam = cacheAgreementBlock;
         consParam.nWaitTime = nNextBlockTime - 2 - GetNetTime();
+        Log("timerelative 2: consParam.nWaitTime[%ld] = nNextBlockTime[%ld] - 2 - GetNetTime()[%ld]",
+            consParam.nWaitTime, nNextBlockTime, nNextBlockTime - consParam.nWaitTime - 2);
     }
     if (!cacheAgreementBlock.agreement.IsProofOfWork())
     {
         nNextBlockTime = pCoreProtocol->GetNextBlockTimeStamp(nLastMintType, nLastTime, CTransaction::TX_STAKE, nLastHeight + 1);
         consParam.nWaitTime = nNextBlockTime - 2 - GetNetTime();
+        Log("timerelative 3: consParam.nWaitTime[%ld] = nNextBlockTime[%ld] - 2 - GetNetTime()[%ld]",
+            consParam.nWaitTime, nNextBlockTime, nNextBlockTime - consParam.nWaitTime - 2);
         if (consParam.nWaitTime > 0)
         {
+            Error("GetNextConsensus: nWaitTime > 0 [2]");
             return false;
         }
     }
diff --git a/src/bigbang/core.cpp b/src/bigbang/core.cpp
index 148fe542..3838ed84 100644
--- a/src/bigbang/core.cpp
+++ b/src/bigbang/core.cpp
@@ -298,7 +298,7 @@ Errno CCoreProtocol::ValidateTransaction(const CTransaction& tx, int nHeight)
                 || tid.GetType() == TEMPLATE_DELEGATE
                 || tid.GetType() == TEMPLATE_VOTE)
             {
-                return DEBUG(ERR_TRANSACTION_OUTPUT_INVALID, "send to address invalid 2");
+//                return DEBUG(ERR_TRANSACTION_OUTPUT_INVALID, "send to address invalid 2");
             }
         }
     }
diff --git a/src/bigbang/dispatcher.cpp b/src/bigbang/dispatcher.cpp
index 0fd8db5c..50f0e951 100644
--- a/src/bigbang/dispatcher.cpp
+++ b/src/bigbang/dispatcher.cpp
@@ -8,6 +8,7 @@
 #include <future>
 #include <thread>
 
+#include "defs.h"
 #include "event.h"
 
 using namespace std;
@@ -32,6 +33,8 @@ CDispatcher::CDispatcher()
     pNetChannel = nullptr;
     pDelegatedChannel = nullptr;
     pDataStat = nullptr;
+    nNodeCat = 0;
+    pMQCluster = nullptr;
 }
 
 CDispatcher::~CDispatcher()
@@ -106,6 +109,17 @@ bool CDispatcher::HandleInitialize()
         return false;
     }
     strCmd = dynamic_cast<const CBasicConfig*>(Config())->strBlocknotify;
+
+    nNodeCat = dynamic_cast<const CBasicConfig*>(Config())->nCatOfNode;
+    if (NODE_CAT_DPOSNODE == nNodeCat)
+    {
+        if (!GetObject("mqcluster", pMQCluster))
+        {
+            Error("Failed to request mqcluster");
+            return false;
+        }
+    }
+
     return true;
 }
 
@@ -122,6 +136,7 @@ void CDispatcher::HandleDeinitialize()
     pNetChannel = nullptr;
     pDelegatedChannel = nullptr;
     pDataStat = nullptr;
+    pMQCluster = nullptr;
 }
 
 bool CDispatcher::HandleInvoke()
@@ -129,7 +144,7 @@ bool CDispatcher::HandleInvoke()
     vector<uint256> vActive;
     if (!pForkManager->LoadForkContext(vActive))
     {
-        Error("Failed to load for context");
+        Error("Failed to load fork context");
         return false;
     }
 
@@ -353,31 +368,37 @@ void CDispatcher::UpdatePrimaryBlock(const CBlock& block, const CBlockChainUpdat
     }
 
     CDelegateRoutine routineDelegate;
-    pConsensus->PrimaryUpdate(updateBlockChain, changeTxSet, routineDelegate);
+    if (NODE_CAT_DPOSNODE == nNodeCat)
+    {
+        pConsensus->PrimaryUpdate(updateBlockChain, changeTxSet, routineDelegate);
 
-    pDelegatedChannel->PrimaryUpdate(updateBlockChain.nLastBlockHeight - updateBlockChain.vBlockAddNew.size(),
-                                     routineDelegate.vEnrolledWeight, routineDelegate.vDistributeData,
-                                     routineDelegate.mapPublishData, routineDelegate.hashDistributeOfPublish);
+        pDelegatedChannel->PrimaryUpdate(updateBlockChain.nLastBlockHeight - updateBlockChain.vBlockAddNew.size(),
+                                         routineDelegate.vEnrolledWeight, routineDelegate.vDistributeData,
+                                         routineDelegate.mapPublishData, routineDelegate.hashDistributeOfPublish);
+    }
 
-    for (const CTransaction& tx : routineDelegate.vEnrollTx)
+    if (NODE_CAT_DPOSNODE == nNodeCat && !routineDelegate.vEnrollTx.empty())
     {
-        if (tx.vInput.size() == 0)
+        for (const CTransaction& tx : routineDelegate.vEnrollTx)
         {
-            Error("Send DelegateTx: tx.vInput.size() == 0.");
-            continue;
-        }
-        Errno err = AddNewTx(tx, nNonce);
-        if (err == OK)
-        {
-            Log("Send DelegateTx success, txid: %s, previd: %s.",
-                tx.GetHash().GetHex().c_str(),
-                tx.vInput[0].prevout.hash.GetHex().c_str());
-        }
-        else
-        {
-            Log("Send DelegateTx fail, err: [%d] %s, txid: %s, previd: %s.",
-                err, ErrorString(err), tx.GetHash().GetHex().c_str(),
-                tx.vInput[0].prevout.hash.GetHex().c_str());
+            if (tx.vInput.size() == 0)
+            {
+                Error("Send DelegateTx: tx.vInput.size() == 0.");
+                continue;
+            }
+            Errno err = AddNewTx(tx, nNonce);
+            if (err == OK)
+            {
+                Log("Send DelegateTx success, txid: %s, previd: %s.",
+                    tx.GetHash().GetHex().c_str(),
+                    tx.vInput[0].prevout.hash.GetHex().c_str());
+            }
+            else
+            {
+                Log("Send DelegateTx fail, err: [%d] %s, txid: %s, previd: %s.",
+                    err, ErrorString(err), tx.GetHash().GetHex().c_str(),
+                    tx.vInput[0].prevout.hash.GetHex().c_str());
+            }
         }
     }
 
@@ -401,6 +422,31 @@ void CDispatcher::UpdatePrimaryBlock(const CBlock& block, const CBlockChainUpdat
     {
         SyncForkHeight(updateBlockChain.nLastBlockHeight);
     }
+
+    if (NODE_CAT_DPOSNODE == nNodeCat && !updateBlockChain.vBlockRemove.empty())
+    {
+        CEventMQChainUpdate* pMqChainUpdate = new CEventMQChainUpdate(0);
+        if (pMqChainUpdate != nullptr)
+        {
+            pMqChainUpdate->data.actRollBackLen = updateBlockChain.vBlockRemove.size();
+            pMqChainUpdate->data.vShort.reserve(updateBlockChain.vBlockRemove.size());
+            for (const auto& rb : updateBlockChain.vBlockRemove)
+            {
+                Log("CDispatcher::UpdatePrimaryBlock: removed short link block [%s]",
+                    rb.GetHash().ToString().c_str());
+                pMqChainUpdate->data.vShort.emplace_back(rb.GetHash());
+            }
+            reverse(pMqChainUpdate->data.vShort.begin(), pMqChainUpdate->data.vShort.end());
+            pMqChainUpdate->data.triHeight = pMqChainUpdate->data.vShort.front().Get32(7) - 1;
+            pBlockChain->GetBlockHash(pCoreProtocol->GetGenesisBlockHash(),
+                                      pMqChainUpdate->data.triHeight,
+                                      pMqChainUpdate->data.triHash);
+            Log("CDispatcher::UpdatePrimaryBlock: forked block hash [%s] with height [%d]",
+                pMqChainUpdate->data.triHash.ToString().c_str(), pMqChainUpdate->data.triHeight);
+
+            pMQCluster->PostEvent(pMqChainUpdate);
+        }
+    }
 }
 
 void CDispatcher::ActivateFork(const uint256& hashFork, const uint64& nNonce)
@@ -431,6 +477,10 @@ void CDispatcher::ActivateFork(const uint256& hashFork, const uint64& nNonce)
     }
     pNetChannel->SubscribeFork(hashFork, nNonce);
     Log("Activated fork %s ...", hashFork.GetHex().c_str());
+
+    vector<uint256> forks;
+    forks.push_back(hashFork);
+    pNetChannel->DispatchGetBizForksEvent(forks);
 }
 
 bool CDispatcher::ProcessForkTx(const uint256& txid, const CTransaction& tx)
@@ -506,17 +556,25 @@ void CDispatcher::SyncForkHeight(int nPrimaryHeight)
 {
     map<uint256, CForkStatus> mapForkStatus;
     pBlockChain->GetForkStatus(mapForkStatus);
+    Log("subfork: there may be [%d] forks needed to update", mapForkStatus.size());
     for (map<uint256, CForkStatus>::iterator it = mapForkStatus.begin(); it != mapForkStatus.end(); ++it)
     {
         const uint256& hashFork = (*it).first;
         CForkStatus& status = (*it).second;
-        if (!pForkManager->IsAllowed(hashFork) || !pNetChannel->IsForkSynchronized(hashFork))
+        if (!pForkManager->IsAllowed(hashFork))
         {
+            Log("fork[%s] is not allowed", hashFork.ToString().c_str());
             continue;
         }
 
+        if (!pNetChannel->IsForkSynchronized(hashFork))
+        {
+            Log("fork[%s] has not been synchronized yet", hashFork.ToString().c_str());
+            continue;
+        }
         vector<int64> vTimeStamp;
         int nDepth = nPrimaryHeight - status.nLastBlockHeight;
+        Log("subfork: biz[%s] has depth[%d]", hashFork.ToString().c_str(), nDepth);
 
         if (nDepth > 1 && hashFork != pCoreProtocol->GetGenesisBlockHash()
             && pBlockChain->GetLastBlockTime(pCoreProtocol->GetGenesisBlockHash(), nDepth, vTimeStamp))
@@ -532,12 +590,15 @@ void CDispatcher::SyncForkHeight(int nPrimaryHeight)
                 Errno err = AddNewBlock(block);
                 if (err != OK && err != ERR_ALREADY_HAVE)
                 {
-                    StdError("Dispatcher", "SyncForkHeight: Add new block failed, error: [%d] %s, block: %s",
-                             err, ErrorString(err), block.GetHash().GetHex().c_str());
+                    Log("subfork: add vacant failed errno[%d] err[%s] fork[%s] on height[%d] lastheight[%d]",
+                        err, ErrorString(err), hashFork.ToString().c_str(), nHeight, status.nLastBlockHeight);
                     break;
                 }
+                Log("subfork: add vacant succeeded fork[%s] on height[%d] with lastheight[%d]",
+                    hashFork.ToString().c_str(), nHeight, status.nLastBlockHeight);
                 hashPrev = block.GetHash();
             }
+            Log("subfork: biz[%s] done [%d] depth", hashFork.ToString().c_str(), nDepth - 1);
         }
     }
 }
diff --git a/src/bigbang/dispatcher.h b/src/bigbang/dispatcher.h
index 9fc0ade5..063a41e5 100644
--- a/src/bigbang/dispatcher.h
+++ b/src/bigbang/dispatcher.h
@@ -7,6 +7,7 @@
 
 #include "base.h"
 #include "peernet.h"
+#include "mqcluster.h"
 
 namespace bigbang
 {
@@ -49,6 +50,8 @@ class CDispatcher : public IDispatcher
     network::IDelegatedChannel* pDelegatedChannel;
     IDataStat* pDataStat;
     std::string strCmd;
+    int nNodeCat;
+    IMQCluster* pMQCluster;
 };
 
 } // namespace bigbang
diff --git a/src/bigbang/entry.cpp b/src/bigbang/entry.cpp
index 4da6918d..d80b5462 100644
--- a/src/bigbang/entry.cpp
+++ b/src/bigbang/entry.cpp
@@ -31,6 +31,7 @@
 #include "txpool.h"
 #include "version.h"
 #include "wallet.h"
+#include "mqcluster.h"
 
 #ifdef WIN32
 #ifdef _MSC_VER
@@ -95,17 +96,24 @@ bool CBbEntry::Initialize(int argc, char* argv[])
         return false;
     }
 
-    // purge
-    if (config.GetConfig()->fPurge)
+    // list config if in debug mode
+    if (config.GetConfig()->fDebug)
     {
-        PurgeStorage();
+        config.ListConfig();
+    }
+
+    // check node category
+    if (config.GetConfig()->nCatOfNode < 0 || config.GetConfig()->nCatOfNode > 2)
+    {
+        cerr << "Node Category should be 0(BBCNODE), 1(FORKNODE) or 2(DPOSNODE) but it is " << config.GetConfig()->nCatOfNode << "\n";
         return false;
     }
 
-    // list config if in debug mode
-    if (config.GetConfig()->fDebug)
+    // purge
+    if (config.GetConfig()->fPurge)
     {
-        config.ListConfig();
+        PurgeStorage();
+        return false;
     }
 
     // check log size
@@ -406,6 +414,14 @@ bool CBbEntry::InitializeModules(const EModeType& mode)
             }
             break;
         }
+        case EModuleType::MQCLUSTER:
+        {
+            if (!AttachModule(new CMQCluster(config.GetConfig()->nCatOfNode)))
+            {
+                return false;
+            }
+            break;
+        }
         case EModuleType::RECOVERY:
         {
             if (!AttachModule(new CRecovery()))
diff --git a/src/bigbang/forkmanager.cpp b/src/bigbang/forkmanager.cpp
index aadbe363..66c06f67 100644
--- a/src/bigbang/forkmanager.cpp
+++ b/src/bigbang/forkmanager.cpp
@@ -6,6 +6,7 @@
 
 #include <boost/range/adaptor/reversed.hpp>
 
+#include "defs.h"
 #include "template/fork.h"
 
 using namespace std;
@@ -53,26 +54,35 @@ void CForkManager::HandleDeinitialize()
 
 bool CForkManager::HandleInvoke()
 {
-    boost::unique_lock<boost::shared_mutex> wlock(rwAccess);
-
-    fAllowAnyFork = ForkConfig()->fAllowAnyFork;
-    if (!fAllowAnyFork)
+    int8 nodeCat = dynamic_cast<const CBasicConfig*>(Config())->nCatOfNode;
+    if (NODE_CAT_DPOSNODE == nodeCat)
     {
         setForkAllowed.insert(pCoreProtocol->GetGenesisBlockHash());
-        for (const string& strFork : ForkConfig()->vFork)
+        return true;
+    }
+
+    {
+        boost::unique_lock<boost::shared_mutex> wlock(rwAccess);
+
+        fAllowAnyFork = ForkConfig()->fAllowAnyFork;
+        if (!fAllowAnyFork)
         {
-            uint256 hashFork(strFork);
-            if (hashFork != 0)
+            setForkAllowed.insert(pCoreProtocol->GetGenesisBlockHash());
+            for (const string& strFork : ForkConfig()->vFork)
             {
-                setForkAllowed.insert(hashFork);
+                uint256 hashFork(strFork);
+                if (hashFork != 0)
+                {
+                    setForkAllowed.insert(hashFork);
+                }
             }
-        }
-        for (const string& strFork : ForkConfig()->vGroup)
-        {
-            uint256 hashFork(strFork);
-            if (hashFork != 0)
+            for (const string& strFork : ForkConfig()->vGroup)
             {
-                setGroupAllowed.insert(hashFork);
+                uint256 hashFork(strFork);
+                if (hashFork != 0)
+                {
+                    setGroupAllowed.insert(hashFork);
+                }
             }
         }
     }
@@ -117,20 +127,38 @@ bool CForkManager::LoadForkContext(vector<uint256>& vActive)
 {
     boost::unique_lock<boost::shared_mutex> wlock(rwAccess);
 
+    vector<uint256> vActiveFork;
+    if (!pBlockChain->ListActiveFork(vActiveFork))
+    {
+        Error("ListActiveFork failed");
+        return false;
+    }
+    for (const auto& fork : vActiveFork)
+    {
+        setForkAllowed.insert(fork);
+    }
+
     vector<CForkContext> vForkCtxt;
     if (!pBlockChain->ListForkContext(vForkCtxt))
     {
         return false;
     }
-
+    Log("listforks[%d]", vForkCtxt.size());
     for (const CForkContext& ctxt : vForkCtxt)
     {
+        Log("listfork[%s][%s][%s]", ctxt.strName.c_str(), ctxt.strSymbol.c_str(), ctxt.hashFork.ToString().c_str());
         if (!AddNewForkContext(ctxt, vActive))
         {
+            Error("listfork - add failed[%s][%s][%s]", ctxt.strName.c_str(), ctxt.strSymbol.c_str(), ctxt.hashFork.ToString().c_str());
             return false;
         }
     }
 
+    Log("active forks[%d]", vActive.size());
+    for (const auto& act : vActive)
+    {
+        Log("active fork[%s]", act.ToString().c_str());
+    }
     return true;
 }
 
@@ -264,6 +292,40 @@ bool CForkManager::GetSubline(const uint256& hashFork, vector<pair<int, uint256>
     return true;
 }
 
+bool CForkManager::SetForkFilter(const std::vector<uint256>& vFork, const std::vector<uint256>& vGroup)
+{
+    int8 nodeCat = dynamic_cast<const CBasicConfig*>(Config())->nCatOfNode;
+    if (NODE_CAT_DPOSNODE == nodeCat)
+    {
+        return true;
+    }
+
+    {
+        boost::unique_lock<boost::shared_mutex> wlock(rwAccess);
+        if (!fAllowAnyFork)
+        {
+            for (auto const& fork : vFork)
+            {
+                if (fork != 0)
+                {
+                    setForkAllowed.insert(fork);
+                    Log("CForkManager::SetForkFilter: set fork filter[%s]", fork.ToString().c_str());
+                }
+            }
+            for (auto const& group : vGroup)
+            {
+                if (group != 0)
+                {
+                    setGroupAllowed.insert(group);
+                    Log("CForkManager::SetForkFilter: set fork group filter[%s]", group.ToString().c_str());
+                }
+            }
+        }
+    }
+
+    return true;
+}
+
 bool CForkManager::GetCreatedHeight(const uint256& hashFork, int& nCreatedHeight) const
 {
     boost::shared_lock<boost::shared_mutex> rlock(rwAccess);
diff --git a/src/bigbang/forkmanager.h b/src/bigbang/forkmanager.h
index 3a0a10bc..e337f872 100644
--- a/src/bigbang/forkmanager.h
+++ b/src/bigbang/forkmanager.h
@@ -108,6 +108,7 @@ class CForkManager : public IForkManager
     bool AddNewForkContext(const CForkContext& ctxt, std::vector<uint256>& vActive);
     void GetForkList(std::vector<uint256>& vFork) const override;
     bool GetSubline(const uint256& hashFork, std::vector<std::pair<int, uint256>>& vSubline) const override;
+    bool SetForkFilter(const std::vector<uint256>& vFork = std::vector<uint256>(), const std::vector<uint256>& vGroup = std::vector<uint256>()) override;
     bool GetCreatedHeight(const uint256& hashFork, int& nCreatedHeight) const override;
 
 protected:
diff --git a/src/bigbang/miner.cpp b/src/bigbang/miner.cpp
index 338bbd7b..1335bee7 100644
--- a/src/bigbang/miner.cpp
+++ b/src/bigbang/miner.cpp
@@ -252,7 +252,7 @@ bool CMiner::SendRequest(uint64 nNonce, const string& content)
     CHttpReqData& httpReqData = eventHttpGet.data;
     httpReqData.strIOModule = GetOwnKey();
     httpReqData.nTimeout = Config()->nRPCConnectTimeout;
-    ;
+
     if (Config()->fRPCSSLEnable)
     {
         httpReqData.strProtocol = "https";
diff --git a/src/bigbang/mode/mode.h b/src/bigbang/mode/mode.h
index 4fdca733..56e58c6f 100644
--- a/src/bigbang/mode/mode.h
+++ b/src/bigbang/mode/mode.h
@@ -103,7 +103,7 @@ class CMode
         }
         else
         {
-            return new mode_impl::CCombinConfig<
+            return new mode_impl::CCombineConfig<
                 typename std::remove_pointer<typename std::tuple_element<
                     static_cast<int>(t),
                     decltype(config_type::___ConfigTypeTemplate)>::type>::type...>;
@@ -171,6 +171,7 @@ class CMode
                 EModuleType::HTTPSERVER,
                 EModuleType::RPCMODE,
                 EModuleType::BLOCKMAKER,
+                EModuleType::MQCLUSTER,
                 EModuleType::DATASTAT,
                 EModuleType::RECOVERY } },
             { EModeType::CONSOLE,
diff --git a/src/bigbang/mode/mode_impl.h b/src/bigbang/mode/mode_impl.h
index 7340cd12..c7c63357 100644
--- a/src/bigbang/mode/mode_impl.h
+++ b/src/bigbang/mode/mode_impl.h
@@ -20,11 +20,11 @@ namespace mode_impl
  * Combination of inheriting all need config class.
  */
 template <typename... U>
-class CCombinConfig : virtual public std::enable_if<std::is_base_of<CBasicConfig, U>::value, U>::type...
+class CCombineConfig : virtual public std::enable_if<std::is_base_of<CBasicConfig, U>::value, U>::type...
 {
 public:
-    CCombinConfig() {}
-    virtual ~CCombinConfig() {}
+    CCombineConfig() {}
+    virtual ~CCombineConfig() {}
 
     virtual bool PostLoad()
     {
@@ -51,7 +51,7 @@ class CCombinConfig : virtual public std::enable_if<std::is_base_of<CBasicConfig
 };
 
 template <>
-class CCombinConfig<> : virtual public CCombinConfig<CBasicConfig>
+class CCombineConfig<> : virtual public CCombineConfig<CBasicConfig>
 {
 };
 
diff --git a/src/bigbang/mode/module_type.h b/src/bigbang/mode/module_type.h
index 4431cfc1..3c4de35f 100644
--- a/src/bigbang/mode/module_type.h
+++ b/src/bigbang/mode/module_type.h
@@ -29,6 +29,7 @@ enum class EModuleType
     CONSENSUS,        // CConsensus
     FORKMANAGER,      // CForkManager
     DATASTAT,         // CDataStat
+    MQCLUSTER,        // CMQCluster
     RECOVERY,         // CRecovery
 };
 
diff --git a/src/bigbang/mqcluster.cpp b/src/bigbang/mqcluster.cpp
new file mode 100644
index 00000000..bd804c6d
--- /dev/null
+++ b/src/bigbang/mqcluster.cpp
@@ -0,0 +1,1558 @@
+// Copyright (c) 2019-2020 The Bigbang developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include "mqcluster.h"
+
+#include <atomic>
+#include <chrono>
+#include <cstdlib>
+#include <cstring>
+#include <future>
+#include <iostream>
+#include <string>
+#include <thread> // For sleep
+
+#include "async_client.h"
+
+const int32 FETCH_TIMEOUT = 250;
+
+using namespace std;
+
+namespace bigbang
+{
+
+CMQCluster::CMQCluster(int catNodeIn)
+  : thrMqttClient("mqttcli", boost::bind(&CMQCluster::MqttThreadFunc, this)),
+    thrPostAddBizNode("postaddbiz", boost::bind(&CMQCluster::NodeThreadFunc, this)),
+    pCoreProtocol(nullptr),
+    pBlockChain(nullptr),
+    pService(nullptr),
+    fAbort(false),
+    nReqBlkTimerID(0),
+    nRollNum(0),
+    clientID("")
+{
+    switch (catNodeIn)
+    {
+    case 0:
+        catNode = NODE_CATEGORY::BBCNODE;
+        break;
+    case 1:
+        catNode = NODE_CATEGORY::FORKNODE;
+        break;
+    case 2:
+        catNode = NODE_CATEGORY::DPOSNODE;
+        break;
+    }
+    std::atomic_init(&isMainChainBlockBest, false);
+    std::atomic_init(&fConnected, false);
+    array<string, TOPIC_SUFFIX_MAX> v{};
+    arrTopic = std::move(v);
+}
+
+bool CMQCluster::HandleInitialize()
+{
+    if (!GetObject("coreprotocol", pCoreProtocol))
+    {
+        Error("Failed to request coreprotocol");
+        return false;
+    }
+
+    if (!GetObject("blockchain", pBlockChain))
+    {
+        Error("Failed to request blockchain");
+        return false;
+    }
+
+    if (!GetObject("dispatcher", pDispatcher))
+    {
+        Error("Failed to request dispatcher\n");
+        return false;
+    }
+
+    if (!GetObject("service", pService))
+    {
+        Error("Failed to request service");
+        return false;
+    }
+
+    if (!GetObject("forkmanager", pForkManager))
+    {
+        Error("Failed to request forkmanager");
+        return false;
+    }
+
+    if (NODE_CATEGORY::BBCNODE == catNode)
+    {
+        Log("CMQCluster::HandleInitialize(): bbc node so bypass");
+        return true;
+    }
+
+    addrBroker = dynamic_cast<const CBasicConfig*>(Config())->strMQBrokerURI;
+    if (NODE_CATEGORY::FORKNODE == catNode)
+    {
+        dposNodeCliID = dynamic_cast<const CBasicConfig*>(Config())->strDposNodeID;
+        if (dposNodeCliID.empty())
+        {
+            Error("DPOS NODE CLIENT ID should not be empty for fork node");
+            return false;
+        }
+    }
+    prefixTopic = dynamic_cast<const CBasicConfig*>(Config())->strTopicPrefix;
+
+    return true;
+}
+
+void CMQCluster::HandleDeinitialize()
+{
+    pCoreProtocol = nullptr;
+    pBlockChain = nullptr;
+    pDispatcher = nullptr;
+    pService = nullptr;
+    pForkManager = nullptr;
+}
+
+bool CMQCluster::HandleInvoke()
+{
+    if (NODE_CATEGORY::BBCNODE == catNode)
+    {
+        if (!ThreadDelayStart(thrPostAddBizNode))
+        {
+            return false;
+        }
+
+        Log("CMQCluster::HandleInvoke(): bbc node so bypass");
+        return true;
+    }
+    if (NODE_CATEGORY::FORKNODE == catNode)
+    {
+        if (!ThreadDelayStart(thrPostAddBizNode))
+        {
+            return false;
+        }
+    }
+
+    uint8 mask = 0;
+    if (NODE_CATEGORY::FORKNODE == catNode)
+    {
+        lastHeightResp = pBlockChain->GetBlockCount(pCoreProtocol->GetGenesisBlockHash()) - 1;
+        mask = 2;
+    }
+    if (NODE_CATEGORY::DPOSNODE == catNode)
+    {
+        lastHeightResp = -1;
+        mask = 4;
+    }
+    std::vector<storage::CSuperNode> nodes;
+    if (!pBlockChain->FetchSuperNode(nodes, mask))
+    {
+        Error("CMQCluster::HandleInvoke(): fetch super node failed");
+        return false;
+    }
+    if (nodes.size() > 1)
+    {
+        Error("CMQCluster::HandleInvoke(): there are nodes enrollment info greater than one");
+        return false;
+    }
+    if (nodes.empty())
+    {
+        Log("CMQCluster::HandleInvoke(): this super node has not enrolled yet");
+        if (!ThreadStart(thrMqttClient))
+        {
+            return false;
+        }
+        return IIOModule::HandleInvoke();
+    }
+
+    {
+        boost::unique_lock<boost::mutex> lock(mtxStatus);
+        clientID = nodes[0].superNodeID;
+        ipAddr = nodes[0].ipAddr;
+        for (auto const& fork : nodes[0].vecOwnedForks)
+        {
+            setBizFork.emplace(fork);
+            Log("CMQCluster::HandleInvoke(): super node enrolled fork:[%s]", fork.ToString().c_str());
+        }
+    }
+    Log("CMQCluster::HandleInvoke(): load super node status info successfully \n[%s]",
+        nodes[0].ToString().c_str());
+
+    arrTopic = {};
+    if (NODE_CATEGORY::FORKNODE == catNode)
+    {
+        //        pForkManager->SetForkFilter(nodes[0].vecOwnedForks);
+
+        arrTopic[TOPIC_SUFFIX_REQ_BLOCK] = prefixTopic + clientID + vecSuffixTopic[TOPIC_SUFFIX_REQ_BLOCK];
+        arrTopic[TOPIC_SUFFIX_RESP_BLOCK] = prefixTopic + clientID + vecSuffixTopic[TOPIC_SUFFIX_RESP_BLOCK];
+        arrTopic[TOPIC_SUFFIX_UPDATE_BLOCK] = prefixTopic + dposNodeCliID + vecSuffixTopic[TOPIC_SUFFIX_UPDATE_BLOCK];
+        arrTopic[TOPIC_SUFFIX_ASGN_BIZFORK] = prefixTopic + clientID + vecSuffixTopic[TOPIC_SUFFIX_ASGN_BIZFORK];
+        Log("CMQCluster::HandleInvoke(): fork node clientid [%s] with sub topics:\n\t[%s]\n\t[%s]\n\t[%s]\npub topic:\n\t[%s]",
+            clientID.c_str(), arrTopic[TOPIC_SUFFIX_RESP_BLOCK].c_str(), arrTopic[TOPIC_SUFFIX_UPDATE_BLOCK].c_str(),
+            arrTopic[TOPIC_SUFFIX_ASGN_BIZFORK].c_str(), arrTopic[TOPIC_SUFFIX_REQ_BLOCK].c_str());
+        /*
+        if (!PostBlockRequest(-1))
+        {
+            Error("CMQCluster::HandleInvoke(): failed to post requesting block");
+            return false;
+        }*/
+    }
+    else if (NODE_CATEGORY::DPOSNODE == catNode)
+    {
+        {
+            boost::unique_lock<boost::mutex> lock(mtxStatus);
+            if (setBizFork.size() != 1 || *(setBizFork.begin()) != pCoreProtocol->GetGenesisBlockHash())
+            {
+                Error("CMQCluster::HandleInvoke(): dpos node enrollment info "
+                      "invalid [%d] for self",
+                      setBizFork.size());
+                return false;
+            }
+        }
+        arrTopic[TOPIC_SUFFIX_REQ_BLOCK] = prefixTopic + "+" + vecSuffixTopic[TOPIC_SUFFIX_REQ_BLOCK];
+        arrTopic[TOPIC_SUFFIX_RESP_BLOCK] = prefixTopic + "***" + vecSuffixTopic[TOPIC_SUFFIX_RESP_BLOCK]; //only placeholder
+        arrTopic[TOPIC_SUFFIX_UPDATE_BLOCK] = prefixTopic + clientID + vecSuffixTopic[TOPIC_SUFFIX_UPDATE_BLOCK];
+        arrTopic[TOPIC_SUFFIX_ASGN_BIZFORK] = prefixTopic + "***" + vecSuffixTopic[TOPIC_SUFFIX_ASGN_BIZFORK]; //only placeholder
+        Log("CMQCluster::HandleInvoke(): dpos node clientid [%s] with sub topic [%s], pub topics[%s]"
+            "[%s][%s]",
+            clientID.c_str(), arrTopic[TOPIC_SUFFIX_REQ_BLOCK].c_str(),
+            arrTopic[TOPIC_SUFFIX_RESP_BLOCK].c_str(), arrTopic[TOPIC_SUFFIX_UPDATE_BLOCK].c_str(),
+            arrTopic[TOPIC_SUFFIX_ASGN_BIZFORK].c_str());
+
+        nodes.clear();
+        if (!pBlockChain->FetchSuperNode(nodes, 1 << 1))
+        {
+            Error("CMQCluster::HandleInvoke(): list all mq fork nodes failed");
+            return false;
+        }
+
+        {
+            boost::unique_lock<boost::mutex> lock(mtxCluster);
+            for (auto const& node : nodes)
+            {
+                mapActiveMQForkNode.emplace(make_pair(node.superNodeID,
+                                                      storage::CSuperNode(node.superNodeID, node.ipAddr,
+                                                                          node.vecOwnedForks,
+                                                                          static_cast<int8>(NODE_CATEGORY::FORKNODE))));
+                Log("CMQCluster::HandleInvoke(): load fork node [%s]", node.ToString().c_str());
+            }
+        }
+    }
+
+    nodes.clear();
+    if (!pBlockChain->FetchSuperNode(nodes, 1 << 0))
+    {
+        Error("CMQCluster::HandleInvoke(): list all other outer nodes failed");
+        return false;
+    }
+    {
+        boost::unique_lock<boost::mutex> lock(mtxOuter);
+        for (auto const& node : nodes)
+        {
+            mapOuterNode.emplace(make_pair(node.ipAddr,
+                                           storage::CSuperNode(node.superNodeID, node.ipAddr,
+                                                               node.vecOwnedForks,
+                                                               static_cast<int8>(NODE_CATEGORY::BBCNODE))));
+            Log("CMQCluster::HandleInvoke(): load outer node [%s]", node.ToString().c_str());
+        }
+    }
+
+    if (!ThreadStart(thrMqttClient))
+    {
+        return false;
+    }
+    return IIOModule::HandleInvoke();
+}
+
+void CMQCluster::HandleHalt()
+{
+    if (NODE_CATEGORY::BBCNODE == catNode)
+    {
+        Log("CMQCluster::HandleHalt(): bbc node so bypass");
+        return;
+    }
+
+    IIOModule::HandleHalt();
+
+    fAbort = true;
+
+    {
+        boost::unique_lock<boost::mutex> lock(mtxSend);
+        deqSendBuff.clear();
+    }
+    condSend.notify_one();
+
+    if (thrMqttClient.IsRunning())
+    {
+        thrMqttClient.Interrupt();
+    }
+    ThreadExit(thrMqttClient);
+}
+
+bool CMQCluster::HandleEvent(CEventMQSyncBlock& eventMqSyncBlock)
+{
+    return true;
+}
+
+bool CMQCluster::HandleEvent(CEventMQChainUpdate& eventMqUpdateChain)
+{
+    Log("CMQCluster::HandleEvent(CEventMQChainUpdate): entering forking event handler");
+    if (!fConnected)
+    {
+        Log("CMQCluster::HandleEvent(CEventMQChainUpdate): connection to mq is lost, ignore forking");
+        return true;
+    }
+    CMqRollbackUpdate& update = eventMqUpdateChain.data;
+
+    if (catNode != NODE_CATEGORY::DPOSNODE)
+    {
+        Error("CMQCluster::HandleEvent(CEventMQChainUpdate): only dpos node should receive this kind of event");
+        return false;
+    }
+
+    CRollbackBlock rbc;
+    rbc.rbHeight = update.triHeight;
+    rbc.rbHash = update.triHash;
+    rbc.rbSize = update.actRollBackLen;
+    rbc.hashList = update.vShort;
+
+    CBufferPtr spRBC(new CBufStream);
+    *spRBC.get() << rbc;
+
+    Log("CMQCluster::HandleEvent(CEventMQChainUpdate): rollback-topic[%s]:forkheight[%d] forkhash[%s] shortlen[%d]",
+        arrTopic[TOPIC_SUFFIX_UPDATE_BLOCK].c_str(), rbc.rbHeight, rbc.rbHash.ToString().c_str(), rbc.rbSize);
+
+    AppendSendQueue(arrTopic[TOPIC_SUFFIX_UPDATE_BLOCK], spRBC);
+
+    Log("CMQCluster::HandleEvent(CEventMQChainUpdate): exiting forking event handler");
+    return true;
+}
+
+bool CMQCluster::HandleEvent(CEventMQEnrollUpdate& eventMqUpdateEnroll)
+{
+    Log("CMQCluster::HandleEvent(CEventMQEnrollUpdate): starting process of CEventMQEnrollUpdate");
+    string id = eventMqUpdateEnroll.data.superNodeClientID;
+    vector<uint256> forks = eventMqUpdateEnroll.data.vecForksOwned;
+
+    if (NODE_CATEGORY::FORKNODE == catNode)
+    {
+        if (storage::CLIENT_ID_OUT_OF_MQ_CLUSTER != id)
+        {
+            {
+                boost::unique_lock<boost::mutex> lock(mtxStatus);
+                clientID = id;
+                ipAddr = eventMqUpdateEnroll.data.ipAddr;
+                for (auto const& fork : forks)
+                {
+                    setBizFork.emplace(fork);
+                }
+                arrTopic = {};
+                arrTopic[TOPIC_SUFFIX_REQ_BLOCK] = prefixTopic + clientID + vecSuffixTopic[TOPIC_SUFFIX_REQ_BLOCK]; //only placeholder
+                arrTopic[TOPIC_SUFFIX_RESP_BLOCK] = prefixTopic + clientID + vecSuffixTopic[TOPIC_SUFFIX_RESP_BLOCK];
+                arrTopic[TOPIC_SUFFIX_UPDATE_BLOCK] = prefixTopic + dposNodeCliID + vecSuffixTopic[TOPIC_SUFFIX_UPDATE_BLOCK];
+                arrTopic[TOPIC_SUFFIX_ASGN_BIZFORK] = prefixTopic + clientID + vecSuffixTopic[TOPIC_SUFFIX_ASGN_BIZFORK];
+            }
+            condStatus.notify_all();
+
+            Log("CMQCluster::HandleEvent(CEventMQEnrollUpdate): fork node clientid [%s] with sub topics:[%s];[%s];[%s]\t"
+                "pub topic:[%s]",
+                clientID.c_str(), arrTopic[TOPIC_SUFFIX_RESP_BLOCK].c_str(),
+                arrTopic[TOPIC_SUFFIX_UPDATE_BLOCK].c_str(), arrTopic[TOPIC_SUFFIX_ASGN_BIZFORK].c_str(),
+                arrTopic[TOPIC_SUFFIX_REQ_BLOCK].c_str());
+            for (const auto& fork : forks)
+            {
+                Log("CMQCluster::HandleEvent(CEventMQEnrollUpdate): fork [%s] intended to be produced by this node [%s]:",
+                    fork.ToString().c_str(), clientID.c_str());
+            }
+
+            if (!PostBlockRequest(-1))
+            {
+                Error("CMQCluster::HandleEvent(CEventMQEnrollUpdate): failed to post requesting block");
+                return false;
+            }
+            // FetchBlock(true, -1);
+
+            return true;
+        }
+    }
+    else if (NODE_CATEGORY::DPOSNODE == catNode)
+    {
+        if (1 == forks.size() && 0 == eventMqUpdateEnroll.data.ipAddr
+            && forks[0] == pCoreProtocol->GetGenesisBlockHash())
+        { //dpos node enrolled by self
+            {
+                boost::unique_lock<boost::mutex> lock(mtxStatus);
+                clientID = id;
+                ipAddr = 0;
+                setBizFork.emplace(forks[0]);
+                arrTopic = {};
+                arrTopic[TOPIC_SUFFIX_REQ_BLOCK] = prefixTopic + "+" + vecSuffixTopic[TOPIC_SUFFIX_REQ_BLOCK];
+                arrTopic[TOPIC_SUFFIX_RESP_BLOCK] = prefixTopic + "***" + vecSuffixTopic[TOPIC_SUFFIX_RESP_BLOCK];        //only placeholder
+                arrTopic[TOPIC_SUFFIX_UPDATE_BLOCK] = prefixTopic + clientID + vecSuffixTopic[TOPIC_SUFFIX_UPDATE_BLOCK]; //only placeholder
+                arrTopic[TOPIC_SUFFIX_ASGN_BIZFORK] = prefixTopic + "***" + vecSuffixTopic[TOPIC_SUFFIX_ASGN_BIZFORK];    //only placeholder
+            }
+            condStatus.notify_all();
+
+            Log("CMQCluster::HandleEvent(CEventMQEnrollUpdate): dpos node clientid [%s] with sub topic [%s], pub topics[%s]"
+                "[%s][%s]",
+                clientID.c_str(), arrTopic[TOPIC_SUFFIX_REQ_BLOCK].c_str(),
+                arrTopic[TOPIC_SUFFIX_RESP_BLOCK].c_str(), arrTopic[TOPIC_SUFFIX_UPDATE_BLOCK].c_str(),
+                arrTopic[TOPIC_SUFFIX_ASGN_BIZFORK].c_str());
+
+            return true;
+        }
+
+        if (storage::CLIENT_ID_OUT_OF_MQ_CLUSTER != id)
+        { //fork node enrolled by dpos node
+            {
+                boost::unique_lock<boost::mutex> lock(mtxCluster);
+                mapActiveMQForkNode[id] = storage::CSuperNode(id, eventMqUpdateEnroll.data.ipAddr, forks);
+            }
+            Log("CMQCluster::HandleEvent(CEventMQEnrollUpdate): dpos node register clientid [%s]",
+                eventMqUpdateEnroll.data.superNodeClientID.c_str());
+
+            return true;
+        }
+    }
+
+    //simulating outer biz fork node used by p2p - todo: for test only
+    {
+        boost::unique_lock<boost::mutex> lock(mtxOuter);
+        mapOuterNode.insert(make_pair(eventMqUpdateEnroll.data.ipAddr,
+                                      storage::CSuperNode(id, eventMqUpdateEnroll.data.ipAddr, forks)));
+    }
+    Log("CMQCluster::HandleEvent(CEventMQEnrollUpdate): super node registered simulating outer biz fork node used by p2p [%s - %s]",
+        id.c_str(), storage::CSuperNode::Int2Ip(eventMqUpdateEnroll.data.ipAddr).c_str());
+
+    return true;
+}
+
+bool CMQCluster::HandleEvent(CEventMQAgreement& eventMqAgreement)
+{
+    return true;
+}
+
+bool CMQCluster::HandleEvent(CEventMQBizForkUpdate& eventMqBizFork)
+{
+    Log("CMQCluster::HandleEvent(CEventMQBizForkUpdate): biz forks payload is coming...");
+
+    const storage::CForkKnownIpSetByIp& idxIP = eventMqBizFork.data.get<1>();
+    {
+        boost::unique_lock<boost::mutex> lock(mtxOuter);
+        for (auto const& i : idxIP)
+        {
+            auto& node = mapOuterNode[i.nodeIP];
+            // node.nodeCat = (int8)NODE_CATEGORY::OUTERNODE;
+            node.ipAddr = i.nodeIP;
+            node.vecOwnedForks.push_back(i.forkID);
+            Log("CMQCluster::HandleEvent(CEventMQBizForkUpdate): add IP[%s] biz fork[%s] to mem structure",
+                storage::CSuperNode::Int2Ip(i.nodeIP).c_str(), i.forkID.ToString().c_str());
+        }
+    }
+
+    if (NODE_CATEGORY::FORKNODE == catNode)
+    {
+        PoolAddBizForkNode();
+        Log("CMQCluster::HandleEvent(CEventMQBizForkUpdate): PostAddBizForkNode() done");
+    }
+
+    if (NODE_CATEGORY::DPOSNODE == catNode)
+    { //spread ip/fork through mq broker
+        const storage::CForkKnownIpSetById& idxID = eventMqBizFork.data.get<0>();
+        {
+            boost::unique_lock<boost::mutex> lock(mtxCluster);
+            for (auto const& cli : mapActiveMQForkNode)
+            {
+                CAssignBizFork biz;
+                auto& it = biz.mapIpBizFork;
+                for (auto const& fork : cli.second.vecOwnedForks)
+                {
+                    auto itBegin = idxID.equal_range(fork).first;
+                    auto itEnd = idxID.equal_range(fork).second;
+
+                    while (itBegin != itEnd)
+                    {
+                        it[itBegin->nodeIP].push_back(itBegin->forkID);
+                        ++itBegin;
+                    }
+                }
+                if (!it.empty())
+                {
+                    string topic = prefixTopic + cli.second.superNodeID + vecSuffixTopic[TOPIC_SUFFIX_ASGN_BIZFORK];
+                    PostBizForkAssign(topic, biz);
+                    mapBizForkUpdateTopic[cli.first] = topic;
+                    Log("CMQCluster::HandleEvent(CEventMQBizForkUpdate): PostBizForkAssign to fork node[%s]",
+                        cli.second.superNodeID.c_str());
+                }
+            }
+        }
+    }
+
+    return true;
+}
+
+bool CMQCluster::LogEvent(const string& info)
+{
+    cout << "callback to CMQCluster when MQ-EVENT" << info << endl;
+    Log("CMQCluster::LogMQEvent[%s]", info.c_str());
+    return true;
+}
+
+bool CMQCluster::GetForkNodeFork(std::vector<uint256>& forks)
+{
+    forks.clear();
+    vector<storage::CSuperNode> nodes;
+    if (!pBlockChain->FetchSuperNode(nodes, 1 << 1))
+    {
+        Error("CMQCluster::GetForkNodeFork(): failed to fetch fork nodes");
+        return false;
+    }
+
+    if (nodes.empty())
+    {
+        Log("CMQCluster::GetForkNodeFork(): fork nodes have not been enrolled yet");
+        return true;
+    }
+
+    if (NODE_CATEGORY::FORKNODE == catNode && nodes.size() > 1)
+    {
+        Error("CMQCluster::GetForkNodeFork(): fork enrolled by fork node should not be greater than one");
+        return false;
+    }
+
+    forks = std::move(nodes[0].vecOwnedForks);
+
+    return true;
+}
+
+bool CMQCluster::PostBlockRequest(int syncHeight)
+{
+    Log("CMQCluster::PostBlockRequest(): posting request for block #%d", syncHeight);
+
+    if (clientID.empty())
+    {
+        Log("CMQCluster::PostBlockRequest(): enrollment is empty for this fork node");
+        return true;
+    }
+
+    uint256 hash;
+    int height;
+    if (-1 == syncHeight)
+    {
+        int64 ts;
+        uint16 mint;
+        if (!pBlockChain->GetLastBlock(pCoreProtocol->GetGenesisBlockHash(), hash, height, ts, mint))
+        {
+            Error("CMQCluster::PostBlockRequest(): failed to get last block");
+            return false;
+        }
+    }
+    else
+    {
+        if (nRollNum)
+        {
+            boost::unique_lock<boost::mutex> lock(mtxRoll);
+            hash = vLongFork.back();
+        }
+        else
+        {
+            if (!pBlockChain->GetBlockHash(pCoreProtocol->GetGenesisBlockHash(), syncHeight, hash))
+            {
+                Error("CMQCluster::PostBlockRequest(): failed to get specific block");
+                return false;
+            }
+        }
+        height = syncHeight;
+    }
+    Log("CMQCluster::PostBlockRequest(): posting request for block id[%d] hash[%s]", height, hash.ToString().c_str());
+
+    CSyncBlockRequest req;
+    req.ipAddr = ipAddr;
+    req.forkNodeIdLen = clientID.size();
+    req.forkNodeId = clientID;
+    req.forkNum = setBizFork.size();
+    for (auto const& fork : setBizFork)
+    {
+        req.forkList.emplace_back(fork);
+    }
+    req.lastHeight = height;
+    req.lastHash = hash;
+    req.tsRequest = GetTime();
+    req.nonce = 1;
+
+    CBufferPtr spSS(new CBufStream);
+    *spSS.get() << req;
+
+    AppendSendQueue(arrTopic[TOPIC_SUFFIX_REQ_BLOCK], spSS);
+    return true;
+}
+
+bool CMQCluster::PostBizForkAssign(const std::string& topic, const CAssignBizFork& assign)
+{
+    CBufferPtr spSS(new CBufStream);
+    *spSS.get() << assign;
+
+    AppendSendQueue(topic, spSS);
+    return true;
+}
+
+bool CMQCluster::AppendSendQueue(const std::string& topic, CBufferPtr payload)
+{
+    Log("CMQCluster::AppendSendQueue(): appending msg[%s] to sending queue", topic.c_str());
+    {
+        boost::unique_lock<boost::mutex> lock(mtxSend);
+        if (!deqSendBuff.empty())
+        {
+            const auto& b = deqSendBuff.back();
+            if (topic == b.first)
+            {
+                Log("CMQCluster::AppendSendQueue(): flow control for msg[%s] to sending queue", topic.c_str());
+            }
+            else
+            {
+                deqSendBuff.emplace_back(make_pair(topic, payload));
+                Log("CMQCluster::AppendSendQueue(): appended msg[%s] to sending queue", topic.c_str());
+            }
+        }
+        else
+        {
+            deqSendBuff.emplace_back(make_pair(topic, payload));
+            Log("CMQCluster::AppendSendQueue(): appended msg[%s] to sending queue", topic.c_str());
+        }
+        Log("CMQCluster::AppendSendQueue(): there has/have been left [%d] message(s)", deqSendBuff.size());
+    }
+    condSend.notify_one();
+
+    return true;
+}
+
+void CMQCluster::FetchBlock(bool fObliged, int syncHeight)
+{
+    if (fObliged && nReqBlkTimerID != 0)
+    {
+        CancelTimer(nReqBlkTimerID);
+        nReqBlkTimerID = 0;
+    }
+    PostBlockRequest(syncHeight);
+    if (nReqBlkTimerID == 0)
+    {
+        nReqBlkTimerID = SetTimer(FETCH_TIMEOUT, boost::bind(&CMQCluster::RequestBlockTimerFunc, this, _1));
+    }
+}
+
+void CMQCluster::RequestBlockTimerFunc(uint32 nTimer)
+{
+    if (nReqBlkTimerID == nTimer)
+    {
+        if (!PostBlockRequest(-1))
+        {
+            Error("CMQCluster::RequestBlockTimerFunc(): failed to post request");
+        }
+        else
+        {
+            Log("%s: fetching block succeed periodically", __PRETTY_FUNCTION__);
+        }
+        nReqBlkTimerID = SetTimer(FETCH_TIMEOUT,
+                                  boost::bind(&CMQCluster::RequestBlockTimerFunc, this, _1));
+    }
+}
+
+void CMQCluster::OnReceiveMessage(const std::string& topic, CBufStream& payload)
+{
+    Log("CMQCluster::OnReceiveMessage(): Received message from [%s]", topic.c_str());
+    cout << "\nReceived message from [" << topic << "]..." << endl;
+    payload.Dump();
+
+    switch (catNode)
+    {
+    case NODE_CATEGORY::BBCNODE:
+        Error("CMQCluster::OnReceiveMessage(): bbc node should not come here!");
+        return;
+    case NODE_CATEGORY::FORKNODE:
+    {
+        Log("CMQCluster::OnReceiveMessage(): current sync height is [%d] on fork node side", int(lastHeightResp));
+        if (string::npos != topic.find(vecSuffixTopic[TOPIC_SUFFIX_RESP_BLOCK]) && string::npos != topic.find(prefixTopic))
+        { //respond to request block of main chain
+            Log("CMQCluster::OnReceiveMessage(): entering of fork node processing RESP_BLOCK");
+            //unpack payload
+            CSyncBlockResponse resp;
+            try
+            {
+                payload >> resp;
+            }
+            catch (exception& e)
+            {
+                StdError(__PRETTY_FUNCTION__, e.what());
+                Error("CMQCluster::OnReceiveMessage(): failed to unpack respond msg");
+                return;
+            }
+
+            if (-1 == resp.height && resp.isBest)
+            { //has reached the best height for the first time communication,
+                // then set timer to process the following business rather than req/resp model
+                FetchBlock(false, -1);
+                return;
+            }
+            /*
+            if (-2 == resp.height)
+            { //when missing rollback will come here
+                if (nReqBlkTimerID != 0)
+                {
+                    CancelTimer(nReqBlkTimerID);
+                    nReqBlkTimerID = 0;
+                }
+                PostBlockRequest(0); //todo: using checkpoint is better
+                return;
+            }
+*/
+            //notify to add new block
+            Errno err = pDispatcher->AddNewBlock(resp.block);
+            if (err != OK)
+            {
+                Error("CMQCluster::OnReceiveMessage(): failed to add new block (%d) : %s height[%d]\n",
+                      err, ErrorString(err), resp.height);
+                if (ERR_ALREADY_HAVE == err)
+                {
+                    lastHeightResp = resp.height;
+                    //check if there are rollbacked blocks
+                    if (nRollNum)
+                    {
+                        boost::unique_lock<boost::mutex> lock(mtxRoll);
+                        if (vLongFork.size() < nRollNum)
+                        {
+                            vLongFork.emplace_back(resp.hash);
+                        }
+                        else
+                        {
+                            vLongFork.clear();
+                            nRollNum = 0;
+                        }
+                    }
+                    if (!PostBlockRequest(lastHeightResp))
+                    {
+                        Error("CMQCluster::OnReceiveMessage(): failed to post request on response due to duplication");
+                        return;
+                    }
+                }
+                return;
+            }
+            lastHeightResp = resp.height;
+
+            //check if there are rollbacked blocks
+            if (nRollNum)
+            {
+                boost::unique_lock<boost::mutex> lock(mtxRoll);
+                if (vLongFork.size() < nRollNum)
+                {
+                    vLongFork.emplace_back(resp.hash);
+                }
+                else
+                {
+                    vLongFork.clear();
+                    nRollNum = 0;
+                }
+            }
+
+            //iterate to retrieve next one
+
+            if (resp.isBest)
+            { //when reach best height, send request by timer
+                std::atomic_store(&isMainChainBlockBest, true);
+                FetchBlock(false, -1);
+            }
+            else
+            {
+                std::atomic_store(&isMainChainBlockBest, false);
+                // FetchBlock(false, lastHeightResp);
+                PostBlockRequest(lastHeightResp);
+            }
+
+            return;
+        } // end of dealing with response of requesting block
+
+        if (string::npos != topic.find(vecSuffixTopic[TOPIC_SUFFIX_UPDATE_BLOCK]) && string::npos != topic.find(prefixTopic))
+        { //roll back blocks on main chain
+            Log("CMQCluster::OnReceiveMessage(): entering of fork node processing UPDATE_BLOCK");
+            //unpack payload
+            CRollbackBlock rb;
+            try
+            {
+                payload >> rb;
+            }
+            catch (exception& e)
+            {
+                StdError(__PRETTY_FUNCTION__, e.what());
+                Error("CMQCluster::OnReceiveMessage(): failed to unpack rollback msg");
+                return;
+            }
+
+            Log("CMQCluster::OnReceiveMessage(): rbheight[%d] from dpos node with size[%d], "
+                "lastheight[%d] on this fork node",
+                rb.rbHeight, rb.rbSize, int(lastHeightResp));
+
+            if (rb.rbHeight < lastHeightResp)
+            {
+                //cancel request sync timer
+                if (nReqBlkTimerID != 0)
+                {
+                    CancelTimer(nReqBlkTimerID);
+                    nReqBlkTimerID = 0;
+                }
+
+                //empty sending buffer
+                {
+                    boost::unique_lock<boost::mutex> lock(mtxSend);
+                    deqSendBuff.clear();
+                }
+                condSend.notify_one();
+
+                //check hard fork point
+                uint256 hash;
+                if (!pBlockChain->GetBlockHash(pCoreProtocol->GetGenesisBlockHash(), rb.rbHeight, hash))
+                {
+                    Error("CMQCluster::OnReceiveMessage(): failed to get hard fork block hash or dismatch"
+                          "then re-synchronize block from genesis one");
+                    if (!PostBlockRequest(0)) //re-sync from genesis block, todo: prefer checkpoint to this
+                    {
+                        Error("CMQCluster::OnReceiveMessage(): failed to post request while re-sync");
+                    }
+                    return;
+                }
+
+                if (hash != rb.rbHash)
+                {
+                    Error("CMQCluster::OnReceiveMessage(): hashes do not match - rbhash[%s], lasthash[%s]",
+                          rb.rbHash.ToString().c_str(), hash.ToString().c_str());
+                    if (!PostBlockRequest(0)) //re-sync from genesis block, todo: prefer checkpoint to this
+                    {
+                        Error("CMQCluster::OnReceiveMessage(): failed to post request while re-sync");
+                    }
+                    return;
+                }
+
+                bool fMatch = false;
+                Log("CMQCluster::OnReceiveMessage(): rbhash[%s] vs. hash[%s] on this fork node at height[%d]",
+                    rb.rbHash.ToString().c_str(), hash.ToString().c_str(), rb.rbHeight);
+
+                //check blocks in rollback
+                int nShort = 0;
+                for (int i = 0; i < rb.rbSize; ++i)
+                {
+                    if (!pBlockChain->GetBlockHash(pCoreProtocol->GetGenesisBlockHash(),
+                                                   rb.rbHeight + i + 1, hash))
+                    {
+                        if (i != 0)
+                        {
+                            Log("CMQCluster::OnReceiveMessage(): exceed to get rollback block hash idx[%d]", i);
+                            break;
+                        }
+                        else
+                        {
+                            Error("CMQCluster::OnReceiveMessage(): short chain does not match for one on dpos node:1");
+                            return;
+                        }
+                    }
+                    Log("CMQCluster::OnReceiveMessage(): fork node blkhsh[%s] vs. dpos node blkhsh[%s] "
+                        "at height of [%d]",
+                        rb.hashList[i].ToString().c_str(), hash.ToString().c_str(),
+                        rb.rbHeight + i + 1);
+                    if (hash == rb.hashList[i])
+                    {
+                        Log("CMQCluster::OnReceiveMessage(): fork node has not been rolled back yet"
+                            " with hash [%s]",
+                            hash.ToString().c_str());
+                        fMatch = true;
+                        ++nShort;
+                        continue;
+                    }
+                    else
+                    {
+                        Error("CMQCluster::OnReceiveMessage(): short chain does not match for one on dpos node:2");
+                        if (!PostBlockRequest(0)) //re-sync from genesis block
+                        {
+                            Error("CMQCluster::OnReceiveMessage(): failed to post request while re-sync");
+                        }
+                        return;
+                    }
+                }
+                Log("CMQCluster::OnReceiveMessage(): fork node rb[%d] against dpos node rb[%d]", nShort, rb.rbSize);
+
+                //re-request from hard fork point to sync the best chain
+                if (fMatch)
+                {
+                    lastHeightResp = rb.rbHeight;
+                    Log("CMQCluster::OnReceiveMessage(): match to prepare rollback: rb.rbHeight[%d] against lastHeightResp[%d]", rb.rbHeight, int(lastHeightResp));
+                    if (!PostBlockRequest(lastHeightResp))
+                    {
+                        Error("CMQCluster::OnReceiveMessage(): failed to post request on rollback");
+                        nRollNum = std::min(nShort, rb.rbSize);
+                        return;
+                    }
+                    nRollNum = std::min(nShort, rb.rbSize);
+                }
+
+                return;
+            }
+
+            FetchBlock(true, -1);
+
+            return;
+        } // end of dealing with rollback of main chain
+
+        if (string::npos != topic.find(vecSuffixTopic[TOPIC_SUFFIX_ASGN_BIZFORK]) && string::npos != topic.find(prefixTopic))
+        { //receive biz fork list from dpos node by MQ broker
+            Log("CMQCluster::OnReceiveMessage(): entering of fork node processing ASGN_BIZFORK");
+            //unpack payload
+            CAssignBizFork biz;
+            try
+            {
+                payload >> biz;
+            }
+            catch (exception& e)
+            {
+                StdError(__PRETTY_FUNCTION__, e.what());
+                Error("CMQCluster::OnReceiveMessage(): failed to unpack bizfork msg");
+                return;
+            }
+
+            vector<storage::CSuperNode> outers;
+            {
+                boost::unique_lock<boost::mutex> lock(mtxOuter);
+
+                //populate to memory
+                for (auto const& it : biz.mapIpBizFork)
+                {
+                    if (it.first != ipAddr) //filter out one(s) which is/are same as this fork node self - reflected 'mirrored' node ip from dpos node gotten from outer peers through p2p
+                    {
+                        mapOuterNode[it.first].ipAddr = it.first;
+                        mapOuterNode[it.first].nodeCat = 0;
+                        mapOuterNode[it.first].vecOwnedForks = it.second;
+                        outers.push_back(mapOuterNode[it.first]);
+                        Log("CMQCluster::OnReceiveMessage(): adding new outer nodes from mq broker "
+                            "by dpos node succeeded [%s]",
+                            mapOuterNode[it.first].ToString().c_str());
+                        continue;
+                    }
+                    Log("CMQCluster::OnReceiveMessage(): this ip[%s] is a mirror one by outer peers",
+                        storage::CSuperNode::Int2Ip(it.first).c_str());
+                }
+            }
+
+            //save to db storage
+            if (!outers.empty() && !pBlockChain->AddOuterNodes(outers, true))
+            {
+                Error("CMQCluster::OnReceiveMessage(): failed to add new outer nodes "
+                      "from mq broker by dpos node");
+                return;
+            }
+            Log("CMQCluster::OnReceiveMessage(): adding new outer total (%d) nodes from mq broker "
+                "by dpos node succeeded",
+                outers.size());
+
+            //launch connecting those outer nodes if main chain has been best block
+            if (std::atomic_load(&isMainChainBlockBest))
+            {
+                PoolAddBizForkNode(outers);
+            }
+
+            return;
+        } // end of dealing with biz fork assignment
+
+        break;
+    }
+    case NODE_CATEGORY::DPOSNODE:
+    {
+        //unpack payload
+        CSyncBlockRequest req;
+        try
+        {
+            payload >> req;
+        }
+        catch (exception& e)
+        {
+            StdError(__PRETTY_FUNCTION__, e.what());
+            Error("CMQCluster::OnReceiveMessage(): failed to unpack request msg");
+            return;
+        }
+
+        //check if requesting fork node has been enrolled
+        {
+            boost::unique_lock<boost::mutex> lock(mtxCluster);
+
+            auto node = mapActiveMQForkNode.find(req.forkNodeId);
+            if (node == mapActiveMQForkNode.end())
+            {
+                Error("CMQCluster::OnReceiveMessage(): requesting fork node has not enrolled yet");
+                return;
+            }
+            //check if requesting fork node matches the corresponding one enrolled
+            if (node->second.vecOwnedForks.size() != req.forkNum)
+            {
+                Error("CMQCluster::OnReceiveMessage(): requesting fork node number does not match");
+                return;
+            }
+            for (const auto& fork : req.forkList)
+            {
+                auto pos = find(node->second.vecOwnedForks.begin(), node->second.vecOwnedForks.end(), fork);
+                if (pos == node->second.vecOwnedForks.end())
+                {
+                    Error("CMQCluster::OnReceiveMessage(): requesting fork node detailed forks does not match");
+                    return;
+                }
+            }
+        }
+
+        //check height requested
+        int best = pBlockChain->GetBlockCount(pCoreProtocol->GetGenesisBlockHash()) - 1;
+        CSyncBlockResponse resp;
+        if (req.lastHeight > best)
+        {
+            Error("CMQCluster::OnReceiveMessage(): block height owned by fork node [%s]"
+                  "should not be greater than the best one on dpos node",
+                  req.forkNodeId.c_str());
+            return;
+        }
+        else if (req.lastHeight == best)
+        {
+            Log("CMQCluster::OnReceiveMessage(): block height[%d] owned by fork node[%s] "
+                "has reached the best one on dpos node, please wait...",
+                best, req.forkNodeId.c_str());
+            resp.height = -1;
+            resp.hash = uint256();
+            resp.isBest = 1;
+            resp.block = CBlock();
+            resp.blockSize = xengine::GetSerializeSize(resp.block);
+            return;
+        }
+        else
+        {
+            //check height and hash are matched
+            uint256 hash;
+            if (!pBlockChain->GetBlockHash(pCoreProtocol->GetGenesisBlockHash(), req.lastHeight, hash))
+            {
+                Error("CMQCluster::OnReceiveMessage(): failed to get checking height and hash match "
+                      "at height of [%d] with fork node [%s]",
+                      req.lastHeight, req.forkNodeId.c_str());
+                return;
+            }
+            if (hash != req.lastHash)
+            { //cause maybe rollback not in time or in process
+                Log("CMQCluster::OnReceiveMessage(): height and hash do not match hash[%s] vs. req.lastHash[%s] "
+                    "at height of [%d] with fork node [%s]",
+                    hash.ToString().c_str(),
+                    req.lastHash.ToString().c_str(), req.lastHeight, req.forkNodeId.c_str());
+                /*                resp.height = -2;
+                resp.hash = uint256();
+                resp.isBest = 0;
+                resp.block = CBlock();
+                resp.blockSize = xengine::GetSerializeSize(resp.block);*/
+                return;
+            }
+            else
+            {
+                if (!pBlockChain->GetBlockHash(pCoreProtocol->GetGenesisBlockHash(), req.lastHeight + 1, hash))
+                {
+                    Error("CMQCluster::OnReceiveMessage(): failed to get next block hash at height of [%d] "
+                          "with fork node [%s]",
+                          req.lastHeight + 1, req.forkNodeId.c_str());
+                    return;
+                }
+                CBlock block;
+                if (!pBlockChain->GetBlock(hash, block))
+                {
+                    Error("CMQCluster::OnReceiveMessage(): failed to get next block for fork node [%s]",
+                          req.forkNodeId.c_str());
+                    return;
+                }
+
+                //reply block requested
+                resp.height = req.lastHeight + 1;
+                resp.hash = hash;
+                resp.isBest = req.lastHeight + 1 < best
+                                  ? 0
+                                  : 1;
+                Log("CMQCluster::OnReceiveMessage(): request[%d] best[%d] isBest[%d]",
+                    req.lastHeight + 1, best, resp.isBest);
+                resp.blockSize = xengine::GetSerializeSize(block);
+                resp.block = move(block);
+            }
+        }
+
+        CBufferPtr spSS(new CBufStream);
+        *spSS.get() << resp;
+        string topicRsp = prefixTopic + req.forkNodeId + vecSuffixTopic[TOPIC_SUFFIX_RESP_BLOCK];
+        AppendSendQueue(topicRsp, spSS);
+
+        break;
+    }
+    }
+}
+
+class CActionListener : public virtual mqtt::iaction_listener
+{
+    std::string strName;
+
+    void on_failure(const mqtt::token& tok) override
+    {
+        std::cout << strName << " failure";
+        if (tok.get_message_id() != 0)
+            std::cout << " for token: [" << tok.get_message_id() << "]" << std::endl;
+        std::cout << std::endl;
+    }
+
+    void on_success(const mqtt::token& tok) override
+    {
+        std::cout << strName << " success";
+        if (tok.get_message_id() != 0)
+            std::cout << " for token: [" << tok.get_message_id() << "]" << std::endl;
+        auto top = tok.get_topics();
+        if (top && !top->empty())
+            std::cout << "\ttoken topic: '" << (*top)[0] << "', ..." << std::endl;
+        std::cout << std::endl;
+    }
+
+public:
+    CActionListener(const std::string& name)
+      : strName(name) {}
+};
+
+const int RETRY_ATTEMPTS = 3;
+class CMQCallback :
+  public virtual mqtt::callback,
+  public virtual mqtt::iaction_listener
+{
+    mqtt::async_client& asynCli;
+    mqtt::connect_options& connOpts;
+    CMQCluster& mqCluster;
+    uint8 nRetry;
+    CActionListener subListener;
+
+public:
+    CMQCallback(mqtt::async_client& cli, mqtt::connect_options& connOpts, CMQCluster& clusterIn)
+      : asynCli(cli), connOpts(connOpts), mqCluster(clusterIn), nRetry(0), subListener("sublistener") {}
+
+    void reconnect()
+    {
+        std::this_thread::sleep_for(std::chrono::milliseconds(300));
+        try
+        {
+            asynCli.connect(connOpts, nullptr, *this);
+            mqCluster.LogEvent("[reconnect...]");
+        }
+        catch (const mqtt::exception& exc)
+        {
+            cerr << "Error: " << exc.what() << std::endl;
+            mqCluster.Error("[MQTT_reconnect_ERROR!]");
+        }
+        mqCluster.LogEvent("[reconnected]");
+    }
+
+    void on_failure(const mqtt::token& tok) override
+    {
+        cout << "\tListener failure for token: [multiple]"
+             << tok.get_message_id() << endl;
+        mqCluster.LogEvent("[on_failure]");
+        if (++nRetry > RETRY_ATTEMPTS)
+        {
+            mqCluster.Error("[MQTT_retry_to_reconnect_FAILURE!]");
+        }
+        reconnect();
+    }
+
+    void on_success(const mqtt::token& tok) override
+    {
+        cout << "\tListener success for token: [multiple]"
+             << tok.get_message_id() << endl;
+        mqCluster.LogEvent("[on_success]");
+    }
+
+    void connected(const string& cause) override
+    {
+        mqCluster.fConnected = true;
+        cout << "\nConnection success" << endl;
+        if (!cause.empty())
+        {
+            cout << "\tcause: " << cause << endl;
+        }
+        mqCluster.LogEvent("[connected]");
+        if (CMQCluster::NODE_CATEGORY::FORKNODE == mqCluster.catNode)
+        {
+            asynCli.subscribe(mqCluster.arrTopic[CMQCluster::TOPIC_SUFFIX_RESP_BLOCK], CMQCluster::QOS1, nullptr, subListener);
+            cout << "\nSubscribing to topic '" << mqCluster.arrTopic[CMQCluster::TOPIC_SUFFIX_RESP_BLOCK] << "'\n"
+                 << "\tfor client " << mqCluster.clientID
+                 << " using QoS" << CMQCluster::QOS1 << endl;
+
+            asynCli.subscribe(mqCluster.arrTopic[CMQCluster::TOPIC_SUFFIX_UPDATE_BLOCK], CMQCluster::QOS1, nullptr, subListener);
+            cout << "\nSubscribing to topic '" << mqCluster.arrTopic[CMQCluster::TOPIC_SUFFIX_UPDATE_BLOCK] << "'\n"
+                 << "\tfor client " << mqCluster.clientID
+                 << " using QoS" << CMQCluster::QOS1 << endl;
+
+            asynCli.subscribe(mqCluster.arrTopic[CMQCluster::TOPIC_SUFFIX_ASGN_BIZFORK], CMQCluster::QOS1, nullptr, subListener);
+            cout << "\nSubscribing to topic '" << mqCluster.arrTopic[CMQCluster::TOPIC_SUFFIX_ASGN_BIZFORK] << "'\n"
+                 << "\tfor client " << mqCluster.clientID
+                 << " using QoS" << CMQCluster::QOS1 << endl;
+
+            mqCluster.FetchBlock(true, -1);
+        }
+        else if (CMQCluster::NODE_CATEGORY::DPOSNODE == mqCluster.catNode)
+        {
+            asynCli.subscribe(mqCluster.arrTopic[CMQCluster::TOPIC_SUFFIX_REQ_BLOCK], CMQCluster::QOS1, nullptr, subListener);
+            cout << "\nSubscribing to topic '" << mqCluster.arrTopic[CMQCluster::TOPIC_SUFFIX_REQ_BLOCK] << "'\n"
+                 << "\tfor client " << mqCluster.clientID
+                 << " using QoS" << CMQCluster::QOS1 << endl;
+            std::this_thread::sleep_for(std::chrono::milliseconds(50));
+        }
+        cout << endl;
+        mqCluster.LogEvent("[subscribed]");
+        cout << endl;
+    }
+
+    void connection_lost(const string& cause) override
+    {
+        mqCluster.fConnected = false;
+        cout << "\nConnection lost" << endl;
+        if (!cause.empty())
+        {
+            cout << "\tcause: " << cause << endl;
+        }
+        mqCluster.LogEvent("[connection_lost]");
+        nRetry = 0;
+        reconnect();
+    }
+
+    void message_arrived(mqtt::const_message_ptr msg) override
+    {
+        cout << "Message arrived" << endl;
+        cout << "\ttopic: '" << msg->get_topic() << "'" << endl;
+        cout << "\tpayload: '................'\n"
+             << endl;
+        mqCluster.LogEvent("[message_arrived]");
+
+        xengine::CBufStream ss;
+        ss.Write((const char*)&msg->get_payload()[0], msg->get_payload().size());
+        mqCluster.OnReceiveMessage(msg->get_topic(), ss);
+        /*
+        mqCluster.LogEvent("[asyncing...]");
+        std::async(std::launch::async,
+                   [this, &msg]() {
+                       mqCluster.LogEvent("[entered, handling recv...]");
+                       xengine::CBufStream ss;
+                       ss.Write((const char*)&msg->get_payload()[0], msg->get_payload().size());
+                       mqCluster.OnReceiveMessage(msg->get_topic(), ss);
+                       mqCluster.LogEvent("[handled recv]");
+                   });
+        mqCluster.LogEvent("[asynced]");    */
+    }
+
+    void delivery_complete(mqtt::delivery_token_ptr tok) override
+    {
+        cout << "\tDelivery complete for token: ["
+             << (tok ? tok->get_message_id() : -1) << "]" << endl;
+        mqCluster.LogEvent("[delivery_complete]");
+    }
+};
+
+int CMQCluster::ClientAgent(MQ_CLI_ACTION action)
+{
+    try
+    {
+        static mqtt::async_client client(addrBroker, clientID);
+
+        static mqtt::connect_options connOpts;
+        connOpts.set_keep_alive_interval(20);
+        connOpts.set_clean_session(true);
+
+        static mqtt::token_ptr conntok;
+        static mqtt::delivery_token_ptr delitok;
+
+        static CMQCallback cb(client, connOpts, *this);
+
+        switch (action)
+        {
+        case MQ_CLI_ACTION::CONN:
+        {
+            Log("CMQCluster::ClientAgent(): Initializing for connecting to broker[%s]...", addrBroker.c_str());
+            client.set_callback(cb);
+            Log("CMQCluster::ClientAgent(): ...set callback OK");
+            /*            client.set_message_callback([this](mqtt::const_message_ptr msg) {
+                Log("CMQCluster::ClientAgent(): entering lambda");
+                std::cout << msg->get_payload_str() << std::endl;
+                xengine::CBufStream ss;
+                ss.Write((const char*)&msg->get_payload()[0], msg->get_payload().size());
+                OnReceiveMessage(msg->get_topic(), ss);
+            });
+            cout << "  ...OK" << endl;*/
+
+            Log("CMQCluster::ClientAgent(): Connecting...");
+            conntok = client.connect();
+            Log("CMQCluster::ClientAgent(): Waiting for the connection...");
+            conntok->wait();
+            Log("CMQCluster::ClientAgent(): ...Connected OK");
+            break;
+        }
+        case MQ_CLI_ACTION::SUB:
+        {
+            break;
+        }
+        case MQ_CLI_ACTION::PUB:
+        {
+            if (!client.is_connected())
+            {
+                fConnected = false;
+                Error("CMQCluster::ClientAgent(): there is no connection to broker yet");
+                return -1;
+            }
+
+            pair<string, CBufferPtr> buf;
+
+            {
+                boost::unique_lock<boost::mutex> lock(mtxSend);
+                if (deqSendBuff.empty())
+                {
+                    Log("CMQCluster::ClientAgent(): there is no message to send");
+                    return 0;
+                }
+                buf = deqSendBuff.front();
+                Log("CMQCluster::ClientAgent(): there is/are [%d] message(s) waiting to send", deqSendBuff.size());
+            }
+
+            //            while (!deqSendBuff.empty())
+            {
+                //                pair<string, CBufferPtr> buf = deqSendBuff.front();
+                cout << "\nSending message to [" << buf.first << "]..." << endl;
+                //                buf.second->Dump();
+
+                mqtt::message_ptr pubmsg = mqtt::make_message(buf.first, buf.second->GetData(), buf.second->GetSize());
+                pubmsg->set_qos(QOS1);
+                //                pubmsg->set_qos(QOS0);
+                if (string::npos != buf.first.find("AssignBizFork"))
+                {
+                    Log("CMQCluster::ClientAgent(): AssignBizFork so set retained true[%s]", buf.first.c_str());
+                    pubmsg->set_retained(true);
+                }
+                else
+                {
+                    Log("CMQCluster::ClientAgent(): non-AssignBizFork so set retained false[%s]", buf.first.c_str());
+                    pubmsg->set_retained(mqtt::message::DFLT_RETAINED);
+                }
+                //                delitok = client.publish(pubmsg, nullptr, cb);
+                delitok = client.publish(pubmsg);
+                delitok->wait();
+                cout << "\nSent message to [" << buf.first << "]..." << endl;
+                buf.second->Dump();
+                Log("CMQCluster::ClientAgent(): published to [%s] successfully", buf.first.c_str());
+                //                client.publish(pubmsg);
+                /*                if (delitok->wait_for(100))
+                {
+                    Log("CMQCluster::ClientAgent(): delivery token waiting success[%s]", buf.first.c_str());
+                }
+                else
+                {
+                    Error("CMQCluster::ClientAgent(): delivery token waiting fail[%s]", buf.first.c_str());
+                }*/
+
+                //                deqSendBuff.pop_front();
+            }
+
+            {
+                boost::unique_lock<boost::mutex> lock(mtxSend);
+                if (!deqSendBuff.empty())
+                {
+                    Log("CMQCluster::ClientAgent(): pop front of sending deque");
+                    deqSendBuff.pop_front();
+                    Log("CMQCluster::ClientAgent(): there has/have been left [%d] message(s)", deqSendBuff.size());
+                    return 0;
+                }
+                else
+                {
+                    Log("CMQCluster::ClientAgent(): error: it should not be empty here normally, maybe rollback thread clean up sending queue");
+                    return 0;
+                }
+            }
+
+            break;
+        }
+        case MQ_CLI_ACTION::DISCONN:
+        {
+            //cleanup retained message of biz fork assignment
+            if (NODE_CATEGORY::DPOSNODE == catNode)
+            {
+                boost::unique_lock<boost::mutex> lock(mtxCluster);
+                for (auto const& sub : mapBizForkUpdateTopic)
+                {
+                    mqtt::message_ptr pubmsg = mqtt::make_message(sub.second, nullptr, 0);
+                    pubmsg->set_retained(true);
+                    delitok = client.publish(pubmsg);
+                    delitok->wait();
+                    Log("CMQCluster::ClientAgent(): Cleaned up biz fork assignment [%s]", sub.second.c_str());
+                }
+            }
+
+            // Double check that there are no pending tokens
+            auto toks = client.get_pending_delivery_tokens();
+            if (!toks.empty())
+            {
+                Error("CMQCluster::ClientAgent(): There are pending delivery tokens!");
+            }
+
+            // Disconnect
+            Log("CMQCluster::ClientAgent(): Disconnecting from broker...");
+            conntok = client.disconnect();
+            conntok->wait();
+            Log("CMQCluster::ClientAgent(): ...Disconnected OK");
+            break;
+        }
+        }
+    }
+    catch (const mqtt::exception& exc)
+    {
+        cerr << exc.what() << endl;
+        return -2;
+    }
+
+    return 0;
+}
+
+void CMQCluster::MqttThreadFunc()
+{
+    Log("entering thread function of MQTT");
+
+    //wait for super node itself status available
+    if (!fAbort)
+    {
+        boost::unique_lock<boost::mutex> lock(mtxStatus);
+        while (clientID.empty())
+        {
+            Log("there is no enrollment info, waiting for it coming...");
+            condStatus.wait(lock);
+        }
+    }
+
+    if (NODE_CATEGORY::FORKNODE == catNode)
+    {
+        PoolAddBizForkNode();
+    }
+
+    //establish connection
+    ClientAgent(MQ_CLI_ACTION::CONN);
+
+    //subscribe topics
+    ClientAgent(MQ_CLI_ACTION::SUB);
+
+    if (NODE_CATEGORY::FORKNODE == catNode)
+    { //wait for subscribing done before sending request for main chain block
+        //        std::this_thread::sleep_for(std::chrono::milliseconds(200));
+    }
+
+    //publish topics
+    while (!fAbort)
+    {
+        {
+            boost::unique_lock<boost::mutex> lock(mtxSend);
+            while (deqSendBuff.empty() && !fAbort)
+            {
+                condSend.wait(lock);
+            }
+        }
+
+        if (fAbort)
+        {
+            break;
+        }
+
+        int ret = ClientAgent(MQ_CLI_ACTION::PUB);
+        if (0 == ret)
+        {
+            Log("thread function of MQTT: go through an iteration of publishing");
+        }
+        else if (-1 == ret)
+        {
+            Log("thread function of MQTT: waiting for reconnecting...");
+            std::this_thread::sleep_for(std::chrono::milliseconds(200));
+        }
+        else
+        {
+            Error("thread function of MQTT: publish operation is ignormal, leaving MQTT thread with errno[%d]", ret);
+            return;
+        }
+    }
+
+    //disconnect to broker
+    ClientAgent(MQ_CLI_ACTION::DISCONN);
+
+    Log("exiting thread function of MQTT");
+}
+
+bool CMQCluster::PoolAddBizForkNode(const std::vector<storage::CSuperNode>& outers)
+{
+    vector<uint32> ips;
+    if (outers.empty())
+    {
+        boost::unique_lock<boost::mutex> lock(mtxOuter);
+        for (auto const& node : mapOuterNode)
+        {
+            ips.push_back(node.first);
+        }
+    }
+    else
+    {
+        for (auto const& node : outers)
+        {
+            ips.push_back(node.ipAddr);
+        }
+    }
+    if (!ips.empty())
+    {
+        if (!pService->AddBizForkNodes(ips))
+        {
+            Error("CMQCluster::PoolAddBizForkNode(): failed to post add new node msg");
+            return false;
+        }
+        Log("CMQCluster::PoolAddBizForkNode(): posting add new node msg succeeded");
+        return true;
+    }
+    Log("CMQCluster::PoolAddBizForkNode(): there is no outer node for pooling");
+
+    return true;
+}
+
+bool CMQCluster::PostAddNode()
+{
+    vector<storage::CSuperNode> nodes;
+    if (NODE_CATEGORY::DPOSNODE != catNode && !pBlockChain->FetchSuperNode(nodes, 1 << 0))
+    {
+        Error("CMQCluster::PostAddNode(): bbc/fork node failed to fetch outer nodes");
+        return false;
+    }
+    if (nodes.empty())
+    {
+        Log("CMQCluster::PostAddNode(): bbc/fork node has not had outer nodes yet");
+        return true;
+    }
+
+    vector<uint32> ips;
+    for (const auto& node : nodes)
+    {
+        ips.push_back(node.ipAddr);
+    }
+    if (!ips.empty() && !pService->AddBizForkNodes(ips))
+    {
+        Error("CMQCluster::PostAddNode(): bbc/fork node failed to add outer node for supernode");
+        return false;
+    }
+    return true;
+}
+
+void CMQCluster::NodeThreadFunc()
+{
+    if (PostAddNode())
+    {
+        Log("CMQCluster::NodeThreadFunc(): bbc/fork node has posted add p2p connection");
+    }
+    else
+    {
+        Error("CMQCluster::NodeThreadFunc(): bbc/fork node failed to add p2p connection");
+    }
+}
+
+} // namespace bigbang
diff --git a/src/bigbang/mqcluster.h b/src/bigbang/mqcluster.h
new file mode 100644
index 00000000..6f735440
--- /dev/null
+++ b/src/bigbang/mqcluster.h
@@ -0,0 +1,240 @@
+// Copyright (c) 2019-2020 The Bigbang developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BIGBANG_CMQCLUSTER_H
+#define BIGBANG_CMQCLUSTER_H
+
+#include "base.h"
+#include "mqdb.h"
+#include "mqevent.h"
+#include "xengine.h"
+
+namespace bigbang
+{
+
+class CSyncBlockRequest
+{
+    friend xengine::CStream;
+
+public:
+    uint32 ipAddr;
+    uint8 forkNodeIdLen;
+    std::string forkNodeId;
+    uint8 forkNum;
+    std::vector<uint256> forkList;
+    int32 lastHeight;
+    uint256 lastHash;
+    uint32 tsRequest;
+    int16 nonce;
+
+protected:
+    template <typename O>
+    void Serialize(xengine::CStream& s, O& opt)
+    {
+        s.Serialize(ipAddr, opt);
+        s.Serialize(forkNodeIdLen, opt);
+        s.Serialize(forkNodeId, opt);
+        s.Serialize(forkNum, opt);
+        s.Serialize(forkList, opt);
+        s.Serialize(lastHeight, opt);
+        s.Serialize(lastHash, opt);
+        s.Serialize(tsRequest, opt);
+        s.Serialize(nonce, opt);
+    }
+};
+
+class CSyncBlockResponse
+{
+    friend xengine::CStream;
+
+public:
+    int32 height;
+    uint256 hash;
+    uint8 isBest;
+    int32 blockSize;
+    CBlock block;
+
+protected:
+    template <typename O>
+    void Serialize(xengine::CStream& s, O& opt)
+    {
+        s.Serialize(height, opt);
+        s.Serialize(hash, opt);
+        s.Serialize(isBest, opt);
+        s.Serialize(blockSize, opt);
+        s.Serialize(block, opt);
+    }
+};
+
+class CRollbackBlock
+{
+    friend xengine::CStream;
+
+public:
+    int32 rbHeight;
+    uint256 rbHash;
+    int rbSize;
+    std::vector<uint256> hashList;
+
+protected:
+    template <typename O>
+    void Serialize(xengine::CStream& s, O& opt)
+    {
+        s.Serialize(rbHeight, opt);
+        s.Serialize(rbHash, opt);
+        s.Serialize(rbSize, opt);
+        s.Serialize(hashList, opt);
+    }
+};
+
+class CAssignBizFork
+{
+    friend xengine::CStream;
+
+public:
+    std::map<uint32, std::vector<uint256>> mapIpBizFork;
+
+protected:
+    template <typename O>
+    void Serialize(xengine::CStream& s, O& opt)
+    {
+        s.Serialize(mapIpBizFork, opt);
+    }
+};
+
+class IMQCluster : public xengine::IIOModule, virtual public CMQEventListener
+{
+public:
+    IMQCluster()
+      : IIOModule("mqcluster") {}
+    virtual bool GetForkNodeFork(std::vector<uint256>& forks) = 0;
+};
+
+class CMQCluster : public IMQCluster
+{
+    friend class CMQCallback;
+
+    typedef std::shared_ptr<CBufStream> CBufferPtr;
+
+    enum class NODE_CATEGORY : char
+    {
+        BBCNODE = 0,
+        FORKNODE,
+        DPOSNODE
+    };
+    enum class MQ_CLI_ACTION : char
+    {
+        CONN = 0,
+        SUB,
+        PUB,
+        DISCONN
+    };
+    enum
+    {
+        QOS0 = 0,
+        QOS1,
+        QOS2
+    };
+
+public:
+    CMQCluster(int catNodeIn);
+    ~CMQCluster() = default;
+
+    bool LogEvent(const std::string& info);
+    bool GetForkNodeFork(std::vector<uint256>& forks) override;
+
+protected:
+    bool HandleInitialize() override;
+    void HandleDeinitialize() override;
+    bool HandleInvoke() override;
+    void HandleHalt() override;
+
+    bool HandleEvent(CEventMQSyncBlock& eventMqSyncBlock) override;
+    bool HandleEvent(CEventMQChainUpdate& eventMqUpdateChain) override;
+    bool HandleEvent(CEventMQEnrollUpdate& eventMqUpdateEnroll) override;
+    bool HandleEvent(CEventMQAgreement& eventMqAgreement) override;
+    bool HandleEvent(CEventMQBizForkUpdate& eventMqBizFork) override;
+
+protected:
+    mutable boost::shared_mutex rwAccess;
+    ICoreProtocol* pCoreProtocol;
+    IBlockChain* pBlockChain;
+    IDispatcher* pDispatcher;
+    IService* pService;
+    IForkManager* pForkManager;
+
+    boost::mutex mutex;
+    boost::condition_variable condMQ;
+    xengine::CThread thrMqttClient;
+    xengine::CThread thrPostAddBizNode;
+
+private:
+    bool PostBlockRequest(int syncHeight = -1);
+    bool PostBizForkAssign(const std::string& topic, const CAssignBizFork& assign);
+    bool AppendSendQueue(const std::string& topic, CBufferPtr payload);
+    void FetchBlock(bool fObliged, int syncHeight);
+    void RequestBlockTimerFunc(uint32 nTimer);
+    void OnReceiveMessage(const std::string& topic, CBufStream& payload);
+    int ClientAgent(MQ_CLI_ACTION action);
+    void MqttThreadFunc();
+    void NodeThreadFunc();
+    bool PoolAddBizForkNode(const std::vector<storage::CSuperNode>& outers = std::vector<storage::CSuperNode>());
+    bool PostAddNode();
+
+    bool fAbort;
+    std::string addrBroker;
+    std::string dposNodeCliID;
+    //    const std::string prefixTopic = "Cluster01/";
+    std::string prefixTopic;
+    enum
+    {
+        TOPIC_SUFFIX_REQ_BLOCK = 0,
+        TOPIC_SUFFIX_RESP_BLOCK = 1,
+        TOPIC_SUFFIX_UPDATE_BLOCK = 2,
+        TOPIC_SUFFIX_ASGN_BIZFORK = 3,
+        TOPIC_SUFFIX_MAX
+    };
+    const std::vector<std::string> vecSuffixTopic = {
+        "/SyncBlockReq",
+        "/SyncBlockResp",
+        "/UpdateBlock",
+        "/AssignBizFork"
+    };
+
+    NODE_CATEGORY catNode;
+
+    std::array<std::string, TOPIC_SUFFIX_MAX> arrTopic; //shared by both dpos and fork node
+
+    boost::mutex mtxStatus;
+    boost::condition_variable condStatus;
+    std::string clientID;
+    uint32 ipAddr;
+    std::set<uint256> setBizFork;
+    std::atomic_bool isMainChainBlockBest;
+    std::atomic_bool fConnected;
+
+    boost::mutex mtxCluster;
+    std::map<string, storage::CSuperNode> mapActiveMQForkNode; //only for dpos node
+    boost::mutex mtxOuter;
+    std::map<uint32, storage::CSuperNode> mapOuterNode;       //for dpos/fork node
+    std::map<std::string, std::string> mapBizForkUpdateTopic; //only for dpos node
+
+    boost::mutex mtxSend;
+    boost::condition_variable condSend;
+    std::deque<std::pair<std::string, CBufferPtr>> deqSendBuff; //topic vs. payload
+    boost::shared_mutex rwRecv;
+    boost::condition_variable condRecv;
+    std::deque<std::pair<std::string, xengine::CBufStream>> deqRecvBuff; //topic vs. payload
+
+    std::atomic<int> lastHeightResp;
+    std::atomic<uint32> nReqBlkTimerID;
+
+    boost::mutex mtxRoll;
+    std::vector<uint256> vLongFork;
+    std::atomic<int> nRollNum;
+};
+
+} // namespace bigbang
+
+#endif //BIGBANG_CMQCLUSTER_H
diff --git a/src/bigbang/mqevent.h b/src/bigbang/mqevent.h
new file mode 100644
index 00000000..3025287a
--- /dev/null
+++ b/src/bigbang/mqevent.h
@@ -0,0 +1,49 @@
+// Copyright (c) 2019-2020 The Bigbang developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BIGBANG_MQEVENT_H
+#define BIGBANG_MQEVENT_H
+
+#include "xengine.h"
+#include "struct.h"
+
+using namespace xengine;
+
+namespace bigbang
+{
+
+enum
+{
+    EVENT_MQ_BASE = EVENT_USER_BASE,
+    EVENT_MQ_SYNCBLOCK,
+    EVENT_MQ_UPDATEBLOCK,   //dpos node deliver rollback block
+    EVENT_MQ_ENROLLUPDATE,
+    EVENT_MQ_AGREEMENT,
+    EVENT_MQ_UPDATEBIZFORK
+};
+
+class CMQEventListener;
+#define TYPE_MQEVENT(type, body) \
+    CEventCategory<type, CMQEventListener, body, CNil>
+
+typedef TYPE_MQEVENT(EVENT_MQ_SYNCBLOCK, std::string) CEventMQSyncBlock;
+typedef TYPE_MQEVENT(EVENT_MQ_UPDATEBLOCK, CMqRollbackUpdate) CEventMQChainUpdate;
+typedef TYPE_MQEVENT(EVENT_MQ_ENROLLUPDATE, CMqSuperNodeUpdate) CEventMQEnrollUpdate;
+typedef TYPE_MQEVENT(EVENT_MQ_AGREEMENT, CDelegateAgreement) CEventMQAgreement;
+typedef TYPE_MQEVENT(EVENT_MQ_UPDATEBIZFORK, storage::CForkKnownIPSet) CEventMQBizForkUpdate;
+
+class CMQEventListener : virtual public CEventListener
+{
+public:
+    virtual ~CMQEventListener() {}
+    DECLARE_EVENTHANDLER(CEventMQSyncBlock);
+    DECLARE_EVENTHANDLER(CEventMQChainUpdate);
+    DECLARE_EVENTHANDLER(CEventMQEnrollUpdate);
+    DECLARE_EVENTHANDLER(CEventMQAgreement);
+    DECLARE_EVENTHANDLER(CEventMQBizForkUpdate);
+};
+
+} // namespace bigbang
+
+#endif //BIGBANG_MQEVENT_H
diff --git a/src/bigbang/netchn.cpp b/src/bigbang/netchn.cpp
index d388ceb5..949ab3af 100644
--- a/src/bigbang/netchn.cpp
+++ b/src/bigbang/netchn.cpp
@@ -5,6 +5,7 @@
 #include "netchn.h"
 
 #include <boost/bind.hpp>
+#include <defs.h>
 
 #include "schedule.h"
 
@@ -57,7 +58,7 @@ void CNetChannelPeer::CNetChannelPeerFork::ClearExpiredTx()
 
 bool CNetChannelPeer::IsSynchronized(const uint256& hashFork) const
 {
-    map<uint256, CNetChannelPeerFork>::const_iterator it = mapSubscribedFork.find(hashFork);
+    auto it = mapSubscribedFork.find(hashFork);
     if (it != mapSubscribedFork.end())
     {
         return it->second.fSynchronized;
@@ -67,7 +68,7 @@ bool CNetChannelPeer::IsSynchronized(const uint256& hashFork) const
 
 bool CNetChannelPeer::SetSyncStatus(const uint256& hashFork, bool fSync, bool& fInverted)
 {
-    map<uint256, CNetChannelPeerFork>::iterator it = mapSubscribedFork.find(hashFork);
+    auto it = mapSubscribedFork.find(hashFork);
     if (it != mapSubscribedFork.end())
     {
         fInverted = (it->second.fSynchronized != fSync);
@@ -79,7 +80,7 @@ bool CNetChannelPeer::SetSyncStatus(const uint256& hashFork, bool fSync, bool& f
 
 void CNetChannelPeer::AddKnownTx(const uint256& hashFork, const vector<uint256>& vTxHash, size_t nTotalSynTxCount)
 {
-    map<uint256, CNetChannelPeerFork>::iterator it = mapSubscribedFork.find(hashFork);
+    auto it = mapSubscribedFork.find(hashFork);
     if (it != mapSubscribedFork.end())
     {
         it->second.AddKnownTx(vTxHash, nTotalSynTxCount);
@@ -88,7 +89,7 @@ void CNetChannelPeer::AddKnownTx(const uint256& hashFork, const vector<uint256>&
 
 bool CNetChannelPeer::MakeTxInv(const uint256& hashFork, const vector<uint256>& vTxPool, vector<network::CInv>& vInv)
 {
-    map<uint256, CNetChannelPeerFork>::iterator it = mapSubscribedFork.find(hashFork);
+    auto it = mapSubscribedFork.find(hashFork);
     if (it != mapSubscribedFork.end())
     {
         CNetChannelPeerFork& peerFork = it->second;
@@ -109,7 +110,7 @@ bool CNetChannelPeer::MakeTxInv(const uint256& hashFork, const vector<uint256>&
                 }
                 else if (!peerFork.IsKnownTx(txid))
                 {
-                    vInv.push_back(network::CInv(network::CInv::MSG_TX, txid));
+                    vInv.emplace_back(network::CInv(network::CInv::MSG_TX, txid));
                     vTxHash.push_back(txid);
                 }
             }
@@ -140,7 +141,9 @@ CNetChannel::CNetChannel()
     pService = nullptr;
     pDispatcher = nullptr;
     pConsensus = nullptr;
+    pMQCluster = nullptr;
     fStartIdlePushTxTimer = false;
+    nNodeCat = NODE_CAT_BBCNODE;
 }
 
 CNetChannel::~CNetChannel()
@@ -191,6 +194,12 @@ bool CNetChannel::HandleInitialize()
         return false;
     }
 
+    if (!GetObject("mqcluster", pMQCluster))
+    {
+        Error("Failed to request mqcluster");
+        return false;
+    }
+
     return true;
 }
 
@@ -203,6 +212,7 @@ void CNetChannel::HandleDeinitialize()
     pService = nullptr;
     pDispatcher = nullptr;
     pConsensus = nullptr;
+    pMQCluster = nullptr;
 }
 
 bool CNetChannel::HandleInvoke()
@@ -212,6 +222,7 @@ bool CNetChannel::HandleInvoke()
         nTimerPushTx = 0;
         fStartIdlePushTxTimer = false;
     }
+    nNodeCat = dynamic_cast<const CBasicConfig*>(Config())->nCatOfNode;
     return network::INetChannel::HandleInvoke();
 }
 
@@ -251,7 +262,7 @@ int CNetChannel::GetPrimaryChainHeight()
 bool CNetChannel::IsForkSynchronized(const uint256& hashFork) const
 {
     boost::shared_lock<boost::shared_mutex> rlock(rwNetPeer);
-    map<uint256, set<uint64>>::const_iterator it = mapUnsync.find(hashFork);
+    auto it = mapUnsync.find(hashFork);
     return (it == mapUnsync.end() || (*it).second.empty());
 }
 
@@ -271,13 +282,13 @@ void CNetChannel::BroadcastBlockInv(const uint256& hashFork, const uint256& hash
     }
 
     network::CEventPeerInv eventInv(0, hashFork);
-    eventInv.data.push_back(network::CInv(network::CInv::MSG_BLOCK, hashBlock));
+    eventInv.data.emplace_back(network::CInv(network::CInv::MSG_BLOCK, hashBlock));
     {
         boost::shared_lock<boost::shared_mutex> rlock(rwNetPeer);
-        for (map<uint64, CNetChannelPeer>::iterator it = mapPeer.begin(); it != mapPeer.end(); ++it)
+        for (auto const& p : mapPeer)
         {
-            uint64 nNonce = (*it).first;
-            if (!setKnownPeer.count(nNonce) && (*it).second.IsSubscribed(hashFork))
+            uint64 nNonce = p.first;
+            if (!setKnownPeer.count(nNonce) && p.second.IsSubscribed(hashFork))
             {
                 eventInv.nNonce = nNonce;
                 pPeerNet->DispatchEvent(&eventInv);
@@ -315,21 +326,33 @@ void CNetChannel::SubscribeFork(const uint256& hashFork, const uint64& nNonce)
         boost::recursive_mutex::scoped_lock scoped_lock(mtxSched);
         if (!mapSched.insert(make_pair(hashFork, CSchedule())).second)
         {
-            StdLog("NetChannel", "SubscribeFork: mapSched insert fail, hashFork: %s", hashFork.GetHex().c_str());
+            StdError("NetChannel", "SubscribeFork: mapSched insert fail, hashFork: %s", hashFork.GetHex().c_str());
             return;
         }
         StdLog("NetChannel", "SubscribeFork: mapSched insert success, hashFork: %s", hashFork.GetHex().c_str());
     }
 
+    if (hashFork == pCoreProtocol->GetGenesisBlockHash() && NODE_CAT_FORKNODE == nNodeCat)
+    {
+        StdLog("NetChannel", "SubscribeFork: succeed in filtering the main chain for fork nodes with nonce[%d]", nNonce);
+        return;
+    }
+
+    if (hashFork != pCoreProtocol->GetGenesisBlockHash() && NODE_CAT_DPOSNODE == nNodeCat)
+    {
+        StdLog("NetChannel", "SubscribeFork: succeed in filtering biz chains for dpos nodes with nonce[%d]", nNonce);
+        return;
+    }
+
     vector<uint64> vPeerNonce;
     network::CEventPeerSubscribe eventSubscribe(0ULL, pCoreProtocol->GetGenesisBlockHash());
     eventSubscribe.data.push_back(hashFork);
     {
         boost::shared_lock<boost::shared_mutex> rlock(rwNetPeer);
-        for (map<uint64, CNetChannelPeer>::iterator it = mapPeer.begin(); it != mapPeer.end(); ++it)
+        for (const auto& p : mapPeer)
         {
-            vPeerNonce.push_back((*it).first);
-            eventSubscribe.nNonce = (*it).first;
+            vPeerNonce.push_back(p.first);
+            eventSubscribe.nNonce = p.first;
             pPeerNet->DispatchEvent(&eventSubscribe);
         }
     }
@@ -360,9 +383,9 @@ void CNetChannel::UnsubscribeFork(const uint256& hashFork)
     eventUnsubscribe.data.push_back(hashFork);
     {
         boost::shared_lock<boost::shared_mutex> rlock(rwNetPeer);
-        for (map<uint64, CNetChannelPeer>::iterator it = mapPeer.begin(); it != mapPeer.end(); ++it)
+        for (const auto& p : mapPeer)
         {
-            eventUnsubscribe.nNonce = (*it).first;
+            eventUnsubscribe.nNonce = p.first;
             pPeerNet->DispatchEvent(&eventUnsubscribe);
         }
     }
@@ -545,31 +568,104 @@ bool CNetChannel::AddCacheLocalPowBlock(const CBlock& block)
     return ret;
 }
 
+void CNetChannel::DispatchGetBizForksEvent(const vector<uint256>& bizForks)
+{
+    map<uint64, vector<uint256>> mapRequest;
+    for (const auto& hashFork : bizForks)
+    {
+        boost::shared_lock<boost::shared_mutex> rlock(rwNetPeer);
+        for (auto const& p : mapPeer)
+        {
+            if (p.second.IsSubscribed(hashFork))
+            {
+                uint64 nNonce = p.first;
+                mapRequest[nNonce].push_back(hashFork);
+            }
+        }
+    }
+    for (const auto& req : mapRequest)
+    {
+        uint64 nNonce = req.first;
+        network::CEventPeerGetBizForks eventGetBiz(nNonce);
+        eventGetBiz.data.assign(req.second.begin(), req.second.end());
+        pPeerNet->DispatchEvent(&eventGetBiz);
+        StdLog("NetChannel", "DispatchGetBizForksEvent: request for bizforks to peer[%s]", GetPeerAddressInfo(nNonce).c_str());
+    }
+}
+
+void CNetChannel::BroadcastBizForks(const uint32& nIP, const vector<uint256>& bizForks)
+{
+    map<uint64, pair<uint256, uint32>> mapNote;
+    for (const auto& hashFork : bizForks)
+    {
+        boost::shared_lock<boost::shared_mutex> rlock(rwNetPeer);
+        for (auto const& p : mapPeer)
+        {
+            if (p.second.IsSubscribed(hashFork))
+            {
+                uint64 nNonce = p.first;
+                mapNote.insert(make_pair(nNonce, make_pair(hashFork, nIP)));
+                StdLog("NetChannel", "BroadcastBizForks: peer[%ld] has subscribed fork[%s]", nNonce,
+                       hashFork.ToString().c_str());
+            }
+        }
+    }
+    StdLog("NetChannel", "BroadcastBizForks: mapNote.size()[%d] for nIP[%d]", mapNote.size(), nIP);
+    for (const auto& peer : mapNote)
+    {
+        uint64 nNonce = peer.first;
+        network::CEventPeerBizForks eventBiz(nNonce);
+        network::CBizFork& biz = eventBiz.data;
+        vector<uint32> vIP;
+        vIP.push_back(peer.second.second);
+        biz.mapFork[peer.second.first] = move(vIP);
+        pPeerNet->DispatchEvent(&eventBiz);
+        StdLog("NetChannel", "BroadcastBizForks: broadcast biz[%s]ip[%d] to peer[%s]", peer.second.first.ToString().c_str(),
+               peer.second.second, GetPeerAddressInfo(nNonce).c_str());
+    }
+}
+
 bool CNetChannel::HandleEvent(network::CEventPeerActive& eventActive)
 {
     uint64 nNonce = eventActive.nNonce;
     {
         boost::unique_lock<boost::shared_mutex> wlock(rwNetPeer);
-        mapPeer[nNonce] = CNetChannelPeer(eventActive.data.nService, eventActive.data, pCoreProtocol->GetGenesisBlockHash());
-        mapUnsync[pCoreProtocol->GetGenesisBlockHash()].insert(nNonce);
+        if (eventActive.data.nService & network::NODE_SUPERNODE || NODE_CAT_FORKNODE == nNodeCat)
+        {
+            mapPeer[nNonce] = CNetChannelPeer(eventActive.data.nService, eventActive.data, uint256());
+        }
+        else
+        {
+            mapPeer[nNonce] = CNetChannelPeer(eventActive.data.nService, eventActive.data, pCoreProtocol->GetGenesisBlockHash());
+            mapUnsync[pCoreProtocol->GetGenesisBlockHash()].insert(nNonce);
+        }
     }
     StdLog("NetChannel", "CEventPeerActive: peer: %s", GetPeerAddressInfo(nNonce).c_str());
     if ((eventActive.data.nService & network::NODE_NETWORK))
     {
+        if (NODE_CAT_FORKNODE != nNodeCat)
         {
-            boost::recursive_mutex::scoped_lock scoped_lock(mtxSched);
-            DispatchGetBlocksEvent(nNonce, pCoreProtocol->GetGenesisBlockHash());
+            {
+                boost::recursive_mutex::scoped_lock scoped_lock(mtxSched);
+                DispatchGetBlocksEvent(nNonce, pCoreProtocol->GetGenesisBlockHash());
+            }
+            BroadcastTxInv(pCoreProtocol->GetGenesisBlockHash());
+        }
+        else
+        {
+            StdLog("NetChannel", "CEventPeerActive: succeeded in filtering to get main chain from fork node stemmed from peer[%s]",
+                   GetPeerAddressInfo(nNonce).c_str());
         }
-        BroadcastTxInv(pCoreProtocol->GetGenesisBlockHash());
 
         network::CEventPeerSubscribe eventSubscribe(nNonce, pCoreProtocol->GetGenesisBlockHash());
         {
             boost::recursive_mutex::scoped_lock scoped_lock(mtxSched);
-            for (map<uint256, CSchedule>::iterator it = mapSched.begin(); it != mapSched.end(); ++it)
+            for (auto const& sch : mapSched)
             {
-                if ((*it).first != pCoreProtocol->GetGenesisBlockHash())
+                if (sch.first != pCoreProtocol->GetGenesisBlockHash())
                 {
-                    eventSubscribe.data.push_back((*it).first);
+                    eventSubscribe.data.push_back(sch.first);
+                    StdLog("NetChannel", "CEventPeerActive: prepare to subscribe fork[%s]", sch.first.ToString().c_str());
                 }
             }
         }
@@ -577,6 +673,66 @@ bool CNetChannel::HandleEvent(network::CEventPeerActive& eventActive)
         {
             pPeerNet->DispatchEvent(&eventSubscribe);
         }
+
+        network::CEventPeerGetBizForks eventGetBiz(nNonce);
+        switch (nNodeCat)
+        {
+        case NODE_CAT_FORKNODE:
+        {
+            // forks enrolled by super node
+            if (!pMQCluster->GetForkNodeFork(eventGetBiz.data))
+            {
+                StdError("NetChannel", "CEventPeerActive: GetForkNodeFork failed");
+                return true;
+            }
+        } // deliberately provide no break in order to fall down sharing operations
+        case NODE_CAT_BBCNODE:
+        {
+            // forks configured by options
+            vector<string> vFork;
+            vector<string> vGroup;
+            vFork = dynamic_cast<const CForkConfigOption*>(Config())->vFork;
+            vGroup = dynamic_cast<const CForkConfigOption*>(Config())->vGroup;
+            if (vFork.end() != find(vFork.begin(), vFork.end(), "any")
+                || vGroup.end() != find(vGroup.begin(), vGroup.end(), pCoreProtocol->GetGenesisBlockHash().ToString()))
+            {
+                // send request for all biz forks while set fork filter as "any"
+                StdLog("NetChannel", "CEventPeerActive: watched fork as any or watched group as genesis");
+                eventGetBiz.data.clear();
+                break;
+            }
+            {
+                boost::recursive_mutex::scoped_lock scoped_lock(mtxSched);
+                for (auto const& sched : mapSched)
+                {
+                    if (sched.first == pCoreProtocol->GetGenesisBlockHash())
+                    {
+                        continue;
+                    }
+                    eventGetBiz.data.push_back(sched.first);
+                    StdLog("NetChannel", "CEventPeerActive: prepare to submit request for fork[%s]",
+                           sched.first.ToString().c_str());
+                }
+            }
+            if (eventGetBiz.data.empty())
+            {
+                StdLog("NetChannel", "CEventPeerActive: no biz fork needed to fetch, so bypass getbizforks");
+                NotifyPeerUpdate(nNonce, true, eventActive.data);
+                return true;
+            }
+            // remove duplicated items
+            sort(eventGetBiz.data.begin(), eventGetBiz.data.end());
+            auto it = unique(eventGetBiz.data.begin(), eventGetBiz.data.end());
+            eventGetBiz.data.erase(it, eventGetBiz.data.end());
+        }
+        break;
+        case NODE_CAT_DPOSNODE:
+        {
+            // send request for all biz forks as a dpos node
+            eventGetBiz.data.clear();
+        }
+        }
+        pPeerNet->DispatchEvent(&eventGetBiz);
     }
     NotifyPeerUpdate(nNonce, true, eventActive.data);
     return true;
@@ -588,22 +744,22 @@ bool CNetChannel::HandleEvent(network::CEventPeerDeactive& eventDeactive)
     StdLog("NetChannel", "CEventPeerDeactive: peer: %s", GetPeerAddressInfo(nNonce).c_str());
     {
         boost::recursive_mutex::scoped_lock scoped_lock(mtxSched);
-        for (map<uint256, CSchedule>::iterator it = mapSched.begin(); it != mapSched.end(); ++it)
+        for (auto& sch : mapSched)
         {
-            CSchedule& sched = (*it).second;
+            CSchedule& sched = sch.second;
             set<uint64> setSchedPeer;
             sched.RemovePeer(nNonce, setSchedPeer);
 
             for (const uint64 nNonceSched : setSchedPeer)
             {
-                SchedulePeerInv(nNonceSched, (*it).first, sched);
+                SchedulePeerInv(nNonceSched, sch.first, sched);
             }
         }
     }
     {
         boost::unique_lock<boost::shared_mutex> wlock(rwNetPeer);
 
-        map<uint64, CNetChannelPeer>::iterator it = mapPeer.find(nNonce);
+        auto it = mapPeer.find(nNonce);
         if (it != mapPeer.end())
         {
             for (auto& subFork : (*it).second.mapSubscribedFork)
@@ -618,28 +774,268 @@ bool CNetChannel::HandleEvent(network::CEventPeerDeactive& eventDeactive)
     return true;
 }
 
+bool CNetChannel::HandleEvent(network::CEventPeerGetBizForks& eventGetBizForks)
+{
+    uint64 nNonce = eventGetBizForks.nNonce;
+    vector<uint256>& bizForks = eventGetBizForks.data;
+    for (auto const& f : bizForks)
+    {
+        StdLog("NetChannel", "CEventPeerGetBizForks: peer[%s] is asking for fork[%s]",
+               GetPeerAddressInfo(nNonce).c_str(), f.ToString().c_str());
+    }
+    StdLog("NetChannel", "CEventPeerGetBizForks: peer[%s] is asking for total [%d] biz fork(s)",
+           GetPeerAddressInfo(nNonce).c_str(), bizForks.size());
+
+    vector<storage::CSuperNode> nodes;
+    if (!pBlockChain->ListSuperNode(nodes))
+    {
+        StdError("NetChannel", "CEventPeerGetBizForks: ListSuperNode failed");
+        return false;
+    }
+
+    //filter out dpos node itself
+    for (auto it = nodes.begin(); it != nodes.end(); ++it)
+    {
+        if (0 == it->ipAddr)
+        {
+            nodes.erase(it);
+            break;
+        }
+    }
+
+    StdLog("NetChannel", "CEventPeerGetBizForks: there is/are [%d] biz fork node(s) all", nodes.size());
+    for (auto const& node : nodes)
+    {
+        StdLog("NetChannel", "CEventPeerGetBizForks: biz fork as [%s]", node.ToString().c_str());
+    }
+
+    if (nodes.empty())
+    {
+        StdLog("NetChannel", "CEventPeerGetBizForks: there has been no biz fork till now.");
+        return true;
+    }
+
+    storage::CForkKnownIPSet setForkIp;
+    for (auto const& node : nodes)
+    {
+        for (auto const& fork : node.vecOwnedForks)
+        {
+            setForkIp.emplace(storage::CForkKnownIP(fork, node.ipAddr));
+        }
+    }
+
+    if (bizForks.empty())
+    { //fetch all to acquiring peer of dpos/bbc node
+        map<uint256, vector<uint32>> mapForkIps;
+        const storage::CForkKnownIpSetById& idxForkID = setForkIp.get<0>();
+        for (auto const& it : idxForkID)
+        {
+            mapForkIps[it.forkID].emplace_back(it.nodeIP);
+        }
+        StdLog("NetChannel", "CEventPeerGetBizForks: peer asked for all [%d] biz fork(s)", mapForkIps.size());
+        for (auto& it : mapForkIps)
+        {
+            auto& ips = it.second;
+            sort(ips.begin(), ips.end());
+            auto last = unique(ips.begin(), ips.end());
+            ips.erase(last, ips.end());
+            StdLog("NetChannel", "CEventPeerGetBizForks: peer asked for biz fork[%s] with [%d] IP(s)",
+                   it.first.ToString().c_str(), ips.size());
+            for (auto const& i : ips)
+            {
+                StdLog("NetChannel", "CEventPeerGetBizForks: IP[%s]", storage::CSuperNode::Int2Ip(i).c_str());
+            }
+        }
+
+        network::CEventPeerBizForks eventFork(nNonce);
+        eventFork.data = mapForkIps;
+        pPeerNet->DispatchEvent(&eventFork);
+
+        return true;
+    }
+
+    for (auto const& fork : bizForks)
+    { //fetch matched biz fork(s) to acquiring peer of fork node or bbc node
+        map<uint256, vector<uint32>> mapForkIps;
+        const storage::CForkKnownIpSetById& idxForkID = setForkIp.get<0>();
+        auto itBegin = idxForkID.equal_range(fork).first;
+        auto itEnd = idxForkID.equal_range(fork).second;
+        while (itBegin != itEnd)
+        {
+            mapForkIps[fork].emplace_back(itBegin->nodeIP);
+            ++itBegin;
+        }
+        StdLog("NetChannel", "CEventPeerGetBizForks: peer asked for [%d] biz fork(s) partly", mapForkIps.size());
+        for (auto& it : mapForkIps)
+        {
+            auto& ips = it.second;
+            sort(ips.begin(), ips.end());
+            auto last = unique(ips.begin(), ips.end());
+            ips.erase(last, ips.end());
+            StdLog("NetChannel", "CEventPeerGetBizForks: peer asked for biz fork[%s] with [%d] IP(s)",
+                   it.first.ToString().c_str(), ips.size());
+            for (auto const& i : ips)
+            {
+                StdLog("NetChannel", "CEventPeerGetBizForks: IP[%s]", storage::CSuperNode::Int2Ip(i).c_str());
+            }
+        }
+
+        if (mapForkIps.empty())
+        {
+            StdLog("NetChannel", "CEventPeerGetBizForks: there is no matched biz fork to feedback, "
+                                 "so bypass bizforks to peer of bbc or fork node");
+            return true;
+        }
+
+        network::CEventPeerBizForks eventFork(nNonce);
+        eventFork.data = mapForkIps;
+        pPeerNet->DispatchEvent(&eventFork);
+    }
+
+    return true;
+}
+
+bool CNetChannel::HandleEvent(network::CEventPeerBizForks& eventBizForks)
+{
+    uint64 nNonce = eventBizForks.nNonce;
+    map<uint256, vector<uint32>> mapForkIps = eventBizForks.data.mapFork;
+
+    StdLog("NetChannel", "CEventPeerBizForks: peer[%s] has fed total [%d] biz fork(s)",
+           GetPeerAddressInfo(nNonce).c_str(), mapForkIps.size());
+
+    if (mapForkIps.empty())
+    {
+        StdLog("NetChannel", "CEventPeerBizForks: there is no fork to be provided");
+        return true;
+    }
+
+    storage::CForkKnownIPSet setForkIp;
+    for (auto const& fork : mapForkIps)
+    {
+        StdLog("NetChannel", "CEventPeerBizForks: peer[%s] is feeding total [%d] IPs for fork[%s]",
+               GetPeerAddressInfo(nNonce).c_str(), fork.second.size(), fork.first.ToString().c_str());
+        for (auto const ip : fork.second)
+        {
+            StdLog("NetChannel", "CEventPeerBizForks: peer[%s] is feeding IP[%s] for fork[%s]",
+                   GetPeerAddressInfo(nNonce).c_str(), storage::CSuperNode::Int2Ip(ip).c_str(),
+                   fork.first.ToString().c_str());
+            setForkIp.emplace(storage::CForkKnownIP(fork.first, ip));
+        }
+    }
+
+    map<uint32, vector<uint256>> mapIpForks;
+    const storage::CForkKnownIpSetByIp& idxNodeID = setForkIp.get<1>();
+    for (auto const& it : idxNodeID)
+    {
+        mapIpForks[it.nodeIP].push_back(it.forkID);
+    }
+
+    vector<storage::CSuperNode> nodes;
+    for (auto const& it : mapIpForks)
+    {
+        nodes.emplace_back(storage::CSuperNode(storage::CLIENT_ID_OUT_OF_MQ_CLUSTER, it.first, it.second, 0));
+    }
+
+    if (!pBlockChain->AddOuterNodes(nodes, NODE_CAT_BBCNODE != nNodeCat))
+    {
+        StdError("NetChannel", "CEventPeerBizForks: AddOuterNodes failed with sum of [%d]", nodes.size());
+        return true;
+    }
+    StdLog("NetChannel", "CEventPeerBizForks: AddOuterNodes succeeded with sum of [%d]", nodes.size());
+
+    //if dpos node self, dispatch them to fork nodes by MQ later; if this is a fork node, just notify it.
+    if (NODE_CAT_DPOSNODE == nNodeCat || NODE_CAT_FORKNODE == nNodeCat)
+    {
+        auto pEvent = new CEventMQBizForkUpdate(nNonce);
+        if (pEvent != nullptr)
+        {
+            pEvent->data = setForkIp;
+            pMQCluster->PostEvent(pEvent);
+            StdLog("NetChannel", "CEventPeerBizForks: peer[%s] has posted biz forks "
+                                 "with total [%d] ip(s), [%d] fork(s)",
+                   GetPeerAddressInfo(nNonce).c_str(), mapIpForks.size(), mapForkIps.size());
+        }
+        return true;
+    }
+
+    set<uint32> setIP;
+    for (auto const& it : mapForkIps)
+    {
+        bool fOwned = false;
+        {
+            boost::recursive_mutex::scoped_lock scoped_lock(mtxSched);
+            fOwned = mapSched.count(it.first);
+        }
+        if (fOwned)
+        {
+            setIP.insert(it.second.begin(), it.second.end());
+            StdLog("NetChannel", "CEventPeerBizForks: Add [%d] peer node(s) with biz fork[%s]",
+                   it.second.size(), it.first.ToString().c_str());
+        }
+    }
+    for (auto const& nIP : setIP)
+    {
+        string strIP = storage::CSuperNode::Int2Ip(nIP);
+        CNetHost host(strIP, DEFAULT_P2PPORT);
+        CEventPeerNetAddNode eventAddNode(0);
+        eventAddNode.data = host;
+        if (!pPeerNet->DispatchEvent(&eventAddNode))
+        {
+            StdError("NetChannel", "CEventPeerBizForks: Adding outer peer node[%s] failed", strIP.c_str());
+            return false;
+        }
+        StdLog("NetChannel", "CEventPeerBizForks: Adding outer peer node[%s] succeeded", strIP.c_str());
+    }
+
+    return true;
+}
+
 bool CNetChannel::HandleEvent(network::CEventPeerSubscribe& eventSubscribe)
 {
     uint64 nNonce = eventSubscribe.nNonce;
     uint256& hashFork = eventSubscribe.hashFork;
-    StdLog("NetChannel", "CEventPeerSubscribe: peer: %s, fork: %s", GetPeerAddressInfo(nNonce).c_str(), hashFork.GetHex().c_str());
+    StdLog("NetChannel", "CEventPeerSubscribe: peer: %s, mainfork: %s", GetPeerAddressInfo(nNonce).c_str(), hashFork.GetHex().c_str());
+    for (const auto& fork : eventSubscribe.data)
+    {
+        StdLog("NetChannel", "CEventPeerSubscribe: peer: %s, bizfork: %s", GetPeerAddressInfo(nNonce).c_str(), fork.GetHex().c_str());
+    }
+
+    if (NODE_CAT_DPOSNODE == nNodeCat)
+    {
+        StdTrace("NetChannel", "CEventPeerSubscribe: peer[%s] is subscribing biz chains from a dpos node",
+                 GetPeerAddressInfo(nNonce).c_str());
+        // return true;
+    }
+
     if (hashFork == pCoreProtocol->GetGenesisBlockHash())
     {
         vector<uint256> vDispatchHash;
         {
             boost::unique_lock<boost::shared_mutex> wlock(rwNetPeer);
-            map<uint64, CNetChannelPeer>::iterator it = mapPeer.find(nNonce);
+            auto it = mapPeer.find(nNonce);
             if (it != mapPeer.end())
             {
                 for (const uint256& hash : eventSubscribe.data)
                 {
+                    if (NODE_CAT_FORKNODE == nNodeCat && hash == pCoreProtocol->GetGenesisBlockHash())
+                    {
+                        StdError("NetChannel", "CEventPeerSubscribe: peer[%ld] is subscribing a main chain "
+                                               "from a fork node, just ignore it",
+                                 nNonce);
+                        continue;
+                    }
+                    StdTrace("NetChannel", "CEventPeerSubscribe: note peer[%d] as subscribed to fork[%s]",
+                             nNonce, hash.ToString().c_str());
                     (*it).second.Subscribe(hash);
-                    mapUnsync[hash].insert(nNonce);
+                    if (NODE_CAT_DPOSNODE != nNodeCat)
+                    {
+                        mapUnsync[hash].insert(nNonce);
+                    }
                     vDispatchHash.push_back(hash);
                 }
             }
         }
-        if (!vDispatchHash.empty())
+        if (!vDispatchHash.empty() && NODE_CAT_DPOSNODE != nNodeCat)
         {
             boost::recursive_mutex::scoped_lock scoped_lock(mtxSched);
             for (const uint256& hash : vDispatchHash)
@@ -663,16 +1059,40 @@ bool CNetChannel::HandleEvent(network::CEventPeerUnsubscribe& eventUnsubscribe)
     uint64 nNonce = eventUnsubscribe.nNonce;
     uint256& hashFork = eventUnsubscribe.hashFork;
     StdLog("NetChannel", "CEventPeerUnsubscribe: peer: %s, fork: %s", GetPeerAddressInfo(nNonce).c_str(), hashFork.GetHex().c_str());
+    for (const auto& fork : eventUnsubscribe.data)
+    {
+        StdLog("NetChannel", "CEventPeerUnsubscribe: peer: %s, fork: %s", GetPeerAddressInfo(nNonce).c_str(), fork.GetHex().c_str());
+    }
+
+    if (NODE_CAT_DPOSNODE == nNodeCat)
+    {
+        StdTrace("NetChannel", "CEventPeerUnsubscribe: peer[%s] is unsubscribing biz chains from a dpos node",
+                 GetPeerAddressInfo(nNonce).c_str());
+        // return true;
+    }
+
     if (hashFork == pCoreProtocol->GetGenesisBlockHash())
     {
         boost::unique_lock<boost::shared_mutex> wlock(rwNetPeer);
-        map<uint64, CNetChannelPeer>::iterator it = mapPeer.find(nNonce);
+        auto it = mapPeer.find(nNonce);
         if (it != mapPeer.end())
         {
             for (const uint256& hash : eventUnsubscribe.data)
             {
+                if (NODE_CAT_FORKNODE == nNodeCat && hash == pCoreProtocol->GetGenesisBlockHash())
+                {
+                    StdError("NetChannel", "CEventPeerUnsubscribe: peer[%ld] is unsubscribing a main chain "
+                                           "from a fork node, just ignore it",
+                             nNonce);
+                    continue;
+                }
+                StdTrace("NetChannel", "CEventPeerUnsubscribe: note peer[%d] as unsubscribed to fork[%s]",
+                         nNonce, hash.ToString().c_str());
                 (*it).second.Unsubscribe(hash);
-                mapUnsync[hash].erase(nNonce);
+                if (NODE_CAT_DPOSNODE != nNodeCat)
+                {
+                    mapUnsync[hash].erase(nNonce);
+                }
             }
         }
     }
@@ -688,6 +1108,27 @@ bool CNetChannel::HandleEvent(network::CEventPeerInv& eventInv)
 {
     uint64 nNonce = eventInv.nNonce;
     uint256& hashFork = eventInv.hashFork;
+    if (NODE_CAT_FORKNODE == nNodeCat)
+    {
+        if (hashFork == pCoreProtocol->GetGenesisBlockHash())
+        {
+            StdTrace("NetChannel", "CEventPeerInv: peer[%s] is feeding a main chain inv "
+                                   "to a fork node, just ignore it",
+                     GetPeerAddressInfo(nNonce).c_str());
+            return true;
+        }
+    }
+    if (NODE_CAT_DPOSNODE == nNodeCat)
+    {
+        if (hashFork != pCoreProtocol->GetGenesisBlockHash())
+        {
+            StdTrace("NetChannel", "CEventPeerInv: peer[%s] is feeding a main chain inv "
+                                   "to a dpos node, just ignore it",
+                     GetPeerAddressInfo(nNonce).c_str());
+            return true;
+        }
+    }
+
     try
     {
         if (eventInv.data.size() > network::CInv::MAX_INV_COUNT)
@@ -841,7 +1282,8 @@ bool CNetChannel::HandleEvent(network::CEventPeerGetData& eventGetData)
             }
             else
             {
-                StdError("NetChannel", "CEventPeerGetData: Get transaction fail, txid: %s", inv.nHash.GetHex().c_str());
+                StdError("NetChannel", "CEventPeerGetData: Get transaction fail, txid: %s",
+                         inv.nHash.GetHex().c_str());
                 eventGetFail.data.push_back(inv);
             }
         }
@@ -903,6 +1345,28 @@ bool CNetChannel::HandleEvent(network::CEventPeerGetBlocks& eventGetBlocks)
 {
     uint64 nNonce = eventGetBlocks.nNonce;
     uint256& hashFork = eventGetBlocks.hashFork;
+
+    if (NODE_CAT_FORKNODE == nNodeCat)
+    {
+        if (hashFork == pCoreProtocol->GetGenesisBlockHash())
+        {
+            StdTrace("NetChannel", "CEventPeerGetBlocks: peer[%s] is asking main chain blocks "
+                                   "from a fork node, just ignore it",
+                     GetPeerAddressInfo(nNonce).c_str());
+            return true;
+        }
+    }
+    if (NODE_CAT_DPOSNODE == nNodeCat)
+    {
+        if (hashFork != pCoreProtocol->GetGenesisBlockHash())
+        {
+            StdTrace("NetChannel", "CEventPeerGetBlocks: peer[%s] is asking biz chain blocks "
+                                   "from a dpos node, just ignore it",
+                     GetPeerAddressInfo(nNonce).c_str());
+            return true;
+        }
+    }
+
     vector<uint256> vBlockHash;
 
     StdTrace("NetChannel", "CEventPeerGetBlocks: peer: %s, fork: %s",
@@ -966,6 +1430,28 @@ bool CNetChannel::HandleEvent(network::CEventPeerTx& eventTx)
 {
     uint64 nNonce = eventTx.nNonce;
     uint256& hashFork = eventTx.hashFork;
+
+    if (NODE_CAT_FORKNODE == nNodeCat)
+    {
+        if (hashFork == pCoreProtocol->GetGenesisBlockHash())
+        {
+            StdTrace("NetChannel", "CEventPeerTx: peer[%s] is feeding a main chain tx "
+                                   "to a fork node, just ignore it",
+                     GetPeerAddressInfo(nNonce).c_str());
+            return true;
+        }
+    }
+    if (NODE_CAT_DPOSNODE == nNodeCat)
+    {
+        if (hashFork != pCoreProtocol->GetGenesisBlockHash())
+        {
+            StdTrace("NetChannel", "CEventPeerTx: peer[%s] is feeding a biz chain tx "
+                                   "to a dpos node, just ignore it",
+                     GetPeerAddressInfo(nNonce).c_str());
+            return true;
+        }
+    }
+
     CTransaction& tx = eventTx.data;
     uint256 txid = tx.GetHash();
 
@@ -1018,6 +1504,28 @@ bool CNetChannel::HandleEvent(network::CEventPeerBlock& eventBlock)
 {
     uint64 nNonce = eventBlock.nNonce;
     uint256& hashFork = eventBlock.hashFork;
+
+    if (NODE_CAT_FORKNODE == nNodeCat)
+    {
+        if (hashFork == pCoreProtocol->GetGenesisBlockHash())
+        {
+            StdTrace("NetChannel", "CEventPeerBlock: peer[%s] is feeding a main chain block "
+                                   "to a fork node, just ignore it",
+                     GetPeerAddressInfo(nNonce).c_str());
+            return true;
+        }
+    }
+    if (NODE_CAT_DPOSNODE == nNodeCat)
+    {
+        if (hashFork != pCoreProtocol->GetGenesisBlockHash())
+        {
+            StdTrace("NetChannel", "CEventPeerBlock: peer[%s] is feeding a biz chain block "
+                                   "to a dpos node, just ignore it",
+                     GetPeerAddressInfo(nNonce).c_str());
+            return true;
+        }
+    }
+
     CBlock& block = eventBlock.data;
     uint256 hash = block.GetHash();
     uint32 nBlockHeight = block.GetBlockHeight();
@@ -1918,7 +2426,7 @@ bool CNetChannel::PushTxInv(const uint256& hashFork)
     {
         vector<uint256> vTxPool;
         pTxPool->ListTx(hashFork, vTxPool);
-        if (!vTxPool.empty() && !mapPeer.empty())
+        if (!vTxPool.empty())
         {
             boost::unique_lock<boost::shared_mutex> rlock(rwNetPeer);
             for (map<uint64, CNetChannelPeer>::iterator it = mapPeer.begin(); it != mapPeer.end(); ++it)
diff --git a/src/bigbang/netchn.h b/src/bigbang/netchn.h
index 49284a13..a8c3779e 100644
--- a/src/bigbang/netchn.h
+++ b/src/bigbang/netchn.h
@@ -6,6 +6,7 @@
 #define BIGBANG_NETCHN_H
 
 #include "base.h"
+#include "mqcluster.h"
 #include "peernet.h"
 #include "schedule.h"
 
@@ -18,8 +19,10 @@ class CNetChannelPeer
     {
     public:
         CNetChannelPeerFork()
-          : fSynchronized(false), nSynTxInvStatus(SYNTXINV_STATUS_INIT), nSynTxInvSendTime(0), nSynTxInvRecvTime(0), nPrevGetDataTime(0),
-            nSingleSynTxInvCount(network::CInv::MAX_INV_COUNT / 2), fWaitGetTxComplete(false), nCacheSynTxCount(NETCHANNEL_KNOWNINV_MAXCOUNT)
+          : fSynchronized(false), nSynTxInvStatus(SYNTXINV_STATUS_INIT),
+            nSynTxInvSendTime(0), nSynTxInvRecvTime(0), nPrevGetDataTime(0),
+            nSingleSynTxInvCount(network::CInv::MAX_INV_COUNT / 2),
+            fWaitGetTxComplete(false), nCacheSynTxCount(NETCHANNEL_KNOWNINV_MAXCOUNT)
         {
         }
         enum
@@ -94,7 +97,8 @@ class CNetChannelPeer
                 }
                 break;
             case SYNTXINV_STATUS_WAIT_PEER_COMPLETE:
-                if (nCurTime - nPrevGetDataTime >= SYNTXINV_GETDATA_TIMEOUT || nCurTime - nSynTxInvRecvTime >= SYNTXINV_COMPLETE_TIMEOUT)
+                if (nCurTime - nPrevGetDataTime >= SYNTXINV_GETDATA_TIMEOUT
+                    || nCurTime - nSynTxInvRecvTime >= SYNTXINV_COMPLETE_TIMEOUT)
                 {
                     InitTxInvSynData();
                     nSingleSynTxInvCount = network::CInv::MIN_INV_COUNT;
@@ -148,7 +152,10 @@ class CNetChannelPeer
     CNetChannelPeer(uint64 nServiceIn, const network::CAddress& addr, const uint256& hashPrimary)
       : nService(nServiceIn), addressRemote(addr)
     {
-        mapSubscribedFork.insert(std::make_pair(hashPrimary, CNetChannelPeerFork()));
+        if (hashPrimary != uint256())
+        {
+            mapSubscribedFork.insert(std::make_pair(hashPrimary, CNetChannelPeerFork()));
+        }
 
         boost::asio::ip::tcp::endpoint ep;
         addressRemote.ssEndpoint.GetEndpoint(ep);
@@ -254,6 +261,8 @@ class CNetChannel : public network::INetChannel
     bool SubmitCachePowBlock(const CConsensusParam& consParam) override;
     bool IsLocalCachePowBlock(int nHeight, bool& fIsDpos) override;
     bool AddCacheLocalPowBlock(const CBlock& block) override;
+    void DispatchGetBizForksEvent(const vector<uint256>& bizForks) override;
+    void BroadcastBizForks(const uint32& nIP, const vector<uint256>& bizForks) override;
 
 protected:
     enum
@@ -288,6 +297,8 @@ class CNetChannel : public network::INetChannel
 
     bool HandleEvent(network::CEventPeerActive& eventActive) override;
     bool HandleEvent(network::CEventPeerDeactive& eventDeactive) override;
+    bool HandleEvent(network::CEventPeerGetBizForks& eventGetBizForks) override;
+    bool HandleEvent(network::CEventPeerBizForks& eventBizForks) override;
     bool HandleEvent(network::CEventPeerSubscribe& eventSubscribe) override;
     bool HandleEvent(network::CEventPeerUnsubscribe& eventUnsubscribe) override;
     bool HandleEvent(network::CEventPeerInv& eventInv) override;
@@ -335,6 +346,7 @@ class CNetChannel : public network::INetChannel
     IDispatcher* pDispatcher;
     IService* pService;
     IConsensus* pConsensus;
+    IMQCluster* pMQCluster;
 
     mutable boost::recursive_mutex mtxSched;
     std::map<uint256, CSchedule> mapSched;
@@ -347,6 +359,8 @@ class CNetChannel : public network::INetChannel
     uint32 nTimerPushTx;
     bool fStartIdlePushTxTimer;
     std::set<uint256> setPushTxFork;
+
+    int8 nNodeCat;
 };
 
 } // namespace bigbang
diff --git a/src/bigbang/network.cpp b/src/bigbang/network.cpp
index e5bae8a8..10c400a3 100644
--- a/src/bigbang/network.cpp
+++ b/src/bigbang/network.cpp
@@ -36,7 +36,9 @@ bool CNetwork::HandleInitialize()
         return false;
     }
 
-    Configure(NetworkConfig()->nMagicNum, PROTO_VERSION, network::NODE_NETWORK | network::NODE_DELEGATED,
+    uint8 nodeCat = dynamic_cast<const CBasicConfig*>(xengine::IBase::Config())->nCatOfNode;
+    Configure(NetworkConfig()->nMagicNum, PROTO_VERSION,
+              network::NODE_NETWORK | network::NODE_DELEGATED | (nodeCat == 1 ? network::NODE_SUPERNODE : 0),
               FormatSubVersion(), !NetworkConfig()->vConnectTo.empty(), pCoreProtocol->GetGenesisBlockHash());
 
     CPeerNetConfig config;
diff --git a/src/bigbang/rpcmod.cpp b/src/bigbang/rpcmod.cpp
index 3be1704e..ef08113c 100644
--- a/src/bigbang/rpcmod.cpp
+++ b/src/bigbang/rpcmod.cpp
@@ -16,6 +16,8 @@
 //#include <algorithm>
 
 #include "address.h"
+#include "defs.h"
+#include "mqdb.h"
 #include "rpc/auto_protocol.h"
 #include "template/fork.h"
 #include "template/proof.h"
@@ -108,14 +110,7 @@ static CTransactionData TxToJSON(const uint256& txid, const CTransaction& tx,
     ret.dTxfee = ValueFromAmount(tx.nTxFee);
 
     std::string str(tx.vchData.begin(), tx.vchData.end());
-    if (str.substr(0, 4) == "msg:")
-    {
-        ret.strData = str;
-    }
-    else
-    {
-        ret.strData = xengine::ToHexString(tx.vchData);
-    }
+    ret.strData = xengine::ToHexString(tx.vchData);
     ret.strSig = xengine::ToHexString(tx.vchSig);
     ret.strFork = hashFork.GetHex();
     if (nDepth >= 0)
@@ -286,6 +281,10 @@ CRPCMod::CRPCMod()
         ("gettxfee", &CRPCMod::RPCGetTxFee)
         //
         ("listunspent", &CRPCMod::RPCListUnspent)
+        //
+        ("enrollsupernode", &CRPCMod::RPCEnrollSuperNode)
+        //
+        ("listenrollment", &CRPCMod::RPCListEnrollment)
         /* Mint */
         ("getwork", &CRPCMod::RPCGetWork)
         //
@@ -632,6 +631,17 @@ CRPCResultPtr CRPCMod::RPCListPeer(CRPCParamPtr param)
                     peer.strServices = peer.strServices + ",NODE_DELEGATED";
                 }
             }
+            if (info.nService & network::NODE_SUPERNODE)
+            {
+                if (peer.strServices.empty())
+                {
+                    peer.strServices = "NODE_SUPERNODE";
+                }
+                else
+                {
+                    peer.strServices = peer.strServices + ",NODE_SUPERNODE";
+                }
+            }
             if (peer.strServices.empty())
             {
                 peer.strServices = string("OTHER:") + to_string(info.nService);
@@ -691,10 +701,11 @@ CRPCResultPtr CRPCMod::RPCListFork(CRPCParamPtr param)
     auto spResult = MakeCListForkResultPtr();
     for (size_t i = 0; i < vFork.size(); i++)
     {
+        Log("listfork[%s]", vFork[i].first.ToString().c_str());
         CProfile& profile = vFork[i].second;
         //auto c = std::count(pForkManager->ForkConfig()->vFork.begin(), pForkManager->ForkConfig()->vFork.end(), vFork[i].first.GetHex());
         //if (pForkManager->ForkConfig()->fAllowAnyFork || vFork[i].first == pCoreProtocol->GetGenesisBlockHash() || c > 0)
-        if (pForkManager->IsAllowed(vFork[i].first))
+        if (spParam->fAll || (!spParam->fAll && pForkManager->IsAllowed(vFork[i].first)))
         {
             spResult->vecProfile.push_back({ vFork[i].first.GetHex(), profile.strName, profile.strSymbol,
                                              (double)(profile.nAmount) / COIN, (double)(profile.nMintReward) / COIN, (uint64)(profile.nHalveCycle),
@@ -1631,15 +1642,7 @@ CRPCResultPtr CRPCMod::RPCSendFrom(CRPCParamPtr param)
     if (spParam->strData.IsValid())
     {
         auto strDataTmp = spParam->strData;
-        if (((std::string)strDataTmp).substr(0, 4) == "msg:")
-        {
-            auto hex = xengine::ToHexString((const unsigned char*)strDataTmp.c_str(), strlen(strDataTmp.c_str()));
-            vchData = ParseHexString(hex);
-        }
-        else
-        {
-            vchData = ParseHexString(strDataTmp);
-        }
+        vchData = ParseHexString(strDataTmp);
     }
 
     int64 nTxFee = CalcMinTxFee(vchData.size(), NEW_MIN_TX_FEE);
@@ -2244,7 +2247,7 @@ CRPCResultPtr CRPCMod::RPCMakeOrigin(CRPCParamPtr param)
     int nForkHeight = pService->GetForkHeight(hashParent);
     if (nForkHeight < nJointHeight + MIN_CREATE_FORK_INTERVAL_HEIGHT)
     {
-        throw CRPCException(RPC_INVALID_PARAMETER, "The minimum confirmed height of the previous block is 30");
+        //        throw CRPCException(RPC_INVALID_PARAMETER, string("The minimum confirmed height of the previous block is: ") + std::to_string(MIN_CREATE_FORK_INTERVAL_HEIGHT));
     }
     if ((int64)nForkHeight > (int64)nJointHeight + MAX_JOINT_FORK_INTERVAL_HEIGHT)
     {
@@ -2570,6 +2573,7 @@ CRPCResultPtr CRPCMod::RPCListUnspent(CRPCParamPtr param)
             }
         }
 
+        sort(addresses.begin(), addresses.end());
         auto last = unique(addresses.begin(), addresses.end());
         addresses.erase(last, addresses.end());
 
@@ -2653,9 +2657,132 @@ CRPCResultPtr CRPCMod::RPCListUnspent(CRPCParamPtr param)
     return spResult;
 }
 
+CRPCResultPtr CRPCMod::RPCEnrollSuperNode(rpc::CRPCParamPtr param)
+{
+    int nNodeCat = dynamic_cast<const CBasicConfig*>(Config())->nCatOfNode;
+    if (NODE_CAT_FORKNODE != nNodeCat && NODE_CAT_DPOSNODE != nNodeCat)
+    {
+        throw CRPCException(RPC_INVALID_REQUEST, "Only super node has the feature");
+    }
+
+    auto spParam = CastParamPtr<CEnrollSuperNodeParam>(param);
+    std::string ipStr = spParam->strClientip;
+    unsigned long ipNum = 0;
+    if (!storage::CSuperNode::Ip2Int(ipStr, ipNum))
+    {
+        throw CRPCException(RPC_INVALID_PARAMETER, "Invalid ip address");
+    }
+
+    if (NODE_CAT_FORKNODE == nNodeCat && 0 == ipNum)
+    {
+        throw CRPCException(RPC_INVALID_PARAMETER, "Failed: IP of fork node must not be 0.0.0.0");
+    }
+
+    std::string id = spParam->strClientid;
+    std::vector<std::string> vFork = spParam->vecForks;
+
+    string dposid = dynamic_cast<const CBasicConfig*>(Config())->strDposNodeID;
+    if (NODE_CAT_DPOSNODE == nNodeCat && dposid == id && 0 != ipNum)
+    {
+        throw CRPCException(RPC_INVALID_PARAMETER, "Failed: IP of dpos node must be 0.0.0.0");
+    }
+
+    std::vector<uint256> forks;
+    for (const auto& i : vFork)
+    {
+        if (64 != i.size())
+        {
+            throw CRPCException(RPC_INVALID_PARAMETER, "Invalid fork hash");
+        }
+        uint256 fork;
+        if (fork.SetHex(i) != i.size())
+        {
+            throw CRPCException(RPC_INVALID_PARAMETER, "Invalid fork hash");
+        }
+        forks.emplace_back(fork);
+    }
+
+    if (forks.empty())
+    {
+        throw CRPCException(RPC_INVALID_PARAMETER, "No fork hash parameter");
+    }
+
+    uint256 hashGenesis = pCoreProtocol->GetGenesisBlockHash();
+    if (NODE_CAT_DPOSNODE == nNodeCat)
+    {
+        if (dposid == id && forks.size() > 1)
+        {
+            throw CRPCException(RPC_INVALID_PARAMETER, "Dpos node must have only main chain to enroll");
+        }
+
+        if (dposid == id && forks[0] != hashGenesis)
+        {
+            throw CRPCException(RPC_INVALID_PARAMETER, "The main fork dpos node enrolls does not match:[ " + hashGenesis.ToString() + " ]");
+        }
+    }
+
+    if (NODE_CAT_FORKNODE == nNodeCat
+        || (NODE_CAT_DPOSNODE == nNodeCat && dposid != id
+            && id != storage::CLIENT_ID_OUT_OF_MQ_CLUSTER))
+    {
+        if (forks.end() != find(forks.begin(), forks.end(), hashGenesis))
+        {
+            throw CRPCException(RPC_INVALID_PARAMETER, "The fork fork node enrolls should not be the main fork:[ " + hashGenesis.ToString() + " ]");
+        }
+    }
+
+    storage::CSuperNode newNode;
+    newNode.superNodeID = std::move(id);
+    newNode.ipAddr = ipNum;
+    newNode.vecOwnedForks = std::move(forks);
+    newNode.nodeCat = nNodeCat;
+
+    if (!pService->AddSuperNode(newNode))
+    {
+        throw CRPCException(RPC_INTERNAL_ERROR, "Enroll super node failed");
+    }
+
+    return MakeCEnrollSuperNodeResultPtr(string("Add super node successfully."));
+}
+
+CRPCResultPtr CRPCMod::RPCListEnrollment(rpc::CRPCParamPtr param)
+{
+    vector<storage::CSuperNode> nodes;
+    if (!pService->ListSuperNode(nodes))
+    {
+        throw CRPCException(RPC_INTERNAL_ERROR, "List super nodes failed");
+    }
+
+    auto spResult = MakeCListEnrollmentResultPtr();
+    for (const auto& it : nodes)
+    {
+        CListEnrollmentResult::CNode node;
+        node.strClientid = it.superNodeID;
+        string strAddr;
+        if (!storage::CSuperNode::Int2Ip(it.ipAddr, strAddr))
+        {
+            throw CRPCException(RPC_INTERNAL_ERROR, "Failed to convert ip address");
+        }
+        node.strClientip = strAddr;
+        for (const auto& fork : it.vecOwnedForks)
+        {
+            node.vecForks.push_back(fork.ToString());
+        }
+        spResult->vecNode.push_back(node);
+    }
+
+    return spResult;
+}
+
 // /* Mint */
 CRPCResultPtr CRPCMod::RPCGetWork(CRPCParamPtr param)
 {
+    int nNodeCat = dynamic_cast<const CBasicConfig*>(Config())->nCatOfNode;
+    if (1 == nNodeCat)
+    {
+        throw CRPCException(RPC_INVALID_REQUEST, "This fork node has not feature of POW mining");
+    }
+
     //getwork <"spent"> <"privkey"> ("prev")
     auto spParam = CastParamPtr<CGetWorkParam>(param);
 
@@ -2673,7 +2800,7 @@ CRPCResultPtr CRPCMod::RPCGetWork(CRPCParamPtr param)
     crypto::CPubKey pubkeySpent;
     if (addrSpent.GetPubKey(pubkeySpent) && pubkeySpent == key.GetPubKey())
     {
-        throw CRPCException(RPC_INVALID_ADDRESS_OR_KEY, "Invalid spent address or private key");
+        throw CRPCException(RPC_INVALID_ADDRESS_OR_KEY, "Mining signature private key and spent address cannot be from the same.");
     }
     CTemplateMintPtr ptr = CTemplateMint::CreateTemplatePtr(new CTemplateProof(key.GetPubKey(), static_cast<CDestination&>(addrSpent)));
     if (ptr == nullptr)
@@ -2708,6 +2835,12 @@ CRPCResultPtr CRPCMod::RPCGetWork(CRPCParamPtr param)
 
 CRPCResultPtr CRPCMod::RPCSubmitWork(CRPCParamPtr param)
 {
+    int nNodeCat = dynamic_cast<const CBasicConfig*>(Config())->nCatOfNode;
+    if (1 == nNodeCat)
+    {
+        throw CRPCException(RPC_INVALID_REQUEST, "This fork node has not feature of POW mining");
+    }
+
     auto spParam = CastParamPtr<CSubmitWorkParam>(param);
     vector<unsigned char> vchWorkData(ParseHexString(spParam->strData));
     CAddress addrSpent(spParam->strSpent);
diff --git a/src/bigbang/rpcmod.h b/src/bigbang/rpcmod.h
index b8de2168..de52abdd 100644
--- a/src/bigbang/rpcmod.h
+++ b/src/bigbang/rpcmod.h
@@ -130,6 +130,8 @@ class CRPCMod : public xengine::IIOModule, virtual public xengine::CHttpEventLis
     rpc::CRPCResultPtr RPCDecodeTransaction(rpc::CRPCParamPtr param);
     rpc::CRPCResultPtr RPCGetTxFee(rpc::CRPCParamPtr param);
     rpc::CRPCResultPtr RPCListUnspent(rpc::CRPCParamPtr param);
+    rpc::CRPCResultPtr RPCEnrollSuperNode(rpc::CRPCParamPtr param);
+    rpc::CRPCResultPtr RPCListEnrollment(rpc::CRPCParamPtr param);
     /* Mint */
     rpc::CRPCResultPtr RPCGetWork(rpc::CRPCParamPtr param);
     rpc::CRPCResultPtr RPCSubmitWork(rpc::CRPCParamPtr param);
diff --git a/src/bigbang/service.cpp b/src/bigbang/service.cpp
index 7d59f863..ddc7db3d 100644
--- a/src/bigbang/service.cpp
+++ b/src/bigbang/service.cpp
@@ -20,7 +20,15 @@ namespace bigbang
 // CService
 
 CService::CService()
-  : pCoreProtocol(nullptr), pBlockChain(nullptr), pTxPool(nullptr), pDispatcher(nullptr), pWallet(nullptr), pNetwork(nullptr), pForkManager(nullptr), pNetChannel(nullptr)
+  : pCoreProtocol(nullptr),
+    pBlockChain(nullptr),
+    pTxPool(nullptr),
+    pDispatcher(nullptr),
+    pWallet(nullptr),
+    pNetwork(nullptr),
+    pForkManager(nullptr),
+    pMQCluster(nullptr),
+    pNetChannel(nullptr)
 {
 }
 
@@ -72,6 +80,12 @@ bool CService::HandleInitialize()
         return false;
     }
 
+    if (!GetObject("mqcluster", pMQCluster))
+    {
+        Error("Failed to request mqcluster");
+        return false;
+    }
+
     if (!GetObject("netchannel", pNetChannel))
     {
         Error("Failed to request netchannel");
@@ -90,6 +104,7 @@ void CService::HandleDeinitialize()
     pWallet = nullptr;
     pNetwork = nullptr;
     pForkManager = nullptr;
+    pMQCluster = nullptr;
     pNetChannel = nullptr;
 }
 
@@ -186,6 +201,25 @@ bool CService::RemoveNode(const CNetHost& node)
     return pNetwork->DispatchEvent(&eventRemoveNode);
 }
 
+bool CService::AddBizForkNodes(const std::vector<uint32>& nodes)
+{
+    for (auto const& node : nodes)
+    {
+        string strIP = storage::CSuperNode::Int2Ip(node);
+        CNetHost host(strIP, DEFAULT_P2PPORT);
+        CEventPeerNetAddNode eventAddNode(0);
+        eventAddNode.data = host;
+        if (!pNetwork->DispatchEvent(&eventAddNode))
+        {
+            StdError("CService", "AddBizForkNodes: Adding biz fork peer node[%s] failed", strIP.c_str());
+            return false;
+        }
+        StdLog("CService", "AddBizForkNodes: Adding biz fork peer node[%s] succeeded", strIP.c_str());
+    }
+
+    return true;
+}
+
 int CService::GetForkCount()
 {
     return mapForkStatus.size();
@@ -854,4 +888,45 @@ Errno CService::SubmitWork(const vector<unsigned char>& vchWorkData,
     return OK;
 }
 
+bool CService::AddSuperNode(const storage::CSuperNode& node)
+{
+    if (OK != pBlockChain->AddNewSuperNode(node))
+    {
+        StdError("CService::AddSuperNode", "Adding new super node failed.");
+        return false;
+    }
+    StdLog("CService::AddSuperNode", "Adding new super node succeeded.");
+
+    CEventMQEnrollUpdate* pEvent = new CEventMQEnrollUpdate(0);
+    if (nullptr != pEvent)
+    {
+        pEvent->data.superNodeClientID = node.superNodeID;
+        pEvent->data.ipAddr = node.ipAddr;
+        pEvent->data.vecForksOwned = node.vecOwnedForks;
+        pMQCluster->PostEvent(pEvent);
+        StdLog("CService::AddSuperNode", "Posting CEventMQEnrollUpdate succeeded.");
+    }
+
+    pForkManager->SetForkFilter(node.vecOwnedForks);
+
+    if (0 != node.ipAddr)
+    {
+        pNetChannel->BroadcastBizForks(node.ipAddr, node.vecOwnedForks);
+    }
+
+    return true;
+}
+
+bool CService::ListSuperNode(std::vector<storage::CSuperNode>& nodes)
+{
+    if (!pBlockChain->ListSuperNode(nodes))
+    {
+        StdError("CService::ListSuperNode", "list super nodes failed.");
+        return false;
+    }
+
+    return true;
+}
+
+
 } // namespace bigbang
diff --git a/src/bigbang/service.h b/src/bigbang/service.h
index d9f148e6..a81e3480 100644
--- a/src/bigbang/service.h
+++ b/src/bigbang/service.h
@@ -6,6 +6,8 @@
 #define BIGBANG_SERVICE_H
 
 #include "base.h"
+#include "mqdb.h"
+#include "mqcluster.h"
 #include "network.h"
 #include "xengine.h"
 
@@ -28,6 +30,7 @@ class CService : public IService
     void GetPeers(std::vector<network::CBbPeerInfo>& vPeerInfo) override;
     bool AddNode(const xengine::CNetHost& node) override;
     bool RemoveNode(const xengine::CNetHost& node) override;
+    bool AddBizForkNodes(const std::vector<uint32>& nodes) override;
     /* Blockchain & Tx Pool*/
     int GetForkCount() override;
     bool HaveFork(const uint256& hashFork) override;
@@ -83,6 +86,9 @@ class CService : public IService
                  const CTemplateMintPtr& templMint) override;
     Errno SubmitWork(const std::vector<unsigned char>& vchWorkData, const CTemplateMintPtr& templMint,
                      crypto::CKey& keyMint, uint256& hashBlock) override;
+    /* Util */
+    bool AddSuperNode(const storage::CSuperNode& node) override;
+    bool ListSuperNode(std::vector<storage::CSuperNode>& nodes) override;
 
 protected:
     bool HandleInitialize() override;
@@ -98,6 +104,7 @@ class CService : public IService
     IWallet* pWallet;
     CNetwork* pNetwork;
     IForkManager* pForkManager;
+    IMQCluster* pMQCluster;
     network::INetChannel* pNetChannel;
     mutable boost::shared_mutex rwForkStatus;
     std::map<uint256, CForkStatus> mapForkStatus;
diff --git a/src/bigbang/storage.h b/src/bigbang/storage.h
deleted file mode 100644
index d93446a7..00000000
--- a/src/bigbang/storage.h
+++ /dev/null
@@ -1,45 +0,0 @@
-// Copyright (c) 2019-2020 The Bigbang developers
-// Distributed under the MIT/X11 software license, see the accompanying
-// file COPYING or http://www.opensource.org/licenses/mit-license.php.
-
-#ifndef BIGBANG_STORAGE_H
-#define BIGBANG_STORAGE_H
-
-#include <boost/filesystem.hpp>
-#include <xengine.h>
-
-#include "config.h"
-
-namespace bigbang
-{
-
-class CEntry : public xengine::CEntry
-{
-public:
-    CEntry();
-    ~CEntry();
-    bool Initialize(int argc, char* argv[]);
-    bool Run();
-    void Exit();
-
-protected:
-    bool InitializeService();
-    bool InitializeClient();
-    //    xengine::CHttpHostConfig GetRPCHostConfig();
-    //    xengine::CHttpHostConfig GetWebUIHostConfig();
-
-    boost::filesystem::path GetDefaultDataDir();
-
-    bool SetupEnvironment();
-    bool RunInBackground(const boost::filesystem::path& pathData);
-    void ExitBackground(const boost::filesystem::path& pathData);
-
-protected:
-    CConfig config;
-    xengine::CLog log;
-    xengine::CDocker docker;
-};
-
-} // namespace bigbang
-
-#endif //BIGBANG_STORAGE_H
diff --git a/src/bigbang/struct.h b/src/bigbang/struct.h
index 58d4324b..a3a7a1a8 100644
--- a/src/bigbang/struct.h
+++ b/src/bigbang/struct.h
@@ -54,7 +54,8 @@ class CForkStatus
         nLastBlockTime(0),
         nLastBlockHeight(-1),
         nMoneySupply(0),
-        nMintType(-1)
+        nMintType(-1),
+        nWeight(0)
     {
     }
 
@@ -73,6 +74,8 @@ class CForkStatus
     int nLastBlockHeight;
     int64 nMoneySupply;
     uint16 nMintType;
+    unsigned char nWeight;
+    uint256 nAgreement;
     std::multimap<int, uint256> mapSubline;
 };
 
@@ -126,10 +129,10 @@ class CBlockChainUpdate
 public:
     uint256 hashFork;
     uint256 hashParent;
-    int nOriginHeight;
+    int32 nOriginHeight;
     uint256 hashLastBlock;
     int64 nLastBlockTime;
-    int nLastBlockHeight;
+    int32 nLastBlockHeight;
     uint16 nLastMintType;
     int64 nMoneySupply;
     std::set<uint256> setTxUpdate;
@@ -288,6 +291,24 @@ class CBlockMakerUpdate
     uint16 nMintType;
 };
 
+/* Super node */
+class CMqRollbackUpdate
+{
+public:
+    int32 triHeight;
+    uint256 triHash;
+    int actRollBackLen;
+    std::vector<uint256> vShort;
+};
+
+class CMqSuperNodeUpdate
+{
+public:
+    std::string superNodeClientID;
+    uint32 ipAddr;
+    std::vector<uint256> vecForksOwned;
+};
+
 /* Net Channel */
 class CPeerKnownTx
 {
diff --git a/src/common/CMakeLists.txt b/src/common/CMakeLists.txt
index 39fac9aa..64c87d0d 100755
--- a/src/common/CMakeLists.txt
+++ b/src/common/CMakeLists.txt
@@ -11,13 +11,13 @@ set(template
     template/template.h     template/template.cpp
     template/weighted.h     template/weighted.cpp 
     template/multisig.h     template/multisig.cpp 
-    template/fork.h         template/fork.cpp 
-    template/mint.h         template/mint.cpp 
+    template/fork.h         template/fork.cpp
+    template/mint.h         template/mint.cpp
     template/proof.h        template/proof.cpp 
-    template/delegate.h     template/delegate.cpp 
-    template/exchange.h     template/exchange.cpp 
-    template/vote.h         template/vote.cpp 
-    template/payment.h      template/payment.cpp 
+    template/delegate.h     template/delegate.cpp
+    template/exchange.h     template/exchange.cpp
+    template/vote.h         template/vote.cpp
+    template/payment.h      template/payment.cpp
 )
 
 set(sources
diff --git a/src/common/defs.h b/src/common/defs.h
index 8488c46d..de16f710 100644
--- a/src/common/defs.h
+++ b/src/common/defs.h
@@ -15,4 +15,10 @@ static const unsigned int HEIGHT_HASH_TX_DATA_MAINNET = 133060;
 static const unsigned int HEIGHT_HASH_TX_DATA_TESTNET = 40;
 extern unsigned int HEIGHT_HASH_TX_DATA;
 
+enum
+{
+    NODE_CAT_BBCNODE = 0,
+    NODE_CAT_FORKNODE = 1,
+    NODE_CAT_DPOSNODE = 2
+};
 #endif //BIGBANG_DEFS_H
diff --git a/src/common/template/weighted.cpp b/src/common/template/weighted.cpp
index f43f24d8..ad253204 100644
--- a/src/common/template/weighted.cpp
+++ b/src/common/template/weighted.cpp
@@ -148,24 +148,9 @@ bool CTemplateWeighted::VerifyTxSignature(const uint256& hash, const uint16 nTyp
     }
 
     set<uint256> setPartKey;
-    // before HEIGHT_HASH_MULTI_SIGNER, used defect multi-sign algorithm
-    if (nForkHeight > 0 && nForkHeight < HEIGHT_HASH_MULTI_SIGNER)
+    if (!CryptoMultiVerify(setPubKey, hash.begin(), hash.size(), vchSig, setPartKey))
     {
-        xengine::StdTrace("multi-sign-template", "nHeight: %u, range: (0, %u)", nForkHeight, HEIGHT_HASH_MULTI_SIGNER);
-        if (!CryptoMultiVerifyDefect(setPubKey, hashAnchor.begin(), hashAnchor.size(), hash.begin(), hash.size(), vchSig, setPartKey))
-        {
-            return false;
-        }
-        xengine::StdTrace("multi-sign-template-success", "nHeight: %u, range: (0, %u)", nForkHeight, HEIGHT_HASH_MULTI_SIGNER);
-    }
-    else
-    {
-        xengine::StdTrace("multi-sign-template", "nHeight: %u, range: [%u, infinite)", nForkHeight, HEIGHT_HASH_MULTI_SIGNER);
-        if (!CryptoMultiVerify(setPubKey, hash.begin(), hash.size(), vchSig, setPartKey))
-        {
-            return false;
-        }
-        xengine::StdTrace("multi-sign-template-success", "nHeight: %u, range: [%u, infinite)", nForkHeight, HEIGHT_HASH_MULTI_SIGNER);
+        return false;
     }
 
     int nWeight = 0;
diff --git a/src/delegate/delegate.cpp b/src/delegate/delegate.cpp
index bcf8dfeb..5578b729 100644
--- a/src/delegate/delegate.cpp
+++ b/src/delegate/delegate.cpp
@@ -65,7 +65,7 @@ void CDelegate::Evolve(int nBlockHeight, const map<CDestination, size_t>& mapWei
         map<int, CDelegateVote>::iterator it = mapVote.find(nDelete);
         if (it != mapVote.end())
         {
-            StdTrace("CDelegate", "Evolve Deletate: erase vote, target height: %d, distribute block: %s",
+            StdTrace("CDelegate", "Evolve Delete: erase vote, target height: %d, distribute block: %s",
                      nDelete, it->second.hashDistributeBlock.GetHex().c_str());
             if (it->second.hashDistributeBlock != 0)
             {
@@ -165,7 +165,7 @@ void CDelegate::Evolve(int nBlockHeight, const map<CDestination, size_t>& mapWei
             CDelegateVote& vote = mt->second;
             if (!vote.is_enroll)
             {
-                StdError("CDelegate", "Evolve Publish: not is enroll, target height: %d, distribute block: [%d] %s",
+                StdError("CDelegate", "Evolve Publish: is not enroll, target height: %d, distribute block: [%d] %s",
                          nPublish, hashDistribute.Get32(7), hashDistribute.GetHex().c_str());
                 break;
             }
diff --git a/src/mqtt/CHANGELOG.md b/src/mqtt/CHANGELOG.md
new file mode 100644
index 00000000..eb80fd4d
--- /dev/null
+++ b/src/mqtt/CHANGELOG.md
@@ -0,0 +1,46 @@
+# Change Log
+
+## Version 1.1 (2019-10-12)
+
+This release was primarily to add MQTT v5 support and server responses.
+
+- MQTT v5 support:
+    - **Properties**
+        - New `property` class acts something like a std::variant to hold a property of any supported type.
+        - New `properties` class is a collection type to hold all the properties for a single transmitted packet.
+        - Properties can be added to outbound messages and obtained from received messages.
+        - Properties can also be obtained from server responses to requests such as from a _connect_ call. These are available in the `token` objects when they complete.
+    - The client object tracks the desired MQTT version that the app requested and/or is currently connected at. Internally this is now required by the `response_options` the need to distinguish between pre-v5 and post-v5 callback functions.
+    - MQTT v5 reason codes for requests are available via `token` objects when they complete. They are also available in `exception` objects that are thrown by tokens.
+    - Support for subscibe options, like no local subscriptions, etc.
+    - Sample applications were added showing how to do basic Remote Procedure Calls (RPC's) with MQTT v5 using the *RESPONSE_TOPIC* and *CORRELATION_DATA* properties. These are *rpc_math_cli* and *rpc_math_srvr* in the _src/samples_ directory.
+    - A sample "chat" application was added, showing how to use subscribe options, such as "no local".
+- More descriptive error messages (PR #154), integrated into the `mqtt::exception` class. MQTT v5 reason codes are also included in the exceptions when an error occurs.
+- Applications can (finally) get server responses from the various ACK packets. These are available through the tokens after they complete, as `connect_response`, `subscribe_response`, and `unsubscribe_response`.
+- The `topic` objects can be used to subscribe.
+- Applications can register individual callback functions instead of using a `callback` interface object. This allows easy use of lambda functions for callbacks.
+- The connect options can take a LWT as a plain message, via `connect_options::set_will_message()` 
+- New unit tests have started using _Catch2_.
+- Tested with Paho C v1.3.1
+
+## Version 1.0.1 (2018-12-12)
+
+This is a bug-fix released aimed mainly at issues with the build system and working towards more "modern" usage of CMake. In addition:
+
+- Support for Paho C v1.2.1
+- Fixed a number of build issues, particularly on Windows
+- Windows shared libraries (DLL's) now supported
+- Several minor bug fixes
+
+
+##  Version 1.0.0 (2017-07-23)
+
+The initial Paho C++ Client library for memory-managed platforms (Linux, Windows, etc).
+
+- Requires Paho C Client Library v1.2.
+- MQTT 3.1 & 3.1.1 
+- SSL/TLS
+- Asynchronous & Synchronous interfaces
+- Persistence and off-line buffering
+- Automatic reconnect
+- High availability.
diff --git a/src/mqtt/CMakeLists.txt b/src/mqtt/CMakeLists.txt
new file mode 100644
index 00000000..9ba79461
--- /dev/null
+++ b/src/mqtt/CMakeLists.txt
@@ -0,0 +1,134 @@
+# CMakeLists.txt
+#
+# Top-level CMake file for the Paho C++ library.
+#
+#*******************************************************************************
+# This is part of the Paho MQTT C++ client library.
+#
+# Copyright (c) 2016-2017, Guilherme Maciel Ferreira
+# Copyright (c) 2017, Frank Pagliughi
+#
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License v1.0
+# and Eclipse Distribution License v1.0 which accompany this distribution.
+# 
+# The Eclipse Public License is available at
+#   http://www.eclipse.org/legal/epl-v10.html
+# and the Eclipse Distribution License is available at
+#   http://www.eclipse.org/org/documents/edl-v10.php.
+# 
+# Contributors:
+#   Guilherme Maciel Ferreira - initial version
+#   Frank Pagliughi
+#*******************************************************************************/
+
+## Note: on OS X you should install XCode and the associated command-line tools
+
+## cmake flags
+cmake_minimum_required(VERSION 3.5)
+
+## project name
+project("paho-mqtt-cpp" 
+    VERSION "1.1.0"
+    LANGUAGES CXX
+)
+
+## --- Build options ---
+message(STATUS "mqtt........................")
+if(WIN32)
+  option(PAHO_BUILD_STATIC "Build static library" TRUE)
+  option(PAHO_BUILD_SHARED "Build shared library (DLL)" FALSE)
+  option(PAHO_WITH_SSL "Build SSL-enabled library" FALSE)
+  message(STATUS "win32")
+else()
+  option(PAHO_BUILD_STATIC "Build static library" FALSE)
+  option(PAHO_BUILD_SHARED "Build shared library" TRUE)
+  #option(PAHO_BUILD_STATIC "Build static library" TRUE)
+  #option(PAHO_BUILD_SHARED "Build shared library" FALSE)
+  #set(PAHO_BUILD_STATIC ON)
+  #set(PAHO_BUILD_SHARED OFF)
+  option(PAHO_WITH_SSL "Build SSL-enabled library" TRUE)
+  message(STATUS "non-win32" " " "PAHO_BUILD_STATIC:" ${PAHO_BUILD_STATIC} " " "PAHO_BUILD_SHARED:" ${PAHO_BUILD_SHARED})
+endif()
+
+## --- C++11 build flags ---
+
+set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+# Generate position-independent code (-fPIC on UNIX)
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+
+# --- System Libraries ---
+
+include(GNUInstallDirs)
+
+if(WIN32)
+    set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON)
+    set(LIBS_SYSTEM ws2_32)
+elseif(UNIX)
+    set(LIBS_SYSTEM c stdc++)
+endif()
+
+## --- Build directories ---
+
+# For the paho_mqtt_c module
+list(APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake)
+
+# --- Default library ---
+
+if(PAHO_BUILD_SHARED)
+    set(PAHO_CPP_LIB mqtt-shared)
+    message(STATUS "shared......" ${PAHO_BUILD_SHARED})
+    #set(PAHO_CPP_LIB paho-mqttpp3-static)
+else()
+    message(STATUS "static......")
+    set(PAHO_CPP_LIB mqtt)
+    ## --- Library dependencies ---
+    find_package(PahoMqttC REQUIRED)
+    set (THREADS_PREFER_PTHREAD_FLAG ON)
+    find_package(Threads REQUIRED)
+    set(sources
+            src/async_client.cpp
+            src/client.cpp
+            src/disconnect_options.cpp
+            src/iclient_persistence.cpp
+            src/message.cpp
+            src/properties.cpp
+            src/response_options.cpp
+            src/ssl_options.cpp
+            src/string_collection.cpp
+            src/subscribe_options.cpp
+            src/token.cpp
+            src/topic.cpp
+            src/connect_options.cpp
+            src/will_options.cpp
+            )
+    add_library(mqtt ${sources})
+    include_directories(./src/mqtt ${PAHO_MQTT_C_INCLUDE_DIRS})
+    target_link_libraries(mqtt
+            PRIVATE ${LIBS_SYSTEM}
+            PUBLIC PahoMqttC::PahoMqttC Threads::Threads
+            ${PAHO_MQTT_C_LIBRARIES}
+            )
+
+    target_include_directories(mqtt PUBLIC
+            $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
+            $<INSTALL_INTERFACE:include>
+            )
+endif()
+
+## --- Packaging settings ---
+
+if(WIN32)
+    set(CPACK_GENERATOR "ZIP")
+elseif(UNIX)
+    set(CPACK_GENERATOR "TGZ")
+endif()
+
+include(CPack)
+#add_subdirectory(cmake)
+
+
+
diff --git a/src/mqtt/CODING_STYLE.md b/src/mqtt/CODING_STYLE.md
new file mode 100644
index 00000000..ba0ed06d
--- /dev/null
+++ b/src/mqtt/CODING_STYLE.md
@@ -0,0 +1,30 @@
+# Eclipse Paho MQTT C++ Client Library
+# Coding Styles
+
+This document describes the coding style and language conventions used by the Eclipse Paho C++ Client Library.
+
+## Language Standard
+
+The Paho C++ library uses Modern C++, adhering to the C++11 standard.
+
+Nothing in the library should prevent it from being built with a compiler adhering to a newer standard such as C++14 or C++17, but at this point the library itself doesn't use any newer language feature than C++11. Unfortunately, compilers vary wildly from version to version and platform to platform. So this is a constant struggle to keep true.
+
+Adherence to the base C++11 standard may change at some point in the future. Newer versions of the library will likely start using newer language features some time in the future as they are more widely adapted by compilers and projects. The next logical jump would probably be to C++17.
+
+## Naming Convention
+
+The Paho C++ library attempts to follow the naming conventions of the C++ standard library as much as possible, as this seems the most definitive standard for the language.
+
+ - Class names are lower snake case:  *classes_like_this*
+ - Function names are lower snake case:  *functions_like_this*
+ - Variable names are lower camel case:  *varsLikeThis*
+ - Class memeber are lower camel case with a trailing underscore: *memVarsLikeThis_*
+ - Constants are all caps: *CONSTANTS_LIKE_THIS*
+ 
+## Format Conventions
+
+The top-level project directory contains a _.editorconfig_ file with some basic hints as to formatting conventions for source files. 
+
+A few minutes looking through the existing sources will reveal the basic styles used. Pull Requests should generally try to fit in to the existing style and not try to impose new ones. 
+
+At some point in the future, a formatter may be added to the project (probably Clang format), but until then, any sources that can be fixed up with an automated code generator or beautifier would generally be accepted into the project. But at some point soon after would then be reformat to fit into the overall conventions. 
\ No newline at end of file
diff --git a/src/mqtt/CONTRIBUTING.md b/src/mqtt/CONTRIBUTING.md
new file mode 100644
index 00000000..5f799ef1
--- /dev/null
+++ b/src/mqtt/CONTRIBUTING.md
@@ -0,0 +1,47 @@
+Contributing to Paho
+====================
+
+Thanks for your interest in this project.
+
+Project description:
+--------------------
+
+The Paho project has been created to provide scalable open-source implementations of open and standard messaging protocols aimed at new, existing, and emerging applications for Machine-to-Machine (M2M) and Internet of Things (IoT).
+Paho reflects the inherent physical and cost constraints of device connectivity. Its objectives include effective levels of decoupling between devices and applications, designed to keep markets open and encourage the rapid growth of scalable Web and Enterprise middleware and applications. Paho is being kicked off with MQTT publish/subscribe client implementations for use on embedded platforms, along with corresponding server support as determined by the community.
+
+- https://projects.eclipse.org/projects/technology.paho
+
+Developer resources:
+--------------------
+
+Information regarding source code management, builds, coding standards, and more.
+
+- https://projects.eclipse.org/projects/technology.paho/developer
+
+Contributor License Agreement:
+------------------------------
+
+Before your contribution can be accepted by the project, you need to create and electronically sign the Eclipse Foundation Contributor License Agreement (CLA).
+
+- http://www.eclipse.org/legal/CLA.php
+
+Contact:
+--------
+
+Contact the project developers via the project's "dev" list.
+
+- https://dev.eclipse.org/mailman/listinfo/paho-dev
+
+Search for bugs:
+----------------
+
+This project uses Bugzilla to track ongoing development and issues.
+
+- https://bugs.eclipse.org/bugs/buglist.cgi?product=Paho
+
+Create a new bug:
+-----------------
+
+Be sure to search for existing bugs before you create another one. Remember that contributions are always welcome!
+
+- https://bugs.eclipse.org/bugs/enter_bug.cgi?product=Paho
diff --git a/src/mqtt/README.md b/src/mqtt/README.md
new file mode 100644
index 00000000..6584f59b
--- /dev/null
+++ b/src/mqtt/README.md
@@ -0,0 +1,331 @@
+# Eclipse Paho MQTT C++ Client Library
+
+[![Build Status](https://travis-ci.org/eclipse/paho.mqtt.cpp.svg?branch=master)](https://travis-ci.org/eclipse/paho.mqtt.cpp)
+
+This repository contains the source code for the [Eclipse Paho](http://eclipse.org/paho) MQTT C++ client library on memory-managed operating systems such as Linux/Posix and Windows.
+
+This code builds a library which enables C++11 applications to connect to an [MQTT](http://mqtt.org) broker, publish messages to the broker, and to subscribe to topics and receive published messages.
+
+The library has the following features:
+
+- Support for MQTT v5, v3.1.1, and v 3.1
+- TCP, SSL/TLS, and WebSocket transports
+- Message persistence
+- Automatic reconnect
+- Offline buffering
+- High availability
+- Blocking and non-blocking API's
+
+This code requires the [Paho C library](https://github.com/eclipse/paho.mqtt.c) by Ian Craggs, et al., specifically version 1.3.1 or possibly later.
+
+## Latest News
+
+To keep up with the latest announcements for this project, or to ask questions:
+
+**Twitter:** [@eclipsepaho](https://twitter.com/eclipsepaho) and [@fmpagliughi](https://twitter.com/fmpagliughi)
+
+**EMail:** [Eclipse Paho Mailing List](https://accounts.eclipse.org/mailing-list/paho-dev)
+
+**Mattermost:** [Eclipse Mattermost Paho Channel](https://mattermost.eclipse.org/eclipse/channels/paho)
+
+
+### New Features in Paho C++ v1.1
+
+- MQTT v5 support:
+    - **Properties**
+        - New `property` class acts something like a std::variant to hold a property of any supported type.
+        - New `properties` class is a collection type to hold all the properties for a single transmitted packet.
+        - Properties can be added to outbound messages and obtained from received messages.
+        - Properties can also be obtained from server responses to requests such as from a _connect_ call. These are available in the `token` objects when they complete.
+    - The client object tracks the desired MQTT version that the app requested and/or is currently connected at. Internally this is now required by the `response_options` the need to distinguish between pre-v5 and post-v5 callback functions.
+    - MQTT v5 reason codes for requests are available via `token` objects when they complete. They are also available in `exception` objects that are thrown by tokens.
+    - Support for subscibe options, like no local subscriptions, etc.
+    - Sample applications were added showing how to do basic Remote Procedure Calls (RPC's) with MQTT v5 using the *RESPONSE_TOPIC* and *CORRELATION_DATA* properties. These are *rpc_math_cli* and *rpc_math_srvr* in the _src/samples_ directory.
+    - A sample "chat" application was added, showing how to use subscribe options, such as "no local".
+- More descriptive error messages (PR #154), integrated into the `mqtt::exception` class. MQTT v5 reason codes are also included in the exceptions when an error occurs.
+- Applications can (finally) get server responses from the various ACK packets. These are available through the tokens after they complete, as `connect_response`, `subscribe_response`, and `unsubscribe_response`.
+- The `topic` objects can be used to subscribe.
+- Applications can register individual callback functions instead of using a `callback` interface object. This allows easy use of lambda functions for callbacks.
+- The connect options can take a LWT as a plain message, via `connect_options::set_will_message()` 
+
+### _Catch2_ Unit Tests
+
+Unit tests are being converted to use _Catch2_ for the test framework. The legacy unit tests are still using _CppUnit_, compiled into a separate test executable. If everything goes well with _Catch2_, the older unit tests will be ported to _Catch2_ as well.
+
+_Catch2_ can be found here: [Catch2](https://github.com/catchorg/Catch2)
+
+## Contributing
+
+Contributions to this project are gladly welcomed. Before submitting a Pull Request, please keep two things in mind:
+
+ - This is an official Eclipse project, so it is required that all contributors sign an [Eclipse Contributor Agreement (ECA)](https://www.eclipse.org/legal/ECA.php)
+ - Please submit all Pull Requests against the _develop_ branch (not master).
+ 
+ For full details, see [CONTRIBUTING.md](https://github.com/eclipse/paho.mqtt.cpp/blob/master/CONTRIBUTING.md).
+ 
+## Building from source
+
+*GNU Make and autotools were deprecated and removed in the v1.1 release.*
+
+_CMake_  is a cross-platform build system suitable for Unix and non-Unix platforms such as Microsoft Windows. It is now the only supported build system.
+
+The Paho C++ library requires the Paho C library, v1.3.1 or greater, to be built and installed first. More information below.
+
+CMake allows for options to direct the build. The following are specific to Paho C++:
+
+Variable | Default Value | Description
+------------ | ------------- | -------------
+PAHO_BUILD_SHARED | TRUE (Linux), FALSE (Win32) | Whether to build the shared library
+PAHO_BUILD_STATIC | FALSE (Linux), TRUE (Win32) | Whether to build the static library
+PAHO_BUILD_DOCUMENTATION | FALSE | Create and install the HTML based API documentation (requires Doxygen)
+PAHO_BUILD_SAMPLES | FALSE | Build sample programs
+PAHO_BUILD_TESTS | FALSE | Build the unit tests. (This currently requires both _CppUnit_ and _Catch2_)
+PAHO_WITH_SSL | TRUE (Linux), FALSE (Win32) | Flag that defines whether to build ssl-enabled binaries too
+
+In addition, the C++ build might commonly use `CMAKE_PREFIX_PATH` to help the build system find the location of the Paho C library.
+
+### Unix and Linux
+
+On *nix systems CMake creates Makefiles.
+
+The build process currently supports a number of Unix and Linux flavors. The build process requires the following tools:
+
+  * CMake v3.5 or newer
+  * GCC v4.8 or newer or Clang v3.9 or newer
+  * GNU Make
+
+On Debian based systems this would mean that the following packages have to be installed:
+
+```
+$ sudo apt-get install build-essential gcc make cmake cmake-gui cmake-curses-gui
+```
+
+If you will be using secure sockets (and you probably should):
+
+```
+$ sudo apt-get install libssl-dev 
+```
+
+Building the documentation requires doxygen and optionally graphviz to be installed:
+
+```
+$ sudo apt-get install doxygen graphviz
+```
+
+Unite tests are currently being built using both _CppUnit_ and _Catch2_. The _CppUnit_ tests are being deprecated and replaced with _Catch2_ equivalents. In the meantime, however, both systems are required to build the tests.
+
+```
+$ sudo apt-get install libcppunit-dev
+```
+
+_Catch2_ can be found here: [Catch2](https://github.com/catchorg/Catch2)
+
+
+Before building the C++ library, first, build and install the Paho C library:
+
+```
+$ git clone https://github.com/eclipse/paho.mqtt.c.git
+$ cd paho.mqtt.c
+$ git checkout v1.3.1
+
+$ cmake -Bbuild -H. -DPAHO_WITH_SSL=ON -DPAHO_ENABLE_TESTING=OFF
+$ sudo cmake --build build/ --target install
+$ sudo ldconfig
+```
+
+This builds with SSL/TLS enabled. If that is not desired, omit the `-DPAHO_WITH_SSL=ON`.
+
+If you installed the C library on a non-standard path, you might want to pass it as value to the `CMAKE_PREFIX_PATH` option.
+
+Using these variables CMake can be used to generate your Makefiles. The out-of-source build is the default on CMake. Therefore it is recommended to invoke all build commands inside your chosen build directory.
+
+An example build session might look like this:
+
+```
+$ git clone https://github.com/eclipse/paho.mqtt.cpp
+$ cd paho.mqtt.cpp
+$ cmake -Bbuild -H. -DPAHO_BUILD_DOCUMENTATION=TRUE -DPAHO_BUILD_SAMPLES=TRUE
+$ sudo cmake --build build/ --target install
+$ sudo ldconfig
+```
+
+If you did not install Paho C library to a default system location or you want to build against a different version, use the `CMAKE_PREFIX_PATH` to specify its install location:
+
+```
+$ cmake -Bbuild -H. -DPAHO_BUILD_DOCUMENTATION=TRUE -DPAHO_BUILD_SAMPLES=TRUE \
+    -DCMAKE_PREFIX_PATH=../../paho.mqtt.c/build/install/usr/local
+```
+
+To use another compiler, either the CXX environment variable can be specified in the configuration step:
+
+```
+$ CXX=clang++ cmake ..
+```
+
+or the `CMAKE_CXX_COMPILER` flag can be used:
+
+
+```
+$ cmake -DCMAKE_CXX_COMPILER=clang++
+```
+
+#### Updating CMake on Ubuntu 14.04 or 16.04
+
+The versions of CMake on Ubuntu 14.04 or 16.04 LTS are pretty old and have some problems with Paho C++ library. A newer version can be added by downloading the source and building it. If the older cmake can be removed from the system using the package manager, or it can be kept, using the Ububtu alternatives to chose between the versions. 
+
+For example, here's how to install CMake v3.6 on Ubuntu 14.04, while keeping the older CMake available as _cmake-2.8:_
+
+```
+$ wget http://www.cmake.org/files/v3.6/cmake-3.6.3.tar.gz 
+$ tar -xvzf cmake-3.6.3.tar.gz 
+$ cd cmake-3.6.3/
+$ ./configure
+$ make
+$ sudo make install
+$ sudo mv /usr/bin/cmake /usr/bin/cmake-2.8
+$ sudo update-alternatives --install /usr/bin/cmake cmake /usr/local/bin/cmake 100
+$ sudo update-alternatives --install /usr/bin/cmake cmake /usr/bin/cmake-2.8 200
+$ cmake --version
+cmake version 3.6.3
+```
+
+You can speed up the CMake build on multi-core systems, by specifying parallel buid jobs for the configure and make steps, above, such as the following for a 4-core system:
+```
+$ ./configure --parallel=4
+$ make -j4
+$ sudo make install
+```
+
+### Windows
+
+On Windows systems CMake creates Visual Studio project files.
+
+The build process currently supports a number Windows versions. The build process requires the following tools:
+  * CMake GUI v3.5 or newer
+  * Visual Studio 2015 or newer
+
+First install and open the cmake-gui application. This tutorial is based on cmake-gui 3.5.2.
+
+Second, select the path to the Paho MQTT C library (CMAKE_PREFIX_PATH) if not installed in a standard path. Remember that the Paho MQTT C must be installed on the system. Next, choose if it is supposed to build the documentation (PAHO_BUILD_DOCUMENTATION) and/or the sample applications (PAHO_BUILD_SAMPLES).
+
+Once the configuration is done, click on the Configure button, select the version of the Visual Studio, and then click on Generate button.
+
+At the end of this process you have a Visual Studio solution.
+
+Alternately, the libraries can be completely built at an MSBuild Command Prompt. Download the Paho C and C++ library sources, then open a command window and first compile the Paho C library:
+
+```
+> cd paho.mqtt.c
+> cmake -Bbuild -H. -DCMAKE_INSTALL_PREFIX=C:\mqtt\paho-c
+> cmake --build build/ --target install
+```
+
+Then build the C++ library:
+
+```
+> cd ..\paho.mqtt.cpp
+> cmake -Bbuild -H. -DCMAKE_INSTALL_PREFIX=C:\mqtt\paho-cpp -DPAHO_BUILD_SAMPLES=ON -DPAHO_WITH_SSL=OFF -DCMAKE_PREFIX_PATH=C:\mqtt\paho-c
+> cmake --build build/ --target install
+```
+This builds and installs both libraries to a non-standard location under `C:\mqtt`. Modify this location as desired or use the default location, but either way, the C++ library will most likely need to be told where the C library was built using `CMAKE_PREFIX_PATH`.
+
+It seems quite odd, but even on a 64-bit system using a 64-bit compiler, MSVC seems to default to a 32-bit build target. 
+
+The 64-bit target can be selected using tge CMake generator switch, *-G*, at configuration time. The full version must be provided. For Visual Studio 2015 which is v14 do this to first build the Paho C library:
+
+```
+> cmake -G "Visual Studio 14 Win64" -Bbuild -H. -DCMAKE_INSTALL_PREFIX=C:\mqtt\paho-c
+...
+```
+
+Then use it to build the C++ library:
+
+```
+> cmake -G "Visual Studio 14 Win64" -Bbuild -H. -DCMAKE_INSTALL_PREFIX=C:\mqtt\paho-cpp -DPAHO_WITH_SSL=OFF -DCMAKE_PREFIX_PATH=C:\mqtt\paho-c
+...
+```
+
+*Note that it is very important that you use the same generator (target) to build BOTH libraries, otherwise you will get lots of linker errors when you try to build the C++ library.*
+
+
+## Example
+
+Sample applications can be found in the source repository at _src/samples_:
+https://github.com/eclipse/paho.mqtt.cpp/tree/master/src/samples
+
+This is a partial example of what a typical example might look like:
+
+```cpp
+int main(int argc, char* argv[])
+{
+    sample_mem_persistence persist;
+    mqtt::client client(ADDRESS, CLIENTID, &persist);
+
+    callback cb;
+    client.set_callback(cb);
+
+    mqtt::connect_options connOpts;
+    connOpts.set_keep_alive_interval(20);
+    connOpts.set_clean_session(true);
+
+    try {
+        client.connect(connOpts);
+
+        // First use a message pointer.
+
+        mqtt::message_ptr pubmsg = mqtt::make_message(PAYLOAD1);
+        pubmsg->set_qos(QOS);
+        client.publish(TOPIC, pubmsg);
+
+        // Now try with itemized publish.
+
+        client.publish(TOPIC, PAYLOAD2, strlen(PAYLOAD2)+1, 0, false);
+
+        // Disconnect
+        
+        client.disconnect();
+    }
+    catch (const mqtt::persistence_exception& exc) {
+        cerr << "Persistence Error: " << exc.what() << " ["
+            << exc.get_reason_code() << "]" << endl;
+        return 1;
+    }
+    catch (const mqtt::exception& exc) {
+        cerr << "Error: " << exc.what() << " ["
+            << exc.get_reason_code() << "]" << endl;
+        return 1;
+    }
+
+    return 0;
+}
+```
+
+-----------
+
+The original API organization and documentation were adapted from:
+
+The Paho Java library
+by Dave Locke.
+Copyright (c) 2012, IBM Corp
+
+ All rights reserved. This program and the accompanying materials
+ are made available under the terms of the Eclipse Public License v1.0
+ which accompanies this distribution, and is available at
+ http://www.eclipse.org/legal/epl-v10.html
+
+-----------
+
+This code requires:
+
+The Paho C library by Ian Craggs
+Copyright (c) 2013-2018, IBM Corp.
+
+ All rights reserved. This program and the accompanying materials
+ are made available under the terms of the Eclipse Public License v1.0
+ and Eclipse Distribution License v1.0 which accompany this distribution.
+
+ The Eclipse Public License is available at
+    http://www.eclipse.org/legal/epl-v10.html
+ and the Eclipse Distribution License is available at
+   http://www.eclipse.org/org/documents/edl-v10.php.
+
diff --git a/src/mqtt/about.html b/src/mqtt/about.html
new file mode 100644
index 00000000..6555a44e
--- /dev/null
+++ b/src/mqtt/about.html
@@ -0,0 +1,28 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml"><head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>About</title>
+</head>
+<body lang="EN-US">
+<h2>About This Content</h2>
+ 
+<p><em>December 9, 2013</em></p>	
+<h3>License</h3>
+
+<p>The Eclipse Foundation makes available all content in this plug-in ("Content").  Unless otherwise 
+indicated below, the Content is provided to you under the terms and conditions of the
+Eclipse Public License Version 1.0 ("EPL") and Eclipse Distribution License Version 1.0 ("EDL").
+A copy of the EPL is available at 
+<a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a> 
+and a copy of the EDL is available at 
+<a href="http://www.eclipse.org/org/documents/edl-v10.php">http://www.eclipse.org/org/documents/edl-v10.php</a>. 
+For purposes of the EPL, "Program" will mean the Content.</p>
+
+<p>If you did not receive this Content directly from the Eclipse Foundation, the Content is 
+being redistributed by another party ("Redistributor") and different terms and conditions may
+apply to your use of any object code in the Content.  Check the Redistributor's license that was 
+provided with the Content.  If no such license exists, contact the Redistributor.  Unless otherwise
+indicated below, the terms and conditions of the EPL still apply to any source code in the Content
+and such source code may be obtained at <a href="http://www.eclipse.org/">http://www.eclipse.org</a>.</p>
+
+</body></html>
diff --git a/src/mqtt/buildtst.sh b/src/mqtt/buildtst.sh
new file mode 100755
index 00000000..1df494d3
--- /dev/null
+++ b/src/mqtt/buildtst.sh
@@ -0,0 +1,66 @@
+#!/bin/bash
+#
+# buildtst.sh
+# 
+# Build test for the Paho C++ library.
+#
+# This test the build with a few compilers on Linux. It does a build using 
+# CMake, for the library, tests, and examples, then runs the unit tests.
+# This is repeated for each of the compilers in the list. If a particular 
+# compiler is not installed on the system, it is just skipped.
+#
+# This is not meant to replace Travis or other CI on the repo server, but
+# is a quick test to use locally during development.
+#
+
+COMPILERS="g++-5 g++-6 g++-7 g++-8 clang++-3.9 clang++-4.0 clang++-5.0 clang++-6.0 clang++-7 clang++-8"
+[ "$#" -gt 0 ] && COMPILERS="$@"
+
+[ -z "${BUILD_JOBS}" ] && BUILD_JOBS=4
+[ -n "${PAHO_C_PATH}" ] && PAHO_C_SWITCH="-DCMAKE_PREFIX_PATH=${PAHO_C_PATH}"
+
+for COMPILER in $COMPILERS; do
+    if [ -z "$(which ${COMPILER})" ]; then
+        printf "Compiler not found: %s\n" "${COMPILER}"
+    else
+        printf "===== Testing: %s =====\n\n" "${COMPILER}"
+        rm -rf buildtst-build/
+        mkdir buildtst-build ; pushd buildtst-build &> /dev/null
+
+        if ! cmake -DCMAKE_CXX_COMPILER=${COMPILER} -DPAHO_WITH_SSL=ON -DPAHO_BUILD_SAMPLES=ON -DPAHO_BUILD_TESTS=ON ${PAHO_C_SWITCH} .. ; then
+            printf "\nCMake configuration failed for %s\n" "${COMPILER}"
+            exit 1
+        fi
+
+        if ! make -j${BUILD_JOBS} ; then
+            printf "\nCompilation failed for %s\n" "${COMPILER}"
+            exit 2
+        fi
+
+        printf "Running Catch2 Unit tests for %s:\n" "${COMPILER}"
+        if ! ./test/unit/unit_tests ; then
+            printf "\nCatch2 unit test failed for %s\n" "${COMPILER}"
+            exit 3
+        fi
+
+        printf "Running CppUnit tests for %s:\n" "${COMPILER}"
+        if ! ./test/cppunit/paho-mqttpp-test ; then
+            printf "\nUnit test failed for %s\n" "${COMPILER}"
+            exit 4
+        fi
+
+        popd &> /dev/null
+    fi
+    printf "\n"
+done
+
+rm -rf buildtst-build/
+printf "\nAll builds completed successfully\n\n"
+
+if ! cppcheck --enable=all --std=c++11 --force --quiet src/*.cpp ; then
+    printf "\ncppcheck failed\n"
+    exit 5
+fi
+
+printf "\n===== All tests completed successfully =====\n\n"
+exit 0
diff --git a/src/mqtt/cmake/CMakeLists.txt b/src/mqtt/cmake/CMakeLists.txt
new file mode 100644
index 00000000..a9f89087
--- /dev/null
+++ b/src/mqtt/cmake/CMakeLists.txt
@@ -0,0 +1,22 @@
+set(package_name PahoMqttCpp)
+configure_file(${package_name}Config.cmake.in ${package_name}Config.cmake @ONLY)
+
+include(CMakePackageConfigHelpers)
+write_basic_package_version_file(
+    "${CMAKE_CURRENT_BINARY_DIR}/${package_name}ConfigVersion.cmake"
+    VERSION ${PROJECT_VERSION}
+    COMPATIBILITY SameMajorVersion) # TODO
+
+export(EXPORT ${package_name}
+    FILE "${CMAKE_CURRENT_BINARY_DIR}/${package_name}Targets.cmake"
+    NAMESPACE ${package_name}::)
+
+install(EXPORT ${package_name} DESTINATION lib/cmake/${package_name}
+    FILE ${package_name}Targets.cmake
+    NAMESPACE ${package_name}::)
+
+install(FILES
+    "${CMAKE_CURRENT_BINARY_DIR}/${package_name}Config.cmake"
+    FindPahoMqttC.cmake
+    "${CMAKE_CURRENT_BINARY_DIR}/${package_name}ConfigVersion.cmake"
+    DESTINATION lib/cmake/${package_name})
diff --git a/src/mqtt/cmake/FindPahoMqttC.cmake b/src/mqtt/cmake/FindPahoMqttC.cmake
new file mode 100644
index 00000000..53f15a39
--- /dev/null
+++ b/src/mqtt/cmake/FindPahoMqttC.cmake
@@ -0,0 +1,31 @@
+# find the Paho MQTT C library
+if(PAHO_WITH_SSL)
+    set(_PAHO_MQTT_C_LIB_NAME paho-mqtt3as)
+    find_package(OpenSSL REQUIRED)
+else()
+    set(_PAHO_MQTT_C_LIB_NAME paho-mqtt3a)
+endif()
+# add suffix when using static Paho MQTT C library variant
+if(PAHO_BUILD_STATIC)
+    set(_PAHO_MQTT_C_LIB_NAME ${_PAHO_MQTT_C_LIB_NAME}-static)
+endif()
+
+find_library(PAHO_MQTT_C_LIBRARIES NAMES ${_PAHO_MQTT_C_LIB_NAME})
+unset(_PAHO_MQTT_C_LIB_NAME)
+find_path(PAHO_MQTT_C_INCLUDE_DIRS NAMES MQTTAsync.h)
+
+add_library(PahoMqttC::PahoMqttC UNKNOWN IMPORTED)
+
+set_target_properties(PahoMqttC::PahoMqttC PROPERTIES
+    IMPORTED_LOCATION "${PAHO_MQTT_C_LIBRARIES}"
+    INTERFACE_INCLUDE_DIRECTORIES "${PAHO_MQTT_C_INCLUDE_DIRS}"
+    IMPORTED_LINK_INTERFACE_LANGUAGES "C")
+if(PAHO_WITH_SSL)
+    set_target_properties(PahoMqttC::PahoMqttC PROPERTIES
+            INTERFACE_COMPILE_DEFINITIONS "OPENSSL=1"
+            INTERFACE_LINK_LIBRARIES "OpenSSL::SSL;OpenSSL::Crypto")
+endif()
+
+include(FindPackageHandleStandardArgs)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(PahoMqttC
+    REQUIRED_VARS PAHO_MQTT_C_LIBRARIES PAHO_MQTT_C_INCLUDE_DIRS)
diff --git a/src/mqtt/cmake/PahoMqttCppConfig.cmake.in b/src/mqtt/cmake/PahoMqttCppConfig.cmake.in
new file mode 100644
index 00000000..aff9472c
--- /dev/null
+++ b/src/mqtt/cmake/PahoMqttCppConfig.cmake.in
@@ -0,0 +1,11 @@
+# save build-time options
+set(PAHO_BUILD_STATIC @PAHO_BUILD_STATIC@)
+set(PAHO_BUILD_SHARED @PAHO_BUILD_SHARED@)
+set(PAHO_WITH_SSL @PAHO_WITH_SSL@)
+
+include(CMakeFindDependencyMacro)
+list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR})
+find_dependency(PahoMqttC REQUIRED)
+list(REMOVE_AT CMAKE_MODULE_PATH -1)
+
+include("${CMAKE_CURRENT_LIST_DIR}/@package_name@Targets.cmake")
diff --git a/src/mqtt/devenv.sh b/src/mqtt/devenv.sh
new file mode 100644
index 00000000..254626bc
--- /dev/null
+++ b/src/mqtt/devenv.sh
@@ -0,0 +1,18 @@
+#!/bin/bash
+#
+# devenv.sh
+#
+# Sets up a development environment for working on the the Paho C++ Library on Linux,
+# using the development tree of the Paho C library. 
+# This is _not_ necessary for building applications against the library once it has 
+# been installed - it's just for library developers.
+#
+# Source it into the current shell as:
+#     $ source devenv.sh
+#
+
+PAHO_C_DIR=$(readlink -e ../paho.mqtt.c)
+
+export DEVELOP=1
+export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:${PAHO_C_DIR}/build/output:${PWD}/lib
+
diff --git a/src/mqtt/dist/Makefile b/src/mqtt/dist/Makefile
new file mode 100644
index 00000000..7c485e7f
--- /dev/null
+++ b/src/mqtt/dist/Makefile
@@ -0,0 +1,11 @@
+VERSION=1.0.0
+
+check:
+	rpmlint -i dist/paho-cpp.spec
+
+rpm-prep:
+	mkdir -p ${HOME}/rpmbuild/SOURCES/
+	tar --transform="s/\./paho-cpp-${VERSION}/" -cf ${HOME}/rpmbuild/SOURCES/v${VERSION}.tar.gz --exclude=./build.paho.cpp --exclude=.git --exclude=*.bz ./ --gzip
+
+rpm: rpm-prep
+	rpmbuild -ba dist/paho-cpp.spec
diff --git a/src/mqtt/dist/paho-cpp.spec b/src/mqtt/dist/paho-cpp.spec
new file mode 100644
index 00000000..6a05157a
--- /dev/null
+++ b/src/mqtt/dist/paho-cpp.spec
@@ -0,0 +1,64 @@
+Summary:            MQTT CPP Client
+Name:               paho-cpp
+Version:            1.0.0
+Release:            0%{?dist}
+License:            Eclipse Distribution License 1.0 and Eclipse Public License 1.0
+Group:              Development/Tools
+Source:             https://github.com/eclipse/paho.mqtt.cpp/archive/v%{version}.tar.gz
+URL:                https://eclipse.org/paho/clients/cpp/
+BuildRequires:      cmake3
+BuildRequires:      gcc
+BuildRequires:      graphviz
+BuildRequires:      doxygen
+BuildRequires:      openssl-devel
+BuildRequires:      paho-c-devel
+Requires:           openssl
+Requires:           paho-c
+
+
+%description
+The Paho MQTT CPP Client is a fully fledged MQTT client written in ANSI standard C++ 11.
+
+
+%package devel
+Summary:            MQTT CPP Client development kit
+Group:              Development/Libraries
+Requires:           paho-cpp
+
+%description devel
+Development files and samples for the the Paho MQTT CPP Client.
+
+
+%package devel-docs
+Summary:            MQTT CPP Client development kit documentation
+Group:              Development/Libraries
+
+%description devel-docs
+Development documentation files for the the Paho MQTT CPP Client.
+
+%prep
+%autosetup -n paho-cpp-%{version}
+
+%build
+mkdir build.paho.cpp && cd build.paho.cpp
+%cmake3 -DPAHO_WITH_SSL=TRUE -DPAHO_BUILD_DOCUMENTATION=TRUE -DPAHO_BUILD_SAMPLES=TRUE ..
+make %{?_smp_mflags}
+
+%install
+cd build.paho.cpp
+make install DESTDIR=%{buildroot}
+
+%files
+%doc edl-v10 epl-v10
+%{_libdir}/*
+
+%files devel
+%{_bindir}/*
+%{_includedir}/*
+
+%files devel-docs
+%{_datadir}/*
+
+%changelog
+* Wed Oct 11 2017 Julien Courtat <julien.courtat@aqsacom.com> - 1.0.0
+- Initial packaging
diff --git a/src/mqtt/edl-v10 b/src/mqtt/edl-v10
new file mode 100644
index 00000000..cf989f14
--- /dev/null
+++ b/src/mqtt/edl-v10
@@ -0,0 +1,15 @@
+
+Eclipse Distribution License - v 1.0
+
+Copyright (c) 2007, Eclipse Foundation, Inc. and its licensors.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+    Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+    Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+    Neither the name of the Eclipse Foundation, Inc. nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. 
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
diff --git a/src/mqtt/epl-v10 b/src/mqtt/epl-v10
new file mode 100644
index 00000000..79e486c3
--- /dev/null
+++ b/src/mqtt/epl-v10
@@ -0,0 +1,70 @@
+Eclipse Public License - v 1.0
+
+THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT.
+
+1. DEFINITIONS
+
+"Contribution" means:
+
+a) in the case of the initial Contributor, the initial code and documentation distributed under this Agreement, and
+b) in the case of each subsequent Contributor:
+i) changes to the Program, and
+ii) additions to the Program;
+where such changes and/or additions to the Program originate from and are distributed by that particular Contributor. A Contribution 'originates' from a Contributor if it was added to the Program by such Contributor itself or anyone acting on such Contributor's behalf. Contributions do not include additions to the Program which: (i) are separate modules of software distributed in conjunction with the Program under their own license agreement, and (ii) are not derivative works of the Program.
+"Contributor" means any person or entity that distributes the Program.
+
+"Licensed Patents" mean patent claims licensable by a Contributor which are necessarily infringed by the use or sale of its Contribution alone or when combined with the Program.
+
+"Program" means the Contributions distributed in accordance with this Agreement.
+
+"Recipient" means anyone who receives the Program under this Agreement, including all Contributors.
+
+2. GRANT OF RIGHTS
+
+a) Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide, royalty-free copyright license to reproduce, prepare derivative works of, publicly display, publicly perform, distribute and sublicense the Contribution of such Contributor, if any, and such derivative works, in source code and object code form.
+b) Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide, royalty-free patent license under Licensed Patents to make, use, sell, offer to sell, import and otherwise transfer the Contribution of such Contributor, if any, in source code and object code form. This patent license shall apply to the combination of the Contribution and the Program if, at the time the Contribution is added by the Contributor, such addition of the Contribution causes such combination to be covered by the Licensed Patents. The patent license shall not apply to any other combinations which include the Contribution. No hardware per se is licensed hereunder.
+c) Recipient understands that although each Contributor grants the licenses to its Contributions set forth herein, no assurances are provided by any Contributor that the Program does not infringe the patent or other intellectual property rights of any other entity. Each Contributor disclaims any liability to Recipient for claims brought by any other entity based on infringement of intellectual property rights or otherwise. As a condition to exercising the rights and licenses granted hereunder, each Recipient hereby assumes sole responsibility to secure any other intellectual property rights needed, if any. For example, if a third party patent license is required to allow Recipient to distribute the Program, it is Recipient's responsibility to acquire that license before distributing the Program.
+d) Each Contributor represents that to its knowledge it has sufficient copyright rights in its Contribution, if any, to grant the copyright license set forth in this Agreement.
+3. REQUIREMENTS
+
+A Contributor may choose to distribute the Program in object code form under its own license agreement, provided that:
+
+a) it complies with the terms and conditions of this Agreement; and
+b) its license agreement:
+i) effectively disclaims on behalf of all Contributors all warranties and conditions, express and implied, including warranties or conditions of title and non-infringement, and implied warranties or conditions of merchantability and fitness for a particular purpose;
+ii) effectively excludes on behalf of all Contributors all liability for damages, including direct, indirect, special, incidental and consequential damages, such as lost profits;
+iii) states that any provisions which differ from this Agreement are offered by that Contributor alone and not by any other party; and
+iv) states that source code for the Program is available from such Contributor, and informs licensees how to obtain it in a reasonable manner on or through a medium customarily used for software exchange.
+When the Program is made available in source code form:
+
+a) it must be made available under this Agreement; and
+b) a copy of this Agreement must be included with each copy of the Program.
+Contributors may not remove or alter any copyright notices contained within the Program.
+
+Each Contributor must identify itself as the originator of its Contribution, if any, in a manner that reasonably allows subsequent Recipients to identify the originator of the Contribution.
+
+4. COMMERCIAL DISTRIBUTION
+
+Commercial distributors of software may accept certain responsibilities with respect to end users, business partners and the like. While this license is intended to facilitate the commercial use of the Program, the Contributor who includes the Program in a commercial product offering should do so in a manner which does not create potential liability for other Contributors. Therefore, if a Contributor includes the Program in a commercial product offering, such Contributor ("Commercial Contributor") hereby agrees to defend and indemnify every other Contributor ("Indemnified Contributor") against any losses, damages and costs (collectively "Losses") arising from claims, lawsuits and other legal actions brought by a third party against the Indemnified Contributor to the extent caused by the acts or omissions of such Commercial Contributor in connection with its distribution of the Program in a commercial product offering. The obligations in this section do not apply to any claims or Losses relating to any actual or alleged intellectual property infringement. In order to qualify, an Indemnified Contributor must: a) promptly notify the Commercial Contributor in writing of such claim, and b) allow the Commercial Contributor to control, and cooperate with the Commercial Contributor in, the defense and any related settlement negotiations. The Indemnified Contributor may participate in any such claim at its own expense.
+
+For example, a Contributor might include the Program in a commercial product offering, Product X. That Contributor is then a Commercial Contributor. If that Commercial Contributor then makes performance claims, or offers warranties related to Product X, those performance claims and warranties are such Commercial Contributor's responsibility alone. Under this section, the Commercial Contributor would have to defend claims against the other Contributors related to those performance claims and warranties, and if a court requires any other Contributor to pay any damages as a result, the Commercial Contributor must pay those damages.
+
+5. NO WARRANTY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely responsible for determining the appropriateness of using and distributing the Program and assumes all risks associated with its exercise of rights under this Agreement , including but not limited to the risks and costs of program errors, compliance with applicable laws, damage to or loss of data, programs or equipment, and unavailability or interruption of operations.
+
+6. DISCLAIMER OF LIABILITY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+
+7. GENERAL
+
+If any provision of this Agreement is invalid or unenforceable under applicable law, it shall not affect the validity or enforceability of the remainder of the terms of this Agreement, and without further action by the parties hereto, such provision shall be reformed to the minimum extent necessary to make such provision valid and enforceable.
+
+If Recipient institutes patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Program itself (excluding combinations of the Program with other software or hardware) infringes such Recipient's patent(s), then such Recipient's rights granted under Section 2(b) shall terminate as of the date such litigation is filed.
+
+All Recipient's rights under this Agreement shall terminate if it fails to comply with any of the material terms or conditions of this Agreement and does not cure such failure in a reasonable period of time after becoming aware of such noncompliance. If all Recipient's rights under this Agreement terminate, Recipient agrees to cease use and distribution of the Program as soon as reasonably practicable. However, Recipient's obligations under this Agreement and any licenses granted by Recipient relating to the Program shall continue and survive.
+
+Everyone is permitted to copy and distribute copies of this Agreement, but in order to avoid inconsistency the Agreement is copyrighted and may only be modified in the following manner. The Agreement Steward reserves the right to publish new versions (including revisions) of this Agreement from time to time. No one other than the Agreement Steward has the right to modify this Agreement. The Eclipse Foundation is the initial Agreement Steward. The Eclipse Foundation may assign the responsibility to serve as the Agreement Steward to a suitable separate entity. Each new version of the Agreement will be given a distinguishing version number. The Program (including Contributions) may always be distributed subject to the version of the Agreement under which it was received. In addition, after a new version of the Agreement is published, Contributor may elect to distribute the Program (including its Contributions) under the new version. Except as expressly stated in Sections 2(a) and 2(b) above, Recipient receives no rights or licenses to the intellectual property of any Contributor under this Agreement, whether expressly, by implication, estoppel or otherwise. All rights in the Program not expressly granted under this Agreement are reserved.
+
+This Agreement is governed by the laws of the State of New York and the intellectual property laws of the United States of America. No party to this Agreement will bring a legal action under this Agreement more than one year after the cause of action arose. Each party waives its rights to a jury trial in any resulting litigation.
diff --git a/src/mqtt/install_catch2.sh b/src/mqtt/install_catch2.sh
new file mode 100755
index 00000000..95c4290d
--- /dev/null
+++ b/src/mqtt/install_catch2.sh
@@ -0,0 +1,22 @@
+#!/bin/bash
+#
+# install_catch2.sh
+#
+# Travis CI build/test helper script for the Eclipse Paho C++ library.
+# This installs Catch2 into the VM.
+#
+
+set -ex
+
+VERSION=2.9.1
+
+# Install Catch2 from sources
+wget https://github.com/catchorg/Catch2/archive/v${VERSION}.tar.gz
+tar -xf v${VERSION}.tar.gz
+cd Catch2-${VERSION}/
+cmake -Bbuild -H. -DBUILD_TESTING=OFF
+
+# CMake bin is installed in a strange place where
+# sudo can not find by default.
+sudo env "PATH=$PATH" cmake --build build/ --target install
+
diff --git a/src/mqtt/install_paho_mqtt_c.sh b/src/mqtt/install_paho_mqtt_c.sh
new file mode 100755
index 00000000..8fd7f4b4
--- /dev/null
+++ b/src/mqtt/install_paho_mqtt_c.sh
@@ -0,0 +1,16 @@
+#!/bin/bash
+#
+# Installs the matching version of Paho MQTT C library required by the C++ lib.
+#
+
+set -ex
+
+git clone https://github.com/eclipse/paho.mqtt.c.git
+cd paho.mqtt.c
+git checkout v1.3.1
+cmake -Bbuild -H. -DPAHO_WITH_SSL=ON -DPAHO_BUILD_STATIC=ON -DCMAKE_POSITION_INDEPENDENT_CODE=ON -DPAHO_ENABLE_TESTING=OFF
+sudo env "PATH=$PATH" cmake --build build/ --target install
+sudo ldconfig
+exit 0
+
+
diff --git a/src/mqtt/m4/README b/src/mqtt/m4/README
new file mode 100644
index 00000000..cb81aba7
--- /dev/null
+++ b/src/mqtt/m4/README
@@ -0,0 +1,3 @@
+Fix the problem
+
+aclocal: error: couldn't open directory 'm4': No such file or directory
diff --git a/src/mqtt/m4/m4_ax_cxx_compile_stdcxx.m4 b/src/mqtt/m4/m4_ax_cxx_compile_stdcxx.m4
new file mode 100644
index 00000000..2c18e49c
--- /dev/null
+++ b/src/mqtt/m4/m4_ax_cxx_compile_stdcxx.m4
@@ -0,0 +1,562 @@
+# ===========================================================================
+#   http://www.gnu.org/software/autoconf-archive/ax_cxx_compile_stdcxx.html
+# ===========================================================================
+#
+# SYNOPSIS
+#
+#   AX_CXX_COMPILE_STDCXX(VERSION, [ext|noext], [mandatory|optional])
+#
+# DESCRIPTION
+#
+#   Check for baseline language coverage in the compiler for the specified
+#   version of the C++ standard.  If necessary, add switches to CXX and
+#   CXXCPP to enable support.  VERSION may be '11' (for the C++11 standard)
+#   or '14' (for the C++14 standard).
+#
+#   The second argument, if specified, indicates whether you insist on an
+#   extended mode (e.g. -std=gnu++11) or a strict conformance mode (e.g.
+#   -std=c++11).  If neither is specified, you get whatever works, with
+#   preference for an extended mode.
+#
+#   The third argument, if specified 'mandatory' or if left unspecified,
+#   indicates that baseline support for the specified C++ standard is
+#   required and that the macro should error out if no mode with that
+#   support is found.  If specified 'optional', then configuration proceeds
+#   regardless, after defining HAVE_CXX${VERSION} if and only if a
+#   supporting mode is found.
+#
+# LICENSE
+#
+#   Copyright (c) 2008 Benjamin Kosnik <bkoz@redhat.com>
+#   Copyright (c) 2012 Zack Weinberg <zackw@panix.com>
+#   Copyright (c) 2013 Roy Stogner <roystgnr@ices.utexas.edu>
+#   Copyright (c) 2014, 2015 Google Inc.; contributed by Alexey Sokolov <sokolov@google.com>
+#   Copyright (c) 2015 Paul Norman <penorman@mac.com>
+#   Copyright (c) 2015 Moritz Klammler <moritz@klammler.eu>
+#
+#   Copying and distribution of this file, with or without modification, are
+#   permitted in any medium without royalty provided the copyright notice
+#   and this notice are preserved.  This file is offered as-is, without any
+#   warranty.
+
+#serial 4
+
+dnl  This macro is based on the code from the AX_CXX_COMPILE_STDCXX_11 macro
+dnl  (serial version number 13).
+
+AC_DEFUN([AX_CXX_COMPILE_STDCXX], [dnl
+  m4_if([$1], [11], [],
+        [$1], [14], [],
+        [$1], [17], [m4_fatal([support for C++17 not yet implemented in AX_CXX_COMPILE_STDCXX])],
+        [m4_fatal([invalid first argument `$1' to AX_CXX_COMPILE_STDCXX])])dnl
+  m4_if([$2], [], [],
+        [$2], [ext], [],
+        [$2], [noext], [],
+        [m4_fatal([invalid second argument `$2' to AX_CXX_COMPILE_STDCXX])])dnl
+  m4_if([$3], [], [ax_cxx_compile_cxx$1_required=true],
+        [$3], [mandatory], [ax_cxx_compile_cxx$1_required=true],
+        [$3], [optional], [ax_cxx_compile_cxx$1_required=false],
+        [m4_fatal([invalid third argument `$3' to AX_CXX_COMPILE_STDCXX])])
+  AC_LANG_PUSH([C++])dnl
+  ac_success=no
+  AC_CACHE_CHECK(whether $CXX supports C++$1 features by default,
+  ax_cv_cxx_compile_cxx$1,
+  [AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])],
+    [ax_cv_cxx_compile_cxx$1=yes],
+    [ax_cv_cxx_compile_cxx$1=no])])
+  if test x$ax_cv_cxx_compile_cxx$1 = xyes; then
+    ac_success=yes
+  fi
+
+  m4_if([$2], [noext], [], [dnl
+  if test x$ac_success = xno; then
+    for switch in -std=gnu++$1 -std=gnu++0x; do
+      cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx$1_$switch])
+      AC_CACHE_CHECK(whether $CXX supports C++$1 features with $switch,
+                     $cachevar,
+        [ac_save_CXX="$CXX"
+         CXX="$CXX $switch"
+         AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])],
+          [eval $cachevar=yes],
+          [eval $cachevar=no])
+         CXX="$ac_save_CXX"])
+      if eval test x\$$cachevar = xyes; then
+        CXX="$CXX $switch"
+        if test -n "$CXXCPP" ; then
+          CXXCPP="$CXXCPP $switch"
+        fi
+        ac_success=yes
+        break
+      fi
+    done
+  fi])
+
+  m4_if([$2], [ext], [], [dnl
+  if test x$ac_success = xno; then
+    dnl HP's aCC needs +std=c++11 according to:
+    dnl http://h21007.www2.hp.com/portal/download/files/unprot/aCxx/PDF_Release_Notes/769149-001.pdf
+    dnl Cray's crayCC needs "-h std=c++11"
+    for switch in -std=c++$1 -std=c++0x +std=c++$1 "-h std=c++$1"; do
+      cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx$1_$switch])
+      AC_CACHE_CHECK(whether $CXX supports C++$1 features with $switch,
+                     $cachevar,
+        [ac_save_CXX="$CXX"
+         CXX="$CXX $switch"
+         AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])],
+          [eval $cachevar=yes],
+          [eval $cachevar=no])
+         CXX="$ac_save_CXX"])
+      if eval test x\$$cachevar = xyes; then
+        CXX="$CXX $switch"
+        if test -n "$CXXCPP" ; then
+          CXXCPP="$CXXCPP $switch"
+        fi
+        ac_success=yes
+        break
+      fi
+    done
+  fi])
+  AC_LANG_POP([C++])
+  if test x$ax_cxx_compile_cxx$1_required = xtrue; then
+    if test x$ac_success = xno; then
+      AC_MSG_ERROR([*** A compiler with support for C++$1 language features is required.])
+    fi
+  fi
+  if test x$ac_success = xno; then
+    HAVE_CXX$1=0
+    AC_MSG_NOTICE([No compiler with C++$1 support was found])
+  else
+    HAVE_CXX$1=1
+    AC_DEFINE(HAVE_CXX$1,1,
+              [define if the compiler supports basic C++$1 syntax])
+  fi
+  AC_SUBST(HAVE_CXX$1)
+])
+
+
+dnl  Test body for checking C++11 support
+
+m4_define([_AX_CXX_COMPILE_STDCXX_testbody_11],
+  _AX_CXX_COMPILE_STDCXX_testbody_new_in_11
+)
+
+
+dnl  Test body for checking C++14 support
+
+m4_define([_AX_CXX_COMPILE_STDCXX_testbody_14],
+  _AX_CXX_COMPILE_STDCXX_testbody_new_in_11
+  _AX_CXX_COMPILE_STDCXX_testbody_new_in_14
+)
+
+
+dnl  Tests for new features in C++11
+
+m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_11], [[
+
+// If the compiler admits that it is not ready for C++11, why torture it?
+// Hopefully, this will speed up the test.
+
+#ifndef __cplusplus
+
+#error "This is not a C++ compiler"
+
+#elif __cplusplus < 201103L
+
+#error "This is not a C++11 compiler"
+
+#else
+
+namespace cxx11
+{
+
+  namespace test_static_assert
+  {
+
+    template <typename T>
+    struct check
+    {
+      static_assert(sizeof(int) <= sizeof(T), "not big enough");
+    };
+
+  }
+
+  namespace test_final_override
+  {
+
+    struct Base
+    {
+      virtual void f() {}
+    };
+
+    struct Derived : public Base
+    {
+      virtual void f() override {}
+    };
+
+  }
+
+  namespace test_double_right_angle_brackets
+  {
+
+    template < typename T >
+    struct check {};
+
+    typedef check<void> single_type;
+    typedef check<check<void>> double_type;
+    typedef check<check<check<void>>> triple_type;
+    typedef check<check<check<check<void>>>> quadruple_type;
+
+  }
+
+  namespace test_decltype
+  {
+
+    int
+    f()
+    {
+      int a = 1;
+      decltype(a) b = 2;
+      return a + b;
+    }
+
+  }
+
+  namespace test_type_deduction
+  {
+
+    template < typename T1, typename T2 >
+    struct is_same
+    {
+      static const bool value = false;
+    };
+
+    template < typename T >
+    struct is_same<T, T>
+    {
+      static const bool value = true;
+    };
+
+    template < typename T1, typename T2 >
+    auto
+    add(T1 a1, T2 a2) -> decltype(a1 + a2)
+    {
+      return a1 + a2;
+    }
+
+    int
+    test(const int c, volatile int v)
+    {
+      static_assert(is_same<int, decltype(0)>::value == true, "");
+      static_assert(is_same<int, decltype(c)>::value == false, "");
+      static_assert(is_same<int, decltype(v)>::value == false, "");
+      auto ac = c;
+      auto av = v;
+      auto sumi = ac + av + 'x';
+      auto sumf = ac + av + 1.0;
+      static_assert(is_same<int, decltype(ac)>::value == true, "");
+      static_assert(is_same<int, decltype(av)>::value == true, "");
+      static_assert(is_same<int, decltype(sumi)>::value == true, "");
+      static_assert(is_same<int, decltype(sumf)>::value == false, "");
+      static_assert(is_same<int, decltype(add(c, v))>::value == true, "");
+      return (sumf > 0.0) ? sumi : add(c, v);
+    }
+
+  }
+
+  namespace test_noexcept
+  {
+
+    int f() { return 0; }
+    int g() noexcept { return 0; }
+
+    static_assert(noexcept(f()) == false, "");
+    static_assert(noexcept(g()) == true, "");
+
+  }
+
+  namespace test_constexpr
+  {
+
+    template < typename CharT >
+    unsigned long constexpr
+    strlen_c_r(const CharT *const s, const unsigned long acc) noexcept
+    {
+      return *s ? strlen_c_r(s + 1, acc + 1) : acc;
+    }
+
+    template < typename CharT >
+    unsigned long constexpr
+    strlen_c(const CharT *const s) noexcept
+    {
+      return strlen_c_r(s, 0UL);
+    }
+
+    static_assert(strlen_c("") == 0UL, "");
+    static_assert(strlen_c("1") == 1UL, "");
+    static_assert(strlen_c("example") == 7UL, "");
+    static_assert(strlen_c("another\0example") == 7UL, "");
+
+  }
+
+  namespace test_rvalue_references
+  {
+
+    template < int N >
+    struct answer
+    {
+      static constexpr int value = N;
+    };
+
+    answer<1> f(int&)       { return answer<1>(); }
+    answer<2> f(const int&) { return answer<2>(); }
+    answer<3> f(int&&)      { return answer<3>(); }
+
+    void
+    test()
+    {
+      int i = 0;
+      const int c = 0;
+      static_assert(decltype(f(i))::value == 1, "");
+      static_assert(decltype(f(c))::value == 2, "");
+      static_assert(decltype(f(0))::value == 3, "");
+    }
+
+  }
+
+  namespace test_uniform_initialization
+  {
+
+    struct test
+    {
+      static const int zero {};
+      static const int one {1};
+    };
+
+    static_assert(test::zero == 0, "");
+    static_assert(test::one == 1, "");
+
+  }
+
+  namespace test_lambdas
+  {
+
+    void
+    test1()
+    {
+      auto lambda1 = [](){};
+      auto lambda2 = lambda1;
+      lambda1();
+      lambda2();
+    }
+
+    int
+    test2()
+    {
+      auto a = [](int i, int j){ return i + j; }(1, 2);
+      auto b = []() -> int { return '0'; }();
+      auto c = [=](){ return a + b; }();
+      auto d = [&](){ return c; }();
+      auto e = [a, &b](int x) mutable {
+        const auto identity = [](int y){ return y; };
+        for (auto i = 0; i < a; ++i)
+          a += b--;
+        return x + identity(a + b);
+      }(0);
+      return a + b + c + d + e;
+    }
+
+    int
+    test3()
+    {
+      const auto nullary = [](){ return 0; };
+      const auto unary = [](int x){ return x; };
+      using nullary_t = decltype(nullary);
+      using unary_t = decltype(unary);
+      const auto higher1st = [](nullary_t f){ return f(); };
+      const auto higher2nd = [unary](nullary_t f1){
+        return [unary, f1](unary_t f2){ return f2(unary(f1())); };
+      };
+      return higher1st(nullary) + higher2nd(nullary)(unary);
+    }
+
+  }
+
+  namespace test_variadic_templates
+  {
+
+    template <int...>
+    struct sum;
+
+    template <int N0, int... N1toN>
+    struct sum<N0, N1toN...>
+    {
+      static constexpr auto value = N0 + sum<N1toN...>::value;
+    };
+
+    template <>
+    struct sum<>
+    {
+      static constexpr auto value = 0;
+    };
+
+    static_assert(sum<>::value == 0, "");
+    static_assert(sum<1>::value == 1, "");
+    static_assert(sum<23>::value == 23, "");
+    static_assert(sum<1, 2>::value == 3, "");
+    static_assert(sum<5, 5, 11>::value == 21, "");
+    static_assert(sum<2, 3, 5, 7, 11, 13>::value == 41, "");
+
+  }
+
+  // http://stackoverflow.com/questions/13728184/template-aliases-and-sfinae
+  // Clang 3.1 fails with headers of libstd++ 4.8.3 when using std::function
+  // because of this.
+  namespace test_template_alias_sfinae
+  {
+
+    struct foo {};
+
+    template<typename T>
+    using member = typename T::member_type;
+
+    template<typename T>
+    void func(...) {}
+
+    template<typename T>
+    void func(member<T>*) {}
+
+    void test();
+
+    void test() { func<foo>(0); }
+
+  }
+
+}  // namespace cxx11
+
+#endif  // __cplusplus >= 201103L
+
+]])
+
+
+dnl  Tests for new features in C++14
+
+m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_14], [[
+
+// If the compiler admits that it is not ready for C++14, why torture it?
+// Hopefully, this will speed up the test.
+
+#ifndef __cplusplus
+
+#error "This is not a C++ compiler"
+
+#elif __cplusplus < 201402L
+
+#error "This is not a C++14 compiler"
+
+#else
+
+namespace cxx14
+{
+
+  namespace test_polymorphic_lambdas
+  {
+
+    int
+    test()
+    {
+      const auto lambda = [](auto&&... args){
+        const auto istiny = [](auto x){
+          return (sizeof(x) == 1UL) ? 1 : 0;
+        };
+        const int aretiny[] = { istiny(args)... };
+        return aretiny[0];
+      };
+      return lambda(1, 1L, 1.0f, '1');
+    }
+
+  }
+
+  namespace test_binary_literals
+  {
+
+    constexpr auto ivii = 0b0000000000101010;
+    static_assert(ivii == 42, "wrong value");
+
+  }
+
+  namespace test_generalized_constexpr
+  {
+
+    template < typename CharT >
+    constexpr unsigned long
+    strlen_c(const CharT *const s) noexcept
+    {
+      auto length = 0UL;
+      for (auto p = s; *p; ++p)
+        ++length;
+      return length;
+    }
+
+    static_assert(strlen_c("") == 0UL, "");
+    static_assert(strlen_c("x") == 1UL, "");
+    static_assert(strlen_c("test") == 4UL, "");
+    static_assert(strlen_c("another\0test") == 7UL, "");
+
+  }
+
+  namespace test_lambda_init_capture
+  {
+
+    int
+    test()
+    {
+      auto x = 0;
+      const auto lambda1 = [a = x](int b){ return a + b; };
+      const auto lambda2 = [a = lambda1(x)](){ return a; };
+      return lambda2();
+    }
+
+  }
+
+  namespace test_digit_seperators
+  {
+
+    constexpr auto ten_million = 100'000'000;
+    static_assert(ten_million == 100000000, "");
+
+  }
+
+  namespace test_return_type_deduction
+  {
+
+    auto f(int& x) { return x; }
+    decltype(auto) g(int& x) { return x; }
+
+    template < typename T1, typename T2 >
+    struct is_same
+    {
+      static constexpr auto value = false;
+    };
+
+    template < typename T >
+    struct is_same<T, T>
+    {
+      static constexpr auto value = true;
+    };
+
+    int
+    test()
+    {
+      auto x = 0;
+      static_assert(is_same<int, decltype(f(x))>::value, "");
+      static_assert(is_same<int&, decltype(g(x))>::value, "");
+      return x;
+    }
+
+  }
+
+}  // namespace cxx14
+
+#endif  // __cplusplus >= 201402L
+
+]])
diff --git a/src/mqtt/m4/m4_ax_cxx_compile_stdcxx_11.m4 b/src/mqtt/m4/m4_ax_cxx_compile_stdcxx_11.m4
new file mode 100644
index 00000000..0aadeafe
--- /dev/null
+++ b/src/mqtt/m4/m4_ax_cxx_compile_stdcxx_11.m4
@@ -0,0 +1,39 @@
+# ============================================================================
+#  http://www.gnu.org/software/autoconf-archive/ax_cxx_compile_stdcxx_11.html
+# ============================================================================
+#
+# SYNOPSIS
+#
+#   AX_CXX_COMPILE_STDCXX_11([ext|noext], [mandatory|optional])
+#
+# DESCRIPTION
+#
+#   Check for baseline language coverage in the compiler for the C++11
+#   standard; if necessary, add switches to CXX and CXXCPP to enable
+#   support.
+#
+#   This macro is a convenience alias for calling the AX_CXX_COMPILE_STDCXX
+#   macro with the version set to C++11.  The two optional arguments are
+#   forwarded literally as the second and third argument respectively.
+#   Please see the documentation for the AX_CXX_COMPILE_STDCXX macro for
+#   more information.  If you want to use this macro, you also need to
+#   download the ax_cxx_compile_stdcxx.m4 file.
+#
+# LICENSE
+#
+#   Copyright (c) 2008 Benjamin Kosnik <bkoz@redhat.com>
+#   Copyright (c) 2012 Zack Weinberg <zackw@panix.com>
+#   Copyright (c) 2013 Roy Stogner <roystgnr@ices.utexas.edu>
+#   Copyright (c) 2014, 2015 Google Inc.; contributed by Alexey Sokolov <sokolov@google.com>
+#   Copyright (c) 2015 Paul Norman <penorman@mac.com>
+#   Copyright (c) 2015 Moritz Klammler <moritz@klammler.eu>
+#
+#   Copying and distribution of this file, with or without modification, are
+#   permitted in any medium without royalty provided the copyright notice
+#   and this notice are preserved. This file is offered as-is, without any
+#   warranty.
+
+#serial 17
+
+AX_REQUIRE_DEFINED([AX_CXX_COMPILE_STDCXX])
+AC_DEFUN([AX_CXX_COMPILE_STDCXX_11], [AX_CXX_COMPILE_STDCXX([11], [$1], [$2])])
diff --git a/src/mqtt/notice.html b/src/mqtt/notice.html
new file mode 100644
index 00000000..f19c483b
--- /dev/null
+++ b/src/mqtt/notice.html
@@ -0,0 +1,108 @@
+<?xml version="1.0" encoding="ISO-8859-1" ?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
+<title>Eclipse Foundation Software User Agreement</title>
+</head>
+
+<body lang="EN-US">
+<h2>Eclipse Foundation Software User Agreement</h2>
+<p>February 1, 2011</p>
+
+<h3>Usage Of Content</h3>
+
+<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
+   (COLLECTIVELY &quot;CONTENT&quot;).  USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
+   CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW.  BY USING THE CONTENT, YOU AGREE THAT YOUR USE
+   OF THE CONTENT IS GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR
+   NOTICES INDICATED OR REFERENCED BELOW.  IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND
+   CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT USE THE CONTENT.</p>
+
+<h3>Applicable Licenses</h3>
+
+<p>Unless otherwise indicated, all Content made available by the Eclipse Foundation is provided to you under the terms and conditions of the Eclipse Public License Version 1.0
+   (&quot;EPL&quot;).  A copy of the EPL is provided with this Content and is also available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
+   For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
+
+<p>Content includes, but is not limited to, source code, object code, documentation and other files maintained in the Eclipse Foundation source code
+   repository (&quot;Repository&quot;) in software modules (&quot;Modules&quot;) and made available as downloadable archives (&quot;Downloads&quot;).</p>
+
+<ul>
+       <li>Content may be structured and packaged into modules to facilitate delivering, extending, and upgrading the Content.  Typical modules may include plug-ins (&quot;Plug-ins&quot;), plug-in fragments (&quot;Fragments&quot;), and features (&quot;Features&quot;).</li>
+       <li>Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java&trade; ARchive) in a directory named &quot;plugins&quot;.</li>
+       <li>A Feature is a bundle of one or more Plug-ins and/or Fragments and associated material.  Each Feature may be packaged as a sub-directory in a directory named &quot;features&quot;.  Within a Feature, files named &quot;feature.xml&quot; may contain a list of the names and version numbers of the Plug-ins
+      and/or Fragments associated with that Feature.</li>
+       <li>Features may also include other Features (&quot;Included Features&quot;). Within a Feature, files named &quot;feature.xml&quot; may contain a list of the names and version numbers of Included Features.</li>
+</ul>
+
+<p>The terms and conditions governing Plug-ins and Fragments should be contained in files named &quot;about.html&quot; (&quot;Abouts&quot;). The terms and conditions governing Features and
+Included Features should be contained in files named &quot;license.html&quot; (&quot;Feature Licenses&quot;).  Abouts and Feature Licenses may be located in any directory of a Download or Module
+including, but not limited to the following locations:</p>
+
+<ul>
+       <li>The top-level (root) directory</li>
+       <li>Plug-in and Fragment directories</li>
+       <li>Inside Plug-ins and Fragments packaged as JARs</li>
+       <li>Sub-directories of the directory named &quot;src&quot; of certain Plug-ins</li>
+       <li>Feature directories</li>
+</ul>
+
+<p>Note: if a Feature made available by the Eclipse Foundation is installed using the Provisioning Technology (as defined below), you must agree to a license (&quot;Feature Update License&quot;) during the
+installation process.  If the Feature contains Included Features, the Feature Update License should either provide you with the terms and conditions governing the Included Features or
+inform you where you can locate them.  Feature Update Licenses may be found in the &quot;license&quot; property of files named &quot;feature.properties&quot; found within a Feature.
+Such Abouts, Feature Licenses, and Feature Update Licenses contain the terms and conditions (or references to such terms and conditions) that govern your use of the associated Content in
+that directory.</p>
+
+<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.  SOME OF THESE
+OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</p>
+
+<ul>
+       <li>Eclipse Distribution License Version 1.0 (available at <a href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)</li>
+       <li>Common Public License Version 1.0 (available at <a href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)</li>
+       <li>Apache Software License 1.1 (available at <a href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)</li>
+       <li>Apache Software License 2.0 (available at <a href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)</li>
+       <li>Metro Link Public License 1.00 (available at <a href="http://www.opengroup.org/openmotif/supporters/metrolink/license.html">http://www.opengroup.org/openmotif/supporters/metrolink/license.html</a>)</li>
+       <li>Mozilla Public License Version 1.1 (available at <a href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)</li>
+</ul>
+
+<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR TO USE OF THE CONTENT.  If no About, Feature License, or Feature Update License is provided, please
+contact the Eclipse Foundation to determine what terms and conditions govern that particular Content.</p>
+
+
+<h3>Use of Provisioning Technology</h3>
+
+<p>The Eclipse Foundation makes available provisioning software, examples of which include, but are not limited to, p2 and the Eclipse
+   Update Manager (&quot;Provisioning Technology&quot;) for the purpose of allowing users to install software, documentation, information and/or
+   other materials (collectively &quot;Installable Software&quot;). This capability is provided with the intent of allowing such users to
+   install, extend and update Eclipse-based products. Information about packaging Installable Software is available at <a
+       href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
+   (&quot;Specification&quot;).</p>
+
+<p>You may use Provisioning Technology to allow other parties to install Installable Software. You shall be responsible for enabling the
+   applicable license agreements relating to the Installable Software to be presented to, and accepted by, the users of the Provisioning Technology
+   in accordance with the Specification. By using Provisioning Technology in such a manner and making it available in accordance with the
+   Specification, you further acknowledge your agreement to, and the acquisition of all necessary rights to permit the following:</p>
+
+<ol>
+       <li>A series of actions may occur (&quot;Provisioning Process&quot;) in which a user may execute the Provisioning Technology
+       on a machine (&quot;Target Machine&quot;) with the intent of installing, extending or updating the functionality of an Eclipse-based
+       product.</li>
+       <li>During the Provisioning Process, the Provisioning Technology may cause third party Installable Software or a portion thereof to be
+       accessed and copied to the Target Machine.</li>
+       <li>Pursuant to the Specification, you will provide to the user the terms and conditions that govern the use of the Installable
+       Software (&quot;Installable Software Agreement&quot;) and such Installable Software Agreement shall be accessed from the Target
+       Machine in accordance with the Specification. Such Installable Software Agreement must inform the user of the terms and conditions that govern
+       the Installable Software and must solicit acceptance by the end user in the manner prescribed in such Installable Software Agreement. Upon such
+       indication of agreement by the user, the provisioning Technology will complete installation of the Installable Software.</li>
+</ol>
+
+<h3>Cryptography</h3>
+
+<p>Content may contain encryption software. The country in which you are currently may have restrictions on the import, possession, and use, and/or re-export to
+   another country, of encryption software. BEFORE using any encryption software, please check the country's laws, regulations and policies concerning the import,
+   possession, or use, and re-export of encryption software, to see if this is permitted.</p>
+
+<p><small>Java and all Java-based trademarks are trademarks of Oracle Corporation in the United States, other countries, or both.</small></p>
+</body>
+</html>
diff --git a/src/mqtt/src/async_client.cpp b/src/mqtt/src/async_client.cpp
new file mode 100644
index 00000000..1a896621
--- /dev/null
+++ b/src/mqtt/src/async_client.cpp
@@ -0,0 +1,822 @@
+// async_client.cpp
+
+/*******************************************************************************
+ * Copyright (c) 2013-2019 Frank Pagliughi <fpagliughi@mindspring.com>
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution.
+ *
+ * The Eclipse Public License is available at
+ *    http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at
+ *   http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *    Frank Pagliughi - initial implementation and documentation
+ *    Frank Pagliughi - MQTT v5 support
+ *******************************************************************************/
+
+#include "mqtt/async_client.h"
+#include "mqtt/token.h"
+#include "mqtt/message.h"
+#include "mqtt/response_options.h"
+#include "mqtt/disconnect_options.h"
+#include <thread>
+#include <mutex>
+#include <condition_variable>
+#include <chrono>
+#include <cstring>
+#include <cstdio>
+
+// TODO: Delete this when #680 is merged into the Paho C lib
+#if !defined(MQTTAsync_createOptions_initializer5)
+	#define MQTTAsync_createOptions_initializer5 { {'M', 'Q', 'C', 'O'}, 0, 0, 100, MQTTVERSION_5 }
+#endif
+
+namespace mqtt {
+
+/////////////////////////////////////////////////////////////////////////////
+// Constructors
+
+async_client::async_client(const string& serverURI, const string& clientId,
+						   const string& persistDir)
+				: async_client(serverURI, clientId, 0, persistDir)
+{
+}
+
+async_client::async_client(const string& serverURI, const string& clientId,
+						   iclient_persistence* persistence /*=nullptr*/)
+				: async_client(serverURI, clientId, 0, persistence)
+{
+}
+
+async_client::async_client(const string& serverURI, const string& clientId,
+						   int maxBufferedMessages, const string& persistDir)
+				: serverURI_(serverURI), clientId_(clientId), mqttVersion_(MQTTVERSION_DEFAULT),
+					persist_(nullptr), userCallback_(nullptr)
+{
+	MQTTAsync_createOptions opts MQTTAsync_createOptions_initializer5;
+
+	if (maxBufferedMessages != 0) {
+		opts.sendWhileDisconnected = to_int(true);
+		opts.maxBufferedMessages = maxBufferedMessages;
+	}
+
+	int rc = MQTTAsync_createWithOptions(&cli_, serverURI.c_str(), clientId.c_str(),
+										 MQTTCLIENT_PERSISTENCE_DEFAULT,
+										 const_cast<char*>(persistDir.c_str()),
+										 &opts);
+
+	if (rc != 0)
+		throw exception(rc);
+}
+
+async_client::async_client(const string& serverURI, const string& clientId,
+						   int maxBufferedMessages, iclient_persistence* persistence /*=nullptr*/)
+				: serverURI_(serverURI), clientId_(clientId), mqttVersion_(MQTTVERSION_DEFAULT),
+					persist_(nullptr), userCallback_(nullptr)
+{
+	MQTTAsync_createOptions opts MQTTAsync_createOptions_initializer5;
+
+	if (maxBufferedMessages != 0) {
+		opts.sendWhileDisconnected = to_int(true);
+		opts.maxBufferedMessages = maxBufferedMessages;
+	}
+
+	int rc = MQTTASYNC_SUCCESS;
+
+	if (!persistence) {
+		rc = MQTTAsync_createWithOptions(&cli_, serverURI.c_str(), clientId.c_str(),
+										 MQTTCLIENT_PERSISTENCE_NONE, nullptr, &opts);
+	}
+	else {
+		persist_.reset(new MQTTClient_persistence {
+			persistence,
+			&iclient_persistence::persistence_open,
+			&iclient_persistence::persistence_close,
+			&iclient_persistence::persistence_put,
+			&iclient_persistence::persistence_get,
+			&iclient_persistence::persistence_remove,
+			&iclient_persistence::persistence_keys,
+			&iclient_persistence::persistence_clear,
+			&iclient_persistence::persistence_containskey
+		});
+
+		rc = MQTTAsync_createWithOptions(&cli_, serverURI.c_str(), clientId.c_str(),
+										 MQTTCLIENT_PERSISTENCE_USER, persist_.get(),
+										 &opts);
+	}
+	if (rc != 0)
+		throw exception(rc);
+}
+
+async_client::~async_client()
+{
+	MQTTAsync_destroy(&cli_);
+}
+
+// --------------------------------------------------------------------------
+// Class static callbacks.
+// These are the callbacks directly from the C-lib. In each case the
+// 'context' should be the address of the async_client object that
+// registered the callback. 
+
+
+// Callback for MQTTAsync_setConnected()
+// This is installed with the normall callbacks and with a call to 
+// reconnect() to indicate that it succeeded. It is called after the token 
+// is notified of success on a normal connect with callbacks. 
+void async_client::on_connected(void* context, char* cause)
+{
+	if (context) {
+		async_client* cli = static_cast<async_client*>(context);
+		callback* cb = cli->userCallback_;
+		auto& connHandler = cli->connHandler_;
+
+		string cause_str = cause ? string(cause) : string();
+
+		if (cb)
+			cb->connected(cause_str);
+
+		if (connHandler)
+			connHandler(cause_str);
+	}
+}
+
+// Callback for when the connection is lost.
+// This is called from the MQTTAsync_connectionLost registered via 
+// MQTTAsync_setCallbacks(). 
+void async_client::on_connection_lost(void *context, char *cause)
+{
+	if (context) {
+		async_client* cli = static_cast<async_client*>(context);
+		callback* cb = cli->userCallback_;
+		consumer_queue_type& que = cli->que_;
+		auto& connLostHandler = cli->connLostHandler_;
+
+		string cause_str = cause ? string(cause) : string();
+
+		if (cb)
+			cb->connection_lost(cause_str);
+
+		if (connLostHandler)
+			connLostHandler(cause_str);
+
+		if (que)
+			que->put(const_message_ptr{});
+	}
+}
+
+// Callback from the C lib for when a disconnect packet is received from
+// the server.
+void async_client::on_disconnected(void* context, MQTTProperties* cprops,
+								   MQTTReasonCodes reasonCode)
+{
+	if (context) {
+		async_client* cli = static_cast<async_client*>(context);
+		auto& disconnectedHandler = cli->disconnectedHandler_;
+
+		if (disconnectedHandler) {
+			properties props(*cprops);
+			disconnectedHandler(props, ReasonCode(reasonCode));
+		}
+	}
+}
+
+// Callback for when a subscribed message arrives.
+// This is called from the MQTTAsync_messageArrived registered via 
+// MQTTAsync_setCallbacks(). 
+int async_client::on_message_arrived(void* context, char* topicName, int topicLen,
+									 MQTTAsync_message* msg)
+{
+	if (context) {
+		async_client* cli = static_cast<async_client*>(context);
+		callback* cb = cli->userCallback_;
+		consumer_queue_type& que = cli->que_;
+		message_handler& msgHandler = cli->msgHandler_;
+
+		if (cb || que || msgHandler) {
+			size_t len = (topicLen == 0) ? strlen(topicName) : size_t(topicLen);
+
+			string topic(topicName, topicName+len);
+			auto m = message::create(std::move(topic), *msg);
+
+			if (msgHandler)
+				msgHandler(m);
+
+			if (cb)
+				cb->message_arrived(m);
+
+			if (que)
+				que->put(m);
+		}
+	}
+
+	MQTTAsync_freeMessage(&msg);
+	MQTTAsync_free(topicName);
+
+	// TODO: Should the user code determine the return value?
+	// The Java version does doesn't seem to...
+	return to_int(true);
+}
+
+// Callback to indicate that a message was delivered to the server.
+// It is called for a message with a QOS >= 1, but it happens before the
+// on_success() call for the token. Thus we don't have the underlying
+// MQTTAsync_token of the outgoing message at the time of this callback.
+//
+// *** So using the Async C library we have no way to match this msgID with
+//     a delivery_token object. So this is useless to us.
+//
+// So, all in all, this callback in it's current implementation seems rather
+// redundant.
+//
+#if 0
+void async_client::on_delivery_complete(void* context, MQTTAsync_token msgID)
+{
+	if (context) {
+		async_client* m = static_cast<async_client*>(context);
+		callback* cb = m->get_callback();
+		if (cb) {
+			delivery_token_ptr tok = m->get_pending_delivery_token(msgID);
+			cb->delivery_complete(tok);
+		}
+	}
+}
+#endif
+
+// --------------------------------------------------------------------------
+// Private methods
+
+void async_client::add_token(token_ptr tok)
+{
+	if (tok) {
+		guard g(lock_);
+		pendingTokens_.push_back(tok);
+	}
+}
+
+void async_client::add_token(delivery_token_ptr tok)
+{
+	if (tok) {
+	   guard g(lock_);
+	   pendingDeliveryTokens_.push_back(tok);
+	}
+}
+
+// Note that we uniquely identify a token by the address of its raw pointer,
+// since the message ID is not unique.
+
+void async_client::remove_token(token* tok)
+{
+	if (!tok)
+		return;
+
+	guard g(lock_);
+	for (auto p=pendingDeliveryTokens_.begin();
+					p!=pendingDeliveryTokens_.end(); ++p) {
+		if (p->get() == tok) {
+			delivery_token_ptr dtok = *p;
+			pendingDeliveryTokens_.erase(p);
+
+			// If there's a user callback registered, we can now call
+			// delivery_complete()
+
+			if (userCallback_) {
+				const_message_ptr msg = dtok->get_message();
+				if (msg && msg->get_qos() > 0) {
+					callback* cb = userCallback_;
+					g.unlock();
+					cb->delivery_complete(dtok);
+				}
+			}
+			return;
+		}
+	}
+	for (auto p=pendingTokens_.begin(); p!=pendingTokens_.end(); ++p) {
+		if (p->get() == tok) {
+			pendingTokens_.erase(p);
+			return;
+		}
+	}
+}
+
+
+// --------------------------------------------------------------------------
+// Callback management
+
+void async_client::set_callback(callback& cb)
+{
+	guard g(lock_);
+	userCallback_ = &cb;
+
+	int rc = MQTTAsync_setConnected(cli_, this, &async_client::on_connected);
+
+	if (rc == MQTTASYNC_SUCCESS) {
+		rc = MQTTAsync_setCallbacks(cli_, this,
+									&async_client::on_connection_lost,
+									&async_client::on_message_arrived,
+									nullptr /*&async_client::on_delivery_complete*/);
+	}
+	else
+		MQTTAsync_setConnected(cli_, nullptr, nullptr);
+
+	if (rc != MQTTASYNC_SUCCESS) {
+		userCallback_ = nullptr;
+		throw exception(rc);
+	}
+}
+
+void async_client::disable_callbacks()
+{
+	// TODO: It would be nice to disable callbacks at the C library level,
+	// but the setCallback function currently does not accept a nullptr for
+	// the "message arrived" parameter. So, for now we send it an empty
+	// lambda function.
+	int rc = MQTTAsync_setCallbacks(cli_, this, nullptr,
+					[](void*,char*,int,MQTTAsync_message*) -> int {return to_int(true);},
+					nullptr);
+
+	if (rc != MQTTASYNC_SUCCESS)
+		throw exception(rc);
+}
+
+void async_client::set_connected_handler(connection_handler cb)
+{
+	connHandler_ = cb;
+	check_ret(::MQTTAsync_setConnected(cli_, this,
+						&async_client::on_connected));
+}
+
+void async_client::set_connection_lost_handler(connection_handler cb)
+{
+	connLostHandler_ = cb;
+	check_ret(::MQTTAsync_setConnectionLostCallback(cli_, this,
+						&async_client::on_connection_lost));
+}
+
+void async_client::set_disconnected_handler(disconnected_handler cb)
+{
+	disconnectedHandler_ = cb;
+	check_ret(::MQTTAsync_setDisconnected(cli_, this,
+						&async_client::on_disconnected));
+}
+
+void async_client::set_message_callback(message_handler cb)
+{
+	msgHandler_ = cb;
+	check_ret(::MQTTAsync_setMessageArrivedCallback(cli_, this,
+						&async_client::on_message_arrived));
+}
+
+// --------------------------------------------------------------------------
+// Connect
+
+token_ptr async_client::connect()
+{ 
+	return connect(connect_options());
+}
+
+token_ptr async_client::connect(connect_options opts)
+{
+	// TODO: We really should get (or update) this value from the response
+	//  	(when the server confirms the requested version)
+	mqttVersion_ = opts.opts_.MQTTVersion;
+
+	// TODO: If connTok_ is non-null, there could be a pending connect
+	// which might complete after creating/assigning a new one. If that
+	// happened, the callback would have the context address of the previous
+	// token which was destroyed. So for now, keep the old one alive within
+	// this function, and check the behavior of the C library...
+	auto tmpTok = connTok_;
+	connTok_ = token::create(token::Type::CONNECT, *this);
+	add_token(connTok_);
+
+	opts.set_token(connTok_);
+
+	int rc = MQTTAsync_connect(cli_, &opts.opts_);
+
+	if (rc != MQTTASYNC_SUCCESS) {
+		remove_token(connTok_);
+		connTok_.reset();
+		throw exception(rc);
+	}
+
+	return connTok_;
+}
+
+token_ptr async_client::connect(connect_options opts, void* userContext,
+										iaction_listener& cb)
+{
+	// TODO: We really should get this value from the response (when
+	// 		the server confirms the requested version)
+	mqttVersion_ = opts.opts_.MQTTVersion;
+
+	auto tmpTok = connTok_;
+	connTok_ = token::create(token::Type::CONNECT, *this, userContext, cb);
+	add_token(connTok_);
+
+	opts.set_token(connTok_);
+
+	int rc = MQTTAsync_connect(cli_, &opts.opts_);
+
+	if (rc != MQTTASYNC_SUCCESS) {
+		remove_token(connTok_);
+		connTok_.reset();
+		throw exception(rc);
+	}
+
+	return connTok_;
+}
+
+// --------------------------------------------------------------------------
+// Re-connect
+
+token_ptr async_client::reconnect()
+{
+	auto tok = connTok_;
+
+	if (!tok)
+		throw exception(MQTTASYNC_FAILURE, "Can't reconnect before a successful connect");
+
+	tok->reset();
+	add_token(tok);
+
+	int rc = MQTTAsync_setConnected(cli_, this, &async_client::on_connected);
+
+	if (rc == MQTTASYNC_SUCCESS)
+		rc = MQTTAsync_reconnect(cli_);
+
+	if (rc != MQTTASYNC_SUCCESS) {
+		remove_token(tok);
+		throw exception(rc);
+	}
+
+	return tok;
+}
+
+// --------------------------------------------------------------------------
+// Disconnect
+
+token_ptr async_client::disconnect(disconnect_options opts)
+{
+	auto tok = token::create(token::Type::DISCONNECT, *this);
+	add_token(tok);
+
+	opts.set_token(tok, mqttVersion_);
+
+	int rc = MQTTAsync_disconnect(cli_, &opts.opts_);
+
+	if (rc != MQTTASYNC_SUCCESS) {
+		remove_token(tok);
+		throw exception(rc);
+	}
+
+	return tok;
+}
+
+token_ptr async_client::disconnect(int timeout, void* userContext, iaction_listener& cb)
+{
+	auto tok = token::create(token::Type::DISCONNECT, *this, userContext, cb);
+	add_token(tok);
+
+	disconnect_options opts(timeout);
+	opts.set_token(tok, mqttVersion_);
+
+	int rc = MQTTAsync_disconnect(cli_, &opts.opts_);
+
+	if (rc != MQTTASYNC_SUCCESS) {
+		remove_token(tok);
+		throw exception(rc);
+	}
+
+	return tok;
+}
+
+// --------------------------------------------------------------------------
+// Queries
+
+delivery_token_ptr async_client::get_pending_delivery_token(int msgID) const
+{
+	// Messages with QOS=1 or QOS=2 that require a response/acknowledge should
+	// have a non-zero 16-bit message ID. The library keeps the token objects
+	// for all of these messages that are in flight. When the acknowledge comes
+	// back from the broker, the C++ library can look up the token from the
+	// msgID and signal it, indicating completion.
+
+	if (msgID > 0) {
+		guard g(lock_);
+		for (const auto& t : pendingDeliveryTokens_) {
+			if (t->get_message_id() == msgID)
+				return t;
+		}
+	}
+	return delivery_token_ptr();
+}
+
+std::vector<delivery_token_ptr> async_client::get_pending_delivery_tokens() const
+{
+	std::vector<delivery_token_ptr> toks;
+	guard g(lock_);
+	for (const auto& t : pendingDeliveryTokens_) {
+		if (t->get_message_id() > 0) {
+			toks.push_back(t);
+		}
+	}
+	return toks;
+}
+
+// --------------------------------------------------------------------------
+// Publish
+
+delivery_token_ptr async_client::publish(string_ref topic, const void* payload,
+										 size_t n, int qos, bool retained)
+{
+	auto msg = message::create(std::move(topic), payload, n, qos, retained);
+	return publish(std::move(msg));
+}
+
+delivery_token_ptr async_client::publish(string_ref topic, binary_ref payload,
+										 int qos, bool retained)
+{
+	auto msg = message::create(std::move(topic), std::move(payload), qos, retained);
+	return publish(std::move(msg));
+}
+
+delivery_token_ptr async_client::publish(string_ref topic,
+										 const void* payload, size_t n,
+										 int qos, bool retained, void* userContext,
+										 iaction_listener& cb)
+{
+	auto msg = message::create(std::move(topic), payload, n, qos, retained);
+	return publish(std::move(msg), userContext, cb);
+}
+
+delivery_token_ptr async_client::publish(const_message_ptr msg)
+{
+	auto tok = delivery_token::create(*this, msg);
+	add_token(tok);
+
+	delivery_response_options rspOpts(tok, mqttVersion_);
+
+	int rc = MQTTAsync_sendMessage(cli_, msg->get_topic().c_str(),
+								   &(msg->msg_), &rspOpts.opts_);
+
+	if (rc == MQTTASYNC_SUCCESS) {
+		tok->set_message_id(rspOpts.opts_.token);
+	}
+	else {
+		remove_token(tok);
+		throw exception(rc);
+	}
+
+	return tok;
+}
+
+delivery_token_ptr async_client::publish(const_message_ptr msg,
+										 void* userContext, iaction_listener& cb)
+{
+	delivery_token_ptr tok = delivery_token::create(*this, msg, userContext, cb);
+	add_token(tok);
+
+	delivery_response_options rspOpts(tok, mqttVersion_);
+
+	int rc = MQTTAsync_sendMessage(cli_, msg->get_topic().c_str(),
+								   &(msg->msg_), &rspOpts.opts_);
+
+	if (rc == MQTTASYNC_SUCCESS) {
+		tok->set_message_id(rspOpts.opts_.token);
+	}
+	else {
+		remove_token(tok);
+		throw exception(rc);
+	}
+
+	return tok;
+}
+
+// --------------------------------------------------------------------------
+// Subscribe
+
+token_ptr async_client::subscribe(const string& topicFilter, int qos,
+								  const subscribe_options& opts /*=subscribe_options()*/)
+{
+	auto tok = token::create(token::Type::SUBSCRIBE, *this, topicFilter);
+	tok->set_num_expected(0);	// Indicates non-array response for single val
+	add_token(tok);
+
+	response_options rspOpts(tok, mqttVersion_);
+	rspOpts.set_subscribe_options(opts);
+
+	int rc = MQTTAsync_subscribe(cli_, topicFilter.c_str(), qos, &rspOpts.opts_);
+
+	if (rc != MQTTASYNC_SUCCESS) {
+		remove_token(tok);
+		throw exception(rc);
+	}
+
+	return tok;
+}
+
+token_ptr async_client::subscribe(const string& topicFilter, int qos,
+								  void* userContext, iaction_listener& cb,
+								  const subscribe_options& opts /*=subscribe_options()*/)
+{
+	auto tok = token::create(token::Type::SUBSCRIBE, *this, topicFilter,
+							 userContext, cb);
+	tok->set_num_expected(0);
+	add_token(tok);
+
+	response_options rspOpts(tok, mqttVersion_);
+	rspOpts.set_subscribe_options(opts);
+
+	int rc = MQTTAsync_subscribe(cli_, topicFilter.c_str(), qos, &rspOpts.opts_);
+
+	if (rc != MQTTASYNC_SUCCESS) {
+		remove_token(tok);
+		throw exception(rc);
+	}
+
+	return tok;
+}
+
+token_ptr async_client::subscribe(const_string_collection_ptr topicFilters,
+								  const qos_collection& qos,
+								  const std::vector<subscribe_options>& opts
+									/*=std::vector<subscribe_options>()*/)
+{
+	size_t n = topicFilters->size();
+
+	if (n != qos.size())
+		throw std::invalid_argument("Collection sizes don't match");
+
+	auto tok = token::create(token::Type::SUBSCRIBE, *this, topicFilters);
+	tok->set_num_expected(n);
+
+	add_token(tok);
+
+	response_options rspOpts(tok, mqttVersion_);
+	rspOpts.set_subscribe_options(opts);
+
+	int rc = MQTTAsync_subscribeMany(cli_, int(n), topicFilters->c_arr(),
+									 const_cast<int*>(qos.data()), &rspOpts.opts_);
+
+	if (rc != MQTTASYNC_SUCCESS) {
+		remove_token(tok);
+		throw exception(rc);
+	}
+
+	return tok;
+}
+
+token_ptr async_client::subscribe(const_string_collection_ptr topicFilters,
+								  const qos_collection& qos,
+								  void* userContext, iaction_listener& cb,
+								  const std::vector<subscribe_options>& opts
+									/*=std::vector<subscribe_options>()*/)
+{
+	size_t n = topicFilters->size();
+
+	if (n != qos.size())
+		throw std::invalid_argument("Collection sizes don't match");
+
+	auto tok = token::create(token::Type::SUBSCRIBE, *this,
+							 topicFilters, userContext, cb);
+	tok->set_num_expected(n);
+	add_token(tok);
+
+	response_options rspOpts(tok, mqttVersion_);
+	rspOpts.set_subscribe_options(opts);
+
+	int rc = MQTTAsync_subscribeMany(cli_, int(n), topicFilters->c_arr(),
+									 const_cast<int*>(qos.data()), &rspOpts.opts_);
+
+	if (rc != MQTTASYNC_SUCCESS) {
+		remove_token(tok);
+		throw exception(rc);
+	}
+
+	return tok;
+}
+
+// --------------------------------------------------------------------------
+// Unsubscribe
+
+token_ptr async_client::unsubscribe(const string& topicFilter)
+{
+	auto tok = token::create(token::Type::UNSUBSCRIBE, *this, topicFilter);
+	tok->set_num_expected(0);	// Indicates non-array response for single val
+	add_token(tok);
+
+	response_options rspOpts(tok, mqttVersion_);
+
+	int rc = MQTTAsync_unsubscribe(cli_, topicFilter.c_str(), &rspOpts.opts_);
+
+	if (rc != MQTTASYNC_SUCCESS) {
+		remove_token(tok);
+		throw exception(rc);
+	}
+
+	return tok;
+}
+
+token_ptr async_client::unsubscribe(const_string_collection_ptr topicFilters)
+{
+	size_t n = topicFilters->size();
+
+	auto tok = token::create(token::Type::UNSUBSCRIBE, *this, topicFilters);
+	tok->set_num_expected(n);
+	add_token(tok);
+
+	response_options rspOpts(tok, mqttVersion_);
+
+	int rc = MQTTAsync_unsubscribeMany(cli_, int(n),
+									   topicFilters->c_arr(), &rspOpts.opts_);
+
+	if (rc != MQTTASYNC_SUCCESS) {
+		remove_token(tok);
+		throw exception(rc);
+	}
+
+	return tok;
+}
+
+token_ptr async_client::unsubscribe(const_string_collection_ptr topicFilters,
+									 void* userContext, iaction_listener& cb)
+{
+	size_t n = topicFilters->size();
+
+	auto tok = token::create(token::Type::UNSUBSCRIBE, *this, topicFilters,
+							 userContext, cb);
+	tok->set_num_expected(n);
+	add_token(tok);
+
+	response_options rspOpts(tok, mqttVersion_);
+
+	int rc = MQTTAsync_unsubscribeMany(cli_, int(n), topicFilters->c_arr(), &rspOpts.opts_);
+
+	if (rc != MQTTASYNC_SUCCESS) {
+		remove_token(tok);
+		throw exception(rc);
+	}
+
+	return tok;
+}
+
+token_ptr async_client::unsubscribe(const string& topicFilter,
+									void* userContext, iaction_listener& cb)
+{
+	auto tok = token::create(token::Type::UNSUBSCRIBE , *this, topicFilter,
+							 userContext, cb);
+	add_token(tok);
+
+	response_options rspOpts(tok, mqttVersion_);
+
+	int rc = MQTTAsync_unsubscribe(cli_, topicFilter.c_str(), &rspOpts.opts_);
+
+	if (rc != MQTTASYNC_SUCCESS) {
+		remove_token(tok);
+		throw exception(rc);
+	}
+
+	return tok;
+}
+
+// --------------------------------------------------------------------------
+
+void async_client::start_consuming()
+{
+	// Make sure callbacks don't happen while we update the que, etc
+	disable_callbacks();
+
+	// TODO: Should we replace user callback?
+	//userCallback_ = nullptr;
+
+	que_.reset(new thread_queue<const_message_ptr>);
+
+	int rc = MQTTAsync_setCallbacks(cli_, this,
+									&async_client::on_connection_lost,
+									&async_client::on_message_arrived,
+									nullptr);
+
+	if (rc != MQTTASYNC_SUCCESS)
+		throw exception(rc);
+}
+
+void async_client::stop_consuming()
+{
+	try {
+		disable_callbacks();
+		que_.reset();
+	}
+	catch (...) {
+		que_.reset();
+		throw;
+	}
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// end namespace mqtt
+}
+
diff --git a/src/mqtt/src/client.cpp b/src/mqtt/src/client.cpp
new file mode 100644
index 00000000..8cd45771
--- /dev/null
+++ b/src/mqtt/src/client.cpp
@@ -0,0 +1,148 @@
+// client.cpp
+// Implementation of the client class for the mqtt C++ client library.
+
+/*******************************************************************************
+ * Copyright (c) 2013-2017 Frank Pagliughi <fpagliughi@mindspring.com>
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution.
+ *
+ * The Eclipse Public License is available at
+ *    http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at
+ *   http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *    Frank Pagliughi - initial implementation and documentation
+ *******************************************************************************/
+
+#include "mqtt/client.h"
+#include <memory>
+#include <iostream>
+
+namespace mqtt {
+
+const std::chrono::minutes client::DFLT_TIMEOUT = std::chrono::minutes(5);
+
+#if __cplusplus < 201703L
+	constexpr int client::DFLT_QOS;
+#endif
+
+/////////////////////////////////////////////////////////////////////////////
+
+
+client::client(const string& serverURI, const string& clientId,
+			   iclient_persistence* persistence /*=nullptr*/)
+		: cli_(serverURI, clientId, persistence),
+			timeout_(DFLT_TIMEOUT), userCallback_(nullptr)
+{
+}
+
+client::client(const string& serverURI, const string& clientId,
+			   const string& persistDir)
+		: cli_(serverURI, clientId, persistDir),
+			timeout_(DFLT_TIMEOUT), userCallback_(nullptr)
+{
+}
+
+client::client(const string& serverURI, const string& clientId,
+			   int maxBufferedMessages, iclient_persistence* persistence /*=nullptr*/)
+		: cli_(serverURI, clientId, maxBufferedMessages, persistence),
+			timeout_(DFLT_TIMEOUT), userCallback_(nullptr)
+{
+}
+
+client::client(const string& serverURI, const string& clientId,
+			   int maxBufferedMessages, const string& persistDir)
+		: cli_(serverURI, clientId, maxBufferedMessages, persistDir),
+			timeout_(DFLT_TIMEOUT), userCallback_(nullptr)
+{
+}
+
+void client::set_callback(callback& cb)
+{
+	userCallback_ = &cb;
+	cli_.set_callback(*this);
+}
+
+connect_response client::connect()
+{
+	cli_.start_consuming();
+	auto tok = cli_.connect();
+	tok->wait_for(timeout_);
+	return tok->get_connect_response();
+}
+
+connect_response client::connect(connect_options opts)
+{
+	cli_.start_consuming();
+	auto tok = cli_.connect(std::move(opts));
+	tok->wait_for(timeout_);
+	return tok->get_connect_response();
+}
+
+connect_response client::reconnect()
+{
+	auto tok = cli_.reconnect();
+	tok->wait_for(timeout_);
+	return tok->get_connect_response();
+}
+
+subscribe_response client::subscribe(const string& topicFilter)
+{
+	auto tok = cli_.subscribe(topicFilter, DFLT_QOS);
+	tok->wait_for(timeout_);
+	return tok->get_subscribe_response();
+}
+
+subscribe_response client::subscribe(const string& topicFilter, int qos)
+{
+	auto tok = cli_.subscribe(topicFilter, qos);
+	tok->wait_for(timeout_);
+	return tok->get_subscribe_response();
+}
+
+subscribe_response client::subscribe(const string_collection& topicFilters)
+{
+	qos_collection qos;
+	for (size_t i=0; i<topicFilters.size(); ++i)
+		qos.push_back(DFLT_QOS);
+
+	auto tok = cli_.subscribe(ptr(topicFilters), qos);
+	tok->wait_for(timeout_);
+	return tok->get_subscribe_response();
+}
+
+subscribe_response client::subscribe(const string_collection& topicFilters,
+									 const qos_collection& qos)
+{
+	auto tok = cli_.subscribe(ptr(topicFilters), qos);
+	tok->wait_for(timeout_);
+	return tok->get_subscribe_response();
+}
+
+unsubscribe_response client::unsubscribe(const string& topicFilter)
+{
+	auto tok = cli_.unsubscribe(topicFilter);
+	tok->wait_for(timeout_);
+	return tok->get_unsubscribe_response();
+}
+
+unsubscribe_response client::unsubscribe(const string_collection& topicFilters)
+{
+	auto tok = cli_.unsubscribe(ptr(topicFilters));
+	tok->wait_for(timeout_);
+	return tok->get_unsubscribe_response();
+}
+
+void client::disconnect()
+{
+	cli_.disconnect()->wait_for(timeout_);
+	cli_.stop_consuming();
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// end namespace mqtt
+}
+
diff --git a/src/mqtt/src/connect_options.cpp b/src/mqtt/src/connect_options.cpp
new file mode 100644
index 00000000..0ce5a21a
--- /dev/null
+++ b/src/mqtt/src/connect_options.cpp
@@ -0,0 +1,209 @@
+/*******************************************************************************
+ * Copyright (c) 2016 Guilherme M. Ferreira <guilherme.maciel.ferreira@gmail.com>
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution.
+ *
+ * The Eclipse Public License is available at
+ *    http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at
+ *   http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *    Guilherme M. Ferreira - initial implementation and documentation
+ *    Frank Pagliughi - Copy and move operations. Bug fixes.
+ *******************************************************************************/
+
+#include "mqtt/connect_options.h"
+#include <cstring>
+
+namespace mqtt {
+
+/////////////////////////////////////////////////////////////////////////////
+
+const MQTTAsync_connectOptions connect_options::DFLT_C_STRUCT = MQTTAsync_connectOptions_initializer;
+
+connect_options::connect_options() : opts_(DFLT_C_STRUCT)
+{
+}
+
+connect_options::connect_options(string_ref userName, binary_ref password)
+		: connect_options()
+{
+	set_user_name(userName);
+	set_password(password);
+}
+
+connect_options::connect_options(const connect_options& opt) : opts_(opt.opts_)
+{
+	if (opts_.will)
+		set_will(opt.will_);
+
+	if (opts_.ssl)
+		set_ssl(opt.ssl_);
+
+	set_user_name(opt.userName_);
+	set_password(opt.password_);
+}
+
+connect_options::connect_options(connect_options&& opt) : opts_(opt.opts_),
+						will_(std::move(opt.will_)),
+						ssl_(std::move(opt.ssl_)),
+						userName_(std::move(opt.userName_)),
+						password_(std::move(opt.password_))
+{
+	if (opts_.will) {
+		opts_.will = &will_.opts_;
+		opts_.willProperties = const_cast<MQTTProperties*>(&will_.props_.c_struct());
+	}
+
+	if (opts_.ssl)
+		opts_.ssl = &ssl_.opts_;
+
+	opts_.username = c_str(userName_);
+	set_password(password_);
+}
+
+connect_options& connect_options::operator=(const connect_options& opt)
+{
+	opts_ = opt.opts_;
+
+	if (opts_.will)
+		set_will(opt.will_);
+
+	if (opts_.ssl)
+		set_ssl(opt.ssl_);
+
+	set_user_name(opt.userName_);
+	set_password(opt.password_);
+
+	return *this;
+}
+
+connect_options& connect_options::operator=(connect_options&& opt)
+{
+	opts_ = opt.opts_;
+
+	if (opts_.will)
+		set_will(std::move(opt.will_));
+
+	if (opts_.ssl)
+		set_ssl(std::move(opt.ssl_));
+
+	userName_ = std::move(opt.userName_);
+	opts_.username = c_str(userName_);
+
+	password_ = std::move(opt.password_);
+	set_password(password_);
+
+	return *this;
+}
+
+void connect_options::set_will(const will_options& will)
+{
+	will_ = will;
+	opts_.will = &will_.opts_;
+	opts_.willProperties = will_.get_properties().empty()
+		? nullptr : const_cast<MQTTProperties*>(&will_.props_.c_struct());
+}
+
+void connect_options::set_will(will_options&& will)
+{
+	will_ = will;
+	opts_.will = &will_.opts_;
+	opts_.willProperties = will_.get_properties().empty()
+		? nullptr : const_cast<MQTTProperties*>(&will_.props_.c_struct());
+}
+
+void connect_options::set_user_name(string_ref userName)
+{
+	userName_ = std::move(userName);
+	opts_.username = c_str(userName_);
+}
+
+void connect_options::set_password(binary_ref password)
+{
+	password_ = std::move(password);
+
+	if (password_.empty()) {
+		opts_.binarypwd.len = 0;
+		opts_.binarypwd.data = nullptr;
+	}
+	else {
+		opts_.binarypwd.len = (int) password_.size();
+		opts_.binarypwd.data = password_.data();
+	}
+}
+
+void connect_options::set_ssl(const ssl_options& ssl)
+{
+	ssl_ = ssl;
+	opts_.ssl = &ssl_.opts_;
+}
+
+void connect_options::set_ssl(ssl_options&& ssl)
+{
+	ssl_ = ssl;
+	opts_.ssl = &ssl_.opts_;
+}
+
+void connect_options::set_token(const token_ptr& tok)
+{
+	tok_ = tok;
+	opts_.context = tok_.get();
+
+	opts_.onSuccess = nullptr;
+	opts_.onFailure = nullptr;
+
+	opts_.onSuccess5 = nullptr;
+	opts_.onFailure5 = nullptr;
+
+	if (tok) {
+		if (opts_.MQTTVersion < MQTTVERSION_5) {
+			opts_.onSuccess = &token::on_success;
+			opts_.onFailure = &token::on_failure;
+		}
+		else {
+			opts_.onSuccess5 = &token::on_success5;
+			opts_.onFailure5 = &token::on_failure5;
+		}
+	}
+}
+
+void connect_options::set_servers(const_string_collection_ptr serverURIs)
+{
+	if (serverURIs) {
+		serverURIs_ = std::move(serverURIs);
+		opts_. serverURIcount = (int) serverURIs_->size();
+		opts_.serverURIs = serverURIs_->c_arr();
+	}
+	else {
+		serverURIs_.reset();
+		opts_.serverURIcount = 0;
+		opts_.serverURIs = nullptr;
+	}
+}
+
+void connect_options::set_mqtt_version(int mqttVersion) {
+	opts_.MQTTVersion = mqttVersion;
+
+	if (mqttVersion < MQTTVERSION_5)
+		opts_.cleanstart = 0;
+	else
+		opts_.cleansession = 0;
+}
+
+void connect_options::set_automatic_reconnect(int minRetryInterval,
+											  int maxRetryInterval)
+{
+	opts_.automaticReconnect = to_int(true);
+	opts_.minRetryInterval = minRetryInterval;
+	opts_.maxRetryInterval = maxRetryInterval;
+}
+
+
+/////////////////////////////////////////////////////////////////////////////
+
+} // end namespace mqtt
+
diff --git a/src/mqtt/src/disconnect_options.cpp b/src/mqtt/src/disconnect_options.cpp
new file mode 100644
index 00000000..8f52ee53
--- /dev/null
+++ b/src/mqtt/src/disconnect_options.cpp
@@ -0,0 +1,67 @@
+// disconnect_options.cpp
+
+#include "mqtt/disconnect_options.h"
+#include <utility>
+#include <cstring>
+
+namespace mqtt {
+
+/////////////////////////////////////////////////////////////////////////////
+
+const MQTTAsync_disconnectOptions disconnect_options::DFLT_C_STRUCT = MQTTAsync_disconnectOptions_initializer;
+
+disconnect_options::disconnect_options() : opts_(DFLT_C_STRUCT)
+{
+}
+
+disconnect_options::disconnect_options(const disconnect_options& opt)
+			: opts_(opt.opts_), tok_(opt.tok_)
+{
+}
+
+disconnect_options::disconnect_options(disconnect_options&& opt)
+			: opts_(opt.opts_), tok_(std::move(opt.tok_))
+{
+}
+
+disconnect_options& disconnect_options::operator=(const disconnect_options& opt)
+{
+	opts_ = opt.opts_;
+	tok_ = opt.tok_;
+	return *this;
+}
+
+disconnect_options& disconnect_options::operator=(disconnect_options&& opt)
+{
+	opts_ = opt.opts_;
+	tok_ = std::move(opt.tok_);
+	return *this;
+}
+
+void disconnect_options::set_token(const token_ptr& tok, int mqttVersion)
+{
+	tok_ = tok;
+	opts_.context = tok_.get();
+
+	opts_.onSuccess = nullptr;
+	opts_.onFailure = nullptr;
+
+	opts_.onSuccess5 = nullptr;
+	opts_.onFailure5 = nullptr;
+
+	if (tok) {
+		if (mqttVersion >= MQTTVERSION_5) {
+			opts_.onSuccess5 = &token::on_success5;
+			opts_.onFailure5 = &token::on_failure5;
+		}
+		else {
+			opts_.onSuccess = &token::on_success;
+			opts_.onFailure = &token::on_failure;
+		}
+	}
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// end namespace 'mqtt'
+}
+
diff --git a/src/mqtt/src/iclient_persistence.cpp b/src/mqtt/src/iclient_persistence.cpp
new file mode 100644
index 00000000..3f8b1a03
--- /dev/null
+++ b/src/mqtt/src/iclient_persistence.cpp
@@ -0,0 +1,151 @@
+// iclient_persistence.cpp
+
+/*******************************************************************************
+ * Copyright (c) 2013-2016 Frank Pagliughi <fpagliughi@mindspring.com>
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution. 
+ *
+ * The Eclipse Public License is available at 
+ *    http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at 
+ *   http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *    Frank Pagliughi - initial implementation and documentation
+ *******************************************************************************/
+
+#include "mqtt/types.h"
+#include "mqtt/iclient_persistence.h"
+#include <cstring>
+#include <cstdlib>
+
+namespace mqtt {
+
+/////////////////////////////////////////////////////////////////////////////
+// Functions to transition C persistence calls to the C++ persistence object.
+
+// Upon the call to persistence_open(), the 'context' has the address of the
+// C++ persistence object, which is reassigned to the 'handle'. Subsequent
+// calls have the object address as the handle.
+
+int iclient_persistence::persistence_open(void** handle, const char* clientID, 
+										  const char* serverURI, void* context)
+{
+	try {
+		if (handle && clientID && serverURI && context) {
+			static_cast<iclient_persistence*>(context)->open(clientID, serverURI);
+			*handle = context;
+			return MQTTASYNC_SUCCESS;
+		}
+	}
+	catch (...) {}
+
+	return MQTTCLIENT_PERSISTENCE_ERROR;
+}
+
+int iclient_persistence::persistence_close(void* handle)
+{
+	try {
+		if (handle) {
+			static_cast<iclient_persistence*>(handle)->close();
+			return MQTTASYNC_SUCCESS;
+		}
+	}
+	catch (...) {}
+
+	return MQTTCLIENT_PERSISTENCE_ERROR;
+}
+
+int iclient_persistence::persistence_put(void* handle, char* key, int bufcount, 
+										 char* buffers[], int buflens[])
+{
+	try {
+		if (handle && bufcount > 0 && buffers && buflens) {
+			std::vector<string_view> vec;
+			for (int i=0; i<bufcount; ++i)
+				vec.push_back(string_view(buffers[i], buflens[i]));
+			static_cast<iclient_persistence*>(handle)->put(key, vec);
+			return MQTTASYNC_SUCCESS;
+		}
+	}
+	catch (...) {}
+
+	return MQTTCLIENT_PERSISTENCE_ERROR;
+}
+
+int iclient_persistence::persistence_get(void* handle, char* key, 
+										 char** buffer, int* buflen)
+{
+	try {
+		if (handle && key && buffer && buflen) {
+			auto sv = static_cast<iclient_persistence*>(handle)->get(key);
+			*buffer = const_cast<char*>(sv.data());
+			*buflen = (int) sv.length();
+			return MQTTASYNC_SUCCESS;
+		}
+	}
+	catch (...) {}
+
+	return MQTTCLIENT_PERSISTENCE_ERROR;
+}
+
+int iclient_persistence::persistence_remove(void* handle, char* key)
+{
+	try {
+		if (handle && key) {
+			static_cast<iclient_persistence*>(handle)->remove(key);
+			return MQTTASYNC_SUCCESS;
+		}
+	}
+	catch (...) {}
+
+	return MQTTCLIENT_PERSISTENCE_ERROR;
+}
+
+int iclient_persistence::persistence_keys(void* handle, char*** keys, int* nkeys)
+{
+	try {
+		if (handle && keys && nkeys) {
+			auto& k = static_cast<iclient_persistence*>(handle)->keys();
+			size_t n = k.size();
+			*nkeys = n;
+			*keys = (n == 0) ? nullptr : const_cast<char**>(k.c_arr());
+			return MQTTASYNC_SUCCESS;
+		}
+	}
+	catch (...) {}
+
+	return MQTTCLIENT_PERSISTENCE_ERROR;
+}
+
+int iclient_persistence::persistence_clear(void* handle)
+{
+	try {
+		if (handle) {
+			static_cast<iclient_persistence*>(handle)->clear();
+			return MQTTASYNC_SUCCESS;
+		}
+	}
+	catch (...) {}
+
+	return MQTTCLIENT_PERSISTENCE_ERROR;
+}
+
+int iclient_persistence::persistence_containskey(void* handle, char* key)
+{
+	try {
+		if (handle && key &&
+				static_cast<iclient_persistence*>(handle)->contains_key(key))
+			return MQTTASYNC_SUCCESS;
+	}
+	catch (...) {}
+
+	return MQTTCLIENT_PERSISTENCE_ERROR;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// end namespace mqtt
+}
+
diff --git a/src/mqtt/src/message.cpp b/src/mqtt/src/message.cpp
new file mode 100644
index 00000000..0a3a59c1
--- /dev/null
+++ b/src/mqtt/src/message.cpp
@@ -0,0 +1,122 @@
+// message.cpp
+
+/*******************************************************************************
+ * Copyright (c) 2013-2017 Frank Pagliughi <fpagliughi@mindspring.com>
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution.
+ *
+ * The Eclipse Public License is available at
+ *    http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at
+ *   http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *    Frank Pagliughi - initial implementation and documentation
+ *******************************************************************************/
+
+
+#include "mqtt/message.h"
+#include <cstring>
+#include <utility>
+
+namespace mqtt {
+
+/////////////////////////////////////////////////////////////////////////////
+
+#if __cplusplus < 201703L
+	constexpr int message::DFLT_QOS;
+	constexpr bool message::DFLT_RETAINED;
+#endif
+
+const MQTTAsync_message message::DFLT_C_STRUCT = MQTTAsync_message_initializer;
+
+// --------------------------------------------------------------------------
+
+message::message() : msg_(DFLT_C_STRUCT)
+{
+}
+
+message::message(string_ref topic, const void* payload, size_t len, int qos, bool retained)
+						: msg_(DFLT_C_STRUCT), topic_(std::move(topic))
+{
+	set_payload(payload, len);
+	set_qos(qos);
+	set_retained(retained);
+}
+
+message::message(string_ref topic, binary_ref payload, int qos, bool retained)
+						: msg_(DFLT_C_STRUCT), topic_(std::move(topic))
+{
+	set_payload(std::move(payload));
+	set_qos(qos);
+	set_retained(retained);
+}
+
+message::message(string_ref topic, const MQTTAsync_message& msg)
+						: msg_(msg), topic_(std::move(topic)), props_(msg.properties)
+{
+	msg_.properties = props_.c_struct();
+	set_payload(msg.payload, msg.payloadlen);
+}
+
+message::message(const message& other) : msg_(other.msg_), topic_(other.topic_)
+{
+	set_payload(other.payload_);
+}
+
+message::message(message&& other) : msg_(other.msg_), topic_(std::move(other.topic_))
+{
+	set_payload(std::move(other.payload_));
+	other.msg_.payloadlen = 0;
+	other.msg_.payload = nullptr;
+}
+
+message& message::operator=(const message& rhs)
+{
+	if (&rhs != this) {
+		msg_ = rhs.msg_;
+		topic_ = rhs.topic_;
+		set_payload(rhs.payload_);
+	}
+	return *this;
+}
+
+message& message::operator=(message&& rhs)
+{
+	if (&rhs != this) {
+		msg_ = rhs.msg_;
+		topic_ = std::move(rhs.topic_);
+		set_payload(std::move(rhs.payload_));
+		rhs.msg_.payloadlen = 0;
+		rhs.msg_.payload = nullptr;
+	}
+	return *this;
+}
+
+void message::clear_payload()
+{
+	payload_.reset();
+	msg_.payload = nullptr;
+	msg_.payloadlen = 0;
+}
+
+void message::set_payload(binary_ref payload)
+{
+	payload_ = std::move(payload);
+
+	if (payload_.empty()) {
+		msg_.payload = nullptr;
+		msg_.payloadlen = 0;
+	}
+	else {
+		msg_.payload = const_cast<binary_ref::value_type*>(payload_.data());
+		msg_.payloadlen = payload_.length();
+	}
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// end namespace mqtt
+}
+
diff --git a/src/mqtt/src/mqtt/async_client.h b/src/mqtt/src/mqtt/async_client.h
new file mode 100644
index 00000000..4bbd95c1
--- /dev/null
+++ b/src/mqtt/src/mqtt/async_client.h
@@ -0,0 +1,710 @@
+/////////////////////////////////////////////////////////////////////////////
+/// @file async_client.h
+/// Declaration of MQTT async_client class
+/// @date May 1, 2013
+/// @author Frank Pagliughi
+/////////////////////////////////////////////////////////////////////////////
+
+/*******************************************************************************
+ * Copyright (c) 2013-2019 Frank Pagliughi <fpagliughi@mindspring.com>
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution.
+ *
+ * The Eclipse Public License is available at
+ *    http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at
+ *   http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *    Frank Pagliughi - initial implementation and documentation
+ *    Frank Pagliughi - MQTT v5 support
+ *******************************************************************************/
+
+#ifndef __mqtt_async_client_h
+#define __mqtt_async_client_h
+
+#include "MQTTAsync.h"
+#include "mqtt/types.h"
+#include "mqtt/token.h"
+#include "mqtt/string_collection.h"
+#include "mqtt/delivery_token.h"
+#include "mqtt/iclient_persistence.h"
+#include "mqtt/iaction_listener.h"
+#include "mqtt/properties.h"
+#include "mqtt/exception.h"
+#include "mqtt/message.h"
+#include "mqtt/callback.h"
+#include "mqtt/thread_queue.h"
+#include "mqtt/iasync_client.h"
+#include <vector>
+#include <list>
+#include <memory>
+#include <tuple>
+#include <functional>
+#include <stdexcept>
+
+namespace mqtt {
+
+// OBSOLETE: The legacy constants that lacked the "PAHO_MQTTPP_" prefix
+// clashed with #define's from other libraries and will be removed at the
+// next major version upgrade.
+
+#if defined(PAHO_MQTTPP_VERSIONS)
+	/** The version number for the client library. */
+	const uint32_t PAHO_MQTTPP_VERSION = 0x01010000;
+	/** The version string for the client library  */
+	const string PAHO_MQTTPP_VERSION_STR("Paho MQTT C++ (mqttpp) v. 1.1");
+	/** Copyright notice for the client library */
+	const string PAHO_MQTTPP_COPYRIGHT("Copyright (c) 2013-2019 Frank Pagliughi");
+#else
+	/** The version number for the client library. */
+	const uint32_t VERSION = 0x01010000;
+	/** The version string for the client library  */
+	const string VERSION_STR("Paho MQTT C++ (mqttpp) v. 1.1");
+	/** Copyright notice for the client library */
+	const string COPYRIGHT("Copyright (c) 2013-2019 Frank Pagliughi");
+#endif
+
+/////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Lightweight client for talking to an MQTT server using non-blocking
+ * methods that allow an operation to run in the background.
+ */
+class async_client : public virtual iasync_client
+{
+public:
+	/** Smart/shared pointer for an object of this class */
+	using ptr_t = std::shared_ptr<async_client>;
+	/** Type for a thread-safe queue to consume messages synchronously */
+	using consumer_queue_type = std::unique_ptr<thread_queue<const_message_ptr>>;
+
+	/** Handler type for registering an individual message callback */
+	using message_handler = std::function<void(const_message_ptr)>;
+	/** Handler type for when a connecion is made or lost */
+	using connection_handler = std::function<void(const string& cause)>;
+	/** Handler type for when a disconnect packet is received */
+	using disconnected_handler = std::function<void(const properties&, ReasonCode)>;
+
+private:
+	/** Lock guard type for this class */
+	using guard = std::unique_lock<std::mutex>;
+	/** Unique lock type for this class */
+	using unique_lock = std::unique_lock<std::mutex>;
+
+	/** Object monitor mutex */
+	mutable std::mutex lock_;
+	/** The underlying C-lib client. */
+	MQTTAsync cli_;
+	/** The server URI string. */
+	string serverURI_;
+	/** The client ID string that we provided to the server. */
+	string clientId_;
+	/** The MQTT protocol version we're connected at */
+	int mqttVersion_;
+	/** A user persistence wrapper (if any) */
+	std::unique_ptr<MQTTClient_persistence> persist_;
+	/** Callback supplied by the user (if any) */
+	callback* userCallback_;
+	/** Connection handler */
+	connection_handler connHandler_;
+	/** Connection lost handler */
+	connection_handler connLostHandler_;
+	/** Disconnected handler */
+	disconnected_handler disconnectedHandler_;
+	/** Message handler (if any) */
+	message_handler msgHandler_;
+	/** Copy of connect token (for re-connects) */
+	token_ptr connTok_;
+	/** A list of tokens that are in play */
+	std::list<token_ptr> pendingTokens_;
+	/** A list of delivery tokens that are in play */
+	std::list<delivery_token_ptr> pendingDeliveryTokens_;
+	/** A queue of messages for consumer API */
+	consumer_queue_type que_;
+
+	/** Callbacks from the C library */
+	static void on_connected(void* context, char* cause);
+	static void on_connection_lost(void *context, char *cause);
+	static void on_disconnected(void* context, MQTTProperties* cprops,
+								MQTTReasonCodes reasonCode);
+	static int  on_message_arrived(void* context, char* topicName, int topicLen,
+								   MQTTAsync_message* msg);
+	static void on_delivery_complete(void* context, MQTTAsync_token tok);
+
+	/** Manage internal list of active tokens */
+	friend class token;
+	virtual void add_token(token_ptr tok);
+	virtual void add_token(delivery_token_ptr tok);
+	virtual void remove_token(token* tok) override;
+	virtual void remove_token(token_ptr tok) { remove_token(tok.get()); }
+	void remove_token(delivery_token_ptr tok) { remove_token(tok.get()); }
+
+	/** Non-copyable */
+	async_client() =delete;
+	async_client(const async_client&) =delete;
+	async_client& operator=(const async_client&) =delete;
+
+	/** Checks a function return code and throws on error. */
+	static void check_ret(int rc) {
+		if (rc != MQTTASYNC_SUCCESS)
+			throw exception(rc);
+	}
+
+public:
+	/**
+	 * Create an async_client that can be used to communicate with an MQTT
+	 * server.
+	 * This uses file-based persistence in the specified directory.
+	 * @param serverURI the address of the server to connect to, specified
+	 *  				as a URI.
+	 * @param clientId a client identifier that is unique on the server
+	 *  			   being connected to
+	 * @param persistDir The directory to use for persistence data
+	 * @throw exception if an argument is invalid
+	 */
+	async_client(const string& serverURI, const string& clientId,
+				 const string& persistDir);
+	/**
+	 * Create an async_client that can be used to communicate with an MQTT
+	 * server.
+	 * This allows the caller to specify a user-defined persistence object,
+	 * or use no persistence.
+	 * @param serverURI the address of the server to connect to, specified
+	 *  				as a URI.
+	 * @param clientId a client identifier that is unique on the server
+	 *  			   being connected to
+	 * @param persistence The user persistence structure. If this is null,
+	 *  				  then no persistence is used.
+	 * @throw exception if an argument is invalid
+	 */
+	async_client(const string& serverURI, const string& clientId,
+				 iclient_persistence* persistence=nullptr);
+	/**
+	 * Create an async_client that can be used to communicate with an MQTT
+	 * server, which allows for off-line message buffering.
+	 * This uses file-based persistence in the specified directory.
+	 * @param serverURI the address of the server to connect to, specified
+	 *  				as a URI.
+	 * @param clientId a client identifier that is unique on the server
+	 *  			   being connected to
+	 * @param maxBufferedMessages the maximum number of messages allowed to
+	 *  						  be buffered while not connected
+	 * @param persistDir The directory to use for persistence data
+	 * @throw exception if an argument is invalid
+	 */
+	async_client(const string& serverURI, const string& clientId,
+				 int maxBufferedMessages, const string& persistDir);
+	/**
+	 * Create an async_client that can be used to communicate with an MQTT
+	 * server, which allows for off-line message buffering.
+	 * This allows the caller to specify a user-defined persistence object,
+	 * or use no persistence.
+	 * @param serverURI the address of the server to connect to, specified
+	 *  				as a URI.
+	 * @param clientId a client identifier that is unique on the server
+	 *  			   being connected to
+	 * @param maxBufferedMessages the maximum number of messages allowed to
+	 *  						  be buffered while not connected
+	 * @param persistence The user persistence structure. If this is null,
+	 *  				  then no persistence is used.
+	 * @throw exception if an argument is invalid
+	 */
+	async_client(const string& serverURI, const string& clientId,
+				 int maxBufferedMessages, iclient_persistence* persistence=nullptr);
+	/**
+	 * Destructor
+	 */
+	~async_client() override;
+	/**
+	 * Sets a callback listener to use for events that happen
+	 * asynchronously.
+	 * @param cb callback receiver which will be invoked for certain
+	 *  		 asynchronous events
+	 */
+	void set_callback(callback& cb) override;
+	/**
+	 * Stops callbacks.
+	 * This is not normally called by the application. It should be used
+	 * cautiously as it may cause the application to lose messages.
+	 */
+	void disable_callbacks() override;
+	/**
+	 * Callback for when a connection is made.
+	 * @param cb Callback functor for when the connection is made.
+	 */
+	void set_connected_handler(connection_handler cb) /*override*/;
+	/**
+	 * Callback for when a connection is lost.
+	 * @param cb Callback functor for when the connection is lost.
+	 */
+	void set_connection_lost_handler(connection_handler cb) /*override*/;
+	/**
+	 * Callback for when a disconnect packet is received from the server.
+	 * @param cb Callback for when the disconnect packet is received.
+	 */
+	void set_disconnected_handler(disconnected_handler cb) /*override*/;
+	/**
+	 * Sets the callback for when a message arrives from the broker.
+	 * Note that the application can only have one message handler which can
+	 * be installed individually using this method, or installled as a
+	 * listener object.
+	 * @param cb The callback functor to register with the library.
+	 */
+	void set_message_callback(message_handler cb) /*override*/;
+	/**
+	 * Connects to an MQTT server using the default options.
+	 * @return token used to track and wait for the connect to complete. The
+	 *  	   token will be passed to any callback that has been set.
+	 * @throw exception for non security related problems
+	 * @throw security_exception for security related problems
+	 */
+	token_ptr connect() override;
+	/**
+	 * Connects to an MQTT server using the provided connect options.
+	 * @param options a set of connection parameters that override the
+	 *  			  defaults.
+	 * @return token used to track and wait for the connect to complete. The
+	 *  	   token will be passed to any callback that has been set.
+	 * @throw exception for non security related problems
+	 * @throw security_exception for security related problems
+	 */
+	token_ptr connect(connect_options options) override;
+	/**
+	 * Connects to an MQTT server using the specified options.
+	 * @param options a set of connection parameters that override the
+	 *  			  defaults.
+	 * @param userContext optional object used to pass context to the
+	 *  				  callback. Use @em nullptr if not required.
+	 * @param cb callback listener that will be notified when the connect
+	 *  			   completes.
+	 * @return token used to track and wait for the connect to complete. The
+	 *  	   token will be passed to any callback that has been set.
+	 * @throw exception for non security related problems
+	 * @throw security_exception for security related problems
+	 */
+	token_ptr connect(connect_options options, void* userContext,
+					  iaction_listener& cb) override;
+	/**
+	 *
+	 * @param userContext optional object used to pass context to the
+	 *  				  callback. Use @em nullptr if not required.
+	 * @param cb callback listener that will be notified when the connect
+	 *  			   completes.
+	 * @return token used to track and wait for the connect to complete. The
+	 *  	   token will be passed to any callback that has been set.
+	 * @throw exception for non security related problems
+	 * @throw security_exception for security related problems
+	 */
+	token_ptr connect(void* userContext, iaction_listener& cb) override {
+		return connect(connect_options{}, userContext, cb);
+	}
+	/**
+	 * Reconnects the client using options from the previous connect.
+	 * The client must have previously called connect() for this to work.
+	 * @return token used to track the progress of the reconnect.
+	 */
+	token_ptr reconnect() override;
+	/**
+	 * Disconnects from the server.
+	 * @return token used to track and wait for the disconnect to complete.
+	 *  	   The token will be passed to any callback that has been set.
+	 * @throw exception for problems encountered while disconnecting
+	 */
+	token_ptr disconnect() override { return disconnect(disconnect_options()); }
+	/**
+	 * Disconnects from the server.
+	 * @param opts Options for disconnecting.
+	 * @return token used to track and wait for the disconnect to complete.
+	 *  	   The token will be passed to any callback that has been set.
+	 * @throw exception for problems encountered while disconnecting
+	 */
+	token_ptr disconnect(disconnect_options opts) override;
+	/**
+	 * Disconnects from the server.
+	 * @param timeout the amount of time in milliseconds to allow for
+	 *  			  existing work to finish before disconnecting. A value
+	 *  			  of zero or less means the client will not quiesce.
+	 * @return Token used to track and wait for disconnect to complete. The
+	 *  	   token will be passed to the callback methods if a callback is
+	 *  	   set.
+	 * @throw exception for problems encountered while disconnecting
+	 */
+	token_ptr disconnect(int timeout) override {
+		return disconnect(disconnect_options(timeout));
+	}
+	/**
+	 * Disconnects from the server.
+	 * @param timeout the amount of time in milliseconds to allow for
+	 *  			  existing work to finish before disconnecting. A value
+	 *  			  of zero or less means the client will not quiesce.
+	 * @return Token used to track and wait for disconnect to complete. The
+	 *  	   token will be passed to the callback methods if a callback is
+	 *  	   set.
+	 * @throw exception for problems encountered while disconnecting
+	 */
+	template <class Rep, class Period>
+	token_ptr disconnect(const std::chrono::duration<Rep, Period>& timeout) {
+		// TODO: check range
+		return disconnect((int) to_milliseconds_count(timeout));
+	}
+	/**
+	 * Disconnects from the server.
+	 * @param timeout the amount of time in milliseconds to allow for
+	 *  			  existing work to finish before disconnecting. A value
+	 *  			  of zero or less means the client will not quiesce.
+	 * @param userContext optional object used to pass context to the
+	 *  				  callback. Use @em nullptr if not required.
+	 * @param cb callback listener that will be notified when the disconnect
+	 *  			   completes.
+	 * @return token_ptr Token used to track and wait for disconnect to
+	 *  	   complete. The token will be passed to the callback methods if
+	 *  	   a callback is set.
+	 * @throw exception for problems encountered while disconnecting
+	 */
+	token_ptr disconnect(int timeout, void* userContext,
+						 iaction_listener& cb) override;
+	/**
+	 * Disconnects from the server.
+	 * @param timeout the amount of time in milliseconds to allow for
+	 *  			  existing work to finish before disconnecting. A value
+	 *  			  of zero or less means the client will not quiesce.
+	 * @param userContext optional object used to pass context to the
+	 *  				  callback. Use @em nullptr if not required.
+	 * @param cb callback listener that will be notified when the disconnect
+	 *  			   completes.
+	 * @return token_ptr Token used to track and wait for disconnect to
+	 *  	   complete. The token will be passed to the callback methods if
+	 *  	   a callback is set.
+	 * @throw exception for problems encountered while disconnecting
+	 */
+	template <class Rep, class Period>
+	token_ptr disconnect(const std::chrono::duration<Rep, Period>& timeout,
+						 void* userContext, iaction_listener& cb) {
+		// TODO: check range
+		return disconnect((int) to_milliseconds_count(timeout), userContext, cb);
+	}
+	/**
+	 * Disconnects from the server.
+	 * @param userContext optional object used to pass context to the
+	 *  				  callback. Use @em nullptr if not required.
+	 * @param cb callback listener that will be notified when the disconnect
+	 *  			   completes.
+	 * @return token_ptr Token used to track and wait for disconnect to
+	 *  	   complete. The token will be passed to the callback methods if
+	 *  	   a callback is set.
+	 * @throw exception for problems encountered while disconnecting
+	 */
+	token_ptr disconnect(void* userContext, iaction_listener& cb) override {
+		return disconnect(0L, userContext, cb);
+	}
+	/**
+	 * Returns the delivery token for the specified message ID.
+	 * @return delivery_token
+	 */
+	delivery_token_ptr get_pending_delivery_token(int msgID) const override;
+	/**
+	 * Returns the delivery tokens for any outstanding publish operations.
+	 * @return delivery_token[]
+	 */
+	std::vector<delivery_token_ptr> get_pending_delivery_tokens() const override;
+	/**
+	 * Returns the client ID used by this client.
+	 * @return The client ID used by this client.
+	 */
+	string get_client_id() const override { return clientId_; }
+	/**
+	 * Returns the address of the server used by this client.
+	 * @return The server's address, as a URI String.
+	 */
+	string get_server_uri() const override { return serverURI_; }
+	/**
+	 * Determines if this client is currently connected to the server.
+	 * @return true if connected, false otherwise.
+	 */
+	bool is_connected() const override { return to_bool(MQTTAsync_isConnected(cli_)); }
+	/**
+	 * Publishes a message to a topic on the server
+	 * @param topic The topic to deliver the message to
+	 * @param payload the bytes to use as the message payload
+	 * @param n the number of bytes in the payload
+	 * @param qos the Quality of Service to deliver the message at. Valid
+	 *  		  values are 0, 1 or 2.
+	 * @param retained whether or not this message should be retained by the
+	 *  			   server.
+	 * @return token used to track and wait for the publish to complete. The
+	 *  	   token will be passed to callback methods if set.
+	 */
+	delivery_token_ptr publish(string_ref topic, const void* payload, size_t n,
+							   int qos, bool retained) override;
+	/**
+	 * Publishes a message to a topic on the server
+	 * @param topic The topic to deliver the message to
+	 * @param payload the bytes to use as the message payload
+	 * @param n the number of bytes in the payload
+	 * @return token used to track and wait for the publish to complete. The
+	 *  	   token will be passed to callback methods if set.
+	 */
+	delivery_token_ptr publish(string_ref topic, const void* payload, size_t n) override {
+		return publish(std::move(topic), payload, n,
+					   message::DFLT_QOS, message::DFLT_RETAINED);
+	}
+	/**
+	 * Publishes a message to a topic on the server
+	 * @param topic The topic to deliver the message to
+	 * @param payload the bytes to use as the message payload
+	 * @param qos the Quality of Service to deliver the message at. Valid
+	 *  		  values are 0, 1 or 2.
+	 * @param retained whether or not this message should be retained by the
+	 *  			   server.
+	 * @return token used to track and wait for the publish to complete. The
+	 *  	   token will be passed to callback methods if set.
+	 */
+	delivery_token_ptr publish(string_ref topic, binary_ref payload,
+							   int qos, bool retained) override;
+	/**
+	 * Publishes a message to a topic on the server
+	 * @param topic The topic to deliver the message to
+	 * @param payload the bytes to use as the message payload
+	 * @return token used to track and wait for the publish to complete. The
+	 *  	   token will be passed to callback methods if set.
+	 */
+	delivery_token_ptr publish(string_ref topic, binary_ref payload) override {
+		return publish(std::move(topic), std::move(payload),
+					   message::DFLT_QOS, message::DFLT_RETAINED);
+	}
+	/**
+	 * Publishes a message to a topic on the server
+	 * @param topic The topic to deliver the message to
+	 * @param payload the bytes to use as the message payload
+	 * @param n the number of bytes in the payload
+	 * @param qos the Quality of Service to deliver the message at. Valid
+	 *  		  values are 0, 1 or 2.
+	 * @param retained whether or not this message should be retained by the
+	 *  			   server.
+	 * @param userContext optional object used to pass context to the
+	 *  				  callback. Use @em nullptr if not required.
+	 * @param cb
+	 * @return token used to track and wait for the publish to complete. The
+	 *  	   token will be passed to callback methods if set.
+	 */
+	delivery_token_ptr publish(string_ref topic,
+							   const void* payload, size_t n,
+							   int qos, bool retained,
+							   void* userContext, iaction_listener& cb) override;
+	/**
+	 * Publishes a message to a topic on the server Takes an Message
+	 * message and delivers it to the server at the requested quality of
+	 * service.
+	 * @param msg the message to deliver to the server
+	 * @return token used to track and wait for the publish to complete. The
+	 *  	   token will be passed to callback methods if set.
+	 */
+	delivery_token_ptr publish(const_message_ptr msg) override;
+	/**
+	 * Publishes a message to a topic on the server.
+	 * @param msg the message to deliver to the server
+	 * @param userContext optional object used to pass context to the
+	 *  				  callback. Use @em nullptr if not required.
+	 * @param cb callback optional listener that will be notified when message
+	 *  			   delivery has completed to the requested quality of
+	 *  			   service
+	 * @return token used to track and wait for the publish to complete. The
+	 *  	   token will be passed to callback methods if set.
+	 */
+	delivery_token_ptr publish(const_message_ptr msg,
+							   void* userContext, iaction_listener& cb) override;
+	/**
+	 * Subscribe to a topic, which may include wildcards.
+	 * @param topicFilter the topic to subscribe to, which can include
+	 *  				  wildcards.
+	 * @param qos
+	 *
+	 * @return token used to track and wait for the subscribe to complete.
+	 *  	   The token will be passed to callback methods if set.
+	 */
+	token_ptr subscribe(const string& topicFilter, int qos,
+						const subscribe_options& opts=subscribe_options()) override;
+	/**
+	 * Subscribe to a topic, which may include wildcards.
+	 * @param topicFilter the topic to subscribe to, which can include
+	 *  				  wildcards.
+	 * @param qos the maximum quality of service at which to subscribe.
+	 *  		  Messages published at a lower quality of service will be
+	 *  		  received at the published QoS. Messages published at a
+	 *  		  higher quality of service will be received using the QoS
+	 *  		  specified on the subscribe.
+	 * @param userContext optional object used to pass context to the
+	 *  				  callback. Use @em nullptr if not required.
+	 * @param cb listener that will be notified when subscribe has completed
+	 * @return token used to track and wait for the subscribe to complete.
+	 *  	   The token will be passed to callback methods if set.
+	 */
+	token_ptr subscribe(const string& topicFilter, int qos,
+						void* userContext, iaction_listener& cb,
+						const subscribe_options& opts=subscribe_options()) override;
+	/**
+	 * Subscribe to multiple topics, each of which may include wildcards.
+	 * @param topicFilters
+	 * @param qos the maximum quality of service at which to subscribe.
+	 *  		  Messages published at a lower quality of service will be
+	 *  		  received at the published QoS. Messages published at a
+	 *  		  higher quality of service will be received using the QoS
+	 *  		  specified on the subscribe.
+	 * @return token used to track and wait for the subscribe to complete.
+	 *  	   The token will be passed to callback methods if set.
+	 */
+	token_ptr subscribe(const_string_collection_ptr topicFilters,
+						const qos_collection& qos,
+						const std::vector<subscribe_options>& opts=std::vector<subscribe_options>()) override;
+	/**
+	 * Subscribes to multiple topics, each of which may include wildcards.
+	 * @param topicFilters
+	 * @param qos the maximum quality of service at which to subscribe.
+	 *  		  Messages published at a lower quality of service will be
+	 *  		  received at the published QoS. Messages published at a
+	 *  		  higher quality of service will be received using the QoS
+	 *  		  specified on the subscribe.
+	 * @param userContext optional object used to pass context to the
+	 *  				  callback. Use @em nullptr if not required.
+	 * @param cb listener that will be notified when subscribe has completed
+	 * @return token used to track and wait for the subscribe to complete.
+	 *  	   The token will be passed to callback methods if set.
+	 */
+	token_ptr subscribe(const_string_collection_ptr topicFilters,
+						const qos_collection& qos,
+						void* userContext, iaction_listener& cb,
+						const std::vector<subscribe_options>& opts=std::vector<subscribe_options>()) override;
+	/**
+	 * Requests the server unsubscribe the client from a topic.
+	 * @param topicFilter the topic to unsubscribe from. It must match a
+	 *  				  topicFilter specified on an earlier subscribe.
+	 * @return token used to track and wait for the unsubscribe to complete.
+	 *  	   The token will be passed to callback methods if set.
+	 */
+	token_ptr unsubscribe(const string& topicFilter) override;
+	/**
+	 * Requests the server unsubscribe the client from one or more topics.
+	 * @param topicFilters one or more topics to unsubscribe from. Each
+	 *  				   topicFilter must match one specified on an
+	 *  				   earlier subscribe.
+	 * @return token used to track and wait for the unsubscribe to complete.
+	 *  	   The token will be passed to callback methods if set.
+	 */
+	token_ptr unsubscribe(const_string_collection_ptr topicFilters) override;
+	/**
+	 * Requests the server unsubscribe the client from one or more topics.
+	 * @param topicFilters
+	 * @param userContext optional object used to pass context to the
+	 *  				  callback. Use @em nullptr if not required.
+	 * @param cb listener that will be notified when unsubscribe has
+	 *  		 completed
+	 * @return token used to track and wait for the unsubscribe to complete.
+	 *  	   The token will be passed to callback methods if set.
+	 */
+	token_ptr unsubscribe(const_string_collection_ptr topicFilters,
+						   void* userContext, iaction_listener& cb) override;
+	/**
+	 * Requests the server unsubscribe the client from a topics.
+	 * @param topicFilter the topic to unsubscribe from. It must match a
+	 *  				  topicFilter specified on an earlier subscribe.
+	 * @param userContext optional object used to pass context to the
+	 *  				  callback. Use @em nullptr if not required.
+	 * @param cb listener that will be notified when unsubscribe has
+	 *  		 completed
+	 * @return token used to track and wait for the unsubscribe to complete.
+	 *  	   The token will be passed to callback methods if set.
+	 */
+	token_ptr unsubscribe(const string& topicFilter,
+						  void* userContext, iaction_listener& cb) override;
+
+	/**
+	 * Start consuming messages.
+	 * This initializes the client to receive messages through a queue that
+	 * can be read synchronously.
+	 */
+	void start_consuming();
+	/**
+	 * Stop consuming messages.
+	 * This shuts down the internal callback and discards any unread
+	 * messages.
+	 */
+	void stop_consuming();
+	/**
+	 * Read the next message from the queue.
+	 * This blocks until a new message arrives.
+	 * @return The message and topic.
+	 */
+	const_message_ptr consume_message() { return que_->get(); }
+	/**
+	 * Try to read the next message from the queue without blocking.
+	 * @param msg Pointer to the value to receive the message
+	 * @return @em true is a message was read, @em false if no message was
+	 *  	   available.
+	 */
+	bool try_consume_message(const_message_ptr* msg) {
+		return que_->try_get(msg);
+	}
+	/**
+	 * Waits a limited time for a message to arrive.
+	 * @param msg Pointer to the value to receive the message
+	 * @param relTime The maximum amount of time to wait for a message.
+	 * @return @em true if a message was read, @em false if a timeout
+	 *  	   occurred.
+	 */
+	template <typename Rep, class Period>
+	bool try_consume_message_for(const_message_ptr* msg,
+								 const std::chrono::duration<Rep, Period>& relTime) {
+		return que_->try_get_for(msg, relTime);
+	}
+	/**
+	 * Waits a limited time for a message to arrive.
+	 * @param relTime The maximum amount of time to wait for a message.
+	 * @return A shared pointer to the message that was received. It will be
+	 *  	   empty on timeout.
+	 */
+	template <typename Rep, class Period>
+	const_message_ptr try_consume_message_for(const std::chrono::duration<Rep, Period>& relTime) {
+		const_message_ptr msg;
+		que_->try_get_for(&msg, relTime);
+		return msg;
+	}
+	/**
+	 * Waits until a specific time for a message to appear.
+	 * @param msg Pointer to the value to receive the message
+	 * @param absTime The time point to wait until, before timing out.
+	 * @return @em true if a message was read, @em false if a timeout
+	 *  	   occurred.
+	 */
+	template <class Clock, class Duration>
+	bool try_consume_message_until(const_message_ptr* msg,
+								   const std::chrono::time_point<Clock,Duration>& absTime) {
+		return que_->try_get_until(msg, absTime);
+	}
+	/**
+	 * Waits until a specific time for a message to appear.
+	 * @param msg Pointer to the value to receive the message
+	 * @param absTime The time point to wait until, before timing out.
+	 * @return @em true if a message was read, @em false if a timeout
+	 *  	   occurred.
+	 */
+	template <class Clock, class Duration>
+	const_message_ptr try_consume_message_until(const std::chrono::time_point<Clock,Duration>& absTime) {
+		const_message_ptr msg;
+		que_->try_get_until(msg, absTime);
+		return msg;
+	}
+
+};
+
+/** Smart/shared pointer to an asynchronous MQTT client object */
+using async_client_ptr = async_client::ptr_t;
+
+/////////////////////////////////////////////////////////////////////////////
+// end namespace mqtt
+}
+
+#endif		// __mqtt_async_client_h
+
diff --git a/src/mqtt/src/mqtt/buffer_ref.h b/src/mqtt/src/mqtt/buffer_ref.h
new file mode 100644
index 00000000..4db9c747
--- /dev/null
+++ b/src/mqtt/src/mqtt/buffer_ref.h
@@ -0,0 +1,305 @@
+/////////////////////////////////////////////////////////////////////////////
+/// @file buffer_ref.h
+/// Buffer reference type for the Paho MQTT C++ library.
+/// @date April 18, 2017
+/// @author Frank Pagliughi
+/////////////////////////////////////////////////////////////////////////////
+
+/*******************************************************************************
+ * Copyright (c) 2017 Frank Pagliughi <fpagliughi@mindspring.com>
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution.
+ *
+ * The Eclipse Public License is available at
+ *    http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at
+ *   http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *    Frank Pagliughi - initial implementation and documentation
+ *******************************************************************************/
+
+#ifndef __mqtt_buffer_ref_h
+#define __mqtt_buffer_ref_h
+
+#include "mqtt/types.h"
+#include <iostream>
+#include <cstring>
+
+namespace mqtt {
+
+/////////////////////////////////////////////////////////////////////////////
+
+/**
+ * A reference object for holding immutable data buffers, with cheap copy
+ * semantics and lifetime management.
+ *
+ * Each object of this class contains a reference-counted pointer to an
+ * immutable data buffer. Objects can be copied freely and easily, even
+ * across threads, since all instances promise not to modify the contents
+ * of the buffer.
+ *
+ * The buffer is immutable but the reference itself acts like a normal
+ * variable. It can be reassigned to point to a different buffer.
+ *
+ * If no value has been assigned to a reference, then it is in a default
+ * "null" state. It is not safe to call any member functions on a null
+ * reference, other than to check if the object is null or empty.
+ * @verbatim
+ * string_ref sr;
+ * if (!sr)
+ *   cout << "null reference" << endl;
+ * else
+ *   cout.write(sr.data(), sr.size());
+ * @endverbatim
+ */
+template <typename T>
+class buffer_ref
+{
+public:
+	/**
+	 * The underlying type for the buffer.
+	 * Normally byte-wide data (char or uint8_t) for Paho.
+	 */
+	using value_type = T;
+	/**
+	 * The type for the buffer.
+	 * We use basic_string for compatibility with string data.
+	 */
+	using blob = std::basic_string<value_type>;
+	/**
+	 *  The pointer we use.
+	 *  Note that it is a pointer to a _const_ blob.
+	 */
+	using pointer_type = std::shared_ptr<const blob>;
+
+private:
+	/** Our data is a shared pointer to a const buffer */
+	pointer_type data_;
+
+public:
+	/**
+	 * Default constructor creates a null reference.
+	 */
+	buffer_ref() =default;
+	/**
+	 * Copy constructor only copies a shared pointer.
+	 * @param buf Another buffer reference.
+	 */
+	buffer_ref(const buffer_ref& buf) =default;
+	/**
+	 * Move constructor only moves a shared pointer.
+	 * @param buf Another buffer reference.
+	 */
+	buffer_ref(buffer_ref&& buf) =default;
+	/**
+	 * Creates a reference to a new buffer by copying data.
+	 * @param b A string from which to create a new buffer.
+	 */
+	buffer_ref(const blob& b) : data_{std::make_shared<blob>(b)} {}
+	/**
+	 * Creates a reference to a new buffer by moving a string into the
+	 * buffer.
+	 * @param b A string from which to create a new buffer.
+	 */
+	buffer_ref(blob&& b) : data_{std::make_shared<blob>(std::move(b))} {}
+	/**
+	 * Creates a reference to an existing buffer by copying the shared
+	 * pointer.
+	 * Note that it is up to the caller to insure that there are no mutable
+	 * references to the buffer.
+	 * @param p A shared pointer to a string.
+	 */
+	buffer_ref(const pointer_type& p) : data_(p) {}
+	/**
+	 * Creates a reference to an existing buffer by moving the shared
+	 * pointer.
+	 * Note that it is up to the caller to insure that there are no mutable
+	 * references to the buffer.
+	 * @param p A shared pointer to a string.
+	 */
+	buffer_ref(pointer_type&& p) : data_(std::move(p)) {}
+	/**
+	 * Creates a reference to a new buffer containing a copy of the data.
+	 * @param buf The memory to copy
+	 * @param n The number of bytes to copy.
+	 */
+	buffer_ref(const value_type* buf, size_t n) : data_{std::make_shared<blob>(buf,n)} {}
+	/**
+	 * Creates a reference to a new buffer containing a copy of the
+	 * NUL-terminated char array.
+	 * @param buf A NUL-terminated char array (C string).
+	 */
+	buffer_ref(const char* buf) : buffer_ref(reinterpret_cast<const value_type*>(buf), 
+											 std::strlen(buf)) {
+		static_assert(sizeof(char) == sizeof(T), "can only use C arr with char or byte buffers");
+	}
+
+	/**
+	 * Copy the reference to the buffer.
+	 * @param rhs Another buffer
+	 * @return A reference to this object
+	 */
+	buffer_ref& operator=(const buffer_ref& rhs) =default;
+	/**
+	 * Move a reference to a buffer.
+	 * @param rhs The other reference to move.
+	 * @return A reference to this object.
+	 */
+	buffer_ref& operator=(buffer_ref&& rhs) =default;
+	/**
+	 * Copy a string into this object, creating a new buffer.
+	 * Modifies the reference for this object, pointing it to a
+	 * newly-created buffer. Other references to the old object remain
+	 * unchanges, so this follows copy-on-write semantics.
+	 * @param b A new blob/string to copy.
+	 * @return A reference to this object.
+	 */
+	buffer_ref& operator=(const blob& b) {
+		data_.reset(new blob(b));
+		return *this;
+	}
+	/**
+	 * Move a string into this object, creating a new buffer.
+	 * Modifies the reference for this object, pointing it to a
+	 * newly-created buffer. Other references to the old object remain
+	 * unchanges, so this follows copy-on-write semantics.
+	 * @param b A new blob/string to move.
+	 * @return A reference to this object.
+	 */
+	buffer_ref& operator=(blob&& b) {
+		data_.reset(new blob(std::move(b)));
+		return *this;
+	}
+	/**
+	 * Copy a NUL-terminated C char array into a new buffer
+	 * @param cstr A NUL-terminated C string.
+	 * @return A reference to this object
+	 */
+	buffer_ref& operator=(const char* cstr) {
+		static_assert(sizeof(char) == sizeof(T), "can only use C arr with char or byte buffers");
+		data_.reset(new blob(reinterpret_cast<const value_type*>(cstr), strlen(cstr)));
+		return *this;
+	}
+	/**
+	 * Copy another type of buffer reference to this one.
+	 * This can copy a buffer of different types, provided that the size of
+	 * the data elements are the same. This is typically used to convert
+	 * from char to byte, where the data is the same, but the interpretation
+	 * is different. Note that this copies the underlying buffer.
+	 * @param rhs A reference to a different type of buffer.
+	 * @return A reference to this object.
+	 */
+	template <typename OT>
+	buffer_ref& operator=(const buffer_ref<OT>& rhs) {
+		static_assert(sizeof(OT) == sizeof(T), "Can only assign buffers if values the same size");
+		data_.reset(new blob(reinterpret_cast<const value_type*>(rhs.data()), rhs.size()));
+		return *this;
+	}
+	/**
+	 * Clears the reference to nil.
+	 */
+	void reset() { data_.reset(); }
+	/**
+	 * Determines if the reference is valid. 
+	 * If the reference is invalid then it is not safe to call @em any 
+	 * member functions other than @ref is_null() and @ref empty() 
+	 * @return @em true if referring to a valid buffer, @em false if the
+	 *  	   reference (pointer) is null.
+	 */
+	explicit operator bool() const { return bool(data_); }
+	/**
+	 * Determines if the reference is invalid.
+	 * If the reference is invalid then it is not safe to call @em any 
+	 * member functions other than @ref is_null() and @ref empty() 
+	 * @return @em true if the reference is null, @em false if it is 
+	 *  	   referring to a valid buffer,
+	 */
+	bool is_null() const { return !data_; }
+	/**
+	 * Determines if the buffer is empty.
+	 * @return @em true if the buffer is empty or thr reference is null, @em
+	 *  	   false if the buffer contains data.
+	 */
+	bool empty() const { return !data_ || data_->empty(); }
+	/**
+	 * Gets a const pointer to the data buffer.
+	 * @return A pointer to the data buffer.
+	 */
+	const value_type* data() const { return data_->data(); }
+	/**
+	 * Gets the size of the data buffer.
+	 * @return The size of the data buffer.
+	 */
+	size_t size() const { return data_->size(); }
+	/**
+	 * Gets the size of the data buffer.
+	 * @return The size of the data buffer.
+	 */
+	size_t length() const { return data_->length(); }
+	/**
+	 * Gets the data buffer as a string.
+	 * @return The data buffer as a string.
+	 */
+	const blob& str() const { return *data_; }
+	/**
+	 * Gets the data buffer as a string.
+	 * @return The data buffer as a string.
+	 */
+	const blob& to_string() const { return str(); }
+	/**
+	 * Gets the data buffer as NUL-terminated C string.
+	 * Note that the reference must be set to call this function.
+	 * @return The data buffer as a string.
+	 */
+	const char* c_str() const { return data_->c_str(); }
+	/**
+	 * Gets a shared pointer to the (const) data buffer.
+	 * @return A shared pointer to the (const) data buffer.
+	 */
+	const pointer_type& ptr() const { return data_; }
+	/**
+	 * Gets elemental access to the data buffer (read only)
+	 * @param i The index into the buffer.
+	 * @return The value at the specified index.
+	 */
+	const value_type& operator[](size_t i) const { return (*data_)[i]; }
+};
+
+/**
+ * Stream inserter for a buffer reference.
+ * This does a binary write of the data in the buffer.
+ * @param os The output stream.
+ * @param buf The buffer reference to write.
+ * @return A reference to the output stream.
+ */
+template <typename T>
+std::ostream& operator<<(std::ostream& os, const buffer_ref<T>& buf) {
+	if (!buf.empty())
+		os.write(buf.data(), buf.size());
+	return os;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+
+/**
+ * A refernce to a text buffer.
+ */
+using string_ref = buffer_ref<char>;
+
+/**
+ * A reference to a binary buffer.
+ * Note that we're using char for the underlying data type to allow
+ * efficient moves to and from std::string's. Using a separate type
+ * indicates that the data may be arbitrary binary.
+ */
+using binary_ref = buffer_ref<char>;
+
+/////////////////////////////////////////////////////////////////////////////
+// end namespace mqtt
+}
+
+#endif		// __mqtt_buffer_ref_h
+
diff --git a/src/mqtt/src/mqtt/buffer_view.h b/src/mqtt/src/mqtt/buffer_view.h
new file mode 100644
index 00000000..9284ecf0
--- /dev/null
+++ b/src/mqtt/src/mqtt/buffer_view.h
@@ -0,0 +1,119 @@
+/////////////////////////////////////////////////////////////////////////////
+/// @file buffer_view.h
+/// Buffer reference type for the Paho MQTT C++ library.
+/// @date April 18, 2017
+/// @author Frank Pagliughi
+/////////////////////////////////////////////////////////////////////////////
+
+/*******************************************************************************
+ * Copyright (c) 2017 Frank Pagliughi <fpagliughi@mindspring.com>
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution.
+ *
+ * The Eclipse Public License is available at
+ *    http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at
+ *   http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *    Frank Pagliughi - initial implementation and documentation
+ *******************************************************************************/
+
+#ifndef __mqtt_buffer_view_h
+#define __mqtt_buffer_view_h
+
+#include "mqtt/types.h"
+
+namespace mqtt {
+
+/////////////////////////////////////////////////////////////////////////////
+
+/**
+ * A reference to a contiguous sequence of items, with no ownership.
+ * This simply contains a pointer to a const array of items, and a size.
+ * This is a similar, but simplified version of the std::string_view
+ * class(es) in the C++17 standard.
+ */
+template <typename T>
+class buffer_view
+{
+public:
+	/** The type of items to be held in the queue. */
+	using value_type = T;
+	/** The type used to specify number of items in the container. */
+	using size_type = size_t;
+
+private:
+	/** Const pointer to the data array */
+	const value_type* data_;
+	/** The size of the array */
+	size_type sz_;
+
+public:
+	/**
+	 * Constructs a buffer view.
+	 * @param data The data pointer
+	 * @param n The number of items
+	 */
+	buffer_view(const value_type* data, size_type n)
+		: data_(data), sz_(n) {}
+	/**
+	 * Constructs a buffer view to a whole string.
+	 * This the starting pointer and length of the whole string.
+	 * @param str The string.
+	 */
+	buffer_view(const std::basic_string<value_type>& str)
+		: data_(str.data()), sz_(str.size()) {}
+	/**
+	 * Gets a pointer the first item in the view.
+	 * @return A const pointer the first item in the view.
+	 */
+	const value_type* data() const { return data_; }
+	/**
+	 * Gets the number of items in the view.
+	 * @return The number of items in the view.
+	 */
+	size_type size() const { return sz_; }
+	/**
+	 * Gets the number of items in the view.
+	 * @return The number of items in the view.
+	 */
+	size_type length() const { return sz_; }
+	/**
+	 * Access an item in the view.
+	 * @param i The index of the item.
+	 * @return A const reference to the requested item.
+	 */
+	const value_type& operator[](size_t i) const { return data_[i]; }
+	/**
+	 * Gets a copy of the view as a string.
+	 * @return A copy of the view as a string.
+	 */
+	std::basic_string<value_type> str() const {
+		return std::basic_string<value_type>(data_, sz_);
+	}
+	/**
+	 * Gets a copy of the view as a string.
+	 * @return A copy of the view as a string.
+	 */
+	string to_string() const {
+		static_assert(sizeof(char) == sizeof(T), "can only get string for char or byte buffers");
+		return string(reinterpret_cast<const char*>(data_), sz_);
+	}
+};
+
+/** A buffer view for character string data. */
+using string_view = buffer_view<char>;
+
+/** A buffer view for binary data */
+using binary_view = buffer_view<char>;
+
+
+/////////////////////////////////////////////////////////////////////////////
+// end namespace mqtt
+}
+
+#endif		// __mqtt_buffer_view_h
+
diff --git a/src/mqtt/src/mqtt/callback.h b/src/mqtt/src/mqtt/callback.h
new file mode 100644
index 00000000..434b9796
--- /dev/null
+++ b/src/mqtt/src/mqtt/callback.h
@@ -0,0 +1,91 @@
+/////////////////////////////////////////////////////////////////////////////
+/// @file callback.h
+/// Declaration of MQTT callback class
+/// @date May 1, 2013
+/// @author Frank Pagliughi
+/////////////////////////////////////////////////////////////////////////////
+
+/*******************************************************************************
+ * Copyright (c) 2013-2019 Frank Pagliughi <fpagliughi@mindspring.com>
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution.
+ *
+ * The Eclipse Public License is available at
+ *    http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at
+ *   http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *    Frank Pagliughi - initial implementation and documentation
+ *******************************************************************************/
+
+#ifndef __mqtt_callback_h
+#define __mqtt_callback_h
+
+#include "MQTTAsync.h"
+#include "mqtt/delivery_token.h"
+#include "mqtt/types.h"
+#include <vector>
+#include <memory>
+
+namespace mqtt {
+
+/////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Provides a mechanism for tracking the completion of an asynchronous
+ * action.
+ */
+class callback
+{
+public:
+	/** Smart/shared pointer to an object of this type */
+	using ptr_t = std::shared_ptr<callback>;
+	/** Smart/shared pointer to a const object of this type */
+	using const_ptr_t = std::shared_ptr<const callback>;
+
+	/**
+	 * Virtual destructor.
+	 */
+	virtual ~callback() {}
+
+	/**
+	 * This method is called when the client is connected. 
+	 * Note that, in response to an initial connect(), the token from the 
+	 * connect call is also signaled with an on_success(). That occurs just 
+	 * before this is called. 
+	 * @param cause
+	 */
+	virtual void connected(const string& /*cause*/) {}
+	/**
+	 * This method is called when the connection to the server is lost.
+	 * @param cause
+	 */
+	virtual void connection_lost(const string& /*cause*/) {}
+	/**
+	 * This method is called when a message arrives from the server.
+	 * @param msg The message
+	 */
+	virtual void message_arrived(const_message_ptr /*msg*/) {}
+	/**
+	 * Called when delivery for a message has been completed, and all
+	 * acknowledgments have been received.
+	 * @param tok The token tracking the message delivery.
+	 */
+	virtual void delivery_complete(delivery_token_ptr /*tok*/) {}
+};
+
+/** Smart/shared pointer to a callback object */
+using callback_ptr = callback::ptr_t;
+
+/** Smart/shared pointer to a const callback object */
+using const_callback_ptr = callback::const_ptr_t;
+
+/////////////////////////////////////////////////////////////////////////////
+// end namespace mqtt
+}
+
+#endif		// __mqtt_callback_h
+
diff --git a/src/mqtt/src/mqtt/client.h b/src/mqtt/src/mqtt/client.h
new file mode 100644
index 00000000..93d5b589
--- /dev/null
+++ b/src/mqtt/src/mqtt/client.h
@@ -0,0 +1,377 @@
+/////////////////////////////////////////////////////////////////////////////
+/// @file client.h
+/// Declaration of MQTT client class
+/// @date May 1, 2013
+/// @author Frank Pagliughi
+/////////////////////////////////////////////////////////////////////////////
+
+/*******************************************************************************
+ * Copyright (c) 2013-2017 Frank Pagliughi <fpagliughi@mindspring.com>
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution.
+ *
+ * The Eclipse Public License is available at
+ *    http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at
+ *   http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *    Frank Pagliughi - initial implementation and documentation
+ *******************************************************************************/
+
+#ifndef __mqtt_client_h
+#define __mqtt_client_h
+
+#include "mqtt/async_client.h"
+#include <future>
+
+namespace mqtt {
+
+/////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Lightweight client for talking to an MQTT server using methods that block
+ * until an operation completes.
+ */
+class client : private callback
+{
+	/** An arbitrary, but relatively long timeout */
+	static const std::chrono::minutes DFLT_TIMEOUT;
+	/** The default quality of service */
+	static constexpr int DFLT_QOS = 1;
+
+	/** The actual client */
+	async_client cli_;
+	/** The longest time to wait for an operation to complete.  */
+	std::chrono::milliseconds timeout_;
+	/** Callback supplied by the user (if any) */
+	callback* userCallback_;
+
+	/**
+	 * Creates a shared pointer to an existing non-heap object.
+	 * The shared pointer is given a no-op deleter, so it will not try to
+	 * destroy the object when it goes out of scope. It is up to the caller
+	 * to ensure that the object remains in memory for as long as there may
+	 * be pointers to it.
+	 * @param val A value which may live anywhere in memory (stack,
+	 *  		  file-scope, etc).
+	 * @return A shared pointer to the object.
+	 */
+	template <typename T>
+	std::shared_ptr<T> ptr(const T& val) {
+		return std::shared_ptr<T>(const_cast<T*>(&val), [](T*){});
+	}
+
+	// User callbacks
+	// Most are launched in a separate thread, for convenience, except
+	// message_arrived, for performance.
+	void connected(const string& cause) override {
+		std::async(std::launch::async, &callback::connected, userCallback_, cause);
+	}
+	void connection_lost(const string& cause) override {
+		std::async(std::launch::async,
+				   &callback::connection_lost, userCallback_, cause);
+	}
+	void message_arrived(const_message_ptr msg) override {
+		userCallback_->message_arrived(msg);
+	}
+	void delivery_complete(delivery_token_ptr tok) override {
+		std::async(std::launch::async, &callback::delivery_complete, userCallback_, tok);
+	}
+
+	/** Non-copyable */
+	client() =delete;
+	client(const async_client&) =delete;
+	client& operator=(const async_client&) =delete;
+
+public:
+	/** Smart pointer type for this object */
+	using ptr_t = std::shared_ptr<client>;
+	/** Type for a collection of QOS values */
+	using qos_collection = async_client::qos_collection;
+
+	/**
+	 * Create a client that can be used to communicate with an MQTT server.
+	 * This allows the caller to specify a user-defined persistence object,
+	 * or use no persistence.
+	 * @param serverURI the address of the server to connect to, specified
+	 *  				as a URI.
+	 * @param clientId a client identifier that is unique on the server
+	 *  			   being connected to
+	 * @param persistence The user persistence structure. If this is null,
+	 *  				  then no persistence is used.
+	 */
+	client(const string& serverURI, const string& clientId,
+		   iclient_persistence* persistence=nullptr);
+	/**
+	 * Create an async_client that can be used to communicate with an MQTT
+	 * server.
+	 * This uses file-based persistence in the specified directory.
+	 * @param serverURI the address of the server to connect to, specified
+	 *  				as a URI.
+	 * @param clientId a client identifier that is unique on the server
+	 *  			   being connected to
+	 * @param persistDir The directory to use for persistence data
+	 */
+	client(const string& serverURI, const string& clientId,
+		   const string& persistDir);
+	/**
+	 * Create a client that can be used to communicate with an MQTT server,
+	 * which allows for off-line message buffering.
+	 * This allows the caller to specify a user-defined persistence object,
+	 * or use no persistence.
+	 * @param serverURI the address of the server to connect to, specified
+	 *  				as a URI.
+	 * @param clientId a client identifier that is unique on the server
+	 *  			   being connected to
+	 * @param maxBufferedMessages the maximum number of messages allowed to
+	 *  						  be buffered while not connected
+	 * @param persistence The user persistence structure. If this is null,
+	 *  				  then no persistence is used.
+	 */
+	client(const string& serverURI, const string& clientId,
+		   int maxBufferedMessages, iclient_persistence* persistence=nullptr);
+	/**
+	 * Create a client that can be used to communicate with an MQTT server,
+	 * which allows for off-line message buffering.
+	 * This uses file-based persistence in the specified directory.
+	 * @param serverURI the address of the server to connect to, specified
+	 *  				as a URI.
+	 * @param clientId a client identifier that is unique on the server
+	 *  			   being connected to
+	 * @param maxBufferedMessages the maximum number of messages allowed to
+	 *  						  be buffered while not connected
+	 * @param persistDir The directory to use for persistence data
+	 */
+	client(const string& serverURI, const string& clientId,
+		   int maxBufferedMessages, const string& persistDir);
+	/**
+	 * Virtual destructor
+	 */
+	virtual ~client() {}
+	/**
+	 * Connects to an MQTT server using the default options.
+	 */
+	virtual connect_response connect();
+	/**
+	 * Connects to an MQTT server using the specified options.
+	 * @param opts
+	 */
+	virtual connect_response connect(connect_options opts);
+	/**
+	 * Reconnects the client using options from the previous connect.
+	 * The client must have previously called connect() for this to work.
+	 */
+	virtual connect_response reconnect();
+	/**
+	 * Disconnects from the server.
+	 */
+	virtual void disconnect();
+	/**
+	 * Disconnects from the server.
+	 * @param timeoutMS the amount of time in milliseconds to allow for
+	 *  			  existing work to finish before disconnecting. A value
+	 *  			  of zero or less means the client will not quiesce.
+	 */
+	virtual void disconnect(int timeoutMS) {
+		cli_.stop_consuming();
+		cli_.disconnect(timeoutMS)->wait_for(timeout_);
+	}
+	/**
+	 * Disconnects from the server.
+	 * @param to the amount of time in milliseconds to allow for
+	 *  			  existing work to finish before disconnecting. A value
+	 *  			  of zero or less means the client will not quiesce.
+	 */
+	template <class Rep, class Period>
+	void disconnect(const std::chrono::duration<Rep, Period>& to) {
+		disconnect((int) to_milliseconds_count(to));
+	}
+	/**
+	 * Gets the client ID used by this client.
+	 * @return The client ID used by this client.
+	 */
+	virtual string get_client_id() const { return cli_.get_client_id(); }
+	/**
+	 * Gets the address of the server used by this client.
+	 * @return The address of the server used by this client, as a URI.
+	 */
+	virtual string get_server_uri() const { return cli_.get_server_uri(); }
+	/**
+	 * Return the maximum time to wait for an action to complete.
+	 * @return int
+	 */
+	virtual std::chrono::milliseconds get_timeout() const { return timeout_; }
+	/**
+	 * Get a topic object which can be used to publish messages on this
+	 * client.
+	 * @param top The topic name
+	 * @return A topic attached to this client.
+	 */
+	virtual topic get_topic(const string& top) { return topic(cli_, top); }
+	/**
+	 * Determines if this client is currently connected to the server.
+	 * @return @em true if the client is currently connected, @em false if
+	 *  	   not.
+	 */
+	virtual bool is_connected() const { return cli_.is_connected(); }
+
+	/**
+	 * Publishes a message to a topic on the server and return once it is
+	 * delivered.
+	 * @param top The topic to publish
+	 * @param payload The data to publish
+	 * @param n The size in bytes of the data
+	 * @param qos The QoS for message delivery
+	 * @param retained Whether the broker should retain the message
+	 */
+	virtual void publish(string_ref top, const void* payload, size_t n,
+						 int qos, bool retained) {
+		cli_.publish(std::move(top), payload, n, qos, retained)->wait_for(timeout_);
+	}
+	/**
+	 * Publishes a message to a topic on the server and return once it is
+	 * delivered.
+	 * @param top The topic to publish
+	 * @param payload The data to publish
+	 * @param n The size in bytes of the data
+	 */
+	virtual void publish(string_ref top, const void* payload, size_t n) {
+		cli_.publish(std::move(top), payload, n)->wait_for(timeout_);
+	}
+	/**
+	 * Publishes a message to a topic on the server.
+	 * @param msg The message
+	 */
+	virtual void publish(const_message_ptr msg) {
+		cli_.publish(msg)->wait_for(timeout_);
+	}
+	/**
+	 * Publishes a message to a topic on the server.
+	 * This version will not timeout since that could leave the library with
+	 * a reference to memory that could disappear while the library is still
+	 * using it.
+	 * @param msg The message
+	 */
+	virtual void publish(const message& msg) {
+		cli_.publish(ptr(msg))->wait();
+	}
+	/**
+	 * Sets the callback listener to use for events that happen
+	 * asynchronously.
+	 * @param cb The callback functions
+	 */
+	virtual void set_callback(callback& cb);
+	/**
+	 * Set the maximum time to wait for an action to complete.
+	 * @param timeoutMS The timeout in milliseconds
+	 */
+	virtual void set_timeout(int timeoutMS) {
+		timeout_ = std::chrono::milliseconds(timeoutMS);
+	}
+	/**
+	 * Set the maximum time to wait for an action to complete.
+	 * @param to The timeout as a std::chrono duration.
+	 */
+	template <class Rep, class Period>
+	void set_timeout(const std::chrono::duration<Rep, Period>& to) {
+		timeout_ = to_milliseconds(to);
+	}
+	/**
+	 * Subscribe to a topic, which may include wildcards using a QoS of 1.
+	 * @param topicFilter
+	 */
+	virtual subscribe_response subscribe(const string& topicFilter);
+	/**
+	 * Subscribe to a topic, which may include wildcards.
+	 * @param topicFilter A single topic to subscribe
+	 * @param qos The QoS of the subscription
+	 */
+	virtual subscribe_response subscribe(const string& topicFilter, int qos);
+	/**
+	 * Subscribes to a one or more topics, which may include wildcards using
+	 * a QoS of 1.
+	 * @param topicFilters A set of topics to subscribe
+	 */
+	virtual subscribe_response subscribe(const string_collection& topicFilters);
+	/**
+	 * Subscribes to multiple topics, each of which may include wildcards.
+	 * @param topicFilters A collection of topics to subscribe
+	 * @param qos A collection of QoS for each topic
+	 */
+	virtual subscribe_response subscribe(const string_collection& topicFilters,
+										 const qos_collection& qos);
+	/**
+	 * Requests the server unsubscribe the client from a topic.
+	 * @param topicFilter A single topic to unsubscribe.
+	 */
+	virtual unsubscribe_response unsubscribe(const string& topicFilter);
+	/**
+	 * Requests the server unsubscribe the client from one or more topics.
+	 * @param topicFilters A collection of topics to unsubscribe.
+	 */
+	virtual unsubscribe_response unsubscribe(const string_collection& topicFilters);
+	/**
+	 * Start consuming messages.
+	 * This initializes the client to receive messages through a queue that
+	 * can be read synchronously.
+	 */
+	void start_consuming() { cli_.start_consuming(); }
+	/**
+	 * Stop consuming messages.
+	 * This shuts down the internal callback and discards any unread
+	 * messages.
+	 */
+	void stop_consuming() { cli_.stop_consuming(); }
+	/**
+	 * Read the next message from the queue.
+	 * This blocks until a new message arrives.
+	 * @return The message and topic.
+	 */
+	const_message_ptr consume_message() { return cli_.consume_message(); }
+	/**
+	 * Try to read the next message from the queue without blocking.
+	 * @param msg Pointer to the value to receive the message
+	 * @return @em true is a message was read, @em false if no message was
+	 *  	   available.
+	 */
+	bool try_consume_message(const_message_ptr* msg) {
+		return cli_.try_consume_message(msg);
+	}
+	/**
+	 * Waits a limited time for a message to arrive.
+	 * @param msg Pointer to the value to receive the message
+	 * @param relTime The maximum amount of time to wait for a message.
+	 * @return @em true if a message was read, @em false if a timeout
+	 *  	   occurred.
+	 */
+	template <typename Rep, class Period>
+	bool try_consume_message_for(const_message_ptr* msg,
+								 const std::chrono::duration<Rep, Period>& relTime) {
+		return cli_.try_consume_message_for(msg, relTime);
+	}
+	/**
+	 * Waits until a specific time for a message to occur.
+	 * @param msg Pointer to the value to receive the message
+	 * @param absTime The time point to wait until, before timing out.
+	 * @return @em true if a message was read, @em false if a timeout
+	 *  	   occurred.
+	 */
+	template <class Clock, class Duration>
+	bool try_consume_message_until(const_message_ptr* msg,
+								   const std::chrono::time_point<Clock,Duration>& absTime) {
+		return cli_.try_consume_message_until(msg, absTime);
+	}
+};
+
+/** Smart/shared pointer to an MQTT synchronous client object */
+using client_ptr = client::ptr_t;
+
+/////////////////////////////////////////////////////////////////////////////
+// end namespace mqtt
+}
+
+#endif		// __mqtt_client_h
+
diff --git a/src/mqtt/src/mqtt/connect_options.h b/src/mqtt/src/mqtt/connect_options.h
new file mode 100644
index 00000000..891bd013
--- /dev/null
+++ b/src/mqtt/src/mqtt/connect_options.h
@@ -0,0 +1,448 @@
+/////////////////////////////////////////////////////////////////////////////
+/// @file connect_options.h
+/// Declaration of MQTT connect_options class
+/// @date May 1, 2013
+/// @author Frank Pagliughi
+/////////////////////////////////////////////////////////////////////////////
+
+/*******************************************************************************
+ * Copyright (c) 2013-2016 Frank Pagliughi <fpagliughi@mindspring.com>
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution.
+ *
+ * The Eclipse Public License is available at
+ *    http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at
+ *   http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *    Frank Pagliughi - initial implementation and documentation
+ *******************************************************************************/
+
+#ifndef __mqtt_connect_options_h
+#define __mqtt_connect_options_h
+
+#include "MQTTAsync.h"
+#include "mqtt/types.h"
+#include "mqtt/message.h"
+#include "mqtt/topic.h"
+#include "mqtt/token.h"
+#include "mqtt/string_collection.h"
+#include "mqtt/will_options.h"
+#include "mqtt/ssl_options.h"
+#include <vector>
+#include <chrono>
+
+namespace mqtt {
+
+/////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Holds the set of options that control how the client connects to a
+ * server.
+ */
+class connect_options
+{
+	/** The default C struct */
+	static const MQTTAsync_connectOptions DFLT_C_STRUCT ;
+
+	/** The underlying C connection options */
+	MQTTAsync_connectOptions opts_;
+
+	/** The LWT options */
+	will_options will_;
+
+	/** The SSL options  */
+	ssl_options ssl_;
+
+	/** The user name to use for the connection. */
+	string_ref userName_;
+
+	/** The password to use for the connection. */
+	binary_ref password_;
+
+	/** Shared token pointer for context, if any */
+	token_ptr tok_;
+
+	/** Collection of server URIs, if any */
+	const_string_collection_ptr serverURIs_;
+
+	/** The connect properties */
+	properties props_;
+
+	/** The client has special access */
+	friend class async_client;
+	friend class connect_options_test;
+	friend class token_test;
+
+	/**
+	 * Gets a pointer to the C-language NUL-terminated strings for the
+	 * struct.
+	 * @note In the connect options, by default, the Paho C treats
+	 * nullptr char arrays as unset values, so we keep that semantic and
+	 * only set those char arrays if the string is non-empty.
+	 * @param str The C++ string object.
+	 * @return Pointer to a NUL terminated string. This is only valid until
+	 *  	   the next time the string is updated.
+	 */
+	const char* c_str(const string_ref& sr) {
+		return sr.empty() ? nullptr : sr.c_str();
+	}
+
+public:
+	/** Smart/shared pointer to an object of this class. */
+	using ptr_t = std::shared_ptr<connect_options>;
+	/** Smart/shared pointer to a const object of this class. */
+	using const_ptr_t = std::shared_ptr<const connect_options>;
+
+	/**
+	 * Constructs a new object using the default values.
+	 */
+	connect_options();
+	/**
+	 * Constructs a new object using the specified user name and password.
+	 * @param userName The name of the user for connecting to the server
+	 * @param password The password for connecting to the server
+	 */
+	connect_options(string_ref userName, binary_ref password);
+	/**
+	 * Copy constructor.
+	 * @param opt Another object to copy.
+	 */
+	connect_options(const connect_options& opt);
+	/**
+	 * Move constructor.
+	 * @param opt Another object to move into this new one.
+	 */
+	connect_options(connect_options&& opt);
+	/**
+	 * Copy assignment.
+	 * @param opt Another object to copy.
+	 */
+	connect_options& operator=(const connect_options& opt);
+	/**
+	 * Move assignment.
+	 * @param opt Another object to move into this new one.
+	 */
+	connect_options& operator=(connect_options&& opt);
+	/**
+	 * Gets the "keep alive" interval.
+	 * @return The keep alive interval in seconds.
+	 */
+	std::chrono::seconds get_keep_alive_interval() const {
+		return std::chrono::seconds(opts_.keepAliveInterval);
+	}
+	/**
+	 * Gets the connection timeout.
+	 * This is the amount of time the underlying library will wait for a
+	 * timeout before failing.
+	 * @return The connect timeout in seconds.
+	 */
+	std::chrono::seconds get_connect_timeout() const {
+		return std::chrono::seconds(opts_.connectTimeout);
+	}
+	/**
+	 * Gets the user name to use for the connection.
+	 * @return The user name to use for the connection.
+	 */
+	string get_user_name() const { return userName_ ? userName_.to_string() : string(); }
+	/**
+	 * Gets the password to use for the connection.
+	 * @return The password to use for the connection.
+	 */
+	binary_ref get_password() const { return password_; }
+	/**
+	 * Gets the password to use for the connection.
+	 * @return The password to use for the connection.
+	 */
+	string get_password_str() const {
+		return password_ ? password_.to_string() : string();
+	}
+	/**
+	 * Gets the maximum number of messages that can be in-flight
+	 * simultaneously.
+	 * @return The maximum number of inflight messages.
+	 */
+	int get_max_inflight() const { return opts_.maxInflight; }
+	/**
+	 * Gets the topic to be used for last will and testament (LWT).
+	 * @return The topic to be used for last will and testament (LWT).
+	 */
+	string get_will_topic() const {
+		return will_.get_topic();
+	}
+	/**
+	 * Gets the message to be sent as last will and testament (LWT).
+	 * @return The message to be sent as last will and testament (LWT).
+	 */
+	const_message_ptr get_will_message() const {
+		return will_.get_message();
+	}
+	/**
+	 * Get the LWT options to use for the connection.
+	 * @return The LWT options to use for the connection.
+	 */
+	const will_options& get_will_options() const { return will_; }
+	/**
+	 * Get the SSL options to use for the connection.
+	 * @return The SSL options to use for the connection.
+	 */
+	const ssl_options& get_ssl_options() const { return ssl_; }
+	/**
+	 * Sets the SSL for the connection.
+	 * These will only have an effect if compiled against the SSL version of
+	 * the Paho C library.
+	 * @param ssl The SSL options.
+	 */
+	void set_ssl(const ssl_options& ssl);
+	void set_ssl(ssl_options&& ssl);
+	/**
+	 * Returns whether the server should remember state for the client
+	 * across reconnects.
+	 * @return @em true if requesting a clean session, @em false if not.
+	 */
+	bool is_clean_session() const { return to_bool(opts_.cleansession); }
+	/**
+	 * Gets the token used as the callback context.
+	 * @return The delivery token used as the callback context.
+	 */
+	token_ptr get_token() const { return tok_; }
+	/**
+	 * Gets the list of servers to which the client will connect.
+	 * @return A collection of server URI's. Each entry should be of the
+	 *  	   form @em protocol://host:port where @em protocol must be tcp
+	 *  	   or @em ssl. For @em host, you can specify either an IP
+	 *  	   address or a domain name.
+	 */
+	const_string_collection_ptr get_servers() const { return serverURIs_; }
+	/**
+      * Gets the version of MQTT to be used on the connect.
+	  * @return
+	  * @li MQTTVERSION_DEFAULT (0) = default: start with 3.1.1, and if that
+	  *     fails, fall back to 3.1
+	  * @li MQTTVERSION_3_1 (3) = only try version 3.1
+	  * @li MQTTVERSION_3_1_1 (4) = only try version 3.1.1
+	  */
+	int get_mqtt_version() const { return opts_.MQTTVersion; }
+	/**
+	 * Determines if the options have been configured for automatic
+	 * reconnect.
+	 * @return @em true if configured for automatic reconnect, @em false if
+	 *  	   not.
+	 */
+	bool get_automatic_reconnect() const { return to_bool(opts_.automaticReconnect); }
+	/**
+	 * Gets the minimum retry interval for automatic reconnect.
+	 * @return The minimum retry interval for automatic reconnect, in
+	 *  	   seconds.
+	 */
+	std::chrono::seconds get_min_retry_interval() const {
+		return std::chrono::seconds(opts_.minRetryInterval);
+	}
+	/**
+	 * Gets the maximum retry interval for automatic reconnect.
+	 * @return The maximum retry interval for automatic reconnect, in
+	 *  	   seconds.
+	 */
+	std::chrono::seconds get_max_retry_interval() const {
+		return std::chrono::seconds(opts_.maxRetryInterval);
+	}
+
+	/**
+	 * Sets whether the server should remember state for the client across
+	 * reconnects.
+	 * @param cleanSession
+	 */
+	void set_clean_session(bool cleanSession) {
+		opts_.cleansession = to_int(cleanSession);
+	}
+	/**
+	 * Sets the "keep alive" interval.
+	 * This is the maximum time that should pass without communications
+	 * between client and server. If no massages pass in this time, the
+	 * client will ping the broker.
+	 * @param keepAliveInterval The keep alive interval in seconds.
+	 */
+	void set_keep_alive_interval(int keepAliveInterval) {
+		opts_.keepAliveInterval = keepAliveInterval;
+	}
+	/**
+	 * Sets the "keep alive" interval with a chrono duration.
+	 * This is the maximum time that should pass without communications
+	 * between client and server. If no massages pass in this time, the
+	 * client will ping the broker.
+	 * @param interval The keep alive interval.
+	 */
+	template <class Rep, class Period>
+	void set_keep_alive_interval(const std::chrono::duration<Rep, Period>& interval) {
+		// TODO: Check range
+		set_keep_alive_interval((int) to_seconds_count(interval));
+	}
+	/**
+	 * Sets the connect timeout in seconds.
+	 * This is the maximum time that the underlying library will wait for a
+	 * connection before failing.
+	 * @param timeout The connect timeout in seconds.
+	 */
+	void set_connect_timeout(int timeout) {
+		opts_.connectTimeout = timeout;
+	}
+	/**
+	 * Sets the connect timeout with a chrono duration.
+	 * This is the maximum time that the underlying library will wait for a
+	 * connection before failing.
+	 * @param timeout The connect timeout in seconds.
+	 */
+	template <class Rep, class Period>
+	void set_connect_timeout(const std::chrono::duration<Rep, Period>& timeout) {
+		// TODO: check range
+		set_connect_timeout((int) to_seconds_count(timeout));
+	}
+	/**
+	 * Sets the user name to use for the connection.
+	 * @param userName
+	 */
+	void set_user_name(string_ref userName);
+	/**
+	 * Sets the password to use for the connection.
+	 */
+	void set_password(binary_ref password);
+	/**
+	 * Sets the maximum number of messages that can be in-flight
+	 * simultaneously.
+	 * @param n The maximum number of inflight messages.
+	 */
+	void set_max_inflight(int n) { opts_.maxInflight = n; }
+	/**
+	 * Sets the "Last Will and Testament" (LWT) for the connection.
+	 * @param will The LWT options.
+	 */
+	void set_will(const will_options& will);
+	void set_will(will_options&& will);
+	/**
+	 * Sets the "Last Will and Testament" (LWT) as a message
+	 * @param msg The LWT message
+	 */
+	void set_will_message(const message& msg) {
+		set_will(will_options(msg));
+	}
+	/**
+	 * Sets the "Last Will and Testament" (LWT) as a message
+	 * @param msg Pointer to a LWT message
+	 */
+	void set_will_message(const_message_ptr msg) {
+		if (msg) set_will(will_options(*msg));
+	}
+	/**
+	 * Sets the callback context to a delivery token.
+	 * @param tok The delivery token to be used as the callback context.
+	 */
+	void set_token(const token_ptr& tok);
+	/**
+	 * Sets the list of servers to which the client will connect.
+	 * @param serverURIs A pointer to a collection of server URI's. Each
+	 *  				 entry should be of the form @em
+	 *  				 protocol://host:port where @em protocol must be
+	 *  				 @em tcp or @em ssl. For @em host, you can specify
+	 *  				 either an IP address or a domain name.
+	 */
+	void set_servers(const_string_collection_ptr serverURIs);
+	/**
+	  * Sets the version of MQTT to be used on the connect.
+	  *
+	  * This will also set other connect options to legal values dependent on
+	  * the selected version.
+	  *
+	  * @param mqttVersion The MQTT version to use for the connection:
+	  *   @li MQTTVERSION_DEFAULT (0) = default: start with 3.1.1, and if
+	  *       that fails, fall back to 3.1
+	  *   @li MQTTVERSION_3_1 (3) = only try version 3.1
+	  *   @li MQTTVERSION_3_1_1 (4) = only try version 3.1.1
+	  *   @li MQTTVERSION_5 (5) = only try version 5
+	  */
+	void set_mqtt_version(int mqttVersion);
+	/**
+	 * Enable or disable automatic reconnects.
+	 * The retry intervals are not affected.
+	 * @param on Whether to turn reconnects on or off
+	 */
+	void set_automatic_reconnect(bool on) {
+		opts_.automaticReconnect = to_int(on);
+	}
+	/**
+	 * Enable or disable automatic reconnects.
+	 * @param minRetryInterval Minimum retry interval in seconds.  Doubled
+	 *  					   on each failed retry.
+	 * @param maxRetryInterval Maximum retry interval in seconds.  The
+	 *  					   doubling stops here on failed retries.
+	 */
+	void set_automatic_reconnect(int minRetryInterval, int maxRetryInterval);
+	/**
+	 * Enable or disable automatic reconnects.
+	 * @param minRetryInterval Minimum retry interval. Doubled on each
+	 *  					   failed retry.
+	 * @param maxRetryInterval Maximum retry interval. The doubling stops
+	 *  					   here on failed retries.
+	 */
+	template <class Rep1, class Period1, class Rep2, class Period2>
+	void set_automatic_reconnect(const std::chrono::duration<Rep1, Period1>& minRetryInterval,
+								 const std::chrono::duration<Rep2, Period2>& maxRetryInterval) {
+		set_automatic_reconnect((int) to_seconds_count(minRetryInterval),
+								(int) to_seconds_count(maxRetryInterval));
+	}
+	/**
+	 * Determines if the 'clean start' flag is set for the connect.
+	 * @return @em true if the 'clean start' flag is set for the connect, @em
+	 *  	   false if not.
+	 */
+	bool is_clean_start() const {
+		return to_bool(opts_.cleanstart);
+	}
+	/**
+	 * Sets the 'clean start' flag for the connection.
+	 * @param cleanStart Whether to set the 'clean start' flag for the connect.
+	 */
+	void set_clean_start(bool cleanStart) {
+		opts_.cleanstart = to_int(cleanStart);
+	}
+	/**
+	 * Gets the connect properties.
+	 * @return A const reference to the properties for the connect.
+	 */
+	const properties& get_properties() const {
+		return props_;
+	}
+	/**
+	 * Sets the properties for the connect.
+	 * @param props The properties to place into the message.
+	 */
+	void set_properties(const properties& props) {
+		props_ = props;
+		opts_.connectProperties = const_cast<MQTTProperties*>(&props_.c_struct());
+	}
+	/**
+	 * Moves the properties for the connect.
+	 * @param props The properties to move into the connect object.
+	 */
+	void set_properties(properties&& props) {
+		props_ = props;
+		opts_.connectProperties = const_cast<MQTTProperties*>(&props_.c_struct());
+	}
+	/**
+	 * Gets a string representation of the object.
+	 * @return A string representation of the object.
+	 */
+	string to_string() const;
+};
+
+/** Smart/shared pointer to a connection options object. */
+using connect_options_ptr = connect_options::ptr_t;
+
+/////////////////////////////////////////////////////////////////////////////
+// end namespace mqtt
+}
+
+#endif		// __mqtt_connect_options_h
+
diff --git a/src/mqtt/src/mqtt/delivery_token.h b/src/mqtt/src/mqtt/delivery_token.h
new file mode 100644
index 00000000..b70d5822
--- /dev/null
+++ b/src/mqtt/src/mqtt/delivery_token.h
@@ -0,0 +1,135 @@
+/////////////////////////////////////////////////////////////////////////////
+/// @file delivery_token.h
+/// Declaration of MQTT delivery_token class
+/// @date May 1, 2013
+/// @author Frank Pagliughi
+/////////////////////////////////////////////////////////////////////////////
+
+/*******************************************************************************
+ * Copyright (c) 2013-2016 Frank Pagliughi <fpagliughi@mindspring.com>
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution.
+ *
+ * The Eclipse Public License is available at
+ *    http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at
+ *   http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *    Frank Pagliughi - initial implementation and documentation
+ *******************************************************************************/
+
+#ifndef __mqtt_delivery_token_h
+#define __mqtt_delivery_token_h
+
+#include "MQTTAsync.h"
+#include "mqtt/token.h"
+#include "mqtt/message.h"
+#include <memory>
+
+namespace mqtt {
+
+/////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Provides a mechanism to track the delivery progress of a message.
+ * Used to track the the delivery progress of a message when a publish is
+ * executed in a non-blocking manner (run in the background) action.
+ */
+class delivery_token : public token
+{
+	/** The message being tracked. */
+	const_message_ptr msg_;
+
+	/** Client has special access. */
+	friend class async_client;
+
+	/**
+	 * Sets the message to which this token corresponds.
+	 * @param msg
+	 */
+	void set_message(const_message_ptr msg) { msg_ = msg; }
+
+public:
+	/** Smart/shared pointer to an object of this class */
+	using ptr_t = std::shared_ptr<delivery_token>;
+	/** Smart/shared pointer to a const object of this class */
+	using const_ptr_t = std::shared_ptr<delivery_token>;
+	/** Weak pointer to an object of this class */
+	using weak_ptr_t = std::weak_ptr<delivery_token>;
+
+	/**
+	 * Creates an empty delivery token connected to a particular client.
+	 * @param cli The asynchronous client object.
+	 */
+	delivery_token(iasync_client& cli) : token(token::Type::PUBLISH, cli) {}
+	/**
+	 * Creates a delivery token connected to a particular client.
+	 * @param cli The asynchronous client object.
+	 * @param msg The message being tracked.
+	 */
+	delivery_token(iasync_client& cli, const_message_ptr msg)
+			: token(token::Type::PUBLISH, cli, msg->get_topic()), msg_(std::move(msg)) {}
+	/**
+	 * Creates a delivery token connected to a particular client.
+	 * @param cli The asynchronous client object.
+	 * @param msg The message data.
+	 * @param userContext optional object used to pass context to the
+	 *  				  callback. Use @em nullptr if not required.
+	 * @param cb callback optional listener that will be notified when message
+	 *  			   delivery has completed to the requested quality of
+	 *  			   service
+	 */
+	delivery_token(iasync_client& cli, const_message_ptr msg,
+				   void* userContext, iaction_listener& cb)
+			: token(token::Type::PUBLISH, cli, msg->get_topic(), userContext, cb), msg_(std::move(msg)) {}
+	/**
+	 * Creates an empty delivery token connected to a particular client.
+	 * @param cli The asynchronous client object.
+	 */
+	static ptr_t create(iasync_client& cli) {
+		return std::make_shared<delivery_token>(cli);
+	}
+	/**
+	 * Creates a delivery token connected to a particular client.
+	 * @param cli The asynchronous client object.
+	 * @param msg The message data.
+	 */
+	static ptr_t create(iasync_client& cli, const_message_ptr msg) {
+		return std::make_shared<delivery_token>(cli, msg);
+	}
+	/**
+	 * Creates a delivery token connected to a particular client.
+	 * @param cli The asynchronous client object.
+	 * @param msg The message data.
+	 * @param userContext optional object used to pass context to the
+	 *  				  callback. Use @em nullptr if not required.
+	 * @param cb callback optional listener that will be notified when message
+	 *  			   delivery has completed to the requested quality of
+	 *  			   service
+	 */
+	static ptr_t create(iasync_client& cli, const_message_ptr msg,
+						void* userContext, iaction_listener& cb) {
+		return std::make_shared<delivery_token>(cli, msg, userContext, cb);
+	}
+	/**
+	 * Gets the message associated with this token.
+	 * @return The message associated with this token.
+	 */
+	virtual const_message_ptr get_message() const { return msg_; }
+};
+
+/** Smart/shared pointer to a delivery_token */
+using delivery_token_ptr = delivery_token::ptr_t;
+
+/** Smart/shared pointer to a const delivery_token */
+using const_delivery_token_ptr = delivery_token::const_ptr_t;
+
+/////////////////////////////////////////////////////////////////////////////
+// end namespace mqtt
+}
+
+#endif		// __mqtt_delivery_token_h
+
diff --git a/src/mqtt/src/mqtt/disconnect_options.h b/src/mqtt/src/mqtt/disconnect_options.h
new file mode 100644
index 00000000..d2ebdbf7
--- /dev/null
+++ b/src/mqtt/src/mqtt/disconnect_options.h
@@ -0,0 +1,176 @@
+/////////////////////////////////////////////////////////////////////////////
+/// @file disconnect_options.h
+/// Implementation of the class 'disconnect_options'
+/// @date 26-Aug-2016
+/////////////////////////////////////////////////////////////////////////////
+
+/****************************************************************************
+ * Copyright (c) 2016-2017 Frank Pagliughi <fpagliughi@mindspring.com>
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution.
+ *
+ * The Eclipse Public License is available at
+ *    http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at
+ *   http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *    Frank Pagliughi - initial implementation and documentation
+ ***************************************************************************/
+
+#ifndef __mqtt_disconnect_options_h
+#define __mqtt_disconnect_options_h
+
+#include "MQTTAsync.h"
+#include "mqtt/types.h"
+#include "mqtt/token.h"
+#include "mqtt/properties.h"
+#include <chrono>
+
+namespace mqtt {
+
+/////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Options for disconnecting from an MQTT broker.
+ */
+class disconnect_options
+{
+	/** The default C struct */
+	static const MQTTAsync_disconnectOptions DFLT_C_STRUCT;
+
+	/** The underlying C disconnect options */
+	MQTTAsync_disconnectOptions opts_;
+
+	/** Shared token pointer for context, if any */
+	token_ptr tok_;
+
+	/** Disconnect message properties */
+	properties props_;
+
+	/** The client has special access */
+	friend class async_client;
+	friend class disconnect_options_test;
+
+public:
+	/**
+	 * Create an empty delivery response object.
+	 */
+	disconnect_options();
+	/**
+	 * Creates disconnect options tied to the specific token.
+	 * @param timeout The timeout (in milliseconds).
+	 */
+	disconnect_options(int timeout) : disconnect_options() {
+		set_timeout(timeout);
+	}
+	/**
+	 * Creates disconnect options tied to the specific token.
+	 * @param to The timeout.
+	 */
+	template <class Rep, class Period>
+	disconnect_options(const std::chrono::duration<Rep, Period>& to)
+			: disconnect_options() {
+		set_timeout(to);
+	}
+	/**
+	 * Copy constructor.
+	 * @param opt Another object to copy.
+	 */
+	disconnect_options(const disconnect_options& opt);
+	/**
+	 * Move constructor.
+	 * @param opt Another object to move into this new one.
+	 */
+	disconnect_options(disconnect_options&& opt);
+	/**
+	 * Copy assignment.
+	 * @param opt Another object to copy.
+	 */
+	disconnect_options& operator=(const disconnect_options& opt);
+	/**
+	 * Move assignment.
+	 * @param opt Another object to move into this new one.
+	 */
+	disconnect_options& operator=(disconnect_options&& opt);
+	/**
+	 * Gets the timeout used for disconnecting.
+	 * @return The timeout for disconnecting (in milliseconds).
+	 */
+	std::chrono::milliseconds get_timeout() const {
+		return std::chrono::milliseconds(opts_.timeout);
+	}
+	/**
+	 * Sets the timeout for disconnecting.
+	 * This allows for any remaining in-flight messages to be delivered.
+	 * @param timeout The timeout (in milliseconds).
+	 */
+	void set_timeout(int timeout) { opts_.timeout = timeout; }
+	/**
+	 * Sets the connect timeout with a chrono duration.
+	 * This is the maximum time that the underlying library will wait for a
+	 * connection before failing.
+	 * @param to The connect timeout in seconds.
+	 */
+	template <class Rep, class Period>
+	void set_timeout(const std::chrono::duration<Rep, Period>& to) {
+		// TODO: check range
+		set_timeout((int) to_milliseconds_count(to));
+	}
+	/**
+	 * Sets the callback context to a delivery token.
+	 * @param tok The delivery token to be used as the callback context.
+	 * @param mqttVersion The version of MQTT we're using for the
+	 *  				  connection.
+	 */
+	void set_token(const token_ptr& tok, int mqttVersion);
+	/**
+	 * Gets the callback context to a delivery token.
+	 * @return The delivery token to be used as the callback context.
+	 */
+	token_ptr get_token() const { return tok_; }
+	/**
+	 * Gets the connect properties.
+	 * @return A const reference to the properties for the connect.
+	 */
+	const properties& get_properties() const { return props_; }
+	/**
+	 * Sets the properties for the connect.
+	 * @param props The properties to place into the message.
+	 */
+	void set_properties(const properties& props) {
+		props_ = props;
+		opts_.properties = props_.c_struct();
+	}
+	/**
+	 * Moves the properties for the connect.
+	 * @param props The properties to move into the connect object.
+	 */
+	void set_properties(properties&& props) {
+		props_ = props;
+		opts_.properties = props_.c_struct();
+	}
+	/**
+	 * Gets the reason code for the disconnect.
+	 * @return The reason code for the disconnect.
+	 */
+	ReasonCode get_reason_code() const {
+		return ReasonCode(opts_.reasonCode);
+	}
+	/**
+	 * Sets the reason code for the disconnect.
+	 * @param code The reason code for the disconnect.
+	 */
+	void set_reason_code(ReasonCode code) {
+		opts_.reasonCode = MQTTReasonCodes(code);
+	}
+};
+
+/////////////////////////////////////////////////////////////////////////////
+// end namespace 'mqtt'
+}
+
+#endif		// __mqtt_disconnect_options_h
+
diff --git a/src/mqtt/src/mqtt/exception.h b/src/mqtt/src/mqtt/exception.h
new file mode 100644
index 00000000..cdcd2fc4
--- /dev/null
+++ b/src/mqtt/src/mqtt/exception.h
@@ -0,0 +1,225 @@
+/////////////////////////////////////////////////////////////////////////////
+/// @file exception.h
+/// Declaration of MQTT exception class
+/// @date May 1, 2013
+/// @author Frank Pagliughi
+/////////////////////////////////////////////////////////////////////////////
+
+/*******************************************************************************
+ * Copyright (c) 2013-2019 Frank Pagliughi <fpagliughi@mindspring.com>
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution.
+ *
+ * The Eclipse Public License is available at
+ *    http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at
+ *   http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *    Frank Pagliughi - initial implementation and documentation
+ *******************************************************************************/
+
+#ifndef __mqtt_exception_h
+#define __mqtt_exception_h
+
+#include "MQTTAsync.h"
+#include "mqtt/types.h"
+#include <vector>
+#include <memory>
+#include <exception>
+#include <stdexcept>
+
+namespace mqtt {
+
+using bad_cast = std::bad_cast;
+
+/////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Base mqtt::exception.
+ * This wraps the error codes which originate from the underlying C library.
+ */
+class exception : public std::runtime_error
+{
+protected:
+	/** The error return code from the C library */
+	int rc_;
+	/** The reason code from the server */
+	ReasonCode reasonCode_;
+	/** The error message from the C library */
+	string msg_;
+
+public:
+	/**
+	 * Creates an MQTT exception.
+	 * @param rc The error return code from the C library.
+	 */
+	explicit exception(int rc)
+		: exception(rc, error_str(rc)) {}
+	/**
+	 * Creates an MQTT exception.
+	 * @param rc The error return code from the C library.
+	 * @param reasonCode The reason code from the server response.
+	 */
+	explicit exception(int rc, ReasonCode reasonCode)
+		: exception(rc, reasonCode, error_str(rc)) {}
+	/**
+	 * Creates an MQTT exception.
+	 * @param rc The error return code from the C library.
+	 * @param msg The text message for the error.
+	 */
+	exception(int rc, const string& msg)
+		: std::runtime_error(printable_error(rc, ReasonCode::SUCCESS, msg)),
+			rc_(rc), reasonCode_(ReasonCode::SUCCESS), msg_(msg) {}
+	/**
+	 * Creates an MQTT exception.
+	 * @param rc The error return code from the C library.
+	 * @param reasonCode The reason code from the server
+	 * @param msg The text message for the error.
+	 */
+	exception(int rc, ReasonCode reasonCode, const string& msg)
+		: std::runtime_error(printable_error(rc, reasonCode, msg)),
+			rc_(rc), reasonCode_(reasonCode), msg_(msg) {}
+	/**
+	 * Gets an error message from an error code.
+	 * @param rc The error code from the C lib
+	 * @return A string explanation of the error
+	 */
+	static string error_str(int rc) {
+		const char *msg = ::MQTTAsync_strerror(rc);
+		return msg ? string(msg) : string();
+	}
+	/**
+	 * Gets a string describing the MQTT v5 reason code.
+	 * @param reasonCode The MQTT v5 reason code.
+	 * @return A string describing the reason code.
+	 */
+	static string reason_code_str(int reasonCode) {
+		if (reasonCode != MQTTPP_V3_CODE) {
+			auto msg = ::MQTTReasonCode_toString(MQTTReasonCodes(reasonCode));
+			if (msg) return string(msg);
+		}
+		return string();
+	}
+	/**
+	 * Gets a detailed error message for an error code.
+	 * @param rc The error code from the C lib
+	 * @param msg An optional additional message. If none is provided, the
+	 *  		  error_str message is used.
+	 * @return A string error message that includes the error code and an
+	 *  	   explanation message.
+	 */
+	static string printable_error(int rc, int reasonCode=ReasonCode::SUCCESS,
+								  const string& msg=string()) {
+		string s = "MQTT error [" + std::to_string(rc) + "]";
+		if (!msg.empty())
+			s += string(": ") + msg;
+		if (reasonCode != MQTTPP_V3_CODE && reasonCode != ReasonCode::SUCCESS)
+			s += string(". Reason: ") + reason_code_str(reasonCode);
+		return s;
+	}
+	/**
+	 * Returns the return code for this exception.
+	 */
+	int get_return_code() const { return rc_; }
+	/**
+	 * Gets a string of the error code.
+	 * @return A string of the error code.
+	 */
+	string get_error_str() const { return error_str(rc_); }
+	/**
+	 * Returns the reason code for this exception.
+	 * For MQTT v3 connections, this is actually the return code.
+	 */
+	int get_reason_code() const {
+		return reasonCode_ == MQTTPP_V3_CODE ? rc_ : reasonCode_;
+	}
+	/**
+	 * Gets a string for the reason code.
+	 * @return A string for the reason code.
+	 */
+	string get_reason_code_str() const {
+		return reason_code_str(reasonCode_);
+	}
+	/**
+	 * Returns the error message for this exception.
+	 */
+	string get_message() const { return msg_; }
+	/**
+	 * Gets a string representation of this exception.
+	 * @return A string representation of this exception.
+	 */
+	string to_string() const { return string(what()); }
+};
+
+/////////////////////////////////////////////////////////////////////////////
+
+class missing_response : public std::runtime_error
+{
+public:
+	missing_response(const string& rsp)
+		: std::runtime_error("Missing "+rsp+" response") {}
+};
+
+/////////////////////////////////////////////////////////////////////////////
+
+/**
+ * This exception is thrown by the implementor of the persistence interface
+ * if there is a problem reading or writing persistent data.
+ */
+class persistence_exception : public exception
+{
+public:
+	/**
+	 * Creates an MQTT persistence exception.
+	 */
+	persistence_exception() : exception(MQTTCLIENT_PERSISTENCE_ERROR) {}
+	/**
+	 * Creates an MQTT persistence exception.
+	 * @param code The error code from the C library.
+	 */
+	explicit persistence_exception(int code) : exception(code) {}
+	/**
+	 * Creates an MQTT persistence exception.
+	 * @param msg The text message for the error.
+	 */
+	explicit persistence_exception(const string& msg)
+				: exception(MQTTCLIENT_PERSISTENCE_ERROR, msg) {}
+	/**
+	 * Creates an MQTT persistence exception.
+	 * @param code The error code
+	 * @param msg The text message for the error.
+	 */
+	persistence_exception(int code, const string& msg)
+				: exception(code, msg) {}
+};
+
+/////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Thrown when a client is not authorized to perform an operation, or if
+ * there is a problem with the security configuration.
+ */
+class security_exception : public exception
+{
+public:
+	/**
+	 * Creates an MQTT security exception
+	 * @param code The error code.
+	 */
+	explicit security_exception(int code) : exception(code) {}
+	/**
+	 * Creates an MQTT security exception
+	 * @param code The error code.
+	 * @param msg The text message for the error.
+	 */
+	security_exception(int code, const string& msg) : exception(code, msg) {}
+};
+
+/////////////////////////////////////////////////////////////////////////////
+// end namespace mqtt
+}
+
+#endif		// __mqtt_token_h
diff --git a/src/mqtt/src/mqtt/iaction_listener.h b/src/mqtt/src/mqtt/iaction_listener.h
new file mode 100644
index 00000000..1e345771
--- /dev/null
+++ b/src/mqtt/src/mqtt/iaction_listener.h
@@ -0,0 +1,84 @@
+/////////////////////////////////////////////////////////////////////////////
+/// @file iaction_listener.h
+/// Declaration of MQTT iaction_listener class
+/// @date May 1, 2013
+/// @author Frank Pagliughi
+/////////////////////////////////////////////////////////////////////////////
+
+/*******************************************************************************
+ * Copyright (c) 2013-2016 Frank Pagliughi <fpagliughi@mindspring.com>
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution.
+ *
+ * The Eclipse Public License is available at
+ *    http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at
+ *   http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *    Frank Pagliughi - initial implementation and documentation
+ *******************************************************************************/
+
+#ifndef __mqtt_iaction_listener_h
+#define __mqtt_iaction_listener_h
+
+#include "MQTTAsync.h"
+#include "mqtt/types.h"
+#include <vector>
+
+namespace mqtt {
+
+class token;
+
+/////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Provides a mechanism for tracking the completion of an asynchronous
+ * action.
+ *
+ * A listener is registered on a token and that token is associated with
+ * an action like connect or publish. When used with tokens on the
+ * async_client the listener will be called back on the MQTT client's
+ * thread. The listener will be informed if the action succeeds or fails. It
+ * is important that the listener returns control quickly otherwise the
+ * operation of the MQTT client will be stalled.
+ */
+class iaction_listener
+{
+public:
+	/** Smart/shared pointer to an object of this class. */
+	using ptr_t = std::shared_ptr<iaction_listener>;
+	/** Smart/shared pointer to a const object of this class. */
+	using const_ptr_t = std::shared_ptr<const iaction_listener>;
+
+	/**
+	 * Virtual base destructor.
+	 */
+	virtual ~iaction_listener() {}
+	/**
+	 * This method is invoked when an action fails.
+	 * @param asyncActionToken
+	 */
+	virtual void on_failure(const token& asyncActionToken) =0;
+	/**
+	 * This method is invoked when an action has completed successfully.
+	 * @param asyncActionToken
+	 */
+	virtual void on_success(const token& asyncActionToken) =0;
+};
+
+/** Smart/shared pointer to an action listener */
+using iaction_listener_ptr = iaction_listener::ptr_t;
+
+/** Smart/shared pointer to a const action listener */
+using const_iaction_listener_ptr = iaction_listener::const_ptr_t;
+
+
+/////////////////////////////////////////////////////////////////////////////
+// end namespace mqtt
+}
+
+#endif		// __mqtt_iaction_listener_h
+
diff --git a/src/mqtt/src/mqtt/iasync_client.h b/src/mqtt/src/mqtt/iasync_client.h
new file mode 100644
index 00000000..d47ab77c
--- /dev/null
+++ b/src/mqtt/src/mqtt/iasync_client.h
@@ -0,0 +1,419 @@
+/////////////////////////////////////////////////////////////////////////////
+/// @file iasync_client.h
+/// Implementation of the interface for the asynchronous clients,
+/// 'iasync_client'
+/// @date 25-Aug-2016
+/////////////////////////////////////////////////////////////////////////////
+
+/*******************************************************************************
+ * Copyright (c) 2013-2016 Frank Pagliughi <fpagliughi@mindspring.com>
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution.
+ *
+ * The Eclipse Public License is available at
+ *    http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at
+ *   http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *    Frank Pagliughi - initial implementation and documentation
+ *******************************************************************************/
+
+
+#ifndef __mqtt_iasync_client_h
+#define __mqtt_iasync_client_h
+
+#include "mqtt/types.h"
+#include "mqtt/token.h"
+#include "mqtt/delivery_token.h"
+#include "mqtt/iclient_persistence.h"
+#include "mqtt/iaction_listener.h"
+#include "mqtt/connect_options.h"
+#include "mqtt/disconnect_options.h"
+#include "mqtt/subscribe_options.h"
+#include "mqtt/exception.h"
+#include "mqtt/message.h"
+#include "mqtt/callback.h"
+#include <vector>
+
+namespace mqtt {
+
+/////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Enables an application to communicate with an MQTT server using
+ * non-blocking methods.
+ *
+ * It provides applications a simple programming interface to all features
+ * of the MQTT version 3.1 specification including:
+ *
+ * @li connect
+ * @li publish
+ * @li subscribe
+ * @li unsubscribe
+ * @li disconnect
+ */
+class iasync_client
+{
+	friend class token;
+	virtual void remove_token(token* tok) =0;
+
+public:
+	/** Type for a collection of QOS values */
+	using qos_collection = std::vector<int>;
+
+	/**
+	 * Virtual destructor
+	 */
+	virtual ~iasync_client() {}
+	/**
+	 * Connects to an MQTT server using the default options.
+	 * @return token used to track and wait for the connect to complete. The
+	 *  	   token will be passed to any callback that has been set.
+	 * @throw exception for non security related problems
+	 * @throw security_exception for security related problems
+	 */
+	virtual token_ptr connect() =0;
+	/**
+	 * Connects to an MQTT server using the provided connect options.
+	 * @param options a set of connection parameters that override the
+	 *  			  defaults.
+	 * @return token used to track and wait for the connect to complete. The
+	 *  	   token will be passed to any callback that has been set.
+	 * @throw exception for non security related problems
+	 * @throw security_exception for security related problems
+	 */
+	virtual token_ptr connect(connect_options options) =0;
+	/**
+	 * Connects to an MQTT server using the specified options.
+	 *
+	 * @param options a set of connection parameters that override the
+	 *  			  defaults.
+	 * @param userContext optional object used to pass context to the
+	 *  				  callback. Use @em nullptr if not required.
+	 * @param cb callback listener that will be notified when the connect
+	 *  			   completes.
+	 * @return token used to track and wait for the connect to complete. The
+	 *  	   token will be passed to any callback that has been set.
+	 * @throw exception for non security related problems
+	 * @throw security_exception for security related problems
+	 */
+	virtual token_ptr connect(connect_options options, void* userContext,
+							  iaction_listener& cb) =0;
+	/**
+	 *
+	 * @param userContext optional object used to pass context to the
+	 *  				  callback. Use @em nullptr if not required.
+	 * @param cb listener that will be notified when the connect completes.
+	 * @return token used to track and wait for the connect to complete. The
+	 *  	   token will be passed to any callback that has been set.
+	 * @throw exception for non security related problems
+	 * @throw security_exception for security related problems
+	 */
+	virtual token_ptr connect(void* userContext, iaction_listener& cb) =0;
+	/**
+	 * Reconnects the client using options from the previous connect.
+	 * The client must have previously called connect() for this to work.
+	 * @return token used to track the progress of the reconnect.
+	 */
+	virtual token_ptr reconnect() =0;
+	/**
+	 * Disconnects from the server.
+	 * @return token used to track and wait for the disconnect to complete.
+	 *  	   The token will be passed to any callback that has been set.
+	 * @throw exception for problems encountered while disconnecting
+	 */
+	virtual token_ptr disconnect() =0;
+	/**
+	 * Disconnects from the server.
+	 * @param opts Options for disconnecting.
+	 * @return token used to track and wait for the disconnect to complete.
+	 *  	   The token will be passed to any callback that has been set.
+	 * @throw exception for problems encountered while disconnecting
+	 */
+	virtual token_ptr disconnect(disconnect_options opts) =0;
+	/**
+	 * Disconnects from the server.
+	 * @param timeout the amount of time in milliseconds to allow for
+	 *  			  existing work to finish before disconnecting. A value
+	 *  			  of zero or less means the client will not quiesce.
+	 * @return token used to track and wait for the disconnect to complete.
+	 *  	   The token will be passed to any callback that has been set.
+	 * @throw exception for problems encountered while disconnecting
+	 */
+	virtual token_ptr disconnect(int timeout) =0;
+	/**
+	 * Disconnects from the server.
+	 * @param timeout the amount of time in milliseconds to allow for
+	 *  			  existing work to finish before disconnecting. A value
+	 *  			  of zero or less means the client will not quiesce.
+	 * @param userContext optional object used to pass context to the
+	 *  				  callback. Use @em nullptr if not required.
+	 * @param cb listener that will be notified when the disconnect
+	 *  		 completes.
+	 * @return token used to track and wait for the disconnect to complete.
+	 *  	   The token will be passed to any callback that has been set.
+	 * @throw exception for problems encountered while disconnecting
+	 */
+	virtual token_ptr disconnect(int timeout, void* userContext, iaction_listener& cb) =0;
+	/**
+	 * Disconnects from the server.
+	 * @param userContext optional object used to pass context to the
+	 *  				  callback. Use @em nullptr if not required.
+	 * @param cb listener that will be notified when the disconnect
+	 *  		 completes.
+	 * @return token used to track and wait for the disconnect to complete.
+	 *  	   The token will be passed to any callback that has been set.
+	 * @throw exception for problems encountered while disconnecting
+	 */
+	virtual token_ptr disconnect(void* userContext, iaction_listener& cb) =0;
+	/**
+	 * Returns the delivery token for the specified message ID.
+	 * @return delivery_token
+	 */
+	virtual delivery_token_ptr get_pending_delivery_token(int msgID) const =0;
+	/**
+	 * Returns the delivery tokens for any outstanding publish operations.
+	 * @return delivery_token[]
+	 */
+	virtual std::vector<delivery_token_ptr> get_pending_delivery_tokens() const =0;
+	/**
+	 * Returns the client ID used by this client.
+	 * @return string
+	 */
+	virtual string get_client_id() const =0;
+	/**
+	 * Returns the address of the server used by this client.
+	 */
+	virtual string get_server_uri() const =0;
+	/**
+	 * Determines if this client is currently connected to the server.
+	 */
+	virtual bool is_connected() const =0;
+	/**
+	 * Publishes a message to a topic on the server
+	 * @param topic The topic to deliver the message to
+	 * @param payload the bytes to use as the message payload
+	 * @param n the number of bytes in the payload
+	 * @param qos the Quality of Service to deliver the message at. Valid
+	 *  		  values are 0, 1 or 2.
+	 * @param retained whether or not this message should be retained by the
+	 *  			   server.
+	 * @return token used to track and wait for the publish to complete. The
+	 *  	   token will be passed to callback methods if set.
+	 */
+	virtual delivery_token_ptr publish(string_ref topic,
+									   const void* payload, size_t n,
+									   int qos, bool retained) =0;
+	/**
+	 * Publishes a message to a topic on the server
+	 * @param topic The topic to deliver the message to
+	 * @param payload the bytes to use as the message payload
+	 * @param n the number of bytes in the payload
+	 * @return token used to track and wait for the publish to complete. The
+	 *  	   token will be passed to callback methods if set.
+	 */
+	virtual delivery_token_ptr publish(string_ref topic,
+									   const void* payload, size_t n) =0;
+	/**
+	 * Publishes a message to a topic on the server
+	 * @param topic The topic to deliver the message to
+	 * @param payload the bytes to use as the message payload
+	 * @param n the number of bytes in the payload
+	 * @param qos the Quality of Service to deliver the message at. Valid
+	 *  		  values are 0, 1 or 2.
+	 * @param retained whether or not this message should be retained by the
+	 *  			   server.
+	 * @param userContext optional object used to pass context to the
+	 *  				  callback. Use @em nullptr if not required.
+	 * @param cb
+	 * @return token used to track and wait for the publish to complete. The
+	 *  	   token will be passed to callback methods if set.
+	 */
+	virtual delivery_token_ptr publish(string_ref topic,
+									   const void* payload, size_t n,
+									   int qos, bool retained,
+									   void* userContext, iaction_listener& cb) =0;
+	/**
+	 * Publishes a message to a topic on the server
+	 * @param topic The topic to deliver the message to
+	 * @param payload the bytes to use as the message payload
+	 * @param qos the Quality of Service to deliver the message at. Valid
+	 *  		  values are 0, 1 or 2.
+	 * @param retained whether or not this message should be retained by the
+	 *  			   server.
+	 * @return token used to track and wait for the publish to complete. The
+	 *  	   token will be passed to callback methods if set.
+	 */
+	virtual delivery_token_ptr publish(string_ref topic, binary_ref payload,
+									   int qos, bool retained) =0;
+	/**
+	 * Publishes a message to a topic on the server.
+	 * @param topic The topic to deliver the message to
+	 * @param payload the bytes to use as the message payload
+	 * @return token used to track and wait for the publish to complete. The
+	 *  	   token will be passed to callback methods if set.
+	 */
+	virtual delivery_token_ptr publish(string_ref topic, binary_ref payload) =0;
+	/**
+	 * Publishes a message to a topic on the server Takes an Message
+	 * message and delivers it to the server at the requested quality of
+	 * service.
+	 * @param msg the message to deliver to the server
+	 * @return token used to track and wait for the publish to complete. The
+	 *  	   token will be passed to callback methods if set.
+	 */
+	virtual delivery_token_ptr publish(const_message_ptr msg) =0;
+	/**
+	 * Publishes a message to a topic on the server.
+	 * @param msg the message to deliver to the server
+	 * @param userContext optional object used to pass context to the
+	 *  				  callback. Use @em nullptr if not required.
+	 * @param cb optional listener that will be notified when message
+	 *  		 delivery has completed to the requested quality of service
+	 * @return token used to track and wait for the publish to complete. The
+	 *  	   token will be passed to callback methods if set.
+	 */
+	virtual delivery_token_ptr publish(const_message_ptr msg,
+									   void* userContext, iaction_listener& cb) =0;
+	/**
+	 * Sets a callback listener to use for events that happen
+	 * asynchronously.
+	 * @param cb callback which will be invoked for certain asynchronous
+	 *  		 events
+	 */
+	virtual void set_callback(callback& cb) =0;
+	/**
+	 * Stops the callbacks.
+	 */
+	virtual void disable_callbacks() =0;
+	/**
+	 * Subscribe to a topic, which may include wildcards.
+	 * @param topicFilter the topic to subscribe to, which can include
+	 *  				  wildcards.
+	 * @param qos the maximum quality of service at which to subscribe.
+	 *  		  Messages published at a lower quality of service will be
+	 *  		  received at the published QoS. Messages published at a
+	 *  		  higher quality of service will be received using the QoS
+	 *  		  specified on the subscribe.
+	 * @param opts The options for the subscription.
+	 * @return token used to track and wait for the subscribe to complete.
+	 *  	   The token will be passed to callback methods if set.
+	 */
+	virtual token_ptr subscribe(const string& topicFilter, int qos,
+								const subscribe_options& opts=subscribe_options()) =0;
+	/**
+	 * Subscribe to a topic, which may include wildcards.
+	 * @param topicFilter the topic to subscribe to, which can include
+	 *  				  wildcards.
+	 * @param qos the maximum quality of service at which to subscribe.
+	 *  		  Messages published at a lower quality of service will be
+	 *  		  received at the published QoS. Messages published at a
+	 *  		  higher quality of service will be received using the QoS
+	 *  		  specified on the subscribe.
+	 * @param userContext optional object used to pass context to the
+	 *  				  callback. Use @em nullptr if not required.
+	 * @param callback listener that will be notified when subscribe has
+	 *  			   completed
+	 * @param opts The options for the subscription.
+	 * @return token used to track and wait for the subscribe to complete.
+	 *  	   The token will be passed to callback methods if set.
+	 */
+	virtual token_ptr subscribe(const string& topicFilter, int qos,
+								void* userContext, iaction_listener& callback,
+								const subscribe_options& opts=subscribe_options()) =0;
+	/**
+	 * Subscribe to multiple topics, each of which may include wildcards.
+	 * Provides an optimized way to subscribe to multiple topics compared to
+	 * subscribing to each one individually.
+	 * @param topicFilters one or more topics to subscribe to, which can
+	 *  				   include wildcards
+	 * @param qos the maximum quality of service at which to subscribe.
+	 *  		  Messages published at a lower quality of service will be
+	 *  		  received at the published QoS. Messages published at a
+	 *  		  higher quality of service will be received using the QoS
+	 *  		  specified on the subscribe.
+	 * @param opts A collection of subscription optsions (one for each
+	 *  		   topic)
+	 * @return token used to track and wait for the subscribe to complete.
+	 *  	   The token will be passed to callback methods if set.
+	 */
+	virtual token_ptr subscribe(const_string_collection_ptr topicFilters,
+								const qos_collection& qos,
+								const std::vector<subscribe_options>& opts=std::vector<subscribe_options>()) =0;
+	/**
+	 * Subscribes to multiple topics, each of which may include wildcards.
+	 * @param topicFilters one or more topics to subscribe to, which can
+	 *  				   include wildcards
+	 * @param qos  the maximum quality of service at which to subscribe.
+	 *  		   Messages published at a lower quality of service will be
+	 *  		   received at the published QoS. Messages published at a
+	 *  		   higher quality of service will be received using the QoS
+	 *  		   specified on the subscribe.
+	 * @param userContext optional object used to pass context to the
+	 *  				  callback. Use @em nullptr if not required.
+	 * @param callback listener that will be notified when subscribe has
+	 *  			   completed
+	 * @param opts A collection of subscription optsions (one for each
+	 *  		   topic)
+	 * @return token used to track and wait for the subscribe to complete.
+	 *  	   The token will be passed to callback methods if set.
+	 */
+	virtual token_ptr subscribe(const_string_collection_ptr topicFilters,
+								const qos_collection& qos,
+								void* userContext, iaction_listener& callback,
+								const std::vector<subscribe_options>& opts=std::vector<subscribe_options>()) =0;
+	/**
+	 * Requests the server unsubscribe the client from a topic.
+	 * @param topicFilter the topic to unsubscribe from. It must match a
+	 *  				  topicFilter specified on an earlier subscribe.
+	 * @return token used to track and wait for the unsubscribe to complete.
+	 *  	   The token will be passed to callback methods if set.
+	 */
+	virtual token_ptr unsubscribe(const string& topicFilter) =0;
+	/**
+	 * Requests the server unsubscribe the client from one or more topics.
+	 * @param topicFilters one or more topics to unsubscribe from. Each
+	 *  				   topicFilter must match one specified on an
+	 *  				   earlier subscribe.
+	 * @return token used to track and wait for the unsubscribe to complete.
+	 *  	   The token will be passed to callback methods if set.
+	 */
+	virtual token_ptr unsubscribe(const_string_collection_ptr topicFilters) =0;
+	/**
+	 * Requests the server unsubscribe the client from one or more topics.
+	 * @param topicFilters one or more topics to unsubscribe from. Each
+	 *  				   topicFilter must match one specified on an
+	 *  				   earlier subscribe.
+	 * @param userContext optional object used to pass context to the
+	 *  				  callback. Use @em nullptr if not required.
+	 * @param cb listener that will be notified when unsubscribe has
+	 *  		 completed
+	 * @return token used to track and wait for the unsubscribe to complete.
+	 *  	   The token will be passed to callback methods if set.
+	 */
+	virtual token_ptr unsubscribe(const_string_collection_ptr topicFilters,
+								   void* userContext, iaction_listener& cb) =0;
+	/**
+	 * Requests the server unsubscribe the client from a topics.
+	 * @param topicFilter the topic to unsubscribe from. It must match a
+	 *  				  topicFilter specified on an earlier subscribe.
+	 * @param userContext optional object used to pass context to the
+	 *  				  callback. Use @em nullptr if not required.
+	 * @param cb listener that will be notified when unsubscribe has
+	 *  		 completed
+	 * @return token used to track and wait for the unsubscribe to complete.
+	 *  	   The token will be passed to callback methods if set.
+	 */
+	virtual token_ptr unsubscribe(const string& topicFilter,
+								  void* userContext, iaction_listener& cb) =0;
+};
+
+/////////////////////////////////////////////////////////////////////////////
+// end namespace 'mqtt'
+}
+
+#endif		// __mqtt_iasync_client_h
+
diff --git a/src/mqtt/src/mqtt/iclient_persistence.h b/src/mqtt/src/mqtt/iclient_persistence.h
new file mode 100644
index 00000000..852ec8ef
--- /dev/null
+++ b/src/mqtt/src/mqtt/iclient_persistence.h
@@ -0,0 +1,135 @@
+/////////////////////////////////////////////////////////////////////////////
+/// @file iclient_persistence.h
+/// Declaration of MQTT iclient_persistence interface
+/// @date May 1, 2013
+/// @author Frank Pagliughi
+/////////////////////////////////////////////////////////////////////////////
+
+/*******************************************************************************
+ * Copyright (c) 2013-2016 Frank Pagliughi <fpagliughi@mindspring.com>
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution.
+ *
+ * The Eclipse Public License is available at
+ *    http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at
+ *   http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *    Frank Pagliughi - initial implementation and documentation
+ *******************************************************************************/
+
+#ifndef __mqtt_iclient_persistence_h
+#define __mqtt_iclient_persistence_h
+
+#include "MQTTAsync.h"
+#include "mqtt/types.h"
+#include "mqtt/buffer_view.h"
+#include "mqtt/string_collection.h"
+#include <vector>
+
+namespace mqtt {
+
+/////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Represents a persistent data store, used to store outbound and inbound
+ * messages while they are in flight, enabling delivery to the QoS
+ * specified. You can specify an implementation of this interface using
+ * client::client(string, string, iclient_persistence), which the
+ * client will use to persist QoS 1 and 2 messages.
+ *
+ * If the methods defined throw the MqttPersistenceException then the state
+ * of the data persisted should remain as prior to the method being called.
+ * For example, if put(string, persistable) throws an exception at any
+ * point then the data will be assumed to not be in the persistent store.
+ * Similarly if remove(string) throws an exception then the data will be
+ * assumed to still be held in the persistent store.
+ *
+ * It is up to the persistence interface to log any exceptions or error
+ * information which may be required when diagnosing a persistence failure.
+ */
+class iclient_persistence
+{
+	friend class async_client;
+	friend class iclient_persistence_test;
+
+	/** Callbacks from the C library */
+	static int persistence_open(void** handle, const char* clientID, const char* serverURI, void* context);
+	static int persistence_close(void* handle);
+	static int persistence_put(void* handle, char* key, int bufcount, char* buffers[], int buflens[]);
+	static int persistence_get(void* handle, char* key, char** buffer, int* buflen);
+	static int persistence_remove(void* handle, char* key);
+	static int persistence_keys(void* handle, char*** keys, int* nkeys);
+	static int persistence_clear(void* handle);
+	static int persistence_containskey(void* handle, char* key);
+
+public:
+	/** Smart/shared pointer to an object of this class. */
+	using ptr_t = std::shared_ptr<iclient_persistence>;
+	/** Smart/shared pointer to a const object of this class. */
+	using const_ptr_t = std::shared_ptr<const iclient_persistence>;
+
+	/**
+	 * Virtual destructor.
+	 */
+	virtual ~iclient_persistence() {}
+	/**
+	 * Initialize the persistent store.
+	 * This uses the client ID and server name to create a unique location
+	 * for the data store.
+	 * @param clientId The identifier string for the client.
+	 * @param serverURI The server to which the client is connected.
+	 */
+	virtual void open(const string& clientId, const string& serverURI) =0;
+	/**
+	 * Close the persistent store that was previously opened.
+	 */
+	virtual void close() =0;
+	/**
+	 * Clears persistence, so that it no longer contains any persisted data.
+	 */
+	virtual void clear() =0;
+	/**
+	 * Returns whether or not data is persisted using the specified key.
+	 * @param key The key to find
+	 * @return @em true if the key exists, @em false if not.
+	 */
+	virtual bool contains_key(const string& key) =0;
+	/**
+	 * Returns a collection of keys in this persistent data store.
+	 * @return A collection of strings representing the keys in the store.
+	 */
+	virtual const string_collection& keys() const =0;
+	/**
+	 * Puts the specified data into the persistent store.
+	 * @param key The key.
+	 * @param bufs The data to store
+	 */
+	virtual void put(const string& key, const std::vector<string_view>& bufs) =0;
+	/**
+	 * Gets the specified data out of the persistent store.
+	 * @param key The key
+	 * @return A const view of the data associated with the key.
+	 */
+	virtual string_view get(const string& key) const =0;
+	/**
+	 * Remove the data for the specified key.
+	 * @param key The key
+	 */
+	virtual void remove(const string& key) =0;
+};
+
+/** Smart/shared pointer to a persistence client */
+using iclient_persistence_ptr = iclient_persistence::ptr_t;
+
+/** Smart/shared pointer to a persistence client */
+using const_iclient_persistence_ptr = iclient_persistence::const_ptr_t;
+
+/////////////////////////////////////////////////////////////////////////////
+// end namespace mqtt
+}
+
+#endif		// __mqtt_iclient_persistence_h
diff --git a/src/mqtt/src/mqtt/message.h b/src/mqtt/src/mqtt/message.h
new file mode 100644
index 00000000..5d64e8d0
--- /dev/null
+++ b/src/mqtt/src/mqtt/message.h
@@ -0,0 +1,409 @@
+/////////////////////////////////////////////////////////////////////////////
+/// @file message.h
+/// Declaration of MQTT message class
+/// @date May 1, 2013
+/// @author Frank Pagliughi
+/////////////////////////////////////////////////////////////////////////////
+
+/*******************************************************************************
+ * Copyright (c) 2013-2019 Frank Pagliughi <fpagliughi@mindspring.com>
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution.
+ *
+ * The Eclipse Public License is available at
+ *    http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at
+ *   http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *    Frank Pagliughi - initial implementation and documentation
+ *    Frank Pagliughi - MQTT v5 support (properties)
+ *******************************************************************************/
+
+#ifndef __mqtt_message_h
+#define __mqtt_message_h
+
+#include "MQTTAsync.h"
+#include "mqtt/buffer_ref.h"
+#include "mqtt/properties.h"
+#include "mqtt/exception.h"
+#include <memory>
+
+namespace mqtt {
+
+/////////////////////////////////////////////////////////////////////////////
+
+/**
+ * An MQTT message holds everything required for an MQTT PUBLISH message.
+ * This holds the binary message payload, topic string, and all the
+ * additional meta-data for an MQTT message. 
+ *
+ * The topic and payload buffers are kept as references to const data, so
+ * they can be reassigned as needed, but the buffers can not be updated
+ * in-place. Normally they would be created externally then copied or moved
+ * into the message. The library to transport the messages never touchec the
+ * payloads or topics.
+ *
+ * This also means that message objects are farily cheap to copy, since they
+ * don't copy the payloads. They simply copy the reference to the buffers.
+ * It is safe to pass these buffer references across threads since all
+ * references promise not to update the contents of the buffer.
+ */
+class message
+{
+public:
+	/** The default QoS for a message */
+	static constexpr int DFLT_QOS = 0;
+	/** The default retained flag */
+	static constexpr bool DFLT_RETAINED = false;
+
+private:
+	/** Initializer for the C struct (from the C library) */
+	static const MQTTAsync_message DFLT_C_STRUCT;
+
+	/** The underlying C message struct */
+	MQTTAsync_message msg_;
+	/** The topic that the message was (or should be) sent on. */
+	string_ref topic_;
+	/** The message payload - an arbitrary binary blob. */
+	binary_ref payload_;
+	/** The properties for the message  */
+	properties props_;
+
+	/** The client has special access. */
+	friend class async_client;
+	friend class message_test;
+
+	/**
+	 * Set the dup flag in the underlying message
+	 * @param dup
+	 */
+	void set_duplicate(bool dup) { msg_.dup = to_int(dup); }
+
+public:
+	/** Smart/shared pointer to this class. */
+	using ptr_t = std::shared_ptr<message>;
+	/** Smart/shared pointer to this class. */
+	using const_ptr_t = std::shared_ptr<const message>;
+
+	/**
+	 * Constructs a message with an empty payload, and all other values set
+	 * to defaults.
+	 */
+	message();
+	/**
+	 * Constructs a message with the specified array as a payload, and all
+	 * other values set to defaults.
+	 * @param topic The message topic
+	 * @param payload the bytes to use as the message payload
+	 * @param len the number of bytes in the payload
+	 * @param qos The quality of service for the message.
+	 * @param retained Whether the message should be retained by the broker.
+	 */
+	message(string_ref topic, const void* payload, size_t len,
+			int qos, bool retained);
+	/**
+	 * Constructs a message with the specified array as a payload, and all
+	 * other values set to defaults.
+	 * @param topic The message topic
+	 * @param payload the bytes to use as the message payload
+	 * @param len the number of bytes in the payload
+	 */
+	message(string_ref topic, const void* payload, size_t len)
+		: message(std::move(topic), payload, len, DFLT_QOS, DFLT_RETAINED) {}
+	/**
+	 * Constructs a message from a byte buffer.
+	 * Note that the payload accepts copy or move semantics.
+	 * @param topic The message topic
+	 * @param payload A byte buffer to use as the message payload.
+	 * @param qos The quality of service for the message.
+	 * @param retained Whether the message should be retained by the broker.
+	 */
+	message(string_ref topic, binary_ref payload, int qos, bool retained);
+	/**
+	 * Constructs a message from a byte buffer.
+	 * Note that the payload accepts copy or move semantics.
+	 * @param topic The message topic
+	 * @param payload A byte buffer to use as the message payload.
+	 */
+	message(string_ref topic, binary_ref payload)
+		: message(std::move(topic), std::move(payload), DFLT_QOS, DFLT_RETAINED) {}
+	/**
+	 * Constructs a message as a copy of the message structure.
+	 * @param topic The message topic
+	 * @param msg A "C" MQTTAsync_message structure.
+	 */
+	message(string_ref topic, const MQTTAsync_message& msg);
+	/**
+	 * Constructs a message as a copy of the other message.
+	 * @param other The message to copy into this one.
+	 */
+	message(const message& other);
+	/**
+	 * Moves the other message to this one.
+	 * @param other The message to move into this one.
+	 */
+	message(message&& other);
+	/**
+	 * Destroys a message and frees all associated resources.
+	 */
+	~message() {}
+
+	/**
+	 * Constructs a message with the specified array as a payload, and all
+	 * other values set to defaults.
+	 * @param topic The message topic
+	 * @param payload the bytes to use as the message payload
+	 * @param len the number of bytes in the payload
+	 * @param qos The quality of service for the message.
+	 * @param retained Whether the message should be retained by the broker.
+	 */
+	static ptr_t create(string_ref topic, const void* payload, size_t len,
+						int qos, bool retained) {
+		return std::make_shared<message>(std::move(topic), payload, len,
+										 qos, retained);
+	}
+	/**
+	 * Constructs a message with the specified array as a payload, and all
+	 * other values set to defaults.
+	 * @param topic The message topic
+	 * @param payload the bytes to use as the message payload
+	 * @param len the number of bytes in the payload
+	 */
+	static ptr_t create(string_ref topic, const void* payload, size_t len) {
+		return std::make_shared<message>(std::move(topic), payload, len,
+										 DFLT_QOS, DFLT_RETAINED);
+	}
+	/**
+	 * Constructs a message from a byte buffer.
+	 * Note that the payload accepts copy or move semantics.
+	 * @param topic The message topic
+	 * @param payload A byte buffer to use as the message payload.
+	 * @param qos The quality of service for the message.
+	 * @param retained Whether the message should be retained by the broker.
+	 */
+	static ptr_t create(string_ref topic, binary_ref payload, int qos, bool retained) {
+		return std::make_shared<message>(std::move(topic), std::move(payload),
+										 qos, retained);
+	}
+	/**
+	 * Constructs a message from a byte buffer.
+	 * Note that the payload accepts copy or move semantics.
+	 * @param topic The message topic
+	 * @param payload A byte buffer to use as the message payload.
+	 */
+	static ptr_t create(string_ref topic, binary_ref payload) {
+		return std::make_shared<message>(std::move(topic), std::move(payload),
+										 DFLT_QOS, DFLT_RETAINED);
+	}
+	/**
+	 * Constructs a message as a copy of the C message struct.
+	 * @param topic The message topic
+	 * @param msg A "C" MQTTAsync_message structure.
+	 */
+	static ptr_t create(string_ref topic, const MQTTAsync_message& msg) {
+		return std::make_shared<message>(std::move(topic), msg);
+	}
+	/**
+	 * Copies another message to this one.
+	 * @param rhs The other message.
+	 * @return A reference to this message.
+	 */
+	message& operator=(const message& rhs);
+	/**
+	 * Moves another message to this one.
+	 * @param rhs The other message.
+	 * @return A reference to this message.
+	 */
+	message& operator=(message&& rhs);
+	/**
+	 * Sets the topic string.
+	 * @param topic The topic on which the message is published.
+	 */
+	void set_topic(string_ref topic) {
+		topic_ = topic_ ? std::move(topic) : string_ref(string());
+	}
+	/**
+	 * Gets the topic reference for the message.
+	 * @return The topic reference for the message.
+	 */
+	const string_ref& get_topic_ref() const { return topic_; }
+	/**
+	 * Gets the topic for the message.
+	 * @return The topic string for the message.
+	 */
+	const string& get_topic() const { 
+		static const string EMPTY_STR;
+		return topic_ ? topic_.str() : EMPTY_STR; 
+	}
+	/**
+	 * Clears the payload, resetting it to be empty.
+	 */
+	void clear_payload();
+	/**
+	 * Gets the payload reference.
+	 */
+	const binary_ref& get_payload_ref() const { return payload_; }
+	/**
+	 * Gets the payload
+	 */
+	const binary& get_payload() const {
+		static const binary EMPTY_BIN;
+		return payload_ ? payload_.str() : EMPTY_BIN; 
+	}
+	/**
+	 * Gets the payload as a string
+	 */
+	const string& get_payload_str() const {
+		static const string EMPTY_STR;
+		return payload_ ? payload_.str() : EMPTY_STR;
+	}
+	/**
+	 * Returns the quality of service for this message.
+	 * @return The quality of service for this message.
+	 */
+	int get_qos() const { return msg_.qos; }
+	/**
+	 * Returns whether or not this message might be a duplicate of one which
+	 * has already been received.
+	 * @return true this message might be a duplicate of one which
+	 * has already been received, false otherwise
+	 */
+	bool is_duplicate() const { return to_bool(msg_.dup); }
+	/**
+	 * Returns whether or not this message should be/was retained by the
+	 * server.
+	 * @return true if this message should be/was retained by the
+	 * server, false otherwise.
+	 */
+	bool is_retained() const { return to_bool(msg_.retained); }
+	/**
+	 * Sets the payload of this message to be the specified buffer.
+	 * Note that this accepts copy or move operations:
+	 *   set_payload(buf);
+	 *   set_payload(std::move(buf));
+	 * @param payload A buffer to use as the message payload.
+	 */
+	void set_payload(binary_ref payload);
+	/**
+	 * Sets the payload of this message to be the specified byte array.
+	 * @param payload the bytes to use as the message payload
+	 * @param n the number of bytes in the payload
+	 */
+	void set_payload(const void* payload, size_t n) {
+		set_payload(binary_ref(static_cast<const binary_ref::value_type*>(payload), n));
+	}
+	/**
+	 * Sets the quality of service for this message.
+	 * @param qos The integer Quality of Service for the message
+	 */
+	void set_qos(int qos) {
+		validate_qos(qos);
+		msg_.qos = qos;
+	}
+	/**
+	 * Determines if the QOS value is a valid one.
+	 * @param qos The QOS value.
+	 * @throw std::invalid_argument If the qos value is invalid.
+	 */
+	static void validate_qos(int qos) {
+		if (qos < 0 || qos > 2)
+			throw exception(MQTTASYNC_BAD_QOS, "Bad QoS");
+	}
+	/**
+	 * Whether or not the publish message should be retained by the broker.
+	 * @param retained @em true if the message should be retained by the
+	 *  			   broker, @em false if not.
+	 */
+	void set_retained(bool retained) { msg_.retained = to_int(retained); }
+	/**
+	 * Gets the properties in the message.
+	 * @return A const reference to the properties in the message.
+	 */
+	const properties& get_properties() const {
+		return props_;
+	}
+	/**
+	 * Sets the properties in the message.
+	 * @param props The properties to place into the message.
+	 */
+	void set_properties(const properties& props) {
+		props_ = props;
+		msg_.properties = props_.c_struct();
+	}
+	/**
+	 * Moves the properties into the message.
+	 * @param props The properties to move into the message.
+	 */
+	void set_properties(properties&& props) {
+		props_ = props;
+		msg_.properties = props_.c_struct();
+	}
+	/**
+	 * Returns a string representation of this messages payload.
+	 * @return A string representation of this messages payload.
+	 */
+	string to_string() const { return get_payload_str(); }
+};
+
+/** Smart/shared pointer to a message */
+using message_ptr = message::ptr_t;
+
+/** Smart/shared pointer to a const message */
+using const_message_ptr = message::const_ptr_t;
+
+/**
+ * Constructs a message with the specified array as a payload, and all
+ * other values set to defaults.
+ * @param topic The message topic
+ * @param payload the bytes to use as the message payload
+ * @param len the number of bytes in the payload
+ */
+inline message_ptr make_message(string_ref topic, const void* payload, size_t len) {
+	return mqtt::message::create(std::move(topic), payload, len);
+}
+
+/**
+ * Constructs a message with the specified array as a payload, and all
+ * other values set to defaults.
+ * @param topic The message topic
+ * @param payload the bytes to use as the message payload
+ * @param len the number of bytes in the payload
+ * @param qos The quality of service for the message.
+ * @param retained Whether the message should be retained by the broker.
+ */
+inline message_ptr make_message(string_ref topic, const void* payload, size_t len,
+								int qos, bool retained) {
+	return mqtt::message::create(std::move(topic), payload, len, qos, retained);
+}
+
+/**
+ * Constructs a message with the specified buffer as a payload, and
+ * all other values set to defaults.
+ * @param topic The message topic
+ * @param payload A string to use as the message payload.
+ */
+inline message_ptr make_message(string_ref topic, binary_ref payload) {
+	return mqtt::message::create(std::move(topic), std::move(payload));
+}
+
+/**
+ * Constructs a message with the specified values.
+ * @param topic The message topic
+ * @param payload A buffer to use as the message payload.
+ * @param qos The quality of service for the message.
+ * @param retained Whether the message should be retained by the broker.
+ */
+inline message_ptr make_message(string_ref topic, binary_ref payload,
+								int qos, bool retained) {
+	return mqtt::message::create(std::move(topic), std::move(payload), qos, retained);
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// end namespace mqtt
+}
+
+#endif		// __mqtt_message_h
+
diff --git a/src/mqtt/src/mqtt/properties.h b/src/mqtt/src/mqtt/properties.h
new file mode 100644
index 00000000..bbe977c8
--- /dev/null
+++ b/src/mqtt/src/mqtt/properties.h
@@ -0,0 +1,389 @@
+/////////////////////////////////////////////////////////////////////////////
+/// @file properties.h
+/// Declaration of MQTT properties class
+/// @date July 7, 2019
+/// @author Frank Pagliughi
+/////////////////////////////////////////////////////////////////////////////
+
+/*******************************************************************************
+ * Copyright (c) 2019 Frank Pagliughi <fpagliughi@mindspring.com>
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution.
+ *
+ * The Eclipse Public License is available at
+ *    http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at
+ *   http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *    Frank Pagliughi - initial implementation and documentation
+ *******************************************************************************/
+
+#ifndef __mqtt_properties_h
+#define __mqtt_properties_h
+
+extern "C" {
+	#include "MQTTProperties.h"
+}
+
+#include "mqtt/types.h"
+#include "mqtt/buffer_ref.h"
+#include "mqtt/exception.h"
+#include <tuple>
+#include <initializer_list>
+
+#include <iostream>
+
+namespace mqtt {
+
+using string_pair = std::tuple<string, string>;
+
+/////////////////////////////////////////////////////////////////////////////
+
+/**
+ * A single MQTT v5 property.
+ */
+class property
+{
+	/** The underlying Paho C property struct. */
+	MQTTProperty prop_;
+
+	// Make a deep copy of the property struct into this one.
+	// For string properties, this allocates memory and copied the string(s)
+	void copy(const MQTTProperty& other);
+
+public:
+	enum code {
+        PAYLOAD_FORMAT_INDICATOR = 1,
+        MESSAGE_EXPIRY_INTERVAL = 2,
+        CONTENT_TYPE = 3,
+        RESPONSE_TOPIC = 8,
+        CORRELATION_DATA = 9,
+        SUBSCRIPTION_IDENTIFIER = 11,
+        SESSION_EXPIRY_INTERVAL = 17,
+        ASSIGNED_CLIENT_IDENTIFER = 18,
+        SERVER_KEEP_ALIVE = 19,
+        AUTHENTICATION_METHOD = 21,
+        AUTHENTICATION_DATA = 22,
+        REQUEST_PROBLEM_INFORMATION = 23,
+        WILL_DELAY_INTERVAL = 24,
+        REQUEST_RESPONSE_INFORMATION = 25,
+        RESPONSE_INFORMATION = 26,
+        SERVER_REFERENCE = 28,
+        REASON_STRING = 31,
+        RECEIVE_MAXIMUM = 33,
+        TOPIC_ALIAS_MAXIMUM = 34,
+        TOPIC_ALIAS = 35,
+        MAXIMUM_QOS = 36,
+        RETAIN_AVAILABLE = 37,
+        USER_PROPERTY = 38,
+        MAXIMUM_PACKET_SIZE = 39,
+        WILDCARD_SUBSCRIPTION_AVAILABLE = 40,
+        SUBSCRIPTION_IDENTIFIERS_AVAILABLE = 41,
+        SHARED_SUBSCRIPTION_AVAILABLE = 42
+	};
+
+	/**
+	 * Create a numeric property.
+	 * This can be a byte, or 2-byte, 4-byte, or variable byte integer.
+	 * @param c The property code
+	 * @param val The integer value for the property
+	 */
+	property(code c, int32_t val);
+	/**
+	 * Create a string or binary property.
+	 * @param c The property code
+	 * @param val The value for the property
+	 */
+	property(code c, string_ref val);
+	/**
+	 * Create a string pair property.
+	 * @param c The property code
+	 * @param name The string name for the property
+	 * @param val The string value for the property
+	 */
+	property(code c, string_ref name, string_ref val);
+	/**
+	 * Creates a property list from an C struct.
+	 * @param cprop A C struct for a property list.
+	 */
+	explicit property(const MQTTProperty& cprop);
+	/**
+	 * Moves a C struct into this property list.
+	 * This takes ownership of any memory that the C struct is holding.
+	 * @param cprop A C struct for a property list.
+	 */
+	explicit property(MQTTProperty&& cprop);
+	/**
+	 * Copy constructor
+	 * @param other The other property to copy into this one.
+	 */
+	property(const property& other);
+	/**
+	 * Move constructor.
+	 * @param other The other property that is moved into this one.
+	 */
+	property(property&& other);
+	/**
+	 * Destructor
+	 */
+	~property();
+	/**
+	 * Copy assignment.
+	 * @param rhs Another property list to copy into this one.
+	 * @return A reference to this object.
+	 */
+	property& operator=(const property& rhs);
+	/**
+	 * Move assignment.
+	 * @param rhs Another property list to move into this one.
+	 * @return A reference to this object.
+	 */
+	property& operator=(property&& rhs);
+	/**
+	 * Gets the underlying C property struct.
+	 * @return A const reference to the underlying C property
+	 *  	   struct.
+	 */
+	const MQTTProperty& c_struct() const { return prop_; }
+	/**
+	 * Gets the property type (identifier).
+	 * @return The code for the property type.
+	 */
+	code type() const { return code(prop_.identifier); }
+	/**
+	 * Gets a printable name for the property type.
+	 * @return A printable name for the property type.
+	 */
+	const char* type_name() const {
+		return ::MQTTPropertyName(prop_.identifier);
+	}
+};
+
+/**
+ * Extracts the value from the property as the specitied type.
+ * @return The value from the property as the specitied type.
+ */
+template <typename T>
+inline T get(const property&) { throw bad_cast(); }
+
+template <>
+inline uint8_t get<uint8_t>(const property& prop) {
+	return (uint8_t) prop.c_struct().value.byte;
+}
+
+template <>
+inline uint16_t get<uint16_t>(const property& prop) {
+	return (uint16_t) prop.c_struct().value.integer2;
+}
+
+template <>
+inline int16_t get<int16_t>(const property& prop) {
+	return (int16_t) prop.c_struct().value.integer2;
+}
+
+template <>
+inline uint32_t get<uint32_t>(const property& prop) {
+	return (uint32_t) prop.c_struct().value.integer4;
+}
+
+template <>
+inline int32_t get<int32_t>(const property& prop) {
+	return (int32_t) prop.c_struct().value.integer4;
+}
+
+template <>
+inline string get<string>(const property& prop) {
+	return (!prop.c_struct().value.data.data) ? string()
+		: string(prop.c_struct().value.data.data, prop.c_struct().value.data.len);
+}
+
+template <>
+inline string_pair get<string_pair>(const property& prop) {
+	string name = (!prop.c_struct().value.data.data) ? string()
+		: string(prop.c_struct().value.data.data, prop.c_struct().value.data.len);
+
+	string value = (!prop.c_struct().value.value.data) ? string()
+		: string(prop.c_struct().value.value.data, prop.c_struct().value.value.len);
+
+	return std::make_tuple(std::move(name), std::move(value));
+}
+
+/////////////////////////////////////////////////////////////////////////////
+
+/**
+ * MQTT v5 property list.
+ *
+ * A collection of properties that can be added to outgoing packets or
+ * retrieved from incoming packets.
+ */
+class properties
+{
+	/** The underlying C properties struct  */
+	MQTTProperties props_;
+
+	template<typename T>
+	friend T get(const properties& props, property::code propid, size_t idx);
+
+	template<typename T>
+	friend T get(const properties& props, property::code propid);
+
+public:
+	/**
+	 * Default constructor.
+	 * Creates an empty properties list.
+	 */
+	properties() {
+		std::memset(&props_, 0, sizeof(MQTTProperties));
+	}
+	/**
+	 * Copy constructor.
+	 * @param other The property list to copy.
+	 */
+	properties(const properties& other)
+			: props_(::MQTTProperties_copy(&other.props_)) {}
+	/**
+	 * Move constructor.
+	 * @param other The property list to move to this one.
+	 */
+	properties(properties&& other) : props_(other.props_) {
+		std::memset(&other.props_, 0, sizeof(MQTTProperties));
+	}
+	/**
+	 * Creates a list of properties from a C struct.
+	 * @param cprops The c struct of properties
+	 */
+	properties(const MQTTProperties& cprops) {
+		props_ = ::MQTTProperties_copy(&cprops);
+	}
+	/**
+	 * Constructs from a list of property objects.
+	 * @param An initializer list of property objects.
+	 */
+	properties(std::initializer_list<property> props);
+	/**
+	 * Destructor.
+	 */
+	~properties() { ::MQTTProperties_free(&props_); }
+	/**
+	 * Gets a reference to the underlying C properties structure.
+	 * @return A const reference to the underlying C properties structure.
+	 */
+	const MQTTProperties& c_struct() const { return props_; }
+	/**
+	 * Copy assignment.
+	 * @param rhs The other property list to copy into this one
+	 * @return A reference to this object.
+	 */
+	properties& operator=(const properties& rhs) {
+		if (&rhs != this) {
+			::MQTTProperties_free(&props_);
+			props_ = ::MQTTProperties_copy(&rhs.props_);
+		}
+		return *this;
+	}
+	/**
+	 * Move assignment
+	 * @param rht The property list to move to this one.
+	 * @return A reference to this object.
+	 */
+	properties& operator=(properties&& rhs) {
+		if (&rhs != this) {
+			::MQTTProperties_free(&props_);
+			props_ = rhs.props_;
+			std::memset(&rhs.props_, 0, sizeof(MQTTProperties));
+		}
+		return *this;
+	}
+	/**
+	 * Determines if the property list is empty.
+	 * @return @em true if there are no properties in the list, @em false if
+	 *  	   the list contains any items.
+	 */
+	bool empty() const { return props_.count == 0; }
+	/**
+	 * Gets the numbers of property items in the list.
+	 * @return The number of property items in the list.
+	 */
+	size_t size() const { return size_t(props_.count); }
+	/**
+	 * Gets the number of bytes required for the serialized
+	 * structure on the wire.
+	 * @return The number of bytes required for the serialized
+	 *  	   struct.
+	 */
+	size_t byte_length() const {
+		return (size_t) ::MQTTProperties_len(const_cast<MQTTProperties*>(&props_));
+	}
+	/**
+	 * Adds a property to the list.
+	 * @param prop The property to add to the list.
+	 */
+	void add(const property& prop) {
+		::MQTTProperties_add(&props_, &prop.c_struct());
+	}
+	/**
+	 * Removes all the items from the property list.
+	 */
+	void clear();
+	/**
+	 * Determines if the list contains a specific property.
+	 * @param propid The property ID (code).
+	 * @return @em true if the list contains the property, @em false if not.
+	 */
+	bool contains(property::code propid) const {
+		return ::MQTTProperties_hasProperty(const_cast<MQTTProperties*>(&props_),
+											MQTTPropertyCodes(propid)) != 0;
+	}
+	/**
+	 * Get the number of properties in the list with the specified property
+	 * ID.
+	 *
+	 * Most properties can exist only once. User properties and subscription
+	 * ID's can exist more than once.
+	 *
+	 * @param propid The property ID (code).
+	 * @return The number of properties in the list with the specified ID.
+	 */
+	size_t count(property::code propid) {
+		return size_t(::MQTTProperties_propertyCount(&props_, MQTTPropertyCodes(propid)));
+	}
+	/**
+	 * Gets the property with the specified ID.
+	 *
+	 * @param propid The property ID (code).
+	 * @param idx Which instance of the property to retrieve, if there are
+	 *  		  more than one.
+	 * @return The requested property
+	 */
+	property get(property::code propid, size_t idx=0);
+};
+
+// --------------------------------------------------------------------------
+
+template<typename T>
+inline T get(const properties& props, property::code propid, size_t idx)
+{
+	MQTTProperty* prop = MQTTProperties_getPropertyAt(
+								const_cast<MQTTProperties*>(&props.c_struct()),
+								MQTTPropertyCodes(propid), int(idx));
+	if (!prop)
+		throw bad_cast();
+
+	return get<T>(property(*prop));
+}
+
+template<typename T>
+inline T get(const properties& props, property::code propid)
+{
+	return get<T>(props, propid, 0);
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// end namespace mqtt
+}
+
+#endif		// __mqtt_properties_h
+
diff --git a/src/mqtt/src/mqtt/response_options.h b/src/mqtt/src/mqtt/response_options.h
new file mode 100644
index 00000000..48f78314
--- /dev/null
+++ b/src/mqtt/src/mqtt/response_options.h
@@ -0,0 +1,121 @@
+/////////////////////////////////////////////////////////////////////////////
+/// @file response_options.h
+/// Implementation of the class 'response_options'
+/// @date 26-Aug-2016
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef __mqtt_response_options_h
+#define __mqtt_response_options_h
+
+#include "MQTTAsync.h"
+#include "mqtt/token.h"
+#include "mqtt/delivery_token.h"
+#include "subscribe_options.h"
+
+namespace mqtt {
+
+class response_options_test;
+class delivery_response_options_test;
+class token_test;
+
+/////////////////////////////////////////////////////////////////////////////
+//							response_options
+/////////////////////////////////////////////////////////////////////////////
+
+/**
+ * The response options for various asynchronous calls.
+ *
+ * This is an internal data structure, only used within the library.
+   Therefor it is not totally fleshed out, but rather only exposes the
+   functionality currently required by the library.
+ */
+class response_options
+{
+	/** The underlying C structure */
+	MQTTAsync_responseOptions opts_;
+
+	/** The token to which we are connected */
+	token::weak_ptr_t tok_;
+
+	/** A list of subscription options for subscribe-many */
+	std::vector<MQTTSubscribe_options> subOpts_;
+
+	/** The client has special access */
+	friend class async_client;
+	friend class response_options_test;
+	friend class token_test;
+
+public:
+	/**
+	 * Create an empty response object.
+	 */
+	explicit response_options(int mqttVersion=MQTTVERSION_DEFAULT);
+	/**
+	 * Creates a response object with the specified callbacks.
+	 * @param tok A token to be used as the context.
+	 */
+	response_options(const token_ptr& tok, int mqttVersion=MQTTVERSION_DEFAULT);
+	/**
+	 * Sets the callback context to a generic token.
+	 * @param tok The token to be used as the callback context.
+	 */
+	void set_token(const token_ptr& tok);
+	/**
+	 * Sets the options for a single topic subscription.
+	 * @param opts The subscribe options.
+	 */
+	void set_subscribe_options(const subscribe_options& opts);
+	/**
+	 * Sets the options for a multi-topic subscription.
+	 * @param opts A vector of the subscribe options.
+	 */
+	void set_subscribe_options(const std::vector<subscribe_options>& opts);
+};
+
+/////////////////////////////////////////////////////////////////////////////
+//						delivery_response_options
+/////////////////////////////////////////////////////////////////////////////
+
+/**
+ * The response options for asynchronous calls targeted at delivery.
+ * Each of these objects is tied to a specific delivery_token.
+ */
+class delivery_response_options
+{
+	/** The underlying C structure */
+	MQTTAsync_responseOptions opts_;
+
+	/** The delivery token to which we are connected */
+	delivery_token::weak_ptr_t dtok_;
+
+	/** The client has special access */
+	friend class async_client;
+	friend class delivery_response_options_test;
+
+public:
+	/**
+	 * Create an empty delivery response object.
+	 */
+	delivery_response_options(int mqttVersion=MQTTVERSION_DEFAULT);
+	/**
+	 * Creates a response object tied to the specific delivery token.
+	 * @param dtok A delivery token to be used as the context.
+	 */
+	delivery_response_options(const delivery_token_ptr& dtok,
+							  int mqttVersion=MQTTVERSION_DEFAULT);
+	/**
+	 * Sets the callback context to a delivery token.
+	 * @param dtok The delivery token to be used as the callback context.
+	 */
+	void set_token(const delivery_token_ptr& dtok) {
+		dtok_ = dtok;
+		opts_.context = dtok.get();
+	}
+};
+
+/////////////////////////////////////////////////////////////////////////////
+// end namespace 'mqtt'
+}
+
+#endif		// __mqtt_response_options_h
+
diff --git a/src/mqtt/src/mqtt/server_response.h b/src/mqtt/src/mqtt/server_response.h
new file mode 100644
index 00000000..7f0fe722
--- /dev/null
+++ b/src/mqtt/src/mqtt/server_response.h
@@ -0,0 +1,202 @@
+/////////////////////////////////////////////////////////////////////////////
+/// @file server_response.h
+/// Declaration of MQTT server response classes.
+/// @date July 26, 2019
+/// @author Frank Pagliughi
+/////////////////////////////////////////////////////////////////////////////
+
+/*******************************************************************************
+ * Copyright (c) 2019 Frank Pagliughi <fpagliughi@mindspring.com>
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution.
+ *
+ * The Eclipse Public License is available at
+ *    http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at
+ *   http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *    Frank Pagliughi - initial implementation and documentation
+ *******************************************************************************/
+
+#ifndef __mqtt_server_response_h
+#define __mqtt_server_response_h
+
+#include "MQTTAsync.h"
+#include "mqtt/types.h"
+#include "mqtt/properties.h"
+
+namespace mqtt {
+
+/**
+ * Base class for responses from the server.
+ */
+class server_response
+{
+	/** The properties from the acknowledge  */
+	properties props_;
+
+public:
+	/**
+	 * Creates a response with empty property list.
+	 */
+	server_response() {}
+	/**
+	 * Creates a server response with the specified properties.
+	 * @param props The properties in the response.
+	 */
+	server_response(const properties& props)
+		: props_(props) {}
+	/**
+	 * Creates a server response with the specified properties.
+	 * @param props The properties in the response.
+	 */
+	server_response(properties&& props)
+		: props_(std::move(props)) {}
+	/**
+	 * Virtual destructor.
+	 */
+	virtual ~server_response() {}
+	/**
+	 * Gets the properties from the response.
+	 * @return The properties from the response.
+	 */
+	const properties& get_properties() const { return props_; }
+};
+
+/**
+ * Response for a connect request
+ */
+class connect_response : public server_response
+{
+	/** The connection string of the server */
+	string serverURI_;
+	/** The version of MQTT being used */
+	int mqttVersion_;
+	/** The session present flag returned from the server */
+	bool sessionPresent_;
+
+	friend class token;
+
+	connect_response(const MQTTAsync_successData5* rsp) :
+		server_response(properties(rsp->properties)),
+		serverURI_(string(rsp->alt.connect.serverURI)),
+		mqttVersion_(rsp->alt.connect.MQTTVersion),
+		sessionPresent_(to_bool(rsp->alt.connect.sessionPresent)) {
+	}
+
+	connect_response(const MQTTAsync_successData* rsp) :
+		serverURI_(string(rsp->alt.connect.serverURI)),
+		mqttVersion_(rsp->alt.connect.MQTTVersion),
+		sessionPresent_(to_bool(rsp->alt.connect.sessionPresent)) {
+	}
+
+public:
+	/**
+	 * Gets the URI of the broker to which we connected.
+	 * @return The URI of the broker.
+	 */
+	string get_server_uri() const { return serverURI_; }
+	/**
+	 * Gets the MQTT version for the connection.
+	 * @return The MQTT version for the connection.
+	 */
+	int get_mqtt_version() const { return mqttVersion_; }
+	/**
+	 * Determines whether a session already existed for this client on the
+	 * server.
+	 * This tells whether the server has a persistent session stored for the
+	 * client, given the ClientID specified in the connect message.
+	 * @return Whether a session already existed for this client on the server.
+	 */
+	bool is_session_present() const { return sessionPresent_; }
+};
+
+/**
+ * Response for subscribe messages
+ */
+struct subscribe_response : public server_response
+{
+	/** The reason/result code for each topic request. */
+	std::vector<ReasonCode> reasonCodes_;
+
+	friend class token;
+
+	subscribe_response(MQTTAsync_successData5* rsp)
+			: server_response(properties(rsp->properties)) {
+		if (rsp->alt.sub.reasonCodeCount == 1)
+			reasonCodes_.push_back(ReasonCode(rsp->reasonCode));
+		else {
+			for (int i=0; i<rsp->alt.sub.reasonCodeCount; ++i)
+				reasonCodes_.push_back(ReasonCode(rsp->alt.sub.reasonCodes[i]));
+		}
+	}
+
+	subscribe_response(size_t n, MQTTAsync_successData* rsp) {
+		if (n == 0)
+			reasonCodes_.push_back(ReasonCode(rsp->alt.qos));
+		else
+			for (size_t i=0; i<n; ++i)
+				reasonCodes_.push_back(ReasonCode(rsp->alt.qosList[i]));
+	}
+
+public:
+	/**
+	 * Gets the reason codes from the server response.
+	 * On a subscribe ack there is a reason code for each topic that
+	 * was sent in the subscribe packet. Each tells the granted QoS
+	 * for the corresponding topic.
+	 * @return A collection of return codes corresponding to
+	 *  	   subscribing each topic. On success, this is the
+	 *  	   granted QoS for each topic. On failure it is the
+	 *  	   reason for the failure.
+	 */
+	const std::vector<ReasonCode>& get_reason_codes() const {
+		return reasonCodes_;
+	}
+};
+
+/**
+ * Response for unsubscribe messages.
+ */
+class unsubscribe_response : public server_response
+{
+	/** The reason/result code for each topic request. */
+	std::vector<ReasonCode> reasonCodes_;
+
+	friend class token;
+
+	unsubscribe_response(MQTTAsync_successData5* rsp)
+			: server_response(properties(rsp->properties)) {
+		if (rsp->alt.unsub.reasonCodeCount == 1)
+			reasonCodes_.push_back(ReasonCode(rsp->reasonCode));
+		else {
+			for (int i=0; i<rsp->alt.unsub.reasonCodeCount; ++i)
+				reasonCodes_.push_back(ReasonCode(rsp->alt.unsub.reasonCodes[i]));
+		}
+	}
+
+	unsubscribe_response(MQTTAsync_successData* rsp) {}
+
+public:
+	/**
+	 * Gets the reason codes from the server response.
+	 * On an unsubscribe ack there is a reason code for each topic
+	 * that was sent in the unsubscribe packet. Each tells the
+	 * result of unsubscribing to the corresponding topic.
+	 * @return A collection of return codes corresponding to
+	 *  	   unsubscribing each topic.
+	 */
+	const std::vector<ReasonCode>& get_reason_codes() const {
+		return reasonCodes_;
+	}
+};
+
+/////////////////////////////////////////////////////////////////////////////
+// end namespace mqtt
+}
+
+#endif		// __mqtt_server_response_h
+
diff --git a/src/mqtt/src/mqtt/ssl_options.h b/src/mqtt/src/mqtt/ssl_options.h
new file mode 100644
index 00000000..f44607c8
--- /dev/null
+++ b/src/mqtt/src/mqtt/ssl_options.h
@@ -0,0 +1,287 @@
+/////////////////////////////////////////////////////////////////////////////
+/// @file ssl_options.h
+/// Declaration of MQTT ssl_options class
+/// @date Jul 7, 2016
+/// @author Guilherme Ferreira
+/////////////////////////////////////////////////////////////////////////////
+
+/*******************************************************************************
+ * Copyright (c) 2016 Guilherme Ferreira <guilherme.maciel.ferreira@gmail.com>
+ * Copyright (c) 2016-2019 Frank Pagliughi <fpagliughi@mindspring.com>
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution.
+ *
+ * The Eclipse Public License is available at
+ *    http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at
+ *   http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *    Guilherme Ferreira - initial implementation and documentation
+ *    Frank Pagliughi - added copy & move operations
+ *    Frank Pagliughi - upgraded compatibility to Paho C 1.3
+ *******************************************************************************/
+
+#ifndef __mqtt_ssl_options_h
+#define __mqtt_ssl_options_h
+
+#include "MQTTAsync.h"
+#include "mqtt/message.h"
+#include "mqtt/topic.h"
+#include "mqtt/types.h"
+#include <vector>
+
+namespace mqtt {
+
+/////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Holds the set of SSL options for connection.
+ */
+class ssl_options
+{
+	/** The default C struct */
+	static const MQTTAsync_SSLOptions DFLT_C_STRUCT ;
+
+	/** The underlying C SSL options */
+	MQTTAsync_SSLOptions opts_;
+
+	/**
+	 * The file containing the public digital certificates trusted by
+	 * the client.
+	 */
+	string trustStore_;
+
+	/** The file containing the public certificate chain of the client. */
+	string keyStore_;
+
+	/** The file containing the client's private key. */
+	string privateKey_;
+
+	/** The password to load the client's privateKey if encrypted. */
+	string privateKeyPassword_;
+
+	/** Path to a directory containing CA certificates in PEM format */
+	string caPath_;
+
+	/**
+	 * The list of cipher suites that the client will present to the
+	 * server during the SSL handshake.
+	 */
+	string enabledCipherSuites_;
+
+	/** The connect options has special access */
+	friend class connect_options;
+	friend class connect_options_test;
+	friend class ssl_options_test;
+
+	/**
+	 * Gets a pointer to the C-language NUL-terminated strings for the
+	 * struct.
+	 * @note In the SSL options, by default, the Paho C treats nullptr char
+	 * arrays as unset values, so we keep that semantic and only set those
+	 * char arrays if the string is non-empty.
+	 * @param str The C++ string object.
+	 * @return Pointer to a NUL terminated string. This is only valid until
+	 *  	   the next time the string is updated.
+	 */
+	const char* c_str(const string& str) {
+		return str.empty() ? nullptr : str.c_str();
+	}
+	/**
+	 * Updates the underlying C structure to match our strings.
+	 */
+	void update_c_struct();
+
+public:
+	/** Smart/shared pointer to an object of this class. */
+	using ptr_t = std::shared_ptr<ssl_options>;
+	/** Smart/shared pointer to a const object of this class. */
+	using const_ptr_t = std::shared_ptr<const ssl_options>;
+
+	/**
+	 * Constructs a new MqttConnectOptions object using the default values.
+	 */
+	ssl_options();
+	/**
+	 * Argument constructor.
+	 * @param trustStore The file containing the public digital certificates
+	 * trusted by the client.
+	 * @param keyStore The file containing the public certificate chain of the
+	 * client.
+	 * @param privateKey The file containing the client's private key.
+	 * @param privateKeyPassword The password to load the client's privateKey
+	 * if encrypted.
+	 * @param enabledCipherSuites The list of cipher suites that the client
+	 * will present to the server during the SSL handshake.
+	 * @param enableServerCertAuth True/False option to enable verification of
+	 * the server certificate
+	 */
+	ssl_options(const string& trustStore, const string& keyStore,
+				const string& privateKey, const string& privateKeyPassword,
+				const string& enabledCipherSuites, bool enableServerCertAuth);
+	/**
+	 * Copy constructor.
+	 * @param opt The other options to copy.
+	 */
+	ssl_options(const ssl_options& opt);
+	/**
+	 * Move constructor.
+	 * @param opt The other options to move to this one.
+	 */
+	ssl_options(ssl_options&& opt);
+	/**
+	 * Copy assignment.
+	 * @param opt The other options to copy.
+	 * @return A reference to this object.
+	 */
+	ssl_options& operator=(const ssl_options& opt);
+	/**
+	 * Move assignment.
+	 * @param opt The other options to move to this one.
+	 * @return A reference to this object.
+	 */
+	ssl_options& operator=(ssl_options&& opt);
+	/**
+	 * Returns the file containing the public digital certificates trusted by
+	 * the client.
+	 * @return string
+	 */
+	string get_trust_store() const { return trustStore_; }
+	/**
+	 * Returns the file containing the public certificate chain of the client.
+	 * @return string
+	 */
+	string get_key_store() const { return keyStore_; }
+	/**
+	 * Returns the file containing the client's private key.
+	 * @return string
+	 */
+	string get_private_key() const { return privateKey_; }
+	/**
+	 * Returns the password to load the client's privateKey if encrypted.
+	 * @return string
+	 */
+	string get_private_key_password() const { return privateKeyPassword_; }
+	/**
+	 * Returns the list of cipher suites that the client will present to the
+	 * server during the SSL handshake.
+	 * @return string
+	 */
+	string get_enabled_cipher_suites() const { return enabledCipherSuites_; }
+	/**
+	 * Returns the true/false to enable verification of the server certificate .
+	 * @return bool
+	 */
+	bool get_enable_server_cert_auth() const {
+		return to_bool(opts_.enableServerCertAuth);
+	}
+	/**
+	 * Sets the file containing the public digital certificates trusted by
+	 * the client.
+	 * @param trustStore The file in PEM format containing the public
+	 *  				 digital certificates trusted by the client.
+	 */
+	void set_trust_store(const string& trustStore);
+	/**
+	 * Sets the file containing the public certificate chain of the client.
+	 * @param keyStore The file in PEM format containing the public
+	 *  			   certificate chain of the client. It may also include
+	 *				   the client's private key.
+	 */
+	void set_key_store(const string& keyStore);
+	/**
+	 * Sets the file containing the client's private key.
+	 * @param privateKey If not included in the sslKeyStore, this is the
+	 *  				 file in PEM format containing the client's private
+	 *  				 key.
+	 */
+	void set_private_key(const string& privateKey);
+	/**
+	 * Sets the password to load the client's privateKey if encrypted.
+	 * @param privateKeyPassword The password to load the privateKey if
+	 *  						 encrypted.
+	 */
+	void set_private_key_password(const string& privateKeyPassword);
+	/**
+	 * Sets the list of cipher suites that the client will present to the server
+	 * during the SSL handshake.
+	 * @param enabledCipherSuites The list of cipher suites that the client
+	 *  						  will present to the server during the SSL
+	 *  						  handshake. For a  full explanation of the
+	 *  						  cipher list format, please see the OpenSSL
+	 *  						  on-line documentation:
+	 *  						  http://www.openssl.org/docs/apps/ciphers.html#CIPHER_LIST_FORMAT
+	 *  						  If this setting is ommitted, its default
+	 *  						  value will be "ALL", that is, all the
+	 *  						  cipher suites -excluding those offering no
+	 *  						  encryption- will be considered. This
+	 *  						  setting can be used to set an SSL
+	 *  						  anonymous connection (empty string value,
+	 *  						  for instance).
+	 */
+	void set_enabled_cipher_suites(const string& enabledCipherSuites);
+	/**
+	 * Enables or disables verification of the server certificate.
+	 * @param enablServerCertAuth enable/disable verification of the server
+	 *  						  certificate
+	 */
+	void set_enable_server_cert_auth(bool enablServerCertAuth);
+	/**
+	 * Gets the requested SSL/TLS version.
+	 * @return The requested SSL/TLS version.
+	 */
+	int get_ssl_version() const { return opts_.sslVersion; }
+	/**
+	 * Set the SSL/TLS version to use.
+	 *
+	 * @param ver The desired SSL/TLS version. Specify one of:
+	 *  	@li MQTT_SSL_VERSION_DEFAULT (0)
+	 *  	@li MQTT_SSL_VERSION_TLS_1_0 (1)
+	 *  	@li MQTT_SSL_VERSION_TLS_1_1 (2)
+	 *  	@li MQTT_SSL_VERSION_TLS_1_2 (3)
+	 */
+	void set_ssl_version(int ver) { opts_.sslVersion = ver; }
+	/**
+	 * Determines whether it will carry out post-connect checks, including
+	 * that a certificate matches the given host name.
+	 * @return Whether it will carry out post-connect checks.
+	 */
+	bool get_verify() const { return to_bool(opts_.verify); }
+	/**
+	 * Sets whether it should carry out post-connect checks, including that
+	 * a certificate matches the given host name.
+	 * @param v Whether it should carry out post-connect checks.
+	 */
+	void set_verify(bool v) { opts_.verify = to_int(v); }
+	/**
+	 * Gets the path to a directory containing CA certificates in PEM
+	 * format.
+	 *
+	 * @return Path to a directory containing CA certificates in PEM format,
+	 *  	   if set. If this isn't set, returns an empty string.
+	 */
+	string ca_path() const { return caPath_; }
+	/**
+	 * Sets the path to a directory containing CA certificates in PEM
+	 * format.
+	 *
+	 * @param path Path to a directory containing CA certificates in PEM
+	 *  	   format.
+	 */
+	void ca_path(const string& path);
+};
+
+/**
+ * Shared pointer to the ssl options class.
+ */
+using ssl_options_ptr = ssl_options::ptr_t;
+
+/////////////////////////////////////////////////////////////////////////////
+// end namespace mqtt
+}
+
+#endif		// __mqtt_ssl_options_h
+
diff --git a/src/mqtt/src/mqtt/string_collection.h b/src/mqtt/src/mqtt/string_collection.h
new file mode 100644
index 00000000..548edc13
--- /dev/null
+++ b/src/mqtt/src/mqtt/string_collection.h
@@ -0,0 +1,241 @@
+/////////////////////////////////////////////////////////////////////////////
+/// @file string_collection.h
+/// Definition of the string_collection class for the Paho MQTT C++ library.
+/// @date April 23, 2017
+/// @author Frank Pagliughi
+/////////////////////////////////////////////////////////////////////////////
+
+/*******************************************************************************
+ * Copyright (c) 2017 Frank Pagliughi <fpagliughi@mindspring.com>
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution.
+ *
+ * The Eclipse Public License is available at
+ *    http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at
+ *   http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *    Frank Pagliughi - initial implementation and documentation
+ *******************************************************************************/
+
+#ifndef __mqtt_string_collection_h
+#define __mqtt_string_collection_h
+
+#include "mqtt/types.h"
+#include <vector>
+#include <memory>
+
+namespace mqtt {
+
+/////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Type for a collection of topics.
+ * This acts like a collection of strings but carries an array of pointers
+ * to the C strings for easy interactions with the Paho C library.
+ */
+class string_collection
+{
+	/** The type for the collection of strings */
+	using collection_type = std::vector<string>;
+	/** The type for the array of C pointers */
+	using c_arr_type = std::vector<const char*>;
+
+	/**
+	 * The collection of strings for the topics.
+	 */
+	collection_type coll_;
+	/**
+	 * A colleciton of pointers to NUL-terminated C strings for the topics.
+	 * This is what is required by the Paho C library, and thus the lifetime
+	 * of the pointers will remain consistent with the lifetime of the
+	 * object. The value is kept consistent with the current topics and
+	 * updated whenever topics are added or removed.
+	 */
+	c_arr_type cArr_;
+	/**
+	 * Updated the cArr_ object to agree with the values in coll_ 
+	 * This should be called any time the coll_ variable is modified 
+	 * <i>in any way</i>. 
+	 */
+	void update_c_arr();
+
+public:
+	/** Smart/shared pointer to an object of this type */
+	using ptr_t = std::shared_ptr<string_collection>;
+	/** Smart/shared pointer to a const object of this type */
+	using const_ptr_t = std::shared_ptr<const string_collection>;
+
+	/**
+	 * Construct an empty string collection.
+	 */
+	string_collection() =default;
+	/**
+	 * Construct a collection initially containing a single string.
+	 * @param str The string
+	 */
+	string_collection(const string& str);
+	/**
+	 * Construct a collection initially containing a single string.
+	 * @param str The string
+	 */
+	string_collection(string&& str);
+	/**
+	 * Constructs a string collection by copying a vector of strings.
+	 * @param vec A vector of strings.
+	 */
+	string_collection(const collection_type& vec);
+	/**
+	 * Constructs a string collection by moving a vector of strings.
+	 * @param vec A vector of strings.
+	 */
+	string_collection(collection_type&& vec);
+	/**
+	 * Copy constructor.
+	 * @param coll An existing string collection.
+	 */
+	string_collection(const string_collection& coll);
+	/**
+	 * Move constructor.
+	 * @param coll An existing string collection.
+	 */
+	string_collection(string_collection&& coll) = default;
+	/**
+	 * Construct a string collection from an initialization list of strings.
+	 * @param sl An initialization list of strings.
+	 */
+	string_collection(std::initializer_list<string> sl);
+	/**
+	 * Construct a string collection from an initialization list of C string
+	 * pointers.
+	 * @param sl An initialization list of C character arrays.
+	 */
+	string_collection(std::initializer_list<const char*> sl);
+	/**
+	 * Create an empty string collection on the heap.
+	 * @return A smart/shared pointer to a string collection.
+	 */
+	static ptr_t create(const string& str) {
+		return std::make_shared<string_collection>(str);
+	}
+	/**
+	 * Create a string collection on the heap, initially containing a single
+	 * string.
+	 * @param str The string
+	 * @return A smart/shared pointer to a string collection.
+	 */
+	static ptr_t create(string&& str) {
+		return std::make_shared<string_collection>(str);
+	}
+	/**
+	 * Creates a string collection on the heap by copying a vector of
+	 * strings.
+	 * @param vec A vector of strings.
+	 */
+	static ptr_t create(const collection_type& vec) {
+		return std::make_shared<string_collection>(vec);
+	}
+	/**
+	 * Creates a string collection on the heap by copying a vector of
+	 * strings.
+	 * @param vec A vector of strings.
+	 * @return A smart/shared pointer to a string collection.
+	 */
+	static ptr_t create(collection_type&& vec) {
+		return std::make_shared<string_collection>(vec);
+	}
+	/**
+	 * Create a string collection on the heap from an initialization list of
+	 * strings.
+	 * @param sl An initialization list of strings.
+	 * @return A smart/shared pointer to a string collection.
+	 */
+	static ptr_t create(std::initializer_list<string> sl) {
+		return std::make_shared<string_collection>(sl);
+	}
+	/**
+	 * Create a string collection on the heap from an initialization list of
+	 * C string pointers.
+	 * @param sl An initialization list of C character arrays.
+	 * @return A smart/shared pointer to a string collection.
+	 */
+	static ptr_t create(std::initializer_list<const char*> sl) {
+		return std::make_shared<string_collection>(sl);
+	}
+	/**
+	 * Copy assignment.
+	 * Copy another string collection to this one.
+	 * @param coll A string collection
+	 * @return A reference to this collection.
+	 */
+	string_collection& operator=(const string_collection& coll);
+	/**
+	 * Move assignment.
+	 * Move another string collection to this one.
+	 * @param coll A string collection
+	 * @return A reference to this collection.
+	 */
+	string_collection& operator=(string_collection&& coll) = default;
+	/**
+	 * Determines if the collection is empty.
+	 * @return @em true if the collection is empty, @em false if not.
+	 */
+	bool empty() const { return coll_.empty(); }
+	/**
+	 * Gets the number of strings in the collection.
+	 * @return The number of strings in the collection.
+	 */
+	size_t size() const { return coll_.size(); }
+	/**
+	 * Copies a string to the back of the collection.
+	 * @param str A string.
+	 */
+	void push_back(const string& str);
+	/**
+	 * Moves a string to the back of the collection.
+	 * @param str A string.
+	 */
+	void push_back(string&& str);
+	/**
+	 * Removes all the strings from the collection.
+	 */
+	void clear();
+	/**
+	 * Gets the n'th string in the collection.
+	 * @param i Index to the desired string.
+	 * @return A const reference to the string.
+	 */
+	const string& operator[](size_t i) const { return coll_[i]; }
+
+	/**
+	 * Gets a pointer to an array of NUL-terminated C string pointers.
+	 * This is the collection type supported by the underlying Paho C
+	 * library. The returned pointer is guaranteed valid so long as the
+	 * object is not updated. The return value may change if the object is
+	 * modified, so the application should not cache the return value, but
+	 * rather request the value when needed.
+	 * @return pointer to an array of NUL-terminated C string pointers of
+	 *  	   the topics in the object.
+	 *
+	 */
+	char* const* c_arr() const { return (char* const *) cArr_.data(); }
+	//const char* const* c_arr() const { return cArr_.data(); }
+};
+
+/////////////////////////////////////////////////////////////////////////////
+
+/** Smart/shared pointer to a topic collection */
+using string_collection_ptr = string_collection::ptr_t;
+
+/** Smart/shared pointer to a const string_collection */
+using const_string_collection_ptr = string_collection::const_ptr_t;
+
+/////////////////////////////////////////////////////////////////////////////
+// end namespace mqtt
+}
+
+#endif		// __mqtt_string_collection_h
+
diff --git a/src/mqtt/src/mqtt/subscribe_options.h b/src/mqtt/src/mqtt/subscribe_options.h
new file mode 100644
index 00000000..753c811b
--- /dev/null
+++ b/src/mqtt/src/mqtt/subscribe_options.h
@@ -0,0 +1,170 @@
+/////////////////////////////////////////////////////////////////////////////
+/// @file subscribe_options.h
+/// Declaration of MQTT subscribe_options class
+/// @date Aug 1, 2019 @
+/// @author Frank Pagliughi
+/////////////////////////////////////////////////////////////////////////////
+
+/*******************************************************************************
+ * Copyright (c) 2019 Frank Pagliughi <fpagliughi@mindspring.com>
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution.
+ *
+ * The Eclipse Public License is available at
+ *    http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at
+ *   http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *    Frank Pagliughi - initial implementation and documentation
+ *******************************************************************************/
+
+#ifndef __mqtt_subscribe_options_h
+#define __mqtt_subscribe_options_h
+
+#include "MQTTAsync.h"
+#include "MQTTSubscribeOpts.h"
+#include "mqtt/types.h"
+
+namespace mqtt {
+
+/////////////////////////////////////////////////////////////////////////////
+
+/**
+ * The MQTT v5 subscription options.
+ * These are defined in section 3.8.3.1 of the MQTT v5 spec.
+ * The defaults use the behavior that was present in MQTT v3.1.1.
+ */
+class subscribe_options
+{
+	/** The underlying C structure */
+	MQTTSubscribe_options opts_;
+
+	friend class async_client;
+	friend class response_options;
+	friend class subscribe_options_test;
+
+public:
+	/** Smart/shared pointer to an object of this class. */
+	using ptr_t = std::shared_ptr<subscribe_options>;
+	/** Smart/shared pointer to a const object of this class. */
+	using const_ptr_t = std::shared_ptr<const subscribe_options>;
+
+	/** Don't receive our own publications */
+	static constexpr bool SUBSCRIBE_NO_LOCAL = true;
+	/** Receive our own publications */
+	static constexpr bool SUBSCRIBE_LOCAL = false;
+
+	/**
+	 * Retain flag is only set on publications sent by a broker if in
+	 * response to a subscribe request
+	 */
+	static constexpr bool NO_RETAIN_AS_PUBLISHED = false;
+	/** Keep the retain flag as on the original publish message */
+	static constexpr bool RETAIN_AS_PUBLISHED = true;
+
+	/** The options for subscription retain handling */
+	enum RetainHandling {
+		/** Send retained messages at the time of the subscribe */
+		SEND_RETAINED_ON_SUBSCRIBE = 0,
+		/** Send retained messages on subscribe only if subscription is new */
+		SEND_RETAINED_ON_NEW = 1,
+		/** Do not send retained messages at all */
+		DONT_SEND_RETAINED = 2
+	};
+
+	/**
+	 * Create default subscription options.
+	 * These are the default options corresponding to the original MQTT (v3)
+	 * behaviors.
+	 */
+	subscribe_options()
+			: opts_(MQTTSubscribe_options_initializer) {}
+	/**
+	 * Creates a set of subscription options.
+	 *
+	 * @param noLocal Whether the server should send back our own
+	 *  			  publications, if subscribed.
+	 * @param retainAsPublished Whether to keep the retained flag as in the
+	 *  						original published message (true).
+	 * @param retainHandling When to send retained messages:
+	 *  	@li (SEND_RETAINED_ON_SUBSCRIBE, 0) At the time of the subscribe
+	 *  	@li (SEND_RETAINED_ON_NEW, 1) Only at the time of a new
+	 *  		subscribe
+	 *  	@li (DONT_SEND_RETAINED, 2) Not at the time of subscribe
+	 */
+	explicit subscribe_options(bool noLocal, byte retainAsPublished=false,
+							   RetainHandling retainHandling=SEND_RETAINED_ON_SUBSCRIBE)
+			: opts_(MQTTSubscribe_options_initializer) {
+		opts_.noLocal = noLocal ? 1 : 0;
+		opts_.retainAsPublished = retainAsPublished ? 1 : 0;
+		opts_.retainHandling = (unsigned char) retainHandling;
+	}
+	/**
+	 * Gets the value of the "no local" flag.
+	 * @return Whether the server should send back our own publications, if
+	 *  	   subscribed.
+	 */
+	bool get_no_local() const {
+		return to_bool(opts_.noLocal);
+	}
+	/**
+	 * Sets the "no local" flag on or off.
+	 * @param on Whether the server should send back our own publications,
+	 *  		 if subscribed.
+	 */
+	void set_no_local(bool on=true) {
+		opts_.noLocal = on ? 1 : 0;
+	}
+	/**
+	 * Gets the "retain as published" flag.
+	 * @return Whether to keep the retained flag as in the original
+	 *  		 published message.
+	 */
+	bool get_retain_as_published() const {
+		return to_bool(opts_.retainAsPublished);
+	}
+	/**
+	 * Sets the "retain as published" flag on or off.
+	 * @param on Whether to keep the retained flag as in the original
+	 *  		 published message.
+	 */
+	void set_retain_as_published(bool on) {
+		opts_.retainAsPublished = on ? 1 : 0;
+	}
+	/**
+	 * Gets the "retasin handling" option.
+	 * @return When to send retained messages:
+	 *  	@li (SEND_RETAINED_ON_SUBSCRIBE, 0) At the time of the subscribe
+	 *  	@li (SEND_RETAINED_ON_NEW, 1) Only at the time of a new
+	 *  		subscribe
+	 *  	@li (DONT_SEND_RETAINED, 2) Not at the time of subscribe
+	 */
+	auto get_retain_handling() const -> RetainHandling {
+		return RetainHandling(opts_.retainHandling);
+	}
+	/**
+	 * Sets the "retain handling" option.
+	 * @param retainHandling When to send retained messages:
+	 *  	@li (SEND_RETAINED_ON_SUBSCRIBE, 0) At the time of the subscribe
+	 *  	@li (SEND_RETAINED_ON_NEW, 1) Only at the time of a new
+	 *  		subscribe
+	 *  	@li (DONT_SEND_RETAINED, 2) Not at the time of subscribe
+	 */
+	void set_retain_handling(RetainHandling retainHandling) {
+		opts_.retainHandling = (unsigned char) retainHandling;
+	}
+};
+
+
+/** Smart/shared pointer to a subscribe options object. */
+using subscribe_options_ptr = subscribe_options::ptr_t;
+
+/////////////////////////////////////////////////////////////////////////////
+// end namespace mqtt
+}
+
+#endif		// __mqtt_subscribe_options_h
+
diff --git a/src/mqtt/src/mqtt/thread_queue.h b/src/mqtt/src/mqtt/thread_queue.h
new file mode 100644
index 00000000..5dafe6eb
--- /dev/null
+++ b/src/mqtt/src/mqtt/thread_queue.h
@@ -0,0 +1,332 @@
+/////////////////////////////////////////////////////////////////////////////
+/// @file thread_queue.h
+/// Implementation of the template class 'thread_queue', a thread-safe,
+/// blocking queue for passing data between threads, safe for use with smart
+/// pointers.
+/// @date 09-Jan-2017
+/////////////////////////////////////////////////////////////////////////////
+
+/*******************************************************************************
+ * Copyright (c) 2017 Frank Pagliughi <fpagliughi@mindspring.com>
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution.
+ *
+ * The Eclipse Public License is available at
+ *    http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at
+ *   http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *    Frank Pagliughi - initial implementation and documentation
+ *******************************************************************************/
+
+#ifndef __mqtt_thread_queue_h
+#define __mqtt_thread_queue_h
+
+#include <thread>
+#include <mutex>
+#include <condition_variable>
+#include <limits>
+#include <deque>
+#include <queue>
+#include <algorithm>
+
+namespace mqtt {
+
+/////////////////////////////////////////////////////////////////////////////
+
+/**
+ * A thread-safe queue for inter-thread communication.
+ * This is a lockinq queue with blocking operations. The get() operations
+ * can always block on an empty queue, but have variations for non-blocking
+ * (try_get) and bounded-time blocking (try_get_for, try_get_until).
+ * @par
+ * The default queue has a capacity that is unbounded in the practical
+ * sense, limited by available memory. In this mode the object will not
+ * block when placing values into the queue. A capacity can bet set with the
+ * construtor or, at any time later by calling the @ref capacity(size_type)
+ * method. Using this latter method, the capacity can be set to an amount
+ * smaller than the current size of the queue. In that case all put's to the
+ * queue will block until the number of items are removed from the queue to
+ * bring the size below the new capacity.
+ * @par
+ * Note that the queue uses move semantics to place items into the queue and
+ * remove items from the queue. This means that the type, T, of the data
+ * held by the queue only needs to follow move semantics; not copy
+ * semantics. In addition, this means that copies of the value will @em not
+ * be left in the queue. This is especially useful when creating queues of
+ * shared pointers, as the "dead" part of the queue will not hold onto a
+ * reference count after the item has been removed from the queue.
+ *
+ * @param T The type of the items to be held in the queue.
+ * @param Container The type of the underlying container to use. It must
+ * support back(), front(), push_back(), pop_front().
+ */
+template <typename T, class Container=std::deque<T>>
+class thread_queue
+{
+public:
+	/** The underlying container type to use for the queue. */
+	using container_type = Container;
+	/** The type of items to be held in the queue. */
+	using value_type = T;
+	/** The type used to specify number of items in the container. */
+	using size_type = typename Container::size_type;
+
+	/** The maximum capacity of the queue. */
+	static constexpr size_type MAX_CAPACITY = std::numeric_limits<size_type>::max();
+
+private:
+	/** Object lock */
+	mutable std::mutex lock_;
+	/** Condition get signaled when item added to empty queue */
+	std::condition_variable notEmptyCond_;
+	/** Condition gets signaled then item removed from full queue */
+	std::condition_variable notFullCond_;
+	/** The capacity of the queue */
+	size_type cap_;
+	/** The actual STL container to hold data */
+	std::queue<T,Container> que_;
+
+	/** Simple, scope-based lock guard */
+	using guard = std::lock_guard<std::mutex>;
+	/** General purpose guard */
+	using unique_guard = std::unique_lock<std::mutex>;
+
+public:
+	/**
+	 * Constructs a queue with the maximum capacity.
+	 */
+	thread_queue() : cap_(MAX_CAPACITY) {}
+	/**
+	 * Constructs a queue with the specified capacity.
+	 * @param cap The maximum number of items that can be placed in the
+	 *  		  queue. The minimum capacity is 1.
+	 */
+	explicit thread_queue(size_t cap) : cap_(std::max<size_type>(cap, 1)) {}
+	/**
+	 * Determine if the queue is empty.
+	 * @return @em true if there are no elements in the queue, @em false if
+	 *  	   there are any items in the queue.
+	 */
+	bool empty() const {
+		guard g(lock_);
+		return que_.empty();
+	}
+	/**
+	 * Gets the capacity of the queue.
+	 * @return The maximum number of elements before the queue is full.
+	 */
+	size_type capacity() const {
+		guard g(lock_);
+		return cap_;
+	}
+	/**
+	 * Sets the capacity of the queue.
+	 * Note that the capacity can be set to a value smaller than the current
+	 * size of the queue. In that event, all calls to put() will block until
+	 * a suffucuent number
+	 */
+	void capacity(size_type cap) {
+		guard g(lock_);
+		cap_ = cap;
+	}
+	/**
+	 * Gets the number of items in the queue.
+	 * @return The number of items in the queue.
+	 */
+	size_type size() const {
+		guard g(lock_);
+		return que_.size();
+	}
+	/**
+	 * Put an item into the queue.
+	 * If the queue is full, this will block the caller until items are
+	 * removed bringing the size less than the capacity.
+	 * @param val The value to add to the queue.
+	 */
+	void put(value_type val) {
+		unique_guard g(lock_);
+		if (que_.size() >= cap_)
+			notFullCond_.wait(g, [=]{return que_.size() < cap_;});
+        bool wasEmpty = que_.empty();
+		que_.emplace(std::move(val));
+		if (wasEmpty) {
+			g.unlock();
+			notEmptyCond_.notify_one();
+		}
+	}
+	/**
+	 * Non-blocking attempt to place an item into the queue.
+	 * @param val The value to add to the queue.
+	 * @return @em true if the item was added to the queue, @em false if the
+	 *  	   item was not added because the queue is currently full.
+	 */
+	bool try_put(value_type val) {
+		unique_guard g(lock_);
+		size_type n = que_.size();
+		if (n >= cap_)
+			return false;
+		que_.emplace(std::move(val));
+		if (n == 0) {
+			g.unlock();
+			notEmptyCond_.notify_one();
+		}
+		return true;
+	}
+	/**
+	 * Attempt to place an item in the queue with a bounded wait.
+	 * This will attempt to place the value in the queue, but if it is full,
+	 * it will wait up to the specified time duration before timing out.
+	 * @param val The value to add to the queue.
+	 * @param relTime The amount of time to wait until timing out.
+	 * @return @em true if the value was added to the queue, @em false if a
+	 *  	   timeout occurred.
+	 */
+	template <typename Rep, class Period>
+	bool try_put_for(value_type* val, const std::chrono::duration<Rep, Period>& relTime) {
+		unique_guard g(lock_);
+		if (que_.size() >= cap_ && !notFullCond_.wait_for(g, relTime, [=]{return que_.size() < cap_;}))
+			return false;
+        bool wasEmpty = que_.empty();
+		que_.emplace(std::move(val));
+		if (wasEmpty) {
+			g.unlock();
+			notEmptyCond_.notify_one();
+		}
+		return true;
+	}
+	/**
+	 * Attempt to place an item in the queue with a bounded wait to an
+	 * absolute time point.
+	 * This will attempt to place the value in the queue, but if it is full,
+	 * it will wait up until the specified time before timing out.
+	 * @param val The value to add to the queue.
+	 * @param absTime The absolute time to wait to before timing out.
+	 * @return @em true if the value was added to the queue, @em false if a
+	 *  	   timeout occurred.
+	 */
+	template <class Clock, class Duration>
+	bool try_put_until(value_type* val, const std::chrono::time_point<Clock,Duration>& absTime) {
+		unique_guard g(lock_);
+		if (que_.size() >= cap_ && !notFullCond_.wait_until(g, absTime, [=]{return que_.size() < cap_;}))
+			return false;
+        bool wasEmpty = que_.empty();
+		que_.emplace(std::move(val));
+		if (wasEmpty) {
+			g.unlock();
+			notEmptyCond_.notify_one();
+		}
+		return true;
+	}
+	/**
+	 * Retrieve a value from the queue.
+	 * If the queue is empty, this will block indefinitely until a value is
+	 * added to the queue by another thread,
+	 * @param val Pointer to a variable to receive the value.
+	 */
+	void get(value_type* val) {
+		unique_guard g(lock_);
+		if (que_.empty())
+			notEmptyCond_.wait(g, [=]{return !que_.empty();});
+		*val = std::move(que_.front());
+		que_.pop();
+		if (que_.size() == cap_-1) {
+			g.unlock();
+			notFullCond_.notify_one();
+		}
+	}
+	/**
+	 * Retrieve a value from the queue.
+	 * If the queue is empty, this will block indefinitely until a value is
+	 * added to the queue by another thread,
+	 * @return The value removed from the queue
+	 */
+	value_type get() {
+		unique_guard g(lock_);
+		if (que_.empty())
+			notEmptyCond_.wait(g, [=]{return !que_.empty();});
+		value_type val = std::move(que_.front());
+		que_.pop();
+		if (que_.size() == cap_-1) {
+			g.unlock();
+			notFullCond_.notify_one();
+		}
+		return val;
+	}
+	/**
+	 * Attempts to remove a value from the queue without blocking.
+	 * If the queue is currently empty, this will return immediately with a
+	 * failure, otherwise it will get the next value and return it.
+	 * @param val Pointer to a variable to receive the value.
+	 * @return @em true if a value was removed from the queue, @em false if
+	 *  	   the queue is empty.
+	 */
+	bool try_get(value_type* val) {
+		unique_guard g(lock_);
+		if (que_.empty())
+			return false;
+		*val = std::move(que_.front());
+		que_.pop();
+		if (que_.size() == cap_-1) {
+			g.unlock();
+			notFullCond_.notify_one();
+		}
+		return true;
+	}
+	/**
+	 * Attempt to remove an item from the queue for a bounded amout of time.
+	 * This will retrieve the next item from the queue. If the queue is
+	 * empty, it will wait the specified amout of time for an item to arive
+	 * before timing out.
+	 * @param val Pointer to a variable to receive the value.
+	 * @param relTime The amount of time to wait until timing out.
+	 * @return @em true if the value was removed the queue, @em false if a
+	 *  	   timeout occurred.
+	 */
+	template <typename Rep, class Period>
+	bool try_get_for(value_type* val, const std::chrono::duration<Rep, Period>& relTime) {
+		unique_guard g(lock_);
+		if (que_.empty() && !notEmptyCond_.wait_for(g, relTime, [=]{return !que_.empty();}))
+			return false;
+		*val = std::move(que_.front());
+		que_.pop();
+		if (que_.size() == cap_-1) {
+			g.unlock();
+			notFullCond_.notify_one();
+		}
+		return true;
+	}
+	/**
+	 * Attempt to remove an item from the queue for a bounded amout of time.
+	 * This will retrieve the next item from the queue. If the queue is
+	 * empty, it will wait until the specified time for an item to arive
+	 * before timing out.
+	 * @param val Pointer to a variable to receive the value.
+	 * @param absTime The absolute time to wait to before timing out.
+	 * @return @em true if the value was removed from the queue, @em false
+	 *  	   if a timeout occurred.
+	 */
+	template <class Clock, class Duration>
+	bool try_get_until(value_type* val, const std::chrono::time_point<Clock,Duration>& absTime) {
+		unique_guard g(lock_);
+		if (que_.empty() && !notEmptyCond_.wait_until(g, absTime, [=]{return !que_.empty();}))
+			return false;
+		*val = std::move(que_.front());
+		que_.pop();
+		if (que_.size() == cap_-1) {
+			g.unlock();
+			notFullCond_.notify_one();
+		}
+		return true;
+	}
+};
+
+/////////////////////////////////////////////////////////////////////////////
+// end namespace mqtt
+}
+
+#endif		// __mqtt_thread_queue_h
+
diff --git a/src/mqtt/src/mqtt/token.h b/src/mqtt/src/mqtt/token.h
new file mode 100644
index 00000000..efb1659b
--- /dev/null
+++ b/src/mqtt/src/mqtt/token.h
@@ -0,0 +1,504 @@
+/////////////////////////////////////////////////////////////////////////////
+/// @file token.h
+/// Declaration of MQTT token class
+/// @date May 1, 2013
+/// @author Frank Pagliughi
+/////////////////////////////////////////////////////////////////////////////
+
+/*******************************************************************************
+ * Copyright (c) 2013-2019 Frank Pagliughi <fpagliughi@mindspring.com>
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution.
+ *
+ * The Eclipse Public License is available at
+ *    http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at
+ *   http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *    Frank Pagliughi - initial implementation and documentation
+ *    Frank Pagliughi - MQTT v5 support & server responses
+ *******************************************************************************/
+
+#ifndef __mqtt_token_h
+#define __mqtt_token_h
+
+#include "MQTTAsync.h"
+#include "mqtt/iaction_listener.h"
+#include "mqtt/exception.h"
+#include "mqtt/types.h"
+#include "mqtt/properties.h"
+#include "mqtt/buffer_ref.h"
+#include "mqtt/string_collection.h"
+#include "mqtt/server_response.h"
+#include <vector>
+#include <thread>
+#include <mutex>
+#include <condition_variable>
+#include <chrono>
+
+namespace mqtt {
+
+class iasync_client;
+
+/////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Provides a mechanism for tracking the completion of an asynchronous
+ * action.
+ */
+class token
+{
+public:
+	/** Smart/shared pointer to an object of this class */
+	using ptr_t = std::shared_ptr<token>;
+	/** Smart/shared pointer to an object of this class */
+	using const_ptr_t = std::shared_ptr<const token>;
+	/** Weak pointer to an object of this class */
+	using weak_ptr_t = std::weak_ptr<token>;
+
+	/** The type of request that the token is tracking */
+	enum Type {
+		CONNECT,
+		SUBSCRIBE,
+		PUBLISH,
+		UNSUBSCRIBE,
+		DISCONNECT
+	};
+
+private:
+	/** Lock guard type for this class. */
+	using guard = std::lock_guard<std::mutex>;
+	/** Unique type for this class. */
+	using unique_lock = std::unique_lock<std::mutex>;
+
+	/** Object monitor mutex. */
+	mutable std::mutex lock_;
+	/** Condition variable signals when the action completes */
+	mutable std::condition_variable cond_;
+
+	/** The type of request that the token is tracking */
+	Type type_;
+	/** The MQTT client that is processing this action */
+	iasync_client* cli_;
+	/** The action success/failure code */
+	int rc_;
+	/** MQTT v5 reason code */
+	ReasonCode reasonCode_;
+	/** Error message from the C lib (if any) */
+	string errMsg_;
+	/** The underlying C token. Note that this is just an integer */
+	MQTTAsync_token msgId_;
+	/** The topic string(s) for the action being tracked by this token */
+	const_string_collection_ptr topics_;
+	/** User supplied context */
+	void* userContext_;
+
+	/**
+	 * User supplied listener.
+	 * Note that the user listener fires after the action is marked
+	 * complete, but before the token is signaled.
+	 */
+	iaction_listener* listener_;
+	/** The number of expected responses */
+	size_t nExpected_;
+	/** Whether the action has yet to complete */
+	bool complete_;
+
+	/** MQTT v5 propeties */
+	//properties props_;
+	/** Connection response (null if not available) */
+	std::unique_ptr<connect_response> connRsp_;
+	/** Subscribe response (null if not available) */
+	std::unique_ptr<subscribe_response> subRsp_;
+	/** Unsubscribe response (null if not available) */
+	std::unique_ptr<unsubscribe_response> unsubRsp_;
+
+	/** Client and token-related options have special access */
+	friend class async_client;
+	friend class token_test;
+
+	friend class connect_options;
+	friend class response_options;
+	friend class delivery_response_options;
+	friend class disconnect_options;
+
+	/**
+	 * Resets the token back to a non-signaled state.
+	 */
+	void reset();
+	/**
+	 * Sets the ID for the message.
+	 * This is a guaranteed atomic operation.
+	 * @param msgId The ID of the message.
+	 */
+	void set_message_id(MQTTAsync_token msgId) {
+		guard g(lock_);
+		msgId_ = msgId;
+	}
+	/**
+	 * C-style callback for success.
+	 * This simply passes the call on to the proper token object for
+	 * processing.
+	 * @param tokObj The token object to process the call. Note that this is
+	 *  			 @em not the user-supplied context pointer. That is
+	 *  			 kept in the object itself.
+	 * @param rsp The success response.
+	 */
+	static void on_success(void* tokObj, MQTTAsync_successData* rsp);
+	static void on_success5(void* tokObj, MQTTAsync_successData5* rsp);
+	/**
+	 * C-style callback for failure.
+	 * This simply passes the call on to the proper token object for
+	 * processing.
+	 * @param tokObj The token object to process the call. Note that this is
+	 *  			 @em not the user-supplied context pointer. That is
+	 *  			 kept in the object itself.
+	 * @param rsp The failure response.
+	 */
+	static void on_failure(void* tokObj, MQTTAsync_failureData* rsp);
+	static void on_failure5(void* tokObj, MQTTAsync_failureData5* rsp);
+	/**
+	 * C-style callback for client (re)connection.
+	 * This is normally only used to process a reconnect completion message.
+	 * The initial connect() is processed via on_success/failure.
+	 * @param tokObj Pointer to the token object used to process the call.
+	 */
+	static void on_connected(void* tokObj, char* /*cause*/);
+	/**
+	 * Internal handler for the success callback.
+	 * @param rsp The success response.
+	 */
+	void on_success(MQTTAsync_successData* rsp);
+	void on_success5(MQTTAsync_successData5* rsp);
+	/**
+	 * Internal handler for the failure callback.
+	 * @param rsp The failure response.
+	 */
+	void on_failure(MQTTAsync_failureData* rsp);
+	void on_failure5(MQTTAsync_failureData5* rsp);
+
+	/**
+	 * Check the current return code and throw an exception if it is not a
+	 * success code.
+	 */
+	void check_ret() const {
+		if (rc_ != MQTTASYNC_SUCCESS || reasonCode_ > ReasonCode::GRANTED_QOS_2)
+			throw exception(rc_, reasonCode_, errMsg_);
+	}
+
+public:
+	/**
+	 * Constructs a token object.
+	 * @param cli The client that created the token.
+	 */
+	token(Type typ, iasync_client& cli)
+		: token(typ, cli, MQTTAsync_token(0)) {}
+	/**
+	 * Constructs a token object.
+	 * @param cli The client that created the token.
+	 * @param userContext optional object used to pass context to the
+	 *  				  callback. Use @em nullptr if not required.
+	 * @param cb callback listener that will be notified when subscribe has
+	 *  		 completed
+	 */
+	token(Type typ, iasync_client& cli, void* userContext, iaction_listener& cb)
+		: token(typ, cli, const_string_collection_ptr(), userContext, cb) {}
+
+	/**
+	 * Constructs a token object.
+	 * @param cli The client that created the token.
+	 * @param topic The topic assiciated with the token
+	 */
+	token(Type typ, iasync_client& cli, const string& topic)
+		: token(typ, cli, string_collection::create(topic)) {}
+	/**
+	 * Constructs a token object.
+	 * @param cli The client that created the token.
+	 * @param topic The topic assiciated with the token
+	 * @param userContext optional object used to pass context to the
+	 *  				  callback. Use @em nullptr if not required.
+	 * @param cb callback listener that will be notified when subscribe has
+	 *  		 completed
+	 */
+	token(Type typ, iasync_client& cli, const string& topic,
+		  void* userContext, iaction_listener& cb)
+		: token(typ, cli, string_collection::create(topic), userContext, cb) {}
+
+	/**
+	 * Constructs a token object.
+	 * @param cli The client that created the token.
+	 * @param topics The topics associated with the token
+	 */
+	token(Type typ, iasync_client& cli, const_string_collection_ptr topics);
+	/**
+	 * Constructs a token object.
+	 * @param cli The client that created the token.
+	 * @param topics The topics associated with the token
+	 * @param userContext optional object used to pass context to the
+	 *  				  callback. Use @em nullptr if not required.
+	 * @param cb callback listener that will be notified when subscribe has
+	 *  		 completed
+	 */
+	token(Type typ, iasync_client& cli, const_string_collection_ptr topics,
+		  void* userContext, iaction_listener& cb);
+	/**
+	 * Constructs a token object.
+	 * @param cli The client that created the token.
+	 * @param tok The message ID
+	 */
+	token(Type typ, iasync_client& cli, MQTTAsync_token tok);
+	/**
+	 * Virtual destructor.
+	 */
+	virtual ~token() {}
+	/**
+	 * Constructs a token object.
+	 * @param cli The client that created the token.
+	 * @return A smart/shared pointer to a token.
+	 */
+	static ptr_t create(Type typ, iasync_client& cli) {
+		return std::make_shared<token>(typ, cli);
+	}
+	/**
+	 * Constructs a token object.
+	 * @param cli The client that created the token.
+	 * @param userContext optional object used to pass context to the
+	 *  				  callback. Use @em nullptr if not required.
+	 * @param cb callback listener that will be notified when subscribe has
+	 *  		 completed
+	 */
+	static ptr_t create(Type typ, iasync_client& cli, void* userContext,
+						iaction_listener& cb) {
+		return std::make_shared<token>(typ, cli, userContext, cb);
+	}
+	/**
+	 * Constructs a token object.
+	 * @param cli The client that created the token.
+	 * @param topic The topic assiciated with the token
+	 */
+	static ptr_t create(Type typ, iasync_client& cli, const string& topic) {
+		return std::make_shared<token>(typ, cli, topic);
+	}
+	/**
+	 * Constructs a token object.
+	 * @param cli The client that created the token.
+	 * @param topic The topic assiciated with the token
+	 * @param userContext optional object used to pass context to the
+	 *  				  callback. Use @em nullptr if not required.
+	 * @param cb callback listener that will be notified when subscribe has
+	 *  		 completed
+	 */
+	static ptr_t create(Type typ, iasync_client& cli, const string& topic,
+						void* userContext, iaction_listener& cb) {
+		return std::make_shared<token>(typ, cli, topic, userContext, cb);
+	}
+	/**
+	 * Constructs a token object.
+	 * @param cli The client that created the token.
+	 * @param topics The topics associated with the token
+	 */
+	static ptr_t create(Type typ, iasync_client& cli, const_string_collection_ptr topics) {
+		return std::make_shared<token>(typ, cli, topics);
+	}
+	/**
+	 * Constructs a token object.
+	 * @param cli The client that created the token.
+	 * @param topics The topics associated with the token
+	 *
+	 * @param userContext optional object used to pass context to the
+	 *  				  callback. Use @em nullptr if not required.
+	 * @param cb callback listener that will be notified when subscribe has
+	 */
+	static ptr_t create(Type typ, iasync_client& cli, const_string_collection_ptr topics,
+						void* userContext, iaction_listener& cb) {
+		return std::make_shared<token>(typ, cli, topics, userContext, cb);
+	}
+	/**
+	 * Gets the type of action the token is tracking, like CONNECT, PUBLISH,
+	 * etc.
+	 * @return The type of action the token is tracking.
+	 */
+	Type get_type() const { return type_; }
+	/**
+	 * Gets the action listener for this token.
+	 * @return The action listener for this token.
+	 */
+	virtual iaction_listener* get_action_callback() const {
+		guard g(lock_);
+		return listener_;
+	}
+	/**
+	 * Returns the MQTT client that is responsible for processing the
+	 * asynchronous action.
+	 * @return The client to which this token is connected.
+	 */
+	virtual iasync_client* get_client() const { return cli_; }
+	/**
+	 * Returns the ID of the message that is associated with the token.
+	 * @return The message ID of the transaction being tracked.
+	 */
+	virtual int get_message_id() const {
+		static_assert(sizeof(msgId_) <= sizeof(int), "MQTTAsync_token must fit into int");
+		return int(msgId_);
+	}
+	/**
+	 * Gets the topic string(s) for the action being tracked by this
+	 * token.
+	 * @return A const pointer to the collection of topics being tracked by
+	 *  	   the token.
+	 */
+	virtual const_string_collection_ptr get_topics() const {
+		return topics_;
+	}
+	/**
+	 * Retrieve the context associated with an action.
+	 * @return The context associated with an action.
+	 */
+	virtual void* get_user_context() const {
+		guard g(lock_);
+		return userContext_;
+	}
+	/**
+	 * Returns whether or not the action has finished.
+	 * @return @em true if the transaction has completed, @em false if not.
+	 */
+	virtual bool is_complete() const { return complete_; }
+	/**
+	 * Gets the return code from the action.
+	 * This is only valid after the action has completed (i.e. if @ref
+	 * is_complete() returns @em true).
+	 * @return The return code from the action.
+	 */
+	virtual int get_return_code() const { return rc_; }
+	/**
+	 * Register a listener to be notified when an action completes.
+	 * @param listener The callback to be notified when actions complete.
+	 */
+	virtual void set_action_callback(iaction_listener& listener) {
+		guard g(lock_);
+		listener_ = &listener;
+	}
+	/**
+	 * Store some context associated with an action.
+	 * @param userContext optional object used to pass context to the
+	 *  				  callback. Use @em nullptr if not required.
+	 */
+	virtual void set_user_context(void* userContext) {
+		guard g(lock_);
+		userContext_ = userContext;
+	}
+	/**
+	 * Sets the number of results expected.
+	 * This is only required for subecribe_many() with < MQTTv5
+	 * @param n The number of results expected.
+	 */
+	void set_num_expected(size_t n) { nExpected_ = n; }
+
+	/**
+	 * Gets the properties for the operation.
+	 * @return A const reference to the properties for the operation
+	 */
+	//const properties& get_properties() const { return props_; }
+	/**
+	 * Gets the reason code for the operation.
+	 * @return The reason code for the operation.
+	 */
+	ReasonCode get_reason_code() const { return reasonCode_; }
+	/**
+	 * Blocks the current thread until the action this token is associated
+	 * with has completed.
+	 */
+	virtual void wait();
+	/**
+	 * Non-blocking check to see if the action has completed.
+	 * @return @em true if the wait finished successfully, @em false if the
+	 *  	   action has not completed yet.
+	 */
+	virtual bool try_wait() {
+		guard g(lock_);
+		if (complete_)
+			check_ret();
+		return complete_;
+	}
+	/**
+	 * Blocks the current thread until the action this token is associated
+	 * with has completed.
+	 * @param timeout The timeout (in milliseconds)
+	 * @return @em true if the wait finished successfully, @em false if a
+	 *  	   timeout occurred.
+	 */
+	virtual bool wait_for(long timeout) {
+		return wait_for(std::chrono::milliseconds(timeout));
+	}
+	/**
+	 * Waits a relative amount of time for the action to complete.
+	 * @param relTime The amount of time to wait for the event.
+	 * @return @em true if the event gets signaled in the specified time,
+	 *  	   @em false on a timeout.
+	 */
+	template <class Rep, class Period>
+	bool wait_for(const std::chrono::duration<Rep, Period>& relTime) {
+		unique_lock g(lock_);
+		if (!cond_.wait_for(g, std::chrono::milliseconds(relTime),
+							[this]{return complete_;}))
+			return false;
+		check_ret();
+		return true;
+	}
+	/**
+	 * Waits until an absolute time for the action to complete.
+	 * @param absTime The absolute time to wait for the event.
+	 * @return @em true if the event gets signaled in the specified time,
+	 *  	   @em false on a timeout.
+	 */
+	template <class Clock, class Duration>
+	bool wait_until( const std::chrono::time_point<Clock, Duration>& absTime) {
+		unique_lock g(lock_);
+		if (!cond_.wait_until(g, absTime, [this]{return complete_;}))
+			return false;
+		check_ret();
+		return true;
+	}
+
+	/**
+	 * Gets the response from a connect operation.
+	 * This returns the result of the completed operation. If the
+	 * operaton is not yet complete this will block until the result
+	 * is available.
+	 * @return The result of the operation.
+	 */
+	connect_response get_connect_response() const;
+	/**
+	 * Gets the response from a connect operation.
+	 * This returns the result of the completed operation. If the
+	 * operaton is not yet complete this will block until the result
+	 * is available.
+	 * @return The result of the operation.
+	 */
+	subscribe_response get_subscribe_response() const;
+	/**
+	 * Gets the response from a connect operation.
+	 * This returns the result of the completed operation. If the
+	 * operaton is not yet complete this will block until the result
+	 * is available.
+	 * @return The result of the operation.
+	 */
+	unsubscribe_response get_unsubscribe_response() const;
+};
+
+/** Smart/shared pointer to a token object */
+using token_ptr = token::ptr_t;
+
+/** Smart/shared pointer to a const token object */
+using const_token_ptr = token::const_ptr_t;
+
+
+/////////////////////////////////////////////////////////////////////////////
+// end namespace mqtt
+}
+
+#endif		// __mqtt_token_h
+
diff --git a/src/mqtt/src/mqtt/topic.h b/src/mqtt/src/mqtt/topic.h
new file mode 100644
index 00000000..618eb85e
--- /dev/null
+++ b/src/mqtt/src/mqtt/topic.h
@@ -0,0 +1,180 @@
+/////////////////////////////////////////////////////////////////////////////
+/// @file topic.h
+/// Declaration of MQTT topic class
+/// @date May 1, 2013
+/// @author Frank Pagliughi
+/////////////////////////////////////////////////////////////////////////////
+
+/*******************************************************************************
+ * Copyright (c) 2013-2016 Frank Pagliughi <fpagliughi@mindspring.com>
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution.
+ *
+ * The Eclipse Public License is available at
+ *    http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at
+ *   http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *    Frank Pagliughi - initial implementation and documentation
+ *******************************************************************************/
+
+#ifndef __mqtt_topic_h
+#define __mqtt_topic_h
+
+#include "MQTTAsync.h"
+#include "mqtt/delivery_token.h"
+#include "mqtt/subscribe_options.h"
+#include "mqtt/message.h"
+#include "mqtt/types.h"
+#include <vector>
+
+namespace mqtt {
+
+class iasync_client;
+
+/////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Represents a topic destination, used for publish/subscribe messaging.
+ */
+class topic
+{
+	/** The client to which this topic is connected */
+	iasync_client& cli_;
+	/** The topic name */
+	string name_;
+	/** The default QoS */
+	int qos_;
+	/** The default retined flag */
+	bool retained_;
+
+public:
+	/** A smart/shared pointer to this class. */
+	using ptr_t = std::shared_ptr<topic>;
+	/** A smart/shared pointer to this class. */
+	using const_ptr_t = std::shared_ptr<const topic>;
+
+	/**
+	 * Construct an MQTT topic destination for messages.
+	 * @param cli Client to which the topic is attached
+	 * @param name The topic string
+	 * @param qos The default QoS for publishing.
+	 * @param retained The default retained flag for the topic.
+	 */
+	topic(iasync_client& cli, const string& name,
+		  int qos=message::DFLT_QOS, bool retained=message::DFLT_RETAINED)
+		: cli_(cli), name_(name), qos_(qos), retained_(retained) {}
+	/**
+	 * Creates a new topic
+	 * @param cli Client to which the topic is attached
+	 * @param name The topic string
+	 * @param qos The default QoS for publishing.
+	 * @param retained The default retained flag for the topic.
+	 * @return A shared pointer to the topic.
+	 */
+	static ptr_t create(iasync_client& cli, const string& name,
+						int qos=message::DFLT_QOS,
+						bool retained=message::DFLT_RETAINED) {
+		return std::make_shared<topic>(cli, name, qos, retained);
+	}
+	/**
+	 * Gets a reference to the MQTT client used by this topic
+	 * @return The MQTT client used by this topic
+	 */
+	iasync_client& get_client() { return cli_; }
+	/**
+	 * Gets the name of the topic.
+	 * @return The name of the topic.
+	 */
+	const string& get_name() const { return name_; }
+	/**
+	 * Gets the default quality of service for this topic.
+	 * @return The default quality of service for this topic.
+	 */
+	int get_qos() const { return qos_; }
+	/**
+	 * Gets the default retained flag used for this topic.
+	 * @return The default retained flag used for this topic.
+	 */
+	bool get_retained() const { return retained_; }
+	/**
+	 * Sets the default quality of service for this topic.
+	 * @param qos The default quality of service for this topic.
+	 */
+	void set_qos(int qos) { 
+		message::validate_qos(qos);
+		qos_ = qos; 
+	}
+	/**
+	 * Sets the default retained flag used for this topic.
+	 * @param retained The default retained flag used for this topic.
+	 */
+	void set_retained(bool retained) { retained_ = retained; }
+	/**
+	 * Publishes a message on the topic using the default QoS and retained
+	 * flag.
+	 * @param payload the bytes to use as the message payload
+	 * @param n the number of bytes in the payload
+	 * @return The delivery token used to track and wait for the publish to
+	 *  	   complete.
+	 */
+	delivery_token_ptr publish(const void* payload, size_t n);
+	/**
+	 * Publishes a message on the topic.
+	 * @param payload the bytes to use as the message payload
+	 * @param n the number of bytes in the payload
+	 * @param qos the Quality of Service to deliver the message at. Valid
+	 *  		  values are 0, 1 or 2.
+	 * @param retained whether or not this message should be retained by the
+	 *  			   server.
+	 * @return The delivery token used to track and wait for the publish to
+	 *  	   complete.
+	 */
+	delivery_token_ptr publish(const void* payload, size_t n,
+							   int qos, bool retained);
+	/**
+	 * Publishes a message on the topic using the default QoS and retained
+	 * flag.
+	 * @param payload the bytes to use as the message payload
+	 * @return The delivery token used to track and wait for the publish to
+	 *  	   complete.
+	 */
+	delivery_token_ptr publish(binary_ref payload);
+	/**
+	 * Publishes a message on the topic.
+	 * @param payload the bytes to use as the message payload
+	 * @param qos the Quality of Service to deliver the message at. Valid
+	 *  		  values are 0, 1 or 2.
+	 * @param retained whether or not this message should be retained by the
+	 *  			   server.
+	 * @return The delivery token used to track and wait for the publish to
+	 *  	   complete.
+	 */
+	delivery_token_ptr publish(binary_ref payload, int qos, bool retained);
+	/**
+	 * Subscribe to the topic.
+	 * @return A token used to track the progress of the operation.
+	 */
+	token_ptr subscribe(const subscribe_options& opts=subscribe_options());
+	/**
+	 * Returns a string representation of this topic.
+	 * @return The name of the topic
+	 */
+	string to_string() const { return name_; }
+};
+
+/** A smart/shared pointer to a topic object. */
+using topic_ptr = topic::ptr_t ;
+
+/** A smart/shared pointer to a const topic object. */
+using const_topic_ptr = topic::const_ptr_t ;
+
+/////////////////////////////////////////////////////////////////////////////
+// end namespace mqtt
+}
+
+#endif		// __mqtt_topic_h
+
diff --git a/src/mqtt/src/mqtt/types.h b/src/mqtt/src/mqtt/types.h
new file mode 100644
index 00000000..9c212343
--- /dev/null
+++ b/src/mqtt/src/mqtt/types.h
@@ -0,0 +1,184 @@
+/////////////////////////////////////////////////////////////////////////////
+/// @file types.h
+/// Basic types and type conversions for the Paho MQTT C++ library.
+/// @date May 17, 2015 @author Frank Pagliughi
+/////////////////////////////////////////////////////////////////////////////
+
+/*******************************************************************************
+ * Copyright (c) 2015-2017 Frank Pagliughi <fpagliughi@mindspring.com>
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution.
+ *
+ * The Eclipse Public License is available at
+ *    http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at
+ *   http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *    Frank Pagliughi - initial implementation and documentation
+ *******************************************************************************/
+
+#ifndef __mqtt_types_h
+#define __mqtt_types_h
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <chrono>
+
+namespace mqtt {
+
+/////////////////////////////////////////////////////////////////////////////
+// Basic data types
+
+/** A 'byte' is an 8-bit, unsigned int */
+using byte = uint8_t;
+
+/** An mqtt string is just a std::string */
+using string = std::string;
+/** A binary blob of data is, umm, just a string too! */
+using binary = std::string;		//std::basic_string<byte>;
+
+/** Smart/shared pointer to a const string */
+using string_ptr = std::shared_ptr<const string>;
+/** Smart/shared pointer to a const binary blob */
+using binary_ptr = std::shared_ptr<const binary>;
+
+/////////////////////////////////////////////////////////////////////////////
+// General protocol enumerations
+
+/**
+ * The MQTT v5 Reason Codes.
+ *
+ * These map to the Paho C MQTTReasonCodes
+ */
+enum ReasonCode {
+    SUCCESS = 0,
+    NORMAL_DISCONNECTION = 0,
+    GRANTED_QOS_0 = 0,
+    GRANTED_QOS_1 = 1,
+    GRANTED_QOS_2 = 2,
+    DISCONNECT_WITH_WILL_MESSAGE = 4,
+    NO_MATCHING_SUBSCRIBERS = 16,
+    NO_SUBSCRIPTION_FOUND = 17,
+    CONTINUE_AUTHENTICATION = 24,
+    RE_AUTHENTICATE = 25,
+    UNSPECIFIED_ERROR = 128,
+    MALFORMED_PACKET = 129,
+    PROTOCOL_ERROR = 130,
+    IMPLEMENTATION_SPECIFIC_ERROR = 131,
+    UNSUPPORTED_PROTOCOL_VERSION = 132,
+    CLIENT_IDENTIFIER_NOT_VALID = 133,
+    BAD_USER_NAME_OR_PASSWORD = 134,
+    NOT_AUTHORIZED = 135,
+    SERVER_UNAVAILABLE = 136,
+    SERVER_BUSY = 137,
+    BANNED = 138,
+    SERVER_SHUTTING_DOWN = 139,
+    BAD_AUTHENTICATION_METHOD = 140,
+    KEEP_ALIVE_TIMEOUT = 141,
+    SESSION_TAKEN_OVER = 142,
+    TOPIC_FILTER_INVALID = 143,
+    TOPIC_NAME_INVALID = 144,
+    PACKET_IDENTIFIER_IN_USE = 145,
+    PACKET_IDENTIFIER_NOT_FOUND = 146,
+    RECEIVE_MAXIMUM_EXCEEDED = 147,
+    TOPIC_ALIAS_INVALID = 148,
+    PACKET_TOO_LARGE = 149,
+    MESSAGE_RATE_TOO_HIGH = 150,
+    QUOTA_EXCEEDED = 151,
+    ADMINISTRATIVE_ACTION = 152,
+    PAYLOAD_FORMAT_INVALID = 153,
+    RETAIN_NOT_SUPPORTED = 154,
+    QOS_NOT_SUPPORTED = 155,
+    USE_ANOTHER_SERVER = 156,
+    SERVER_MOVED = 157,
+    SHARED_SUBSCRIPTIONS_NOT_SUPPORTED = 158,
+    CONNECTION_RATE_EXCEEDED = 159,
+    MAXIMUM_CONNECT_TIME = 160,
+    SUBSCRIPTION_IDENTIFIERS_NOT_SUPPORTED = 161,
+    WILDCARD_SUBSCRIPTIONS_NOT_SUPPORTED = 162,
+	MQTTPP_V3_CODE = 255	// This is not a protocol code; used internally by the library
+};
+
+/////////////////////////////////////////////////////////////////////////////
+// Time functions
+
+/**
+ * Convert a chrono duration to seconds.
+ * This casts away precision to get integer seconds.
+ * @param dur A chrono duration type
+ * @return The duration as a chrono seconds value
+ */
+template <class Rep, class Period>
+std::chrono::seconds to_seconds(const std::chrono::duration<Rep, Period>& dur) {
+	return std::chrono::duration_cast<std::chrono::seconds>(dur);
+}
+
+/**
+ * Convert a chrono duration to a number of seconds.
+ * This casts away precision to get integer seconds.
+ * @param dur A chrono duration type
+ * @return The duration as a number of seconds
+ */
+template <class Rep, class Period>
+long to_seconds_count(const std::chrono::duration<Rep, Period>& dur) {
+	return (long) to_seconds(dur).count();
+}
+
+/**
+ * Convert a chrono duration to milliseconds.
+ * This casts away precision to get integer milliseconds.
+ * @param dur A chrono duration type
+ * @return The duration as a chrono milliseconds value
+ */
+template <class Rep, class Period>
+std::chrono::milliseconds to_milliseconds(const std::chrono::duration<Rep, Period>& dur) {
+	return std::chrono::duration_cast<std::chrono::milliseconds>(dur);
+}
+
+/**
+ * Convert a chrono duration to a number of milliseconds.
+ * This casts away precision to get integer milliseconds.
+ * @param dur A chrono duration type
+ * @return The duration as a number of milliseconds
+ */
+template <class Rep, class Period>
+long to_milliseconds_count(const std::chrono::duration<Rep, Period>& dur) {
+	return (long) to_milliseconds(dur).count();
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Misc
+
+/**
+ * Converts an into to a bool.
+ * @param n An integer.
+ * @return @em true if n not equal to zero, @em false otherwise
+ */
+inline bool to_bool(int n) { return n != 0; }
+/**
+ * Converts the boolean into a C integer true/false value.
+ * @param b A boolean
+ * @return Zero if b is false, non-zero if b is true.
+ */
+inline int to_int(bool b) { return b ? (!0) : 0; }
+
+/**
+ * Gets a valid string for the char pointer.
+ * @param cstr A C-string pointer
+ * @return A string copy of the C array. If `cstr` is NULL, this returns an
+ *  	   empty string.
+ */
+inline string to_string(const char* cstr) {
+	return cstr ? string(cstr) : string();
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// end namespace mqtt
+}
+
+#endif		// __mqtt_types_h
+
diff --git a/src/mqtt/src/mqtt/will_options.h b/src/mqtt/src/mqtt/will_options.h
new file mode 100644
index 00000000..a685a966
--- /dev/null
+++ b/src/mqtt/src/mqtt/will_options.h
@@ -0,0 +1,258 @@
+/////////////////////////////////////////////////////////////////////////////
+/// @file will_options.h
+/// Declaration of MQTT will_options class
+/// @date Jul 7, 2016
+/// @author Guilherme M. Ferreira
+/////////////////////////////////////////////////////////////////////////////
+
+/*******************************************************************************
+ * Copyright (c) 2016 Guilherme M. Ferreira <guilherme.maciel.ferreira@gmail.com>
+ * Copyright (c) 2016-2019 Frank Pagliughi <fpagliughi@mindspring.com>
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution.
+ *
+ * The Eclipse Public License is available at
+ *    http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at
+ *   http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *    Guilherme M. Ferreira - initial implementation and documentation
+ *    Frank Pagliughi - added copy & move operations
+ *******************************************************************************/
+
+#ifndef __mqtt_will_options_h
+#define __mqtt_will_options_h
+
+#include "MQTTAsync.h"
+#include "mqtt/types.h"
+#include "mqtt/message.h"
+#include "mqtt/topic.h"
+
+namespace mqtt {
+
+class connect_options;
+
+/////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Holds the set of options that govern the Last Will and Testament feature.
+ *
+ * @note
+ * This wraps struct v1 of the C library's MQTTAsync_willOptions structure.
+ * It sets the LWT binary payload, via the 'payload' struct field, and
+   leaves the 'message' field as a nullptr.
+ */
+class will_options
+{
+	/** The default QoS for the LWT, if unspecified */
+	static constexpr int DFLT_QOS = 0;
+	/** The defalut retained flag for LWT, if unspecified */
+	static constexpr bool DFLT_RETAINED = false;
+	/** A default C struct to support re-initializing variables */
+	static const MQTTAsync_willOptions DFLT_C_STRUCT;
+
+	/** The underlying C LWT options */
+	MQTTAsync_willOptions opts_;
+
+	/** LWT message topic **/
+	string_ref topic_;
+
+	/** LWT message text */
+	binary_ref payload_;
+
+	/**
+	 * The properties for the LWT message.
+	 * Strangely, in the C lib, the will properties are not in the
+	 * willOptions struct, but are rather in the connectOptions.
+	 */
+	properties props_;
+
+	/** The connect options has special access */
+	friend class connect_options;
+	friend class connect_options_test;
+	friend class will_options_test;
+
+	/**
+	 * Gets a pointer to the C-language NUL-terminated strings for the
+	 * struct.
+	 * Some structs, such as this one, require valid pointers at all times,
+	 * while others expect NULL pointers for missing parameters.
+	 * So we always return a pointer to a valid C char array, even when
+	 * empty.
+	 * @param str The C++ string object.
+	 * @return Pointer to a NUL terminated string. This is only valid until
+	 *  	   the next time the string is updated. This is never nullptr.
+	 */
+	const char* c_str(const string_ref& sr) {
+		return sr ? sr.to_string().c_str() : nullptr;
+	}
+
+public:
+	/** Smart/shared pointer to this class. */
+	using ptr_t = std::shared_ptr<will_options>;
+	/** Smart/shared pointer to a const object of this class. */
+	using const_ptr_t = std::shared_ptr<const will_options>;
+
+	/**
+	 * Constructs a new object using the default values.
+	 */
+	will_options();
+	/**
+	 * Sets the "Last Will and Testament" (LWT) for the connection.
+	 * @param top The LWT message is published to the this topic.
+	 * @param payload The message that is published to the Will Topic.
+	 * @param payload_len The message size in bytes
+	 * @param qos The message Quality of Service.
+	 * @param retained Tell the broker to keep the LWT message after send to
+	 *  			   subscribers.
+	 */
+	will_options(string_ref top, const void *payload, size_t payload_len,
+				 int qos=DFLT_QOS, bool retained=DFLT_RETAINED);
+	/**
+	 * Sets the "Last Will and Testament" (LWT) for the connection.
+	 * @param top The LWT message is published to the this topic.
+	 * @param payload The message that is published to the Will Topic.
+	 * @param payload_len The message size in bytes.
+	 * @param qos The message Quality of Service.
+	 * @param retained Tell the broker to keep the LWT message after send to
+	 *  			   subscribers.
+	 */
+	will_options(const topic& top, const void *payload, size_t payload_len,
+				 int qos=DFLT_QOS, bool retained=DFLT_RETAINED);
+	/**
+	 * Sets the "Last Will and Testament" (LWT) for the connection.
+	 * @param top The LWT message is published to the this topic.
+	 * @param payload The message payload that is published to the Will
+	 *  			  Topic.
+	 * @param qos The message Quality of Service.
+	 * @param retained Tell the broker to keep the LWT message after send to
+	 *  			   subscribers.
+	 */
+	will_options(string_ref top, binary_ref payload,
+				 int qos=DFLT_QOS, bool retained=DFLT_RETAINED);
+	/**
+	 * Sets the "Last Will and Testament" (LWT) for the connection.
+	 * @param top The LWT message is published to the this topic.
+	 * @param payload The message payload that is published to the Will
+	 *  			  Topic, as a string.
+	 * @param qos The message Quality of Service.
+	 * @param retained Tell the broker to keep the LWT message after send to
+	 *  			   subscribers.
+	 */
+	will_options(string_ref top, const string& payload,
+				 int qos=DFLT_QOS, bool retained=DFLT_QOS);
+	/**
+	 * Sets the "Last Will and Testament" (LWT) for the connection.
+	 * @param msg The message that is published to the Will Topic.
+	 */
+	will_options(const message& msg);
+	/**
+	 * Copy constructor for the LWT options.
+	 * @param opt The other options.
+	 */
+	will_options(const will_options& opt);
+	/**
+	 * Move constructor for the LWT options.
+	 * @param opt The other options.
+	 */
+	will_options(will_options&& opt);
+	/**
+	 * Copy assignment for the LWT options.
+	 * @param opt The other options.
+	 */
+	will_options& operator=(const will_options& opt);
+	/**
+	 * Move assignment for the LWT options.
+	 * @param opt The other options.
+	 */
+	will_options& operator=(will_options&& opt);
+	/**
+	 * Gets the LWT message topic name.
+	 * @return The LWT message topic name.
+	 */
+	string get_topic() const { return topic_ ? topic_.to_string() : string(); }
+	/**
+	 * Gets the LWT message payload.
+	 * @return The LWT message payload.
+	 */
+	const binary_ref& get_payload() const { return payload_; }
+	/**
+	 * Gets the LWT message payload as a string.
+	 * @return The LWT message payload as a string.
+	 */
+	string get_payload_str() const { return payload_ ? payload_.to_string() : string(); }
+	/**
+	 * Gets the QoS value for the LWT message.
+	 * @return The QoS value for the LWT message.
+	 */
+	int get_qos() const { return opts_.qos; }
+	/**
+	 * Gets the 'retained' flag for the LWT message.
+	 * @return The 'retained' flag for the LWT message.
+	 */
+	bool is_retained() const { return opts_.retained != 0; }
+	/**
+	 * Gets the LWT message as a message object.
+	 * @return A pointer to a copy of the LWT message.
+	 */
+	const_message_ptr get_message() const {
+		return message::create(topic_, payload_, opts_.qos, to_bool(opts_.retained));
+	}
+	/**
+	 * Sets the LWT message topic name.
+	 * @param top The topic where to sent the message
+	 */
+	void set_topic(string_ref top);
+	/**
+	 * Sets the LWT message text.
+	 * @param msg The LWT message
+	 */
+	void set_payload(binary_ref msg);
+	/**
+	 * Sets the LWT message text.
+	 * @param msg The LWT message
+	 */
+	void set_payload(string msg) { set_payload(binary_ref(std::move(msg))); }
+	/**
+	 * Sets the QoS value.
+	 * @param qos The LWT message QoS
+	 */
+	void set_qos(const int qos) { opts_.qos = qos; }
+	/**
+	 * Sets the retained flag.
+	 * @param retained Tell the broker to keep the LWT message after send to
+	 *  			   subscribers.
+	 */
+	void set_retained(bool retained) { opts_.retained = to_int(retained); }
+	/**
+	 * Gets the connect properties.
+	 * @return A const reference to the properties for the connect.
+	 */
+	const properties& get_properties() const { return props_; }
+	/**
+	 * Sets the properties for the connect.
+	 * @param props The properties to place into the message.
+	 */
+	void set_properties(const properties& props) { props_ = props; }
+	/**
+	 * Moves the properties for the connect.
+	 * @param props The properties to move into the connect object.
+	 */
+	void set_properties(properties&& props) { props_ = props; }
+};
+
+/** Shared pointer to a will options object. */
+using will_options_ptr = will_options::ptr_t;
+
+/** Shared pointer to a const will options object. */
+using const_will_options_ptr = will_options::const_ptr_t;
+
+/////////////////////////////////////////////////////////////////////////////
+// end namespace mqtt
+}
+
+#endif		// __mqtt_will_options_h
+
diff --git a/src/mqtt/src/properties.cpp b/src/mqtt/src/properties.cpp
new file mode 100644
index 00000000..33d2adb7
--- /dev/null
+++ b/src/mqtt/src/properties.cpp
@@ -0,0 +1,183 @@
+// properties.cpp
+
+/*******************************************************************************
+ * Copyright (c) 2019 Frank Pagliughi <fpagliughi@mindspring.com>
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution.
+ *
+ * The Eclipse Public License is available at
+ *    http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at
+ *   http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *    Frank Pagliughi - initial implementation and documentation
+ *******************************************************************************/
+
+#include "mqtt/properties.h"
+
+namespace mqtt {
+
+/////////////////////////////////////////////////////////////////////////////
+
+property::property(code c, int32_t val)
+{
+	prop_.identifier = ::MQTTPropertyCodes(c);
+
+	switch (::MQTTProperty_getType(prop_.identifier)) {
+		case MQTTPROPERTY_TYPE_BYTE:
+			prop_.value.byte = uint8_t(val);
+			break;
+		case MQTTPROPERTY_TYPE_TWO_BYTE_INTEGER:
+			prop_.value.integer2 = int16_t(val);
+			break;
+		case MQTTPROPERTY_TYPE_FOUR_BYTE_INTEGER:
+		case MQTTPROPERTY_TYPE_VARIABLE_BYTE_INTEGER:
+			prop_.value.integer4 = val;
+			break;
+		default:
+			// TODO: Throw an exception
+			break;
+	}
+}
+
+property::property(code c, string_ref val)
+{
+	prop_.identifier = ::MQTTPropertyCodes(c);
+
+	size_t n = val.size();
+	prop_.value.data.len = int(n);
+	prop_.value.data.data = (char*) malloc(n);
+	std::memcpy(prop_.value.data.data, val.data(), n);
+}
+
+property::property(code c, string_ref name, string_ref val)
+{
+	prop_.identifier = MQTTPropertyCodes(c);
+
+	size_t n = name.size();
+	prop_.value.data.len = int(n);
+	prop_.value.data.data = (char*) malloc(n);
+	std::memcpy(prop_.value.data.data, name.data(), n);
+
+	n = val.size();
+	prop_.value.value.len = int(n);
+	prop_.value.value.data = (char*) malloc(n);
+	std::memcpy(prop_.value.value.data, val.data(), n);
+}
+
+property::property(const MQTTProperty& cprop)
+{
+	copy(cprop);
+}
+
+property::property(MQTTProperty&& cprop)
+	:prop_(cprop)
+{
+	memset(&cprop, 0, sizeof(MQTTProperty));
+}
+
+
+property::property(const property& other)
+{
+	copy(other.prop_);
+}
+
+property::property(property&& other)
+{
+	std::memcpy(&prop_, &other.prop_, sizeof(MQTTProperty));
+	memset(&other.prop_, 0, sizeof(MQTTProperty));
+}
+
+property::~property()
+{
+	switch (::MQTTProperty_getType(prop_.identifier)) {
+		case MQTTPROPERTY_TYPE_UTF_8_STRING_PAIR:
+			free(prop_.value.value.data);
+			// Fall-through
+
+		case MQTTPROPERTY_TYPE_BINARY_DATA:
+		case MQTTPROPERTY_TYPE_UTF_8_ENCODED_STRING:
+			free(prop_.value.data.data);
+			break;
+
+		default:
+			// Nothing necessary
+			break;
+	}
+}
+
+void property::copy(const MQTTProperty& cprop)
+{
+	size_t n;
+
+	std::memcpy(&prop_, &cprop, sizeof(MQTTProperty));
+
+	switch (::MQTTProperty_getType(prop_.identifier)) {
+		case MQTTPROPERTY_TYPE_UTF_8_STRING_PAIR:
+			n = prop_.value.value.len;
+			prop_.value.value.data = (char*) malloc(n);
+			memcpy(prop_.value.value.data, cprop.value.value.data, n);
+			// Fall-through
+
+		case MQTTPROPERTY_TYPE_BINARY_DATA:
+		case MQTTPROPERTY_TYPE_UTF_8_ENCODED_STRING:
+			n = prop_.value.data.len;
+			prop_.value.data.data = (char*) malloc(n);
+			memcpy(prop_.value.data.data, cprop.value.data.data, n);
+			break;
+
+		default:
+			// Nothing necessary
+			break;
+	}
+}
+
+property& property::operator=(const property& rhs)
+{
+	if (&rhs != this)
+		copy(rhs.prop_);
+
+	return *this;
+}
+
+property& property::operator=(property&& rhs)
+{
+	if (&rhs != this) {
+		std::memcpy(&prop_, &rhs.prop_, sizeof(MQTTProperty));
+		memset(&rhs.prop_, 0, sizeof(MQTTProperty));
+	}
+	return *this;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+
+properties::properties(std::initializer_list<property> props)
+{
+	std::memset(&props_, 0, sizeof(properties));
+	for (const auto& prop : props)
+		::MQTTProperties_add(&props_, &prop.c_struct());
+}
+
+void properties::clear()
+{
+	::MQTTProperties_free(&props_);
+	memset(&props_, 0, sizeof(MQTTProperties));
+}
+
+property properties::get(property::code propid, size_t idx /*=0*/)
+{
+	MQTTProperty* prop = MQTTProperties_getPropertyAt(&props_,
+									MQTTPropertyCodes(propid), int(idx));
+	if (!prop)
+		throw bad_cast();
+
+	return property(*prop);
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// end namespace 'mqtt'
+}
+
diff --git a/src/mqtt/src/response_options.cpp b/src/mqtt/src/response_options.cpp
new file mode 100644
index 00000000..443de927
--- /dev/null
+++ b/src/mqtt/src/response_options.cpp
@@ -0,0 +1,91 @@
+// response_options.cpp
+
+/*******************************************************************************
+ * Copyright (c) 2019 Frank Pagliughi <fpagliughi@mindspring.com>
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution.
+ *
+ * The Eclipse Public License is available at
+ *    http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at
+ *   http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *    Frank Pagliughi - initial implementation and documentation
+ *******************************************************************************/
+
+#include "mqtt/response_options.h"
+
+namespace mqtt {
+
+/////////////////////////////////////////////////////////////////////////////
+
+response_options::response_options(int mqttVersion /*=MQTTVERSION_DEFAULT*/)
+		: opts_(MQTTAsync_responseOptions_initializer)
+{
+	if (mqttVersion < MQTTVERSION_5) {
+		opts_.onSuccess  = &token::on_success;
+		opts_.onFailure  = &token::on_failure;
+	}
+	else {
+		opts_.onSuccess5 = &token::on_success5;
+		opts_.onFailure5 = &token::on_failure5;
+	}
+}
+
+response_options::response_options(const token_ptr& tok,
+								   int mqttVersion /*=MQTTVERSION_DEFAULT*/)
+		: response_options(mqttVersion)
+{
+	set_token(tok);
+}
+
+void response_options::set_token(const token_ptr& tok)
+{
+	tok_ = tok;
+	opts_.context = tok.get();
+}
+
+void response_options::set_subscribe_options(const subscribe_options& opts)
+{
+	opts_.subscribeOptions = opts.opts_;
+}
+
+void response_options::set_subscribe_options(const std::vector<subscribe_options>& opts)
+{
+	subOpts_.clear();
+	for (const auto& opt : opts)
+		subOpts_.push_back(opt.opts_);
+
+	opts_.subscribeOptionsCount = int(opts.size());
+	opts_.subscribeOptionsList = const_cast<MQTTSubscribe_options*>(subOpts_.data());
+}
+
+/////////////////////////////////////////////////////////////////////////////
+
+delivery_response_options::delivery_response_options(int mqttVersion /*=MQTTVERSION_DEFAULT*/)
+		: opts_(MQTTAsync_responseOptions_initializer)
+{
+	if (mqttVersion < MQTTVERSION_5) {
+		opts_.onSuccess  = &delivery_token::on_success;
+		opts_.onFailure  = &delivery_token::on_failure;
+	}
+	else {
+		opts_.onSuccess5 = &delivery_token::on_success5;
+		opts_.onFailure5 = &delivery_token::on_failure5;
+	}
+}
+
+delivery_response_options::delivery_response_options(const delivery_token_ptr& tok,
+													 int mqttVersion /*=MQTTVERSION_DEFAULT*/)
+		: delivery_response_options(mqttVersion)
+{
+	set_token(tok);
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// end namespace 'mqtt'
+}
+
diff --git a/src/mqtt/src/ssl_options.cpp b/src/mqtt/src/ssl_options.cpp
new file mode 100644
index 00000000..aaaff781
--- /dev/null
+++ b/src/mqtt/src/ssl_options.cpp
@@ -0,0 +1,146 @@
+/*******************************************************************************
+ * Copyright (c) 2016 Guilherme Ferreira <guilherme.maciel.ferreira@gmail.com>
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution.
+ *
+ * The Eclipse Public License is available at
+ *    http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at
+ *   http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *    Guilherme Ferreira - initial implementation and documentation
+ *    Frank Pagliughi - added copy & move operations
+ *******************************************************************************/
+
+#include "mqtt/ssl_options.h"
+#include <utility>
+#include <cstring>
+
+namespace mqtt {
+
+/////////////////////////////////////////////////////////////////////////////
+
+const MQTTAsync_SSLOptions ssl_options::DFLT_C_STRUCT = MQTTAsync_SSLOptions_initializer;
+
+ssl_options::ssl_options() : opts_(DFLT_C_STRUCT)
+{
+}
+
+ssl_options::ssl_options(const string& trustStore, const string& keyStore,
+						 const string& privateKey, const string& privateKeyPassword,
+						 const string& enabledCipherSuites, bool enableServerCertAuth)
+			: opts_(DFLT_C_STRUCT), trustStore_(trustStore), keyStore_(keyStore),
+				privateKey_(privateKey), privateKeyPassword_(privateKeyPassword),
+				enabledCipherSuites_(enabledCipherSuites)
+{
+	update_c_struct();
+	opts_.enableServerCertAuth = enableServerCertAuth;
+}
+
+ssl_options::ssl_options(const ssl_options& opt)
+		: opts_(opt.opts_), trustStore_(opt.trustStore_), keyStore_(opt.keyStore_),
+			privateKey_(opt.privateKey_), privateKeyPassword_(opt.privateKeyPassword_),
+			enabledCipherSuites_(opt.enabledCipherSuites_)
+{
+	update_c_struct();
+}
+
+ssl_options::ssl_options(ssl_options&& opt)
+		: opts_(opt.opts_), trustStore_(std::move(opt.trustStore_)),
+			keyStore_(std::move(opt.keyStore_)), privateKey_(std::move(opt.privateKey_)),
+			privateKeyPassword_(std::move(opt.privateKeyPassword_)),
+			enabledCipherSuites_(std::move(opt.enabledCipherSuites_))
+{
+	update_c_struct();
+}
+
+void ssl_options::update_c_struct()
+{
+	opts_.trustStore = c_str(trustStore_);
+	opts_.keyStore = c_str(keyStore_);
+	opts_.privateKey = c_str(privateKey_);
+	opts_.privateKeyPassword = c_str(privateKeyPassword_);
+	opts_.enabledCipherSuites = c_str(enabledCipherSuites_);
+}
+
+ssl_options& ssl_options::operator=(const ssl_options& rhs)
+{
+	if (&rhs == this)
+		return *this;
+
+	opts_ = rhs.opts_;
+
+	trustStore_ = rhs.trustStore_;
+	keyStore_ = rhs.keyStore_;
+	privateKey_ = rhs.privateKey_;
+	privateKeyPassword_ = rhs.privateKeyPassword_;
+	enabledCipherSuites_ = rhs.enabledCipherSuites_;
+
+	update_c_struct();
+	return *this;
+}
+
+ssl_options& ssl_options::operator=(ssl_options&& rhs)
+{
+	if (&rhs == this)
+		return *this;
+
+	opts_ = rhs.opts_;
+
+	trustStore_ = std::move(rhs.trustStore_);
+	keyStore_ = std::move(rhs.keyStore_);
+	privateKey_ = std::move(rhs.privateKey_);
+	privateKeyPassword_ = std::move(rhs.privateKeyPassword_);
+	enabledCipherSuites_ = std::move(rhs.enabledCipherSuites_);
+
+	update_c_struct();
+	return *this;
+}
+
+void ssl_options::set_trust_store(const string& trustStore)
+{
+	trustStore_ = trustStore;
+	opts_.trustStore = c_str(trustStore_);
+}
+
+void ssl_options::set_key_store(const string& keyStore)
+{
+	keyStore_ = keyStore;
+	opts_.keyStore = c_str(keyStore_);
+}
+
+void ssl_options::set_private_key(const string& privateKey)
+{
+	privateKey_ = privateKey;
+	opts_.privateKey = c_str(privateKey_);
+}
+
+void ssl_options::set_private_key_password(const string& privateKeyPassword)
+{
+	privateKeyPassword_ = privateKeyPassword;
+	opts_.privateKeyPassword = c_str(privateKeyPassword_);
+}
+
+void ssl_options::set_enabled_cipher_suites(const string& enabledCipherSuites)
+{
+	enabledCipherSuites_ = enabledCipherSuites;
+	opts_.enabledCipherSuites = c_str(enabledCipherSuites_);
+}
+
+void ssl_options::set_enable_server_cert_auth(bool enableServerCertAuth)
+{
+	opts_.enableServerCertAuth = to_int(enableServerCertAuth);
+}
+
+void ssl_options::ca_path(const string& path)
+{
+	caPath_ = path;
+	opts_.CApath = c_str(caPath_);
+}
+
+/////////////////////////////////////////////////////////////////////////////
+} // end namespace mqtt
+
diff --git a/src/mqtt/src/string_collection.cpp b/src/mqtt/src/string_collection.cpp
new file mode 100644
index 00000000..f9c9a9ec
--- /dev/null
+++ b/src/mqtt/src/string_collection.cpp
@@ -0,0 +1,103 @@
+// string_collection.cpp
+
+/*******************************************************************************
+ * Copyright (c) 2017 Frank Pagliughi <fpagliughi@mindspring.com>
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution.
+ *
+ * The Eclipse Public License is available at
+ *    http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at
+ *   http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *    Frank Pagliughi - initial implementation and documentation
+ *******************************************************************************/
+
+
+#include "mqtt/string_collection.h"
+
+namespace mqtt {
+
+/////////////////////////////////////////////////////////////////////////////
+
+string_collection::string_collection(const string& str) : coll_{ str }
+{
+	update_c_arr();
+}
+
+string_collection::string_collection(string&& str) : coll_{ std::move(str) }
+{
+	update_c_arr();
+}
+
+string_collection::string_collection(const collection_type& vec) : coll_{ vec }
+{
+	update_c_arr();
+}
+
+string_collection::string_collection(collection_type&& vec) : coll_{ std::move(vec) }
+{
+	update_c_arr();
+}
+
+string_collection::string_collection(const string_collection& coll) : coll_ { coll.coll_ }
+{
+	update_c_arr();
+}
+
+string_collection::string_collection(std::initializer_list<string> sl)
+{
+	for (const auto& s : sl)
+		coll_.push_back(s);
+	update_c_arr();
+}
+
+string_collection::string_collection(std::initializer_list<const char*> sl)
+{
+	for (const auto& s : sl)
+		coll_.push_back(string(s));
+	update_c_arr();
+}
+
+void string_collection::update_c_arr()
+{
+	cArr_.clear();
+	cArr_.reserve(coll_.size());
+	for (const auto& s : coll_)
+		cArr_.push_back(s.c_str());
+}
+
+string_collection& string_collection::operator=(const string_collection& coll)
+{
+	coll_ = coll.coll_;
+	update_c_arr();
+	return *this;
+}
+
+void string_collection::push_back(const string& str)
+{
+	coll_.push_back(str);
+	update_c_arr();
+}
+
+void string_collection::push_back(string&& str)
+{
+	coll_.push_back(str);
+	update_c_arr();
+}
+
+void string_collection::clear()
+{
+	coll_.clear();
+	cArr_.clear();
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// end namespace mqtt
+}
+
+
+
diff --git a/src/mqtt/src/subscribe_options.cpp b/src/mqtt/src/subscribe_options.cpp
new file mode 100644
index 00000000..efa01f81
--- /dev/null
+++ b/src/mqtt/src/subscribe_options.cpp
@@ -0,0 +1,36 @@
+// subscribe_options.cpp
+
+/*******************************************************************************
+ * Copyright (c) 2019 Frank Pagliughi <fpagliughi@mindspring.com>
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution.
+ *
+ * The Eclipse Public License is available at
+ *    http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at
+ *   http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *    Frank Pagliughi - initial implementation and documentation
+ *******************************************************************************/
+
+#include "mqtt/subscribe_options.h"
+
+namespace mqtt {
+
+/////////////////////////////////////////////////////////////////////////////
+
+#if __cplusplus < 201703L
+	constexpr bool subscribe_options::SUBSCRIBE_NO_LOCAL;
+	constexpr bool subscribe_options::SUBSCRIBE_LOCAL;
+
+	constexpr bool subscribe_options::NO_RETAIN_AS_PUBLISHED;
+	constexpr bool subscribe_options::RETAIN_AS_PUBLISHED;
+#endif
+
+/////////////////////////////////////////////////////////////////////////////
+// end namespace 'mqtt'
+}
+
diff --git a/src/mqtt/src/token.cpp b/src/mqtt/src/token.cpp
new file mode 100644
index 00000000..3853cf2a
--- /dev/null
+++ b/src/mqtt/src/token.cpp
@@ -0,0 +1,297 @@
+// token.cpp
+
+/*******************************************************************************
+ * Copyright (c) 2013-2019 Frank Pagliughi <fpagliughi@mindspring.com>
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution.
+ *
+ * The Eclipse Public License is available at
+ *    http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at
+ *   http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *    Frank Pagliughi - initial implementation and documentation
+ *    Frank Pagliughi - MQTT v5 support
+ *******************************************************************************/
+
+#include "mqtt/token.h"
+#include "mqtt/async_client.h"
+#include <cstring>
+
+#include <iostream>
+
+namespace mqtt {
+
+// --------------------------------------------------------------------------
+// Constructors
+
+token::token(Type typ, iasync_client& cli, const_string_collection_ptr topics)
+				: type_(typ), cli_(&cli), rc_(0), reasonCode_(ReasonCode::SUCCESS),
+						msgId_(MQTTAsync_token(0)), topics_(topics),
+						userContext_(nullptr), listener_(nullptr), nExpected_(0),
+						complete_(false)
+{
+}
+
+token::token(Type typ, iasync_client& cli, const_string_collection_ptr topics,
+			 void* userContext, iaction_listener& cb)
+				: type_(typ), cli_(&cli), rc_(0), reasonCode_(ReasonCode::SUCCESS),
+						msgId_(MQTTAsync_token(0)), topics_(topics),
+						userContext_(userContext), listener_(&cb), nExpected_(0),
+						complete_(false)
+{
+}
+
+token::token(Type typ, iasync_client& cli, MQTTAsync_token tok)
+				: type_(typ), cli_(&cli), rc_(0), reasonCode_(ReasonCode::SUCCESS),
+					msgId_(tok), userContext_(nullptr),
+					listener_(nullptr), nExpected_(0), complete_(false)
+{
+}
+
+// --------------------------------------------------------------------------
+// Class static callbacks.
+// These are the callbacks directly from the C library.
+// The 'context' is a raw pointer to the token object.
+
+void token::on_success(void* context, MQTTAsync_successData* rsp)
+{
+	if (context)
+		static_cast<token*>(context)->on_success(rsp);
+}
+
+void token::on_success5(void* context, MQTTAsync_successData5* rsp)
+{
+	if (context)
+		static_cast<token*>(context)->on_success5(rsp);
+}
+
+void token::on_failure(void* context, MQTTAsync_failureData* rsp)
+{
+	if (context)
+		static_cast<token*>(context)->on_failure(rsp);
+}
+
+void token::on_failure5(void* context, MQTTAsync_failureData5* rsp)
+{
+	if (context)
+		static_cast<token*>(context)->on_failure5(rsp);
+}
+
+// --------------------------------------------------------------------------
+// Object callbacks
+
+//
+// The success callback for MQTT v3 connections
+//
+void token::on_success(MQTTAsync_successData* rsp)
+{
+	unique_lock g(lock_);
+	iaction_listener* listener = listener_;
+
+	if (rsp) {
+		msgId_ = rsp->token;
+
+		switch (type_) {
+			case Type::CONNECT:
+				connRsp_.reset(new connect_response(rsp));
+				break;
+
+			case Type::SUBSCRIBE:
+				subRsp_.reset(new subscribe_response(nExpected_, rsp));
+				break;
+
+			case Type::UNSUBSCRIBE:
+				unsubRsp_.reset(new unsubscribe_response(rsp));
+				break;
+
+			default:
+				// The others don't have responses
+				break;
+		}
+	}
+
+	rc_ = MQTTASYNC_SUCCESS;
+	complete_ = true;
+	g.unlock();
+
+	// Note: callback always completes before the object is signaled.
+	if (listener)
+		listener->on_success(*this);
+	cond_.notify_all();
+
+	cli_->remove_token(this);
+}
+
+//
+// The success callback for MQTT v5 connections
+//
+void token::on_success5(MQTTAsync_successData5* rsp)
+{
+	unique_lock g(lock_);
+	iaction_listener* listener = listener_;
+	if (rsp) {
+		msgId_ = rsp->token;
+		reasonCode_ = ReasonCode(rsp->reasonCode);
+
+		switch (type_) {
+			case Type::CONNECT:
+				connRsp_.reset(new connect_response(rsp));
+				break;
+
+			case Type::SUBSCRIBE:
+				subRsp_.reset(new subscribe_response(rsp));
+				break;
+
+			case Type::UNSUBSCRIBE:
+				unsubRsp_.reset(new unsubscribe_response(rsp));
+				break;
+
+			default:
+				// The others don't have responses
+				break;
+		}
+	}
+	rc_ = MQTTASYNC_SUCCESS;
+	complete_ = true;
+	g.unlock();
+
+	// Note: callback always completes before the object is signaled.
+	if (listener)
+		listener->on_success(*this);
+	cond_.notify_all();
+
+	cli_->remove_token(this);
+}
+
+//
+// The failure callback for MQTT v3 connections
+//
+void token::on_failure(MQTTAsync_failureData* rsp)
+{
+	unique_lock g(lock_);
+	iaction_listener* listener = listener_;
+	if (rsp) {
+		msgId_ = rsp->token;
+		rc_ = rsp->code;
+
+		// HACK: For backward compatability with v3 connections
+		reasonCode_ = ReasonCode(MQTTPP_V3_CODE);
+
+		if (rsp->message)
+			errMsg_ = string(rsp->message);
+	}
+	else {
+		rc_ = -1;
+	}
+	complete_ = true;
+	g.unlock();
+
+	// Note: callback always completes before the obect is signaled.
+	if (listener)
+		listener->on_failure(*this);
+	cond_.notify_all();
+
+	cli_->remove_token(this);
+}
+
+//
+// The failure callback for MQTT v5 connections
+//
+void token::on_failure5(MQTTAsync_failureData5* rsp)
+{
+	unique_lock g(lock_);
+	iaction_listener* listener = listener_;
+	if (rsp) {
+		msgId_ = rsp->token;
+		reasonCode_ = ReasonCode(rsp->reasonCode);
+		//props_ = properties(rsp->properties);
+		rc_ = rsp->code;
+		if (rsp->message)
+			errMsg_ = string(rsp->message);
+	}
+	else {
+		rc_ = -1;
+	}
+	complete_ = true;
+	g.unlock();
+
+	// Note: callback always completes before the obect is signaled.
+	if (listener)
+		listener->on_failure(*this);
+	cond_.notify_all();
+
+	cli_->remove_token(this);
+}
+
+// --------------------------------------------------------------------------
+// API
+
+void token::reset()
+{
+	guard g(lock_);
+	complete_ = false;
+	rc_ = MQTTASYNC_SUCCESS;
+	reasonCode_ = ReasonCode::SUCCESS;
+	errMsg_.clear();
+}
+
+void token::wait()
+{
+	unique_lock g(lock_);
+	cond_.wait(g, [this]{return complete_;});
+	check_ret();
+}
+
+connect_response token::get_connect_response() const
+{
+	if (type_ != Type::CONNECT)
+		throw bad_cast();
+
+	unique_lock g(lock_);
+	cond_.wait(g, [this]{return complete_;});
+	check_ret();
+
+	if (!connRsp_)
+		throw missing_response("connect");
+
+	return *connRsp_;
+}
+
+subscribe_response token::get_subscribe_response() const
+{
+	if (type_ != Type::SUBSCRIBE)
+		throw bad_cast();
+
+	unique_lock g(lock_);
+	cond_.wait(g, [this]{return complete_;});
+	check_ret();
+
+	if (!subRsp_)
+		throw missing_response("subscribe");
+
+	return *subRsp_;
+}
+
+unsubscribe_response token::get_unsubscribe_response() const
+{
+	if (type_ != Type::UNSUBSCRIBE)
+		throw bad_cast();
+
+	unique_lock g(lock_);
+	cond_.wait(g, [this]{return complete_;});
+	check_ret();
+
+	if (!unsubRsp_)
+		throw missing_response("unsubscribe");
+
+	return *unsubRsp_;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// end namespace mqtt
+}
+
diff --git a/src/mqtt/src/topic.cpp b/src/mqtt/src/topic.cpp
new file mode 100644
index 00000000..8e486a9e
--- /dev/null
+++ b/src/mqtt/src/topic.cpp
@@ -0,0 +1,57 @@
+// topic.cpp
+
+/*******************************************************************************
+ * Copyright (c) 2013-2016 Frank Pagliughi <fpagliughi@mindspring.com>
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution.
+ *
+ * The Eclipse Public License is available at
+ *    http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at
+ *   http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *    Frank Pagliughi - initial implementation and documentation
+ *******************************************************************************/
+
+#include "mqtt/topic.h"
+#include "mqtt/async_client.h"
+
+namespace mqtt {
+
+/////////////////////////////////////////////////////////////////////////////
+
+delivery_token_ptr topic::publish(const void* payload, size_t n)
+{
+	return cli_.publish(name_, payload, n, qos_, retained_);
+}
+
+delivery_token_ptr topic::publish(const void* payload, size_t n,
+								  int qos, bool retained)
+{
+	return cli_.publish(name_, payload, n, qos, retained);
+}
+
+delivery_token_ptr topic::publish(binary_ref payload)
+{
+	return cli_.publish(name_, std::move(payload), qos_, retained_);
+}
+
+delivery_token_ptr topic::publish(binary_ref payload, int qos, bool retained)
+{
+	return cli_.publish(name_, std::move(payload), qos, retained);
+}
+
+token_ptr topic::subscribe(const subscribe_options& opts)
+{
+	return cli_.subscribe(name_, qos_, opts);
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// end namespace mqtt
+}
+
+
+
diff --git a/src/mqtt/src/will_options.cpp b/src/mqtt/src/will_options.cpp
new file mode 100644
index 00000000..457d0603
--- /dev/null
+++ b/src/mqtt/src/will_options.cpp
@@ -0,0 +1,133 @@
+/*******************************************************************************
+ * Copyright (c) 2016 Guilherme M. Ferreira <guilherme.maciel.ferreira@gmail.com>
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution.
+ *
+ * The Eclipse Public License is available at
+ *    http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at
+ *   http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *    Guilherme M. Ferreira - initial implementation and documentation
+ *    Frank Pagliughi - added copy & move operations
+ *******************************************************************************/
+
+#include "mqtt/will_options.h"
+#include <utility>
+#include <cstring>
+
+namespace mqtt {
+
+#if __cplusplus < 201703L
+	constexpr int  will_options::DFLT_QOS;
+	constexpr bool will_options::DFLT_RETAINED;
+#endif
+
+const MQTTAsync_willOptions will_options::DFLT_C_STRUCT = MQTTAsync_willOptions_initializer;
+
+/////////////////////////////////////////////////////////////////////////////
+
+will_options::will_options() : opts_(DFLT_C_STRUCT)
+{
+	set_topic(string());
+//	set_payload(binary_ref());
+}
+
+will_options::will_options(string_ref top,
+						   const void *payload, size_t payloadlen,
+						   int qos, bool retained)
+		: opts_(DFLT_C_STRUCT)
+{
+	opts_.qos = qos;
+	opts_.retained = retained;
+	set_topic(std::move(top));
+	set_payload(binary_ref(static_cast<const binary_ref::value_type*>(payload), payloadlen));
+}
+
+will_options::will_options(const topic& top,
+						   const void *payload, size_t payloadlen,
+						   int qos, bool retained)
+		: will_options(top.get_name(), payload, payloadlen, qos, retained)
+{
+}
+
+
+will_options::will_options(string_ref top, binary_ref payload,
+						   int qos, bool retained)
+		: opts_(DFLT_C_STRUCT)
+{
+	opts_.qos = qos;
+	opts_.retained = retained;
+	set_topic(std::move(top));
+	set_payload(std::move(payload));
+}
+
+will_options::will_options(string_ref top, const string& payload,
+						   int qos, bool retained)
+		: opts_(DFLT_C_STRUCT)
+{
+	opts_.qos = qos;
+	opts_.retained = retained;
+	set_topic(std::move(top));
+	set_payload(payload);
+}
+
+will_options::will_options(const message& msg)
+	: will_options(msg.get_topic(), msg.get_payload(), msg.get_qos(), msg.is_retained())
+{
+}
+
+will_options::will_options(const will_options& opt) : opts_(opt.opts_)
+{
+	set_topic(opt.topic_);
+	set_payload(opt.payload_);
+}
+
+will_options::will_options(will_options&& other) : opts_(other.opts_)
+{
+	set_topic(std::move(other.topic_));
+	set_payload(std::move(other.payload_));
+}
+
+will_options& will_options::operator=(const will_options& rhs)
+{
+	if (&rhs != this) {
+		opts_ = rhs.opts_;
+		set_topic(rhs.topic_);
+		set_payload(rhs.payload_);
+	}
+	return *this;
+}
+
+will_options& will_options::operator=(will_options&& rhs)
+{
+	if (&rhs != this) {
+		opts_ = rhs.opts_;
+		set_topic(std::move(rhs.topic_));
+		set_payload(std::move(rhs.payload_));
+	}
+	return *this;
+}
+
+void will_options::set_topic(string_ref top)
+{
+	topic_ = top ? std::move(top) : string_ref(string());
+	opts_.topicName = topic_.c_str();
+}
+
+void will_options::set_payload(binary_ref msg)
+{
+	// The C struct payload must not be nullptr for will options
+	payload_ = msg ? std::move(msg) : binary_ref(binary());
+
+	opts_.payload.len = (int) payload_.size();
+	opts_.payload.data = payload_.data();
+}
+
+/////////////////////////////////////////////////////////////////////////////
+
+} // end namespace mqtt
+
diff --git a/src/network/peerevent.h b/src/network/peerevent.h
index ffc99d4f..4b27942f 100644
--- a/src/network/peerevent.h
+++ b/src/network/peerevent.h
@@ -23,6 +23,8 @@ enum
     //PEER
     EVENT_PEER_ACTIVE,
     EVENT_PEER_DEACTIVE,
+    EVENT_PEER_GETBIZFORKS,
+    EVENT_PEER_BIZFORKS,
     EVENT_PEER_SUBSCRIBE,
     EVENT_PEER_UNSUBSCRIBE,
     EVENT_PEER_INV,
@@ -209,6 +211,8 @@ class CBbPeerEventListener;
 
 typedef TYPE_PEEREVENT(EVENT_PEER_ACTIVE, CAddress) CEventPeerActive;
 typedef TYPE_PEEREVENT(EVENT_PEER_DEACTIVE, CAddress) CEventPeerDeactive;
+typedef TYPE_PEEREVENT(EVENT_PEER_GETBIZFORKS, std::vector<uint256>) CEventPeerGetBizForks;
+typedef TYPE_PEEREVENT(EVENT_PEER_BIZFORKS, CBizFork) CEventPeerBizForks;
 typedef TYPE_PEERDATAEVENT(EVENT_PEER_SUBSCRIBE, std::vector<uint256>) CEventPeerSubscribe;
 typedef TYPE_PEERDATAEVENT(EVENT_PEER_UNSUBSCRIBE, std::vector<uint256>) CEventPeerUnsubscribe;
 typedef TYPE_PEERDATAEVENT(EVENT_PEER_INV, std::vector<CInv>) CEventPeerInv;
@@ -230,6 +234,8 @@ class CBbPeerEventListener : virtual public xengine::CEventListener
     virtual ~CBbPeerEventListener() {}
     DECLARE_EVENTHANDLER(CEventPeerActive);
     DECLARE_EVENTHANDLER(CEventPeerDeactive);
+    DECLARE_EVENTHANDLER(CEventPeerGetBizForks);
+    DECLARE_EVENTHANDLER(CEventPeerBizForks);
     DECLARE_EVENTHANDLER(CEventPeerSubscribe);
     DECLARE_EVENTHANDLER(CEventPeerUnsubscribe);
     DECLARE_EVENTHANDLER(CEventPeerInv);
diff --git a/src/network/peernet.cpp b/src/network/peernet.cpp
index 8c558986..5b87567c 100644
--- a/src/network/peernet.cpp
+++ b/src/network/peernet.cpp
@@ -70,6 +70,30 @@ void CBbPeerNet::HandleDeinitialize()
     pDelegatedChannel = nullptr;
 }
 
+bool CBbPeerNet::HandleEvent(CEventPeerGetBizForks& eventGetBizForks)
+{
+    CBufStream ssPayload;
+    ssPayload << eventGetBizForks;
+    CBbPeer* pBbPeer = static_cast<CBbPeer*>(GetPeer(eventGetBizForks.nNonce));
+    if (pBbPeer == nullptr)
+    {
+        return false;
+    }
+    return pBbPeer->SendMessage(PROTO_CHN_NETWORK, PROTO_CMD_GETBIZFORK, ssPayload);
+}
+
+bool CBbPeerNet::HandleEvent(CEventPeerBizForks& eventBizForks)
+{
+    CBufStream ssPayload;
+    ssPayload << eventBizForks;
+    CBbPeer* pBbPeer = static_cast<CBbPeer*>(GetPeer(eventBizForks.nNonce));
+    if (pBbPeer == nullptr)
+    {
+        return false;
+    }
+    return pBbPeer->SendMessage(PROTO_CHN_NETWORK, PROTO_CMD_BIZFORK, ssPayload);
+}
+
 bool CBbPeerNet::HandleEvent(CEventPeerSubscribe& eventSubscribe)
 {
     CBufStream ssPayload;
@@ -427,6 +451,7 @@ bool CBbPeerNet::HandlePeerRecvMessage(CPeer* pPeer, int nChannel, int nCommand,
             return pBbPeer->SendMessage(PROTO_CHN_NETWORK, PROTO_CMD_ADDRESS, ss);
         }
         case PROTO_CMD_ADDRESS:
+        {
             if (!fEnclosed)
             {
                 vector<CAddress> vAddr;
@@ -469,6 +494,7 @@ bool CBbPeerNet::HandlePeerRecvMessage(CPeer* pPeer, int nChannel, int nCommand,
                 return true;
             }
             break;
+        }
         case PROTO_CMD_PING:
         {
             uint32 nSeq;
@@ -497,6 +523,28 @@ bool CBbPeerNet::HandlePeerRecvMessage(CPeer* pPeer, int nChannel, int nCommand,
             }
             return true;
         }
+        case PROTO_CMD_GETBIZFORK:
+        {
+            CEventPeerGetBizForks* pEvent = new CEventPeerGetBizForks(pBbPeer->GetNonce());
+            if (pEvent != nullptr)
+            {
+                ssPayload >> pEvent->data;
+                pNetChannel->PostEvent(pEvent);
+                return true;
+            }
+            break;
+        }
+        case PROTO_CMD_BIZFORK:
+        {
+            CEventPeerBizForks* pEvent = new CEventPeerBizForks(pBbPeer->GetNonce());
+            if (pEvent != nullptr)
+            {
+                ssPayload >> pEvent->data;
+                pNetChannel->PostEvent(pEvent);
+                return true;
+            }
+            break;
+        }
         default:
             break;
         }
diff --git a/src/network/peernet.h b/src/network/peernet.h
index cd247359..6e143225 100644
--- a/src/network/peernet.h
+++ b/src/network/peernet.h
@@ -28,6 +28,8 @@ class INetChannel : public xengine::IIOModule, virtual public CBbPeerEventListen
     virtual bool SubmitCachePowBlock(const CConsensusParam& consParam) = 0;
     virtual bool IsLocalCachePowBlock(int nHeight, bool& fIsDpos) = 0;
     virtual bool AddCacheLocalPowBlock(const CBlock& block) = 0;
+    virtual void DispatchGetBizForksEvent(const std::vector<uint256>& bizForks) = 0;
+    virtual void BroadcastBizForks(const uint32& nIP, const std::vector<uint256>& bizForks) = 0;
 };
 
 class IDelegatedChannel : public xengine::IIOModule, virtual public CBbPeerEventListener
@@ -59,6 +61,8 @@ class CBbPeerNet : public xengine::CPeerNet, virtual public CBbPeerEventListener
 protected:
     bool HandleInitialize() override;
     void HandleDeinitialize() override;
+    bool HandleEvent(CEventPeerGetBizForks& eventGetBizForks) override;
+    bool HandleEvent(CEventPeerBizForks& eventBizForks) override;
     bool HandleEvent(CEventPeerSubscribe& eventSubscribe) override;
     bool HandleEvent(CEventPeerUnsubscribe& eventUnsubscribe) override;
     bool HandleEvent(CEventPeerInv& eventInv) override;
diff --git a/src/network/proto.h b/src/network/proto.h
index bf742bbd..00b6ac7e 100644
--- a/src/network/proto.h
+++ b/src/network/proto.h
@@ -19,6 +19,7 @@ enum
 {
     NODE_NETWORK = (1 << 0),
     NODE_DELEGATED = (1 << 1),
+    NODE_SUPERNODE = (1 << 2),
 };
 
 enum
@@ -37,6 +38,8 @@ enum
     PROTO_CMD_ADDRESS = 4,
     PROTO_CMD_PING = 5,
     PROTO_CMD_PONG = 6,
+    PROTO_CMD_GETBIZFORK = 7,
+    PROTO_CMD_BIZFORK = 8,
 };
 
 enum
@@ -130,6 +133,26 @@ class CPeerMessageHeader
     }
 };
 
+class CBizFork
+{
+    friend class xengine::CStream;
+
+public:
+    CBizFork() {}
+    CBizFork(const std::map<uint256, std::vector<uint32>>& rForkIn)
+      : mapFork(rForkIn) {}
+
+protected:
+    template <typename O>
+    void Serialize(xengine::CStream& s, O& opt)
+    {
+        s.Serialize(mapFork, opt);
+    }
+
+public:
+    std::map<uint256, std::vector<uint32>> mapFork;
+};
+
 class CMsgRsp
 {
     friend class xengine::CStream;
diff --git a/src/storage/CMakeLists.txt b/src/storage/CMakeLists.txt
index f2717800..e8488d95 100755
--- a/src/storage/CMakeLists.txt
+++ b/src/storage/CMakeLists.txt
@@ -20,6 +20,7 @@ set(sources
     leveldbeng.cpp      leveldbeng.h
     txindexdb.cpp       txindexdb.h
     ctsdb.cpp           ctsdb.h
+    mqdb.cpp            mqdb.h
     delegatevotesave.cpp delegatevotesave.h
 )
 
diff --git a/src/storage/blockbase.cpp b/src/storage/blockbase.cpp
index 85726c92..d7ebd28b 100644
--- a/src/storage/blockbase.cpp
+++ b/src/storage/blockbase.cpp
@@ -469,7 +469,7 @@ bool CBlockBase::Initiate(const uint256& hashGenesis, const CBlock& blockGenesis
         CForkContext ctxt(hashGenesis, uint64(0), uint64(0), profile);
         if (!dbBlock.AddNewForkContext(ctxt))
         {
-            StdTrace("BlockBase", "Add New Fork COntext %s block failed", hashGenesis.ToString().c_str());
+            StdTrace("BlockBase", "Add New Fork Context %s block failed", hashGenesis.ToString().c_str());
             return false;
         }
 
@@ -576,6 +576,76 @@ bool CBlockBase::AddNewForkContext(const CForkContext& ctxt)
     return true;
 }
 
+bool CBlockBase::AddNewSuperNode(const CSuperNode& superNode)
+{
+    if (!dbBlock.AddNewSuperNode(superNode))
+    {
+        Error("CBlockBase::AddNewSuperNode", "Failed to addnew supernode in %s", superNode.superNodeID.c_str());
+        return false;
+    }
+    Log("CBlockBase::AddNewSuperNode", "AddNew supernode,cliID=%s with %d forks", superNode.superNodeID.c_str(),
+        superNode.vecOwnedForks.size());
+    for (const auto& i : superNode.vecOwnedForks)
+    {
+        Log("CBlockBase::AddNewSuperNode", "AddNew supernode with fork [%s]", i.ToString().c_str());
+    }
+    return true;
+}
+
+bool CBlockBase::ListSuperNode(vector<storage::CSuperNode>& nodes)
+{
+    if (!dbBlock.ListSuperNode(nodes))
+    {
+        Error("CBlockBase::ListSuperNode", "Failed to list supernode");
+        return false;
+    }
+    Log("CBlockBase::ListSuperNode", "List supernode successfully");
+    for (const auto& node : nodes)
+    {
+        for (const auto& fork : node.vecOwnedForks)
+        {
+            Log("CBlockBase::ListSuperNode", "supernode client ID [%s] IP [%s]: fork [%s]",
+                node.superNodeID.c_str(), CSuperNode::Int2Ip(node.ipAddr).c_str(), fork.ToString().c_str());
+        }
+    }
+    return true;
+}
+
+bool CBlockBase::FetchSuperNode(vector<storage::CSuperNode>& nodes, const uint8 mask)
+{
+    if (!dbBlock.FetchSuperNode(nodes, mask))
+    {
+        Error("CBlockBase::FetchSuperNode", "Failed to fetch supernode");
+        return false;
+    }
+    Log("CBlockBase::FetchSuperNode", "Fetch supernode successfully");
+    for (const auto& node : nodes)
+    {
+        for (const auto& fork : node.vecOwnedForks)
+        {
+            Log("CBlockBase::FetchSuperNode", "supernode client ID [%s] IP [%s]: fork [%s]",
+                node.superNodeID.c_str(), CSuperNode::Int2Ip(node.ipAddr).c_str(), fork.ToString().c_str());
+        }
+    }
+    return true;
+}
+
+bool CBlockBase::AddOuterNodes(const std::vector<CSuperNode>& outers, bool fSuper)
+{
+    if (!dbBlock.AddOuterNodes(outers, fSuper))
+    {
+        Error("CBlockBase::AddOuterNodes", "Failed to add [%d] outer nodes", outers.size());
+        return false;
+    }
+
+    Log("CBlockBase::AddOuterNodes", "Adding [%d] outer nodes successfully", outers.size());
+    for (auto const& o : outers)
+    {
+        Log("CBlockBase::AddOuterNodes", "Succeeded in adding outer node :[%s]", o.ToString().c_str());
+    }
+    return true;
+}
+
 bool CBlockBase::Retrieve(const uint256& hash, CBlock& block)
 {
     block.SetNull();
@@ -2016,6 +2086,23 @@ bool CBlockBase::GetBlockDelegatedEnrollTx(const uint256& hashBlock, map<int, se
     return true;
 }
 
+bool CBlockBase::ListActiveFork(std::vector<uint256>& forks)
+{
+    vector<pair<uint256, uint256>> vFork;
+    if (!dbBlock.ListFork(vFork))
+    {
+        return false;
+    }
+
+    forks.clear();
+    for (const auto& fork : vFork)
+    {
+        forks.push_back(fork.first);
+    }
+
+    return true;
+}
+
 bool CBlockBase::VerifyRefBlock(const uint256& hashGenesis, const uint256& hashRefBlock)
 {
     CReadLock rlock(rwAccess);
@@ -2532,9 +2619,9 @@ bool CBlockBase::GetTxNewIndex(CBlockView& view, CBlockIndex* pIndexNew, vector<
 
         CVarInt var(block.vtx.size());
         nOffset += ss.GetSerializeSize(var);
-        for (int i = 0; i < block.vtx.size(); i++)
+        for (int j = 0; j < block.vtx.size(); j++)
         {
-            CTransaction& tx = block.vtx[i];
+            CTransaction& tx = block.vtx[j];
             uint256 txid = tx.GetHash();
             CTxIndex txIndex(nHeight, pIndex->nFile, nOffset);
             vTxNew.push_back(make_pair(txid, txIndex));
@@ -2686,6 +2773,7 @@ bool CBlockBase::LoadDB()
         ClearCache();
         return false;
     }
+    Log(__FUNCTION__, "listfork[%d]", vFork.size());
     for (int i = 0; i < vFork.size(); i++)
     {
         CBlockIndex* pIndex = GetIndex(vFork[i].second);
@@ -2704,6 +2792,7 @@ bool CBlockBase::LoadDB()
         {
             return false;
         }
+        Log(__FUNCTION__, "listfork[%s]", vFork[i].first.ToString().c_str());
     }
 
     return true;
diff --git a/src/storage/blockbase.h b/src/storage/blockbase.h
index bd794a96..e92a9db3 100644
--- a/src/storage/blockbase.h
+++ b/src/storage/blockbase.h
@@ -243,6 +243,10 @@ class CBlockBase
     bool Initiate(const uint256& hashGenesis, const CBlock& blockGenesis, const uint256& nChainTrust);
     bool AddNew(const uint256& hash, CBlockEx& block, CBlockIndex** ppIndexNew, const uint256& nChainTrust, int64 nMinEnrollAmount);
     bool AddNewForkContext(const CForkContext& ctxt);
+    bool AddNewSuperNode(const CSuperNode& superNode);
+    bool ListSuperNode(std::vector<storage::CSuperNode>& nodes);
+    bool FetchSuperNode(std::vector<storage::CSuperNode>& nodes, const uint8 mask);
+    bool AddOuterNodes(const std::vector<CSuperNode>& outers, bool fSuper);
     bool Retrieve(const uint256& hash, CBlock& block);
     bool Retrieve(const CBlockIndex* pIndex, CBlock& block);
     bool Retrieve(const uint256& hash, CBlockEx& block);
@@ -287,6 +291,7 @@ class CBlockBase
     bool GetBlockDelegateVote(const uint256& hashBlock, std::map<CDestination, int64>& mapVote);
     bool GetDelegateEnrollTx(int height, const std::vector<uint256>& vBlockRange, std::map<CDestination, CDiskPos>& mapEnrollTxPos);
     bool GetBlockDelegatedEnrollTx(const uint256& hashBlock, std::map<int, std::set<CDestination>>& mapEnrollDest);
+    bool ListActiveFork(std::vector<uint256>& forks);
     bool VerifyRefBlock(const uint256& hashGenesis, const uint256& hashRefBlock);
     CBlockIndex* GetForkValidLast(const uint256& hashGenesis, const uint256& hashFork, int nRefVacantHeight);
     bool VerifySameChain(const uint256& hashPrevBlock, const uint256& hashAfterBlock);
diff --git a/src/storage/blockdb.cpp b/src/storage/blockdb.cpp
index f56e1eb6..2045767b 100644
--- a/src/storage/blockdb.cpp
+++ b/src/storage/blockdb.cpp
@@ -51,6 +51,11 @@ bool CBlockDB::Initialize(const boost::filesystem::path& pathData)
         return false;
     }
 
+    if (!dbSuperNode.Initialize(pathData))
+    {
+        return false;
+    }
+
     return LoadFork();
 }
 
@@ -61,6 +66,7 @@ void CBlockDB::Deinitialize()
     dbTxIndex.Deinitialize();
     dbBlockIndex.Deinitialize();
     dbFork.Deinitialize();
+    dbSuperNode.Deinitialize();
 }
 
 bool CBlockDB::RemoveAll()
@@ -70,6 +76,7 @@ bool CBlockDB::RemoveAll()
     dbTxIndex.Clear();
     dbBlockIndex.Clear();
     dbFork.Clear();
+    dbSuperNode.Clear();
 
     return true;
 }
@@ -249,5 +256,26 @@ bool CBlockDB::LoadFork()
     return true;
 }
 
+bool CBlockDB::AddNewSuperNode(const CSuperNode& superNode)
+{
+    return dbSuperNode.AddNewSuperNode(superNode);
+}
+
+bool CBlockDB::ListSuperNode(std::vector<CSuperNode>& nodes)
+{
+    return dbSuperNode.ListSuperNode(nodes);
+}
+
+bool CBlockDB::FetchSuperNode(std::vector<CSuperNode>& nodes, const uint8 mask)
+{
+    return dbSuperNode.FetchSuperNode(nodes, mask);
+}
+
+bool CBlockDB::AddOuterNodes(const std::vector<CSuperNode>& outers, bool fSuper)
+{
+    return dbSuperNode.AddOuterNodes(outers, fSuper);
+}
+
+
 } // namespace storage
 } // namespace bigbang
diff --git a/src/storage/blockdb.h b/src/storage/blockdb.h
index 68815c7d..067619ad 100644
--- a/src/storage/blockdb.h
+++ b/src/storage/blockdb.h
@@ -13,6 +13,7 @@
 #include "transaction.h"
 #include "txindexdb.h"
 #include "unspentdb.h"
+#include "mqdb.h"
 
 namespace bigbang
 {
@@ -48,6 +49,10 @@ class CBlockDB
     bool RetrieveEnroll(const uint256& hash, std::map<int, std::map<CDestination, CDiskPos>>& mapEnrollTxPos);
     bool RetrieveEnroll(int height, const std::vector<uint256>& vBlockRange,
                         std::map<CDestination, CDiskPos>& mapEnrollTxPos);
+    bool AddNewSuperNode(const CSuperNode& superNode);
+    bool ListSuperNode(std::vector<CSuperNode>& nodes);
+    bool FetchSuperNode(std::vector<CSuperNode>& nodes, const uint8 mask);
+    bool AddOuterNodes(const std::vector<CSuperNode>& outers, bool fSuper);
 
 protected:
     bool LoadFork();
@@ -58,6 +63,7 @@ class CBlockDB
     CTxIndexDB dbTxIndex;
     CUnspentDB dbUnspent;
     CDelegateDB dbDelegate;
+    CSuperNodeDB dbSuperNode;
 };
 
 } // namespace storage
diff --git a/src/storage/mqdb.cpp b/src/storage/mqdb.cpp
new file mode 100644
index 00000000..92c86219
--- /dev/null
+++ b/src/storage/mqdb.cpp
@@ -0,0 +1,274 @@
+// Copyright (c) 2019-2020 The Bigbang developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include "mqdb.h"
+
+#include "leveldbeng.h"
+
+#include "defs.h"
+
+using namespace std;
+using namespace xengine;
+
+namespace bigbang
+{
+namespace storage
+{
+
+//////////////////////////////
+// CSuperNodeDB
+
+bool CSuperNodeDB::Initialize(const boost::filesystem::path& pathData)
+{
+    CLevelDBArguments args;
+    args.path = (pathData / "supernode").string();
+    args.syncwrite = true;
+    args.files = 16;
+    args.cache = 2 << 20;
+
+    CLevelDBEngine* engine = new CLevelDBEngine(args);
+
+    if (!Open(engine))
+    {
+        delete engine;
+        return false;
+    }
+
+    return true;
+}
+
+void CSuperNodeDB::Deinitialize()
+{
+    Close();
+}
+
+bool CSuperNodeDB::AddNewSuperNode(const CSuperNode& cli)
+{
+    bool ret = false;
+    switch (cli.nodeCat)
+    {
+    case NODE_CAT_BBCNODE:
+    {
+        ret = Write(make_pair(CLIENT_ID_OUT_OF_MQ_CLUSTER, cli.ipAddr), cli.vecOwnedForks, true);
+        break;
+    }
+    case NODE_CAT_FORKNODE:
+    case NODE_CAT_DPOSNODE:
+    {
+        if (!ClearSuperNode(cli))
+        {
+            return false;
+        }
+        ret = Write(make_pair(cli.superNodeID, cli.ipAddr), cli.vecOwnedForks, true);
+    }
+    }
+    return ret;
+}
+
+bool CSuperNodeDB::RemoveSuperNode(const string& cliID, const uint32& ipNum)
+{
+    return Erase(make_pair(cliID, ipNum));
+}
+
+bool CSuperNodeDB::RetrieveSuperNode(const string& cliID, const uint32& ipNum, vector<uint256>& vFork)
+{
+    return Read(make_pair(cliID, ipNum), vFork);
+}
+
+bool CSuperNodeDB::UpdateSuperNode(const string& cliID, const uint32& ipNum, const vector<uint256>& vFork)
+{
+    return Write(make_pair(cliID, ipNum), vFork, true);
+}
+
+bool CSuperNodeDB::ListSuperNode(std::vector<CSuperNode>& vCli)
+{
+    map<pair<string, uint32>, vector<uint256>> mapCli;
+
+    if (!WalkThrough(boost::bind(&CSuperNodeDB::LoadSuperNodeWalker, this, _1, _2, boost::ref(mapCli))))
+    {
+        return false;
+    }
+
+    vCli.reserve(mapCli.size());
+    for (const auto& it : mapCli)
+    {
+        CSuperNode node;
+        node.superNodeID = it.first.first;
+        node.ipAddr = it.first.second;
+        node.vecOwnedForks = it.second;
+        vCli.emplace_back(node);
+    }
+    return true;
+}
+
+void CSuperNodeDB::Clear()
+{
+    RemoveAll();
+}
+
+bool CSuperNodeDB::FetchSuperNodeWalker(xengine::CBufStream& ssKey, xengine::CBufStream& ssValue,
+                                        map<pair<string, uint32>, vector<uint256>>& mapCli, const uint8& mask)
+{
+    string strCliID;
+    uint32 nIP;
+    ssKey >> strCliID >> nIP;
+
+    if (((mask & 0x1 << 0) == 0) && strCliID == CLIENT_ID_OUT_OF_MQ_CLUSTER)
+    {
+        return true;
+    }
+
+    if (((mask & 0x1 << 1) == 0) && strCliID != CLIENT_ID_OUT_OF_MQ_CLUSTER && 0 != nIP)
+    {
+        return true;
+    }
+
+    if (((mask & 0x1 << 2) == 0) && strCliID != CLIENT_ID_OUT_OF_MQ_CLUSTER && 0 == nIP)
+    {
+        return true;
+    }
+
+    std::vector<uint256> forks;
+    ssValue >> forks;
+    mapCli.insert(make_pair(make_pair(strCliID, nIP), forks));
+    return true;
+}
+
+bool CSuperNodeDB::FetchSuperNode(std::vector<CSuperNode>& vCli, const uint8& mask)
+{
+    map<pair<string, uint32>, vector<uint256>> mapCli;
+
+    if (!WalkThrough(boost::bind(&CSuperNodeDB::FetchSuperNodeWalker, this, _1, _2, boost::ref(mapCli), mask)))
+    {
+        return false;
+    }
+
+    vCli.reserve(mapCli.size());
+    for (const auto& it : mapCli)
+    {
+        CSuperNode node;
+        node.superNodeID = it.first.first;
+        node.ipAddr = it.first.second;
+        node.vecOwnedForks = it.second;
+        vCli.emplace_back(node);
+    }
+    return true;
+}
+
+bool CSuperNodeDB::AddOuterNodes(const std::vector<CSuperNode>& outers, bool fSuper)
+{
+    vector<CSuperNode> outersIn = outers;
+    vector<CSuperNode> outersPrev;
+    if (!FetchSuperNode(outersPrev, 1 << 0))
+    {
+        return false;
+    }
+    for (auto& sn : outersIn)
+    {
+        for (auto& prev : outersPrev)
+        {
+            if (sn.ipAddr == prev.ipAddr)
+            {
+                vector<uint256>& v1 = sn.vecOwnedForks;
+                vector<uint256>& v2 = prev.vecOwnedForks;
+                for (auto& f2 : v2)
+                {
+                    auto it = std::find(v1.begin(), v1.end(), f2);
+                    if (v1.end() == it)
+                    {
+                        v1.push_back(f2);
+                    }
+                }
+            }
+        }
+    }
+
+    if (!fSuper)
+    {
+        for (auto const& n : outersIn)
+        {
+            if (!Write(make_pair(CLIENT_ID_OUT_OF_MQ_CLUSTER, n.ipAddr), n.vecOwnedForks, true))
+            {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    vector<CSuperNode> forknodes;
+    if (!FetchSuperNode(forknodes, 1 << 1))
+    {
+        return false;
+    }
+    vector<uint32> forknodeips;
+    for (auto& fn : forknodes)
+    {
+        forknodeips.emplace_back(fn.ipAddr);
+    }
+    for (auto const& n : outersIn)
+    {
+        if (forknodeips.end() == find(forknodeips.begin(), forknodeips.end(), n.ipAddr))
+        {
+            if (!Write(make_pair(CLIENT_ID_OUT_OF_MQ_CLUSTER, n.ipAddr), n.vecOwnedForks, true))
+            {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
+bool CSuperNodeDB::ClearSuperNode(const CSuperNode& cli)
+{
+    vector<CSuperNode> vSuperNode;
+    if (!FetchSuperNode(vSuperNode, 6))
+    {
+        return false;
+    }
+
+    if (vSuperNode.empty())
+    {
+        return true;
+    }
+
+    if (NODE_CAT_FORKNODE == cli.nodeCat) //fork node updates self by remove all supernode entries
+    {
+        for (auto const& supernode : vSuperNode)
+        {
+            if (!RemoveSuperNode(supernode.superNodeID, supernode.ipAddr))
+            {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    if (NODE_CAT_DPOSNODE == cli.nodeCat && 0 == cli.ipAddr) //dpos node updates oneself
+    {
+        for (auto const& supernode : vSuperNode)
+        {
+            if (0 == supernode.ipAddr && !RemoveSuperNode(supernode.superNodeID, supernode.ipAddr)) //need to remove previous one first
+            {
+                return false;
+            }
+        }
+    }
+
+    return true;
+}
+
+bool CSuperNodeDB::LoadSuperNodeWalker(xengine::CBufStream& ssKey, xengine::CBufStream& ssValue,
+                                       map<pair<string, uint32>, vector<uint256>>& mapCli)
+{
+    string strCliID;
+    uint32 nIP;
+    ssKey >> strCliID >> nIP;
+    std::vector<uint256> forks;
+    ssValue >> forks;
+    mapCli.insert(make_pair(make_pair(strCliID, nIP), forks));
+    return true;
+}
+
+} // namespace storage
+} // namespace bigbang
diff --git a/src/storage/mqdb.h b/src/storage/mqdb.h
new file mode 100644
index 00000000..acac22ce
--- /dev/null
+++ b/src/storage/mqdb.h
@@ -0,0 +1,135 @@
+// Copyright (c) 2019-2020 The Bigbang developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BIGBANG_MQDB_H
+#define BIGBANG_MQDB_H
+
+#include <boost/asio.hpp>
+
+#include "uint256.h"
+#include "xengine.h"
+
+namespace bigbang
+{
+namespace storage
+{
+
+const std::string CLIENT_ID_OUT_OF_MQ_CLUSTER = "OUTER-NODE";
+
+class CForkKnownIP
+{
+public:
+    CForkKnownIP() {}
+    CForkKnownIP(const uint256& forkidIn, const uint32& nodeipIn)
+      : forkID(forkidIn), nodeIP(nodeipIn) {}
+
+public:
+    uint256 forkID;
+    uint32 nodeIP;
+};
+
+typedef boost::multi_index_container<
+    CForkKnownIP,
+    boost::multi_index::indexed_by<
+        boost::multi_index::ordered_non_unique<boost::multi_index::member<CForkKnownIP, uint256, &CForkKnownIP::forkID>>,
+        boost::multi_index::ordered_non_unique<boost::multi_index::member<CForkKnownIP, uint32, &CForkKnownIP::nodeIP>>>>
+    CForkKnownIPSet;
+
+typedef CForkKnownIPSet::nth_index<0>::type CForkKnownIpSetById;
+typedef CForkKnownIPSet::nth_index<1>::type CForkKnownIpSetByIp;
+
+class CSuperNode
+{
+    friend class xengine::CStream;
+
+public:
+    std::string superNodeID;
+    uint32 ipAddr;
+    std::vector<uint256> vecOwnedForks;
+    int8 nodeCat;
+
+public:
+    CSuperNode(const std::string& id = std::string(), uint32 ip = 0,
+               const std::vector<uint256>& forks = std::vector<uint256>(), int8 cat = 0)
+      : superNodeID(id),
+        ipAddr(ip),
+        vecOwnedForks(forks),
+        nodeCat(cat) {}
+
+    static bool Ip2Int(const std::string& ipStr, unsigned long& ipNum)
+    {
+        boost::system::error_code ec;
+        boost::asio::ip::address_v4 addr = boost::asio::ip::address_v4::from_string(ipStr, ec);
+        if (!ec)
+        {
+            ipNum = addr.to_ulong();
+            return true;
+        }
+        return false;
+    }
+
+    static bool Int2Ip(const unsigned long& ipNum, std::string& ipStr)
+    {
+        boost::asio::ip::address_v4 addr(ipNum);
+        ipStr = addr.to_string();
+        return true;
+    }
+
+    static std::string Int2Ip(const unsigned long& ipNum)
+    {
+        boost::asio::ip::address_v4 addr(ipNum);
+        return addr.to_string();
+    }
+
+    std::string ToString() const
+    {
+        std::ostringstream oss;
+        oss << "CSuperNode : superNodeID=" << superNodeID
+            << " ipAddr=" << Int2Ip(ipAddr) << " ";
+        for (auto const& f : vecOwnedForks)
+        {
+            oss << " ownedFork=" << f.ToString() << " ";
+        }
+        oss << " nodeCat=" << std::to_string(nodeCat) << " ";
+        return oss.str();
+    }
+
+protected:
+    template <typename O>
+    void Serialize(xengine::CStream& s, O& opt)
+    {
+        s.Serialize(superNodeID, opt);
+        s.Serialize(ipAddr, opt);
+        s.Serialize(vecOwnedForks, opt);
+        s.Serialize(nodeCat, opt);
+    }
+};
+
+class CSuperNodeDB : public xengine::CKVDB
+{
+public:
+    CSuperNodeDB() = default;
+    bool Initialize(const boost::filesystem::path& pathData);
+    void Deinitialize();
+    bool AddNewSuperNode(const CSuperNode& cli);
+    bool RemoveSuperNode(const std::string& cliID, const uint32& ipNum);
+    bool RetrieveSuperNode(const std::string& superNodeID, const uint32& ipNum, std::vector<uint256>& vFork);
+    bool UpdateSuperNode(const std::string& cliID, const uint32& ipNum, const std::vector<uint256>& vFork);
+    bool ListSuperNode(std::vector<CSuperNode>& vCli); //return all nodes
+    void Clear();
+    bool ClearSuperNode(const CSuperNode& cli);
+    bool FetchSuperNode(std::vector<CSuperNode>& vCli, const uint8& mask);  //only return super nodes on request
+    bool AddOuterNodes(const std::vector<CSuperNode>& outers, bool fSuper); //outer nodes come from peers
+
+protected:
+    bool LoadSuperNodeWalker(xengine::CBufStream& ssKey, xengine::CBufStream& ssValue,
+                             std::map<std::pair<std::string, uint32>, std::vector<uint256>>& mapCli);
+    bool FetchSuperNodeWalker(xengine::CBufStream& ssKey, xengine::CBufStream& ssValue,
+                              std::map<std::pair<std::string, uint32>, std::vector<uint256>>& mapCli, const uint8& mask);
+};
+
+} // namespace storage
+} // namespace bigbang
+
+#endif //BIGBANG_MQDB_H
diff --git a/src/xengine/docker/config.cpp b/src/xengine/docker/config.cpp
index 70dc0515..40d3fa33 100644
--- a/src/xengine/docker/config.cpp
+++ b/src/xengine/docker/config.cpp
@@ -45,19 +45,32 @@ bool CConfig::Load(int argc, char* argv[], const fs::path& pathDefault, const st
     {
         vector<string> vecIgnoreCmd;
 
-        defaultDesc.add_options()("cmd", po::value<vector<string>>(&vecCommand))("help", po::value<bool>(&fHelp)->default_value(false))("daemon", po::value<bool>(&fDaemon)->default_value(false))("debug", po::value<bool>(&fDebug)->default_value(false))("datadir", po::value<string>(&strRoot)->default_value(pathDefault.string()))("conf", po::value<string>(&strConfig)->default_value(strConfile))("ignore", po::value<vector<string>>(&vecIgnoreCmd));
+        defaultDesc.add_options()
+        ("cmd", po::value<vector<string>>(&vecCommand))
+        ("help", po::value<bool>(&fHelp)->default_value(false))
+        ("daemon", po::value<bool>(&fDaemon)->default_value(false))
+        ("debug", po::value<bool>(&fDebug)->default_value(false))
+        ("datadir", po::value<string>(&strRoot)->default_value(pathDefault.string()))
+        ("conf", po::value<string>(&strConfig)->default_value(strConfile))
+        ("ignore", po::value<vector<string>>(&vecIgnoreCmd));
 
         po::positional_options_description defaultPosDesc;
         defaultPosDesc.add("cmd", -1).add("ignore", ignoreCmd);
 
-        auto parser = po::command_line_parser(argc, argv).options(defaultDesc).style(defaultCmdStyle).extra_parser(CConfig::ExtraParser).positional(defaultPosDesc);
+        auto parser = po::command_line_parser(argc, argv)
+                .options(defaultDesc)
+                .style(defaultCmdStyle)
+                .extra_parser(CConfig::ExtraParser)
+                .positional(defaultPosDesc);
         po::store(parser.run(), vm);
-
         po::notify(vm);
+
         pathRoot = strRoot;
         pathConfile = strConfig;
         if (!STD_DEBUG)
+        {
             STD_DEBUG = fDebug;
+        }
 
         if (fHelp)
         {
@@ -72,7 +85,12 @@ bool CConfig::Load(int argc, char* argv[], const fs::path& pathDefault, const st
         vector<string> confToken;
         if (TokenizeConfile(pathConfile.string().c_str(), confToken))
         {
-            po::store(po::command_line_parser(confToken).options(defaultDesc).style(defaultCmdStyle).extra_parser(CConfig::ExtraParser).allow_unregistered().run(), vm);
+            po::store(po::command_line_parser(confToken)
+                                              .options(defaultDesc)
+                                              .style(defaultCmdStyle)
+                                              .extra_parser(CConfig::ExtraParser)
+                                              .allow_unregistered()
+                                              .run(), vm);
             po::notify(vm);
         }
     }
diff --git a/src/xengine/http/httpget.cpp b/src/xengine/http/httpget.cpp
index 8722edaa..cc12410b 100644
--- a/src/xengine/http/httpget.cpp
+++ b/src/xengine/http/httpget.cpp
@@ -9,7 +9,7 @@
 #include "httputil.h"
 #include "netio/netio.h"
 
-#define HTTPGET_CONNET_TIMEOUT 10
+#define HTTPGET_CONNECT_TIMEOUT 10
 
 using namespace std;
 using boost::asio::ip::tcp;
@@ -271,7 +271,7 @@ void CHttpGet::HostResolved(const CNetHost& host, const tcp::endpoint& ep)
     if (it != mapRequest.upper_bound(host))
     {
         CHttpReqData& httpReqData = (*it).second.data;
-        if (SSLConnect(ep, HTTPGET_CONNET_TIMEOUT, GetSSLOption(httpReqData, host.strHost)))
+        if (SSLConnect(ep, HTTPGET_CONNECT_TIMEOUT, GetSSLOption(httpReqData, host.strHost)))
         {
             mapRequest.insert(make_pair(CNetHost(ep), (*it).second));
         }
@@ -413,7 +413,7 @@ bool CHttpGet::HandleEvent(CEventHttpGet& eventGet)
     tcp::endpoint ep = host.ToEndPoint();
     if (ep != tcp::endpoint())
     {
-        if (!SSLConnect(ep, HTTPGET_CONNET_TIMEOUT, GetSSLOption(httpReqData, host.strHost)))
+        if (!SSLConnect(ep, HTTPGET_CONNECT_TIMEOUT, GetSSLOption(httpReqData, host.strHost)))
         {
             PostError(httpReqData.strIOModule, nNonce, HTTPGET_CONNECT_FAILED);
             return true;
diff --git a/src/xengine/util.cpp b/src/xengine/util.cpp
index 4bc07ed2..79e14c8a 100644
--- a/src/xengine/util.cpp
+++ b/src/xengine/util.cpp
@@ -223,7 +223,7 @@ void StdTrace(const char* pszName, const char* pszFormat, ...)
         ss << arg_buffer;
         std::string str = ss.str();
 
-        BOOST_LOG_SCOPED_THREAD_TAG("ThreadName", GetThreadName().c_str());
+        BOOST_LOG_SCOPED_THREAD_TAG("ThreadName", GetThreadName().c_str())
         BOOST_LOG_CHANNEL_SEV(lg::get(), pszName, debug) << str;
     }
 }
@@ -241,7 +241,7 @@ void StdDebug(const char* pszName, const char* pszFormat, ...)
         ss << arg_buffer;
         std::string str = ss.str();
 
-        BOOST_LOG_SCOPED_THREAD_TAG("ThreadName", GetThreadName().c_str());
+        BOOST_LOG_SCOPED_THREAD_TAG("ThreadName", GetThreadName().c_str())
         BOOST_LOG_CHANNEL_SEV(lg::get(), pszName, debug) << str;
     }
 }
@@ -259,7 +259,7 @@ void StdLog(const char* pszName, const char* pszFormat, ...)
         ss << arg_buffer;
         std::string str = ss.str();
 
-        BOOST_LOG_SCOPED_THREAD_TAG("ThreadName", GetThreadName().c_str());
+        BOOST_LOG_SCOPED_THREAD_TAG("ThreadName", GetThreadName().c_str())
         BOOST_LOG_CHANNEL_SEV(lg::get(), pszName, info) << str;
     }
 }
@@ -277,7 +277,7 @@ void StdWarn(const char* pszName, const char* pszFormat, ...)
         ss << arg_buffer;
         std::string str = ss.str();
 
-        BOOST_LOG_SCOPED_THREAD_TAG("ThreadName", GetThreadName().c_str());
+        BOOST_LOG_SCOPED_THREAD_TAG("ThreadName", GetThreadName().c_str())
         BOOST_LOG_CHANNEL_SEV(lg::get(), pszName, warn) << str;
     }
 }
@@ -295,7 +295,7 @@ void StdError(const char* pszName, const char* pszFormat, ...)
         ss << arg_buffer;
         std::string str = ss.str();
 
-        BOOST_LOG_SCOPED_THREAD_TAG("ThreadName", GetThreadName().c_str());
+        BOOST_LOG_SCOPED_THREAD_TAG("ThreadName", GetThreadName().c_str())
         BOOST_LOG_CHANNEL_SEV(lg::get(), pszName, error) << str;
     }
 }