transactd 2.1.0 → 2.2.0

data/source/bzs/db/protocol/tdap/mysql/tdapCommandExecuter.h

@@ -24,6 +24,17 @@
 #include "request.h"
 #include <bzs/env/crosscompile.h>
 
+
+#define GRANT_APPLY_NONE 0
+#define GRANT_APPLY_ALL  1
+
+#define AUTH_TYPE_NONE_STR  "none"
+#define AUTH_TYPE_MYSQL_STR  "mysql_native"
+
+#define AUTH_TYPE_NONE  0
+#define AUTH_TYPE_MYSQL 1
+
+extern char* g_auth_type;
 extern int g_tableNmaeLower;
 
 namespace bzs
@@ -31,6 +42,8 @@ namespace bzs
 namespace db
 {
 class blobBuffer;
+namespace engine{namespace mysql{class database;}}
+
 namespace protocol
 {
 namespace tdap
@@ -53,12 +66,13 @@ class dbExecuter : public engine::mysql::dbManager
 {
     ReadRecordsHandler* m_readHandler;
     blobBuffer* m_blobBuffer;
-
-    void connect(request& req);
+    unsigned char m_scramble[MYSQL_SCRAMBLE_LENGTH+1];
+    netsvc::server::IAppModule* m_mod;
     void releaseDatabase(request& req, int op);
     std::string makeSQLcreateTable(const request& req);
-    inline void doCreateTable(request& req);
-    inline void doOpenTable(request& req);
+    bool connect(request& req);
+    inline bool doCreateTable(request& req);
+    inline bool doOpenTable(request& req);
     inline void doSeekKey(request& req, int op, engine::mysql::rowLockMode* lock);
     inline void doMoveFirst(request& req, engine::mysql::rowLockMode* lock);
     inline void doMoveKey(request& req, int op, engine::mysql::rowLockMode* lock);
@@ -75,16 +89,19 @@ class dbExecuter : public engine::mysql::dbManager
     inline void doInsertBulk(request& req);
     inline void doStat(request& req);
     inline short seekEach(extRequestSeeks* ereq, bool noBookMark);
-
+    inline bool doAuthentication(request& req, engine::mysql::database* db);
+    bool getDatabaseWithAuth(request& req, engine::mysql::database** db, bool connect=false);
 public:
-    dbExecuter();
+    dbExecuter(netsvc::server::IAppModule* mod);
     ~dbExecuter();
     int commandExec(request& req, netsvc::server::netWriter* nw);
+    size_t getAcceptMessage(char* message, size_t size);
     int errorCode(int ha_error);
     short_td errorCodeSht(int ha_error)
     {
         return (short_td)errorCode(ha_error);
-    };
+    }
+    netsvc::server::IAppModule* mod() { return m_mod; };
 };
 
 /** Command dispatcher for connectionManager
@@ -110,17 +127,15 @@ class commandExecuter : public ICommandExecuter,
 
     int readStatistics(char* buf, size_t& size);
     int cmdStatistics(char* buf, size_t& size);
-    unsigned __int64 m_modHandle;
 
 public:
-    commandExecuter(__int64 parent);
+    commandExecuter(netsvc::server::IAppModule* mod);
     ~commandExecuter();
     size_t perseRequestEnd(const char* p, size_t size, bool& comp) const;
 
     size_t getAcceptMessage(char* message, size_t size)
     {
-        strcpy_s(message, size, "200 OK\n");
-        return strlen(message);
+        return m_dbExec->getAcceptMessage(message, size);
     }
 
     bool parse(const char* p, size_t size);
@@ -128,7 +143,8 @@ public:
     int execute(netsvc::server::netWriter* nw)
     {
         if (m_req.op == TD_STASTISTICS)
-            return connMgrExecuter(m_req, m_modHandle).commandExec(nw);
+            return connMgrExecuter(m_req, (unsigned __int64)m_dbExec->mod())
+                                            .commandExec(nw);
         return m_dbExec->commandExec(m_req, nw);
     }
 

data/source/bzs/db/protocol/tdap/tdapRequest.h

@@ -115,13 +115,14 @@ struct clientID
 
 #ifdef __x86_64__
     bzs::netsvc::client::connection* con;
-
-    char_td reserved[4];
+    unsigned short transaction_isolation;
+    unsigned short lock_wait_timeout;
 #else // NOT __x86_64__
 
     bzs::netsvc::client::connection* con;
-
-    char_td reserved[8];
+    unsigned short transaction_isolation;
+    unsigned short lock_wait_timeout;
+    char_td reserved[4];
 #endif // NOT __x86_64__
     char_td aid[2];
     ushort_td id;

data/source/bzs/db/protocol/tdap/tdapSchema.h

@@ -216,7 +216,12 @@ public:
     uchar_td nullValue; // null value
     ushort_td userOption; // ** option
     uchar_td lookDBNum; // ** database number of reference bitD
-    ushort_td keylen; // key length for mysql of part key
+    
+    /** The length of the mysql part key
+    
+       If this field is used by two or more keys, and both this length is used. 
+    */
+    ushort_td keylen; 
 
 protected:
     uchar_td m_charsetIndex; // charctor set index of this field data

data/source/bzs/db/protocol/tdap/tdapcapi.h

@@ -68,7 +68,7 @@ typedef short_td(__STDCALL* DLLUNLOADCALLBACK_PTR)(dllUnloadCallback func);
 #define MAX_KEYLEN                      0X3FF   // 1023
 #endif
 #define BTRV_MAX_DATA_SIZE              57000
-#define TDAP_MAX_DATA_SIZE              6291456 // 3Mbyte
+#define TDAP_MAX_DATA_SIZE              6291456 // 6Mbyte
 #define BOOKMARK_ALLOC_SIZE             40960
 
 /** operation type
@@ -143,6 +143,7 @@ typedef short_td(__STDCALL* DLLUNLOADCALLBACK_PTR)(dllUnloadCallback func);
 #define TD_GET_BLOB_BUF                 93
 #define TD_STASTISTICS                  94
 #define TD_KEY_SEEK_MULTI               95
+#define TD_ACL_RELOAD                   96
 
 /** create sub operations
  */
@@ -246,6 +247,7 @@ typedef short_td(__STDCALL* DLLUNLOADCALLBACK_PTR)(dllUnloadCallback func);
 
 /** btrv transaction lock options
  */
+#define LOCK_BIAS_DEFAULT               0
 #define LOCK_SINGLE_WAIT                100
 #define LOCK_SINGLE_NOWAIT              200
 #define LOCK_MULTI_WAIT                 300
@@ -276,6 +278,12 @@ typedef short_td(__STDCALL* DLLUNLOADCALLBACK_PTR)(dllUnloadCallback func);
 #define ROW_LOCK_X                      LOCK_SINGLE_NOWAIT
 #define ROW_LOCK_S                      5000 + LOCK_SINGLE_NOWAIT
 
+//Server isoration
+#define SRV_ISO_READ_UNCOMMITED   0
+#define SRV_ISO_READ_COMMITED     1
+#define SRV_ISO_REPEATABLE_READ   2
+#define SRV_ISO_SERIALIZABLE      3
+
 /** open mode
  */
 #define TD_OPEN_NORMAL                  0
@@ -365,6 +373,7 @@ typedef short_td(__STDCALL* DLLUNLOADCALLBACK_PTR)(dllUnloadCallback func);
 #define STATUS_INVALID_DATASIZE         STATUS_BUFFERTOOSMALL
 #define STATUS_INVALID_FIELDNAME        STATUS_INVALID_FIELD_OFFSET
 #define ERROR_TD_INVALID_CLINETHOST     171
+#define ERROR_NO_DATABASE               172
 #define ERROR_NOSPECIFY_TABLE           176
 #define ERROR_LOAD_CLIBRARY             200
 #define ERROR_INDEX_RND_INIT            201
@@ -420,13 +429,29 @@ struct trdVersiton
     ushort_td srvMinor;
     ushort_td srvRelease;
 };
+
+#define MYSQL_SCRAMBLE_LENGTH 20
+#define MYSQL_USERNAME_MAX    16
+
+struct handshale_t
+{
+    unsigned int size;  // size of this
+    unsigned int options;
+    trdVersiton ver;
+    unsigned short transaction_isolation;
+    unsigned short lock_wait_timeout;
+    unsigned char scramble[MYSQL_SCRAMBLE_LENGTH+1]; //user auth scramble
+};
+
+#define HST_OPTION_NO_SCRAMBLE 1
+
 /** @endcond */
 
 /* In the case of "tdclcppxxx" library of msvc, The ($TargetName) is not changed automatically.
  If you change this version then you need change The ($TargetName) project options too.
  */
 #define C_INTERFACE_VER_MAJOR "2"//##1 Build marker! Don't remove
-#define C_INTERFACE_VER_MINOR "1"//##2 Build marker! Don't remove
+#define C_INTERFACE_VER_MINOR "2"//##2 Build marker! Don't remove
 #define C_INTERFACE_VER_RELEASE "0"//##3 Build marker! Don't remove
 
 /* dnamic load library name.
@@ -490,7 +515,7 @@ struct trdVersiton
  */
 
 #define CPP_INTERFACE_VER_MAJOR "2"//##4 Build marker! Don't remove
-#define CPP_INTERFACE_VER_MINOR "1"//##5 Build marker! Don't remove
+#define CPP_INTERFACE_VER_MINOR "2"//##5 Build marker! Don't remove
 #define CPP_INTERFACE_VER_RELEASE "0"//##6 Build marker! Don't remove
 
 /* use autolink tdclcpp */
@@ -507,7 +532,7 @@ struct trdVersiton
 #endif
 
 #define TRANSACTD_VER_MAJOR 2//##7 Build marker! Don't remove
-#define TRANSACTD_VER_MINOR 1//##8 Build marker! Don't remove
+#define TRANSACTD_VER_MINOR 2//##8 Build marker! Don't remove
 #define TRANSACTD_VER_RELEASE 0//##9 Build marker! Don't remove
 
 #endif // BZS_DB_PROTOCOL_TDAP_TDAPCAPI_H

data/source/bzs/db/protocol/tdap/uri.h

@@ -0,0 +1,297 @@
+#ifndef BZS_DB_PROTOCOL_TDAP_URI_H
+#define BZS_DB_PROTOCOL_TDAP_URI_H
+/* =================================================================
+ Copyright (C) 2015 BizStation Corp All rights reserved.
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ 02111-1307, USA.
+ ================================================================= */
+#include <bzs/env/compiler.h>
+#include <bzs/env/crosscompile.h>
+#include <tchar.h>
+#include <boost/version.hpp>
+
+#if BOOST_VERSION > 103901
+#include <boost/uuid/sha1.hpp>
+#else
+#include <global/boost/sha1.hpp>
+#endif
+#include <bzs/db/protocol/tdap/tdapcapi.h>
+
+namespace bzs
+{
+namespace db
+{
+namespace protocol
+{
+namespace tdap
+{
+
+inline const _TCHAR* protocol(const _TCHAR* uri)
+{
+    const _TCHAR* st = _tcsstr(uri, _T("tdap://"));
+    if (st)
+        return _T("tdap");
+    else
+    {
+        st = _tcsstr(uri, _T("btrv://"));
+        return _T("btrv");
+    }
+    return _T("");
+}
+
+inline const _TCHAR* hostName(const _TCHAR* uri, _TCHAR* buf, size_t size)
+{
+    buf[0] = 0x00;
+    const _TCHAR* st = _tcsstr(uri, _T("@"));
+    if (st) 
+        ++st;
+    else
+    {
+        st = _tcsstr(uri, _T("://"));
+        if (st) st+=3;
+    }
+    if (st)
+    {
+        const _TCHAR* en = _tcsstr(st, _T("/"));
+        if (en)
+        {
+            _tcsncpy_s(buf, size, st, en - st);
+            buf[en - st] = 0x00;
+        }
+    }
+    return buf;
+}
+
+inline const _TCHAR* dbname(const _TCHAR* uri, _TCHAR* buf, size_t size)
+{
+    buf[0] = 0x00;
+    const _TCHAR* st = _tcsstr(uri, _T("://"));
+    if (st)
+    {
+        st = _tcsstr(st + 3, _T("/"));
+        if (st)
+        {
+            const _TCHAR* en = _tcsstr(st + 1, _T("?"));
+            if (en)
+            {
+                _tcsncpy_s(buf, size, st + 1, en - (st + 1));
+                buf[en - (st + 1)] = 0x00;
+            }
+        }
+    }
+    return buf;
+}
+
+inline const _TCHAR* schemaTable(const _TCHAR* uri, _TCHAR* buf, size_t size)
+{
+    buf[0] = 0x00;
+    const _TCHAR* st = _tcsstr(uri, _T("dbfile="));
+    if (st)
+    {
+        st+= 7;
+        const _TCHAR* en = _tcsrchr(uri, _T('.'));
+        if (en)
+        {
+            _tcsncpy_s(buf, size, st, en - st);
+            buf[en - st] = 0x00;
+        }else if (_tcsstr(st, TRANSACTD_SCHEMANAME))
+            _tcscpy_s(buf, size, TRANSACTD_SCHEMANAME);
+    }
+    return buf;
+}
+
+inline const _TCHAR* userName(const _TCHAR* uri, _TCHAR* buf, size_t size)
+{
+    buf[0] = 0x00;
+    const _TCHAR* st = _tcsstr(uri, _T("://"));
+    if (st) st+=3;
+ 
+    if (st)
+    {
+        const _TCHAR* en = _tcsstr(st, _T("@"));
+        if (en)
+        {
+            _tcsncpy_s(buf, size, st, en - st);
+            buf[en - st] = 0x00;
+        }
+    }
+    return buf;
+}
+
+inline const _TCHAR* passwd(const _TCHAR* uri, _TCHAR* buf, size_t size)
+{
+    buf[0] = 0x00;
+    const _TCHAR* st = _tcsstr(uri, _T("pwd="));
+    if (st)
+        _tcscpy_s(buf, size, st+4);
+    return buf;
+}
+
+inline const _TCHAR* stripAuth(const _TCHAR* uri, _TCHAR* buf, size_t size)
+{
+    _tcscpy_s(buf, size, uri);
+    _TCHAR* st = _tcsstr(buf, _T("://"));
+    if (st)
+    {
+        const _TCHAR* en = _tcsstr(uri, _T("@"));
+        if (en)
+        {
+            _tcscpy_s(st+3, size, ++en);
+            _TCHAR* st2 = _tcsstr(st, _T("&pwd="));
+            if (st2)
+                *st2 = 0x00;
+            else
+            {
+                st2 = _tcsstr(st, _T("?pwd="));
+                if (st2) *st2 = 0x00;
+            }
+        }
+    }
+    return buf;
+}
+
+inline const _TCHAR* stripPasswd(const _TCHAR* uri, _TCHAR* buf, size_t size)
+{
+    _tcscpy_s(buf, size, uri);
+    _TCHAR* st = _tcsstr(buf, _T("://"));
+    if (st)
+    {
+        st = _tcsstr(st, _T("pwd="));
+        if (st)
+            *(st + 4) = 0x00;
+    }
+    return buf;
+}
+
+inline const _TCHAR* stripPasswdParam(const _TCHAR* uri, _TCHAR* buf, size_t size)
+{
+    _tcscpy_s(buf, size, uri);
+    _TCHAR* st = _tcsstr(buf, _T("://"));
+    if (st)
+    {
+        _TCHAR* st2 = _tcsstr(st, _T("&pwd="));
+        if (st2)
+            *(st2) = 0x00;
+        else
+        {
+            st2 = _tcsstr(st, _T("?pwd="));
+            if (st2)
+                *(st2) = 0x00;
+        }
+    }
+    return buf;
+}
+
+inline void reorder_digest(boost::uuids::detail::sha1::digest_type val)
+{
+    for (int i=0;i<5;++i)
+    {
+        unsigned char* p = (unsigned char*)&val[i];
+        std::swap(*p, *(p+3));
+        std::swap(*(p+1), *(p+2));
+    }
+}
+
+inline void sha1Passwd(boost::uuids::detail::sha1::digest_type retVal , 
+                                    const char* src)
+{
+    boost::uuids::detail::sha1 sha1;
+    sha1.reset();
+    sha1.process_bytes(src, strlen(src));
+    sha1.get_digest(retVal);
+    reorder_digest(retVal);
+}
+
+inline void cryptKeyGen(boost::uuids::detail::sha1::digest_type retVal, 
+             const unsigned int* sha1Passwd, const unsigned char *scramble)
+{
+    boost::uuids::detail::sha1 sha1;
+    sha1.reset();
+    sha1.process_bytes(sha1Passwd, MYSQL_SCRAMBLE_LENGTH);
+    sha1.get_digest(retVal);
+    reorder_digest(retVal);
+    sha1.reset();
+    sha1.process_bytes(scramble, MYSQL_SCRAMBLE_LENGTH);
+    sha1.process_bytes(retVal, MYSQL_SCRAMBLE_LENGTH);
+    sha1.get_digest(retVal);
+    reorder_digest(retVal);
+}
+
+inline void xorCrypt(char *retVal, const unsigned char *src, const unsigned char *key, 
+        unsigned int len)
+{
+    const unsigned char *end = src + len;
+    while (src < end)
+        *retVal++ = *src++ ^ *key++;
+}
+
+/* scramble size = MYSQL_SCRAMBLE_LENGTH only 
+   retVal size = MYSQL_SCRAMBLE_LENGTH
+*/
+inline void mysqlCryptPwd(char *retVal, const char* src, const unsigned char *scramble)
+{
+    unsigned int sha1pwd[5];
+    unsigned int key[5];
+    sha1Passwd(sha1pwd, src);
+    cryptKeyGen(key, sha1pwd, scramble);
+    xorCrypt(retVal, (const unsigned char*)sha1pwd, (const unsigned char*)key, 
+                        MYSQL_SCRAMBLE_LENGTH);
+}
+
+// binary to ascii return bytes = size * 2
+inline char* binToHex(char* retVal, const unsigned char *src, int size)
+{
+    const unsigned char* end = src + size;
+    char* p = retVal;
+    for (const unsigned char* n = src; n != end; ++n)
+    {
+	    unsigned int v = (*n >> 4);
+	    *p++ = (v < 10) ? '0' + v : 'A' + (v - 10);
+	    v = *n & 0x0F;
+	    *p++ = (v < 10) ? '0' + v : 'A' + (v - 10);
+    }
+    *p = 0x00;
+    return retVal;
+}
+
+// ascii to binary return bytes = size / 2
+inline unsigned char* hexTobin(unsigned char* retVal, const char *src, int size)
+{
+    const char* end = src + size;
+    unsigned char* p = retVal;
+    for (const char* n = src; n != end; ++n)
+    {
+        if (*n >= '0' && *n <= '9')
+            *p = *n - '0';
+        else
+            *p = (*n - 'A')+10;
+        ++n;
+        *p = *p << 4;
+        if (*n >= '0' && *n <= '9')
+            *p += *n - '0';
+        else
+            *p += (*n - 'A')+10;
+        ++p;
+    }
+    return retVal;
+}
+
+
+} // namespace tdap
+} // namespace protocol
+} // namespace db
+} // namespace bzs
+#endif // BZS_DB_PROTOCOL_TDAP_URI_H

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

@@ -308,12 +308,12 @@ module::module(const boost::asio::ip::tcp::endpoint& endpoint,
     : m_endpoint(endpoint), m_connection(connection), m_useThreadPool(tpool)
 {
     if (type & PROTOCOL_TYPE_BTRV)
-        m_commandExecuter.reset(new protocol::tdap::mysql::commandExecuter(
-            (unsigned __int64) this));
+        m_commandExecuter.reset(new protocol::tdap::mysql::commandExecuter(this));
+            
 #ifdef USE_HANDLERSOCKET
     else if (type & PROTOCOL_TYPE_HS)
         m_commandExecuter.reset(
-            new protocol::hs::commandExecuter((unsigned __int64) this));
+            new protocol::hs::commandExecuter(this));
 #endif
     boost::mutex::scoped_lock lck(modulesMutex);
     modules.push_back(this);
@@ -361,8 +361,8 @@ size_t module::onAccept(char* message, size_t bufsize)
 
 static const char* addressMasks[3] = { ".0.0.0/255.0.0.0", ".0.0/255.255.0.0",
                                        ".0/255.255.255.0" };
-
-char* addressClass(char* buf, int bufsize, const char* host, int type)
+static const char* addressWildcard[3] = { ".%", ".%", ".%" };
+char* addressClass(char* buf, int bufsize, const char* host, int type, const char* ar[] )
 {
     strcpy_s(buf, bufsize, host);
     for (int i = 3; i >= type; i--)
@@ -372,43 +372,68 @@ char* addressClass(char* buf, int bufsize, const char* host, int type)
             return buf;
         *p = 0x00;
     }
-    strcat_s(buf, bufsize, addressMasks[type - 1]);
+    strcat_s(buf, bufsize, ar[type - 1]);
     return buf;
 }
 
-bool isAclUser(const char* host, const char* user)
+bool isAclUser(const char* &host, const char* user, char* buf, int size)
 {
     bool ret = is_acl_user(host, user);
     if (ret)
         return true;
-    for (int i = 1; i <= 3; i++)
+    
+    for (int i = 3; i >= 1; --i)
     {
-        char buf[256];
-        ret = is_acl_user(addressClass(buf, 256, host, i), user);
+        ret = is_acl_user(addressClass(buf, size, host, i, addressMasks), user);
         if (ret)
+        {
+            host = buf;
             return true;
+        }
+    }
+    for (int i = 3; i >= 1; --i)
+    {
+        ret = is_acl_user(addressClass(buf, size, host, i, addressWildcard), user);
+        if (ret)
+        {
+            host = buf;
+            return true;
+        }
     }
     return false;
 }
 
-bool module::checkHost(const char* hostCheckname)
+bool module::checkHost(const char* hostCheckname, /*out*/char* hostName, int size)
 {
+    // if size=0 called by server, size !=0 called by user auth
+    if ((size == 0) && (strcmp(g_auth_type, AUTH_TYPE_MYSQL_STR)==0))
+        return true;
     std::string addr = m_endpoint.address().to_string();
     size_t pos = addr.find_last_of(":");
     if (pos != std::string::npos)
         addr = addr.substr(pos + 1);
-
+    const char* p = addr.c_str();
     bool ret = true;
-    if (!isAclUser(addr.c_str(), hostCheckname))
+    char buf[256];
+    if (!isAclUser(p, hostCheckname, buf, 256))
     {
-        ret =
-            isAclUser(m_endpoint.address().to_string().c_str(), hostCheckname);
+        p = m_endpoint.address().to_string().c_str();
+        ret = isAclUser(p, hostCheckname, buf, 256);
         if (!ret && m_endpoint.address().is_v4())
         {
             if (addr == std::string("127.0.0.1"))
-                ret = isAclUser("localhost", hostCheckname);
+            {
+                p = "localhost";
+                ret = isAclUser(p, hostCheckname, buf, 256);
+            }
         }
     }
+    if (hostName && (size > (int)strlen(p)))
+    {
+        if (strcmp(p , "127.0.0.1") == 0)
+            p = "localhost";
+        strcpy(hostName, p);
+    }
     return ret;
 }
 

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

@@ -52,7 +52,6 @@ class module : public netsvc::server::IAppModule, private boost::noncopyable
     bool perseLineEnd(const char* p, size_t size) const;
     size_t onRead(const char* data, size_t size, bool& complete);
     size_t onAccept(char* message, size_t bufsize);
-
 public:
     module(const boost::asio::ip::tcp::endpoint& endpoint,
            bzs::netsvc::server::iconnection* connection, bool tpool, int type);
@@ -62,7 +61,7 @@ public:
                 netsvc::server::buffers* optionalData);
     void cleanup() { m_commandExecuter->cleanup(); };
     bool isShutDown() { return m_commandExecuter->isShutDown(); }
-    bool checkHost(const char* hostCheckname);
+    bool checkHost(const char* hostCheckname, /*out*/char* hostName, int size);
     void disconnect();
     boost::mutex& mutex() const { return m_mutex; };
 };