transactd 2.3.0 → 2.4.0

data/source/bzs/db/transactd/connManager.cpp

@@ -20,6 +20,12 @@
 #include "appModule.h"
 #include <bzs/db/protocol/tdap/mysql/tdapCommandExecuter.h>
 #include "connManager.h"
+#include <bzs/db/engine/mysql/mysqlThd.h>
+#include <bzs/db/protocol/tdap/mysql/databaseSchema.h>
+#include <bzs/db/engine/mysql/errorMessage.h>
+
+/* implemnts in transactd.cpp */
+extern const char* get_trd_sys_var(int index);
 
 namespace bzs
 {
@@ -47,11 +53,8 @@ const module* getMod(unsigned __int64 conid)
     return NULL;
 }
 
-const database* connManager::getDatabase(const module* mod, int dbid) const
+const database* connManager::getDatabase(igetDatabases* dbm, int dbid) const
 {
-
-    igetDatabases* dbm =
-        dynamic_cast<igetDatabases*>(mod->m_commandExecuter.get());
     const databases& dbs = dbm->dbs();
     if (dbid < (int)dbs.size())
         return dbs[dbid].get();
@@ -75,21 +78,43 @@ void connManager::getConnectionList() const
     }
 }
 
-void connManager::getDatabaseList(const module* mod) const
+void connManager::getDatabaseList(igetDatabases* dbm, const module* mod) const
 {
-    igetDatabases* dbm =
-        dynamic_cast<igetDatabases*>(mod->m_commandExecuter.get());
     const databases& dbs = dbm->dbs();
     for (size_t j = 0; j < dbs.size(); j++)
     {
-
         if (dbs[j])
         {
+            const database* db = dbs[j].get(); 
             m_records.push_back(connection::record());
             connection::record& rec = m_records[m_records.size() - 1];
             rec.conId = (unsigned __int64)mod;
-            rec.cid = dbs[j]->clientID();
+            rec.cid = db->clientID();
             rec.dbid = (unsigned short)j;
+            rec.status = 0;
+            rec.inTransaction = db->inTransaction();
+            rec.inSnapshot = db->inSnapshot();
+            if (rec.inTransaction)
+            {
+                if (db->transactionIsolation() == ISO_REPEATABLE_READ)
+                    rec.trnType = MULTILOCK_GAP;
+                else if (db->transactionIsolation() == ISO_READ_COMMITTED)
+                {
+                    if (db->transactionType() == TRN_RECORD_LOCK_SINGLE)
+                        rec.trnType = SINGLELOCK_NOGAP;
+                    else
+                        rec.trnType = MULTILOCK_NOGAP;
+                }
+            }
+            if (rec.inSnapshot)
+            {
+                if (db->transactionIsolation() == 0)
+                    rec.trnType = CONSISTENT_READ;
+                else if (db->transactionIsolation() == ISO_REPEATABLE_READ)
+                    rec.trnType = MULTILOCK_GAP_SHARE;
+                else if (db->transactionIsolation() == ISO_READ_COMMITTED)
+                    rec.trnType = MULTILOCK_NOGAP_SHARE;
+            }
             strncpy_s(rec.name, 64, dbs[j]->name().c_str(), 64);
         }
     }
@@ -108,33 +133,44 @@ const connManager::records& connManager::getRecords(unsigned __int64 conid,
         const module* mod = getMod(conid);
         if (mod)
         {
-            //Lock module execute
-            boost::try_mutex::scoped_try_lock m(mod->mutex(),
-                                                boost::try_to_lock_t());
-            if (m.owns_lock())
+            igetDatabases* dbm =
+                dynamic_cast<igetDatabases*>(mod->m_commandExecuter.get());
+
+            //Lock database add remove
+            boost::mutex::scoped_lock lck(dbm->mutex());
+ 
+            if (dbid < 0)
+                getDatabaseList(dbm, mod);
+            else
             {
-                if (dbid < 0)
-                    getDatabaseList(mod);
-                else
+                const database* db = getDatabase(dbm, dbid);
+                if (db)
                 {
-                    const database* db = getDatabase(mod, dbid);
-                    if (db)
+                    const std::vector<boost::shared_ptr<table> >& tables =
+                        db->tables();
+
+                    //Lock table add release in the db
+                    boost::mutex::scoped_lock lckt(database::tableRef.mutex());
+                    for (size_t k = 0; k < tables.size(); k++)
                     {
-                        const std::vector<boost::shared_ptr<table> >& tables =
-                            db->tables();
-                        for (size_t k = 0; k < tables.size(); k++)
+                        const table* tb = tables[k].get();
+                        if (tb)
                         {
-                            const table* tb = tables[k].get();
-                            if (tb)
-                            {
-                                m_records.push_back(connection::record());
-                                connection::record& rec =
-                                    m_records[m_records.size() - 1];
-                                rec.conId = (unsigned __int64)mod;
-                                rec.cid = db->clientID();
-
-                                strncpy_s(rec.name, 64, tb->name().c_str(), 64);
-                            }
+                            m_records.push_back(connection::record());
+                            connection::record& rec =
+                                m_records[m_records.size() - 1];
+                            rec.conId = (unsigned __int64)mod;
+                            rec.cid = tb->id();
+                            rec.readCount = tb->readCount();
+                            rec.updCount = tb->updCount();
+                            rec.delCount = tb->delCount();
+                            rec.insCount = tb->insCount();
+                            rec.status = 0;
+                            rec.openNormal = (tb->mode() == TD_OPEN_NORMAL);
+                            rec.openReadOnly = (tb->mode() == TD_OPEN_READONLY);
+                            rec.openEx = (tb->mode() == TD_OPEN_EXCLUSIVE);
+                            rec.openReadOnlyEx = (tb->mode() == TD_OPEN_READONLY_EXCLUSIVE);
+                            strncpy_s(rec.name, 64, tb->name().c_str(), 64);
                         }
                     }
                 }
@@ -144,6 +180,138 @@ const connManager::records& connManager::getRecords(unsigned __int64 conid,
     return m_records;
 }
 
+const connManager::records& connManager::systemVariables() const
+{
+    m_records.clear();
+    for (int i = 0 ; i < TD_VAR_SIZE; ++i)
+    {
+        const char* p =  ::get_trd_sys_var(i);
+        if (p)
+        {
+            m_records.push_back(connection::record());
+            connection::record& rec = m_records[m_records.size() - 1];
+            rec.value_id = i;
+            switch(i)
+            {
+            case TD_VER_DB:
+            case TD_VAR_LISTENADDRESS:
+            case TD_VAR_LISTENPORT:
+            case TD_VAR_HOSTCHECKNAME:
+            case TD_VAR_ISOLATION:
+            case TD_VAR_AUTHTYPE:
+            case TD_VAR_HSLISTENPORT:
+                strncpy(rec.value, p , 65);
+                break;
+            case TD_VER_SERVER:
+                sprintf_s(rec.value, 65, "%d.%d.%d", TRANSACTD_VER_MAJOR, TRANSACTD_VER_MINOR, TRANSACTD_VER_RELEASE);
+                break;
+            default:
+                _ltoa_s(*((unsigned int*)p), rec.value, 65, 10);
+                break;
+            }
+        }
+    }
+    return m_records;
+}
+
+inline void appenDbList(connManager::records& recs, LEX_STRING* db_name)
+{
+    recs.push_back(connection::record());
+    connection::record& rec = recs[recs.size() - 1];
+    strncpy(rec.name, db_name->str, 64);
+    rec.name[64] = 0x00;
+}
+
+const connManager::records& connManager::getDefinedDatabaseList() const
+{
+    m_records.clear();
+    THD* thd = createThdForThread();
+    try
+    {
+        if (thd)
+        {
+            cp_security_ctx(thd)->skip_grants();
+            SQL_Strings files;
+            db_list(thd, &files);
+#ifdef MARIADDB_10_0
+            for (int i = 0; i < (int)files.elements(); ++i)
+                appenDbList(m_records, files.at(i));
+#else
+            List_iterator_fast<LEX_STRING> it(files);
+            LEX_STRING* db_name;
+            while ((db_name = it++))
+                appenDbList(m_records, db_name);
+#endif
+            deleteThdForThread(thd);
+        }
+    }
+    catch (bzs::rtl::exception& e)
+    {
+        if (thd)
+            deleteThdForThread(thd);
+        const int* code = getCode(e);
+        if (code)
+            m_stat = *code;
+        else
+        {
+            m_stat = 20000;
+            sql_print_error("%s", boost::diagnostic_information(e).c_str());
+        }
+        printWarningMessage(code, getMsg(e));
+    }
+    catch (...)
+    {
+        try
+        {
+            m_stat = 20001;
+            deleteThdForThread(thd);
+        }
+        catch(...){}
+    }
+    return m_records;
+}
+
+const connManager::records& connManager::schemaTableList(const char* dbname)
+{
+    try
+    {    
+        m_records.clear();
+        if (dbname && dbname[0])
+        {
+            boost::shared_ptr<database> db(new database(dbname, 1));
+            if (db)
+            {
+                std::vector<std::string> tablelist;
+                schemaBuilder::listSchemaTable(db.get(), tablelist);
+                for (int i = 0; i < (int)tablelist.size(); ++i)
+                {
+                    m_records.push_back(connection::record());
+                    connection::record& rec = m_records[m_records.size() - 1];
+                    strncpy(rec.name, tablelist[i].c_str(), 64);
+                    rec.name[64] = 0x00;
+                }
+            }
+        }
+    }
+    catch (bzs::rtl::exception& e)
+    {
+        const int* code = getCode(e);
+        if (code)
+            m_stat = *code;
+        else
+        {
+            m_stat = 20000;
+            sql_print_error("%s", boost::diagnostic_information(e).c_str());
+        }
+        printWarningMessage(code, getMsg(e));
+    }
+    catch (...)
+    {
+        m_stat = 20001;
+    }
+    return m_records;
+}
+
 void connManager::doDisconnect(unsigned __int64 conid)
 {
     module* mod = const_cast<module*>(getMod(conid));
@@ -179,7 +347,8 @@ void connManager::doDisconnectAll()
     for (size_t i = 0; i < modules.size(); i++)
     {
         const module* mod = dynamic_cast<module*>(modules[i]);
-        doDisconnect((unsigned __int64)mod);
+        if (mod && ((unsigned __int64)mod != m_me))
+            doDisconnect((unsigned __int64)mod);
     }
 }
 

data/source/bzs/db/transactd/connManager.h

@@ -30,6 +30,7 @@ namespace engine
 namespace mysql
 {
 class database;
+class igetDatabases;
 }
 }
 namespace transactd
@@ -45,19 +46,25 @@ public:
 private:
     mutable records m_records;
     unsigned __int64 m_me;
+    mutable short m_stat;
     void getConnectionList() const;
-    void getDatabaseList(const module* mod) const;
-    const bzs::db::engine::mysql::database* getDatabase(const module* mod,
-                                                        int dbid) const;
+    void getDatabaseList(bzs::db::engine::mysql::igetDatabases* dbm, 
+                            const module* mod) const;
+    const bzs::db::engine::mysql::database* getDatabase(
+                bzs::db::engine::mysql::igetDatabases* dbm, int dbid) const;
     void doDisconnect(unsigned __int64 conid);
     void doDisconnectAll();
 
 public:
-    connManager(unsigned __int64 me) : m_me(me){};
+    connManager(unsigned __int64 me) : m_me(me), m_stat(0){};
     virtual ~connManager();
+    const connManager::records& systemVariables() const;
     const records& getRecords(unsigned __int64 conid, int dbid) const;
+    const records& getDefinedDatabaseList() const;
+    const records& schemaTableList(const char* dbname);
     void disconnect(unsigned __int64 conid);
     void disconnectAll();
+    short stat() const {return m_stat;}
 };
 
 } // namespace transactd

data/source/bzs/db/transactd/connectionRecord.h

@@ -34,15 +34,24 @@ namespace connection
 {
 struct record
 {
-    record() : conId(0), cid(0), dbid(0)
+    record() : conId(0), cid(0), dbid(0), trnType(0), status(0), readCount(0), 
+        updCount(0), delCount(0), insCount(0)
     {
         name[0] = 0x00;
-        status = 0;
     }
     __int64 conId;
-    unsigned int cid;
+    union
+    {
+        unsigned int cid;
+        unsigned int value_id;
+    };
     unsigned short dbid;
-    char name[64];
+    short trnType;
+    union 
+    {
+        char name[67];
+        char value[67];
+    };
     union
     {
         char status;
@@ -53,9 +62,14 @@ struct record
             char openNormal : 1;
             char openReadOnly : 1;
             char openEx : 1;
-            char dummy : 3;
+            char openReadOnlyEx : 1;
+            char dummy : 2;
         };
     };
+    unsigned int readCount;
+    unsigned int updCount;
+    unsigned int delCount;
+    unsigned int insCount;
 };
 
 } // connection

data/source/bzs/db/transactd/transactd.cpp

@@ -21,6 +21,7 @@
 #include <bzs/netsvc/server/serverTpool.h>
 #include <bzs/rtl/exception.h>
 #include <bzs/rtl/debuglog.h>
+#include <bzs/db/protocol/tdap/tdapcapi.h>
 #include <stdio.h>
 #include <iostream>
 #include <string>
@@ -46,16 +47,14 @@ using namespace bzs::netsvc::server;
 static char* g_listenAddress = NULL;
 static char* g_listenPort = NULL;
 static char* g_hostCheckUserName = NULL;
-
 static unsigned int g_tcpServerType = TCP_CPT_SERVER;
-
 static unsigned int g_maxTcpConnections = 200;
 static unsigned int g_pool_threads = 20;
-unsigned int g_pipeCommSharememSize = PIPE_SHARE_MEM_SIZE;
 int g_tableNmaeLower = 1; // defined in btrvProtocol.h
 unsigned int g_lock_wait_timeout = 1;
 char* g_transaction_isolation = NULL;
 char* g_auth_type = NULL;
+unsigned int g_pipeCommSharememSize = PIPE_SHARE_MEM_SIZE;
 //int g_grant_apply = 0;//skip
 
 
@@ -145,7 +144,9 @@ static int transactd_plugin_init(void* p)
         {
             boost::shared_ptr<IAppModuleBuilder> app(new transctionalIF(
                 PROTOCOL_TYPE_BTRV | PROTOCOL_TYPE_MEMBUFFER));
-            srv_p.reset(new pipe::server(app, PIPE_NAME, g_maxPipeConnections,
+            srv_p.reset(new pipe::server(app, PIPE_NAME, 
+                                         ((strcmp(g_listenPort, "8610") == 0) ? "": g_listenPort),
+                                         g_maxPipeConnections,
                                          g_pipeCommSharememSize,
                                          g_hostCheckUserName));
             srv_p->registerErrorHandler(&srvErh);
@@ -226,7 +227,7 @@ static struct st_mysql_daemon transactd_info = {
     MYSQL_DAEMON_INTERFACE_VERSION
 };
 
-/** system valiable define
+/** system variables define
  */
 static MYSQL_SYSVAR_STR(address, g_listenAddress,
                         PLUGIN_VAR_READONLY | PLUGIN_VAR_MEMALLOC,
@@ -300,9 +301,39 @@ static struct st_mysql_sys_var* g_systemVariables[] =
     0
 };
 
-/** show valiables struct.
+const char* get_trd_sys_var(int index)
+{
+    switch(index)
+    {
+    case TD_VAR_LISTENADDRESS:return g_listenAddress;
+    case TD_VAR_LISTENPORT:return g_listenPort;
+    case TD_VAR_HOSTCHECKNAME:return g_hostCheckUserName;
+    case TD_VAR_MAXTCPCONNECTIONS:return (const char*)&g_maxTcpConnections;
+    case TD_VAR_TABLENAMELOWER:return (const char*)&g_tableNmaeLower;
+    case TD_VAR_POOLTHREADS:return (const char*)&g_pool_threads;
+    case TD_VAR_TCPSERVERTYPE:return (const char*)&g_tcpServerType;
+    case TD_VAR_LOCKWAITTIMEOUT:return (const char*)&g_lock_wait_timeout;
+    case TD_VAR_ISOLATION:return g_transaction_isolation;
+    case TD_VAR_AUTHTYPE:return g_auth_type;
+#ifdef PIPE_SERVER
+    case TD_VAR_PIPESHAREMEMSIZE:return (const char*)&g_pipeCommSharememSize;
+    case TD_VAR_MAXPIPECONNECTIONS:return (const char*)&g_maxPipeConnections;
+    case TD_VAR_USEPIPE:return (const char*)&g_usePipedLocal;
+#endif
+#ifdef USE_HANDLERSOCKET
+    case TD_VAR_HSLISTENPORT:return g_hs_listenPort;
+    case TD_VAR_USEHS:return (const char*)&g_use_hs;
+#endif
+    case TD_VER_DB: return MYSQL_SERVER_VERSION;
+    case TD_VER_SERVER:return "";
+
+    };
+    return NULL;
+}
+
+/** show status struct.
  */
-static st_mysql_show_var g_showVariables[] = {
+static st_mysql_show_var g_statusVariables[] = {
     { "trnsctd_tcp_connections", (char*)&cpt::g_connections, SHOW_INT },
     { "trnsctd_tcp_wait_threads", (char*)&cpt::g_waitThread, SHOW_INT },
     { "trnsctd_tpool_connections", (char*)&tpool::g_connections, SHOW_INT },
@@ -329,7 +360,7 @@ mysql_declare_plugin(transactd)
     transactd_plugin_init,
     transactd_plugin_deinit, 
     0x0100, 
-    g_showVariables,
+    g_statusVariables,
     g_systemVariables,
     NULL
 }

data/source/bzs/env/crosscompile.cpp

@@ -127,7 +127,7 @@ int wmemcmp16(const char16_t* sl, const char16_t* sr, size_t n)
         ++sl;
         ++sr;
     }
-    return 0 - *sr;
+    //return 0 - *sr;
 }
 
 

data/source/bzs/example/queryData.cpp

@@ -241,7 +241,7 @@ bool createUserExtTable(dbdef* def)
 
 bool createCacheTable(dbdef* def)
 {
-    short tableid = 4;
+    short tableid = 5;
     tabledef t;
     tabledef* td = &t;
     td->charsetIndex = mysql::charsetIndex(GetACP());

data/source/bzs/netsvc/client/iconnection.h

@@ -29,6 +29,7 @@
 #include <boost/asio/ip/tcp.hpp>
 #include <boost/asio/buffer.hpp>
 #endif
+#include <boost/system/system_error.hpp>
 #include <vector>
 
 
@@ -105,6 +106,7 @@ public:
     virtual void write(unsigned int writeSize) = 0;
     virtual char* read() = 0;
     virtual bool isHandShakable() const = 0;
+    virtual const boost::system::error_code& error() const = 0;
 };
 
 #define CONNECTION_FUNCTION_DIRECT_READ 1

data/source/bzs/netsvc/client/tcpClient.cpp

@@ -39,7 +39,7 @@ namespace netsvc
 namespace client
 {
 
-char connections::port[PORTNUMBUF_SIZE] = { "8610" };
+char connections::m_port[PORTNUMBUF_SIZE] = { "8610" };
 bool connections::m_usePipedLocal = true;
 #ifdef _WIN32
 int connections::connectTimeout = 20000;
@@ -68,7 +68,7 @@ connections::connections(const char* pipeName) : m_pipeName(pipeName),m_resolver
         m_usePipedLocal = (atol(tmp) != 0);
         GetPrivateProfileString("transctd_client", "port", "8610", tmp, 30,
                                 buf);
-        strcpy_s(port, PORTNUMBUF_SIZE, tmp);
+        strcpy_s(m_port, PORTNUMBUF_SIZE, tmp);
         GetPrivateProfileString("transctd_client", "connectTimeout", 
             DEFAULT_CONNECT_TIMEOUT, tmp, 30, buf);
         connectTimeout = atoi(tmp)*1000;
@@ -93,7 +93,7 @@ connections::connections(const char* pipeName) : m_pipeName(pipeName),m_resolver
             std::string p = pt.get<std::string>("transctd_client.port");
             if (p == "")
                 p = "8610";
-            strcpy_s(port, PORTNUMBUF_SIZE, p.c_str());
+            strcpy_s(m_port, PORTNUMBUF_SIZE, p.c_str());
 
             p = pt.get<std::string>("transctd_client.connectTimeout");
             connectTimeout = atol(p.c_str());
@@ -137,8 +137,11 @@ connection* connections::getConnection(asio::ip::tcp::endpoint& ep)
 }
 
 asio::ip::tcp::endpoint connections::endpoint(const std::string& host,
+                                              const char* port,
                                               boost::system::error_code& ec)
 {
+
+    if (!port || port[0] == 0x00) port = m_port;
     tcp::resolver::query query(host, port);
 
     tcp::resolver::iterator dest = m_resolver.resolve(query, ec);
@@ -156,11 +159,11 @@ asio::ip::tcp::endpoint connections::endpoint(const std::string& host,
     return endpoint;
 }
 
-connection* connections::getConnection(const std::string& host)
+connection* connections::getConnection(const std::string& host, const char* port)
 {
     mutex::scoped_lock lck(m_mutex);
     boost::system::error_code ec;
-    tcp::endpoint ep = endpoint(host, ec);
+    tcp::endpoint ep = endpoint(host, port, ec);
     if (!ec)
         return getConnection(ep);
     return NULL;
@@ -204,14 +207,14 @@ bool connections::disconnect(connection* c)
  */
 bool connections::isUseNamedPipe(asio::ip::tcp::endpoint& ep)
 {
-    boost::system::error_code ec;
-    asio::ip::tcp::endpoint local = endpoint("127.0.0.1", ec);
-    if (!ec && (local == ep))
+    asio::ip::tcp::endpoint local(ip::address::from_string("127.0.0.1"), ep.port()); 
+    if (local == ep)
         return true;
     char buf[MAX_PATH];
     if (::gethostname(buf, MAX_PATH) == 0)
     {
-        local = endpoint(buf, ec);
+        boost::system::error_code ec;
+        local = endpoint(buf, m_port, ec);
         if (local == ep)
             return true;
     }
@@ -238,27 +241,35 @@ inline connection* connections::doConnect(connection* c)
     try
     {
         c->connect();
-        return c;
+        if (c->isConnected())
+            return c;
+        m_e = c->error();
+        delete c;
+        return NULL;
     }
     catch (bzs::netsvc::client::exception& e)
     {
+        m_e = boost::system::error_code(e.error(), get_system_category());
         delete c;
-        throw e;
+        return NULL;
     }
     catch (boost::system::system_error& e)
     {
+        m_e = e.code();
         delete c;
-        throw e;
+        return NULL;
     }
-    catch (std::exception& e)
+    catch (std::exception& /*e*/)
     {
+        m_e = boost::system::error_code(1, get_system_category());
         delete c;
-        throw e;
+        return NULL;
     }
     catch (...)
     {
+        m_e = boost::system::error_code(1, get_system_category());
         delete c;
-        throw;
+        return NULL;
     }
 }
 
@@ -272,34 +283,42 @@ inline bool connections::doHandShake(connection* c, handshake f, void* data)
         {
             if (!f)
                 c->read();
-            else 
+            else
                 ret = f(c, data);
+            if (c->error())
+                m_e = asio::error::connection_refused;
+            else if (!ret)
+                m_e = asio::error::no_permission;
             if (!ret)
                 delete c;
         }
         return ret;
     }
-    catch (bzs::netsvc::client::exception& /*e*/)
+    catch (bzs::netsvc::client::exception& e)
     {
         delete c;
-        throw;
+        m_e = boost::system::error_code(e.error(), get_system_category());
+        return false;
     }
-    catch (boost::system::system_error& /*e*/)
+    catch (boost::system::system_error& e)
     {
+        m_e = e.code();
         delete c;
-        throw;
+        return false;
     }
 }
 
+#if defined(__BCPLUSPLUS__)
+#pragma warn -8004
+#endif
 // The connection of found from connection list of same address is returned.
-connection* connections::connect(const std::string& host, handshake f, void* data, bool newConnection)
+connection* connections::connect(const std::string& host, const char* port, handshake f, void* data, bool newConnection)
 {
     bool namedPipe = false;
-    boost::system::error_code ec;
     connection* c;
     mutex::scoped_lock lck(m_mutex);
-    asio::ip::tcp::endpoint ep = endpoint(host, ec);
-    if (ec)
+    asio::ip::tcp::endpoint ep = endpoint(host, port, m_e);
+    if (m_e)
         return NULL;
 #ifdef USE_PIPE_CLIENT
     namedPipe =  (m_usePipedLocal && isUseNamedPipe(ep));
@@ -319,13 +338,16 @@ connection* connections::connect(const std::string& host, handshake f, void* dat
     c->addref();
     return c;
 }
+#if defined(__BCPLUSPLUS__)
+#pragma warn .8004
+#endif
 
-bool connections::reconnect(connection* c, const std::string& host,
+bool connections::reconnect(connection* c, const std::string& host, const char* port,
                         handshake f, void* data)
 {
     boost::system::error_code ec;
     mutex::scoped_lock lck(m_mutex);
-    asio::ip::tcp::endpoint ep = endpoint(host, ec);
+    asio::ip::tcp::endpoint ep = endpoint(host, port, ec);
     if (ec)
         return false;
     c->reconnect(ep);