transactd 2.1.0 → 2.2.0

data/source/global/boost/sha1.hpp

@@ -0,0 +1,223 @@
+// boost/uuid/sha1.hpp header file  ----------------------------------------------//
+
+// Copyright 2007 Andy Tompkins.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// Revision History
+//  29 May 2007 - Initial Revision
+//  25 Feb 2008 - moved to namespace boost::uuids::detail
+//  10 Jan 2012 - can now handle the full size of messages (2^64 - 1 bits)
+
+// This is a byte oriented implementation
+
+#ifndef BOOST_UUID_SHA1_H
+#define BOOST_UUID_SHA1_H
+
+#include <boost/static_assert.hpp>
+#include <stdexcept>
+#include <boost/throw_exception.hpp>
+#include <cstddef>
+
+#ifdef BOOST_NO_STDC_NAMESPACE
+namespace std {
+    using ::size_t;
+} // namespace std
+#endif
+
+namespace boost {
+namespace uuids {
+namespace detail {
+
+BOOST_STATIC_ASSERT(sizeof(unsigned char)*8 == 8);
+BOOST_STATIC_ASSERT(sizeof(unsigned int)*8 == 32);
+
+inline unsigned int left_rotate(unsigned int x, std::size_t n)
+{
+    return (x<<n) ^ (x>> (32-n));
+}
+
+class sha1
+{
+public:
+    typedef unsigned int(&digest_type)[5];
+public:
+    sha1();
+
+    void reset();
+
+    void process_byte(unsigned char byte);
+    void process_block(void const* bytes_begin, void const* bytes_end);
+    void process_bytes(void const* buffer, std::size_t byte_count);
+
+    void get_digest(digest_type digest);
+
+private:
+    void process_block();
+    void process_byte_impl(unsigned char byte);
+
+private:
+    unsigned int h_[5];
+
+    unsigned char block_[64];
+
+    std::size_t block_byte_index_;
+    std::size_t bit_count_low;
+    std::size_t bit_count_high;
+};
+
+inline sha1::sha1()
+{
+    reset();
+}
+
+inline void sha1::reset()
+{
+    h_[0] = 0x67452301;
+    h_[1] = 0xEFCDAB89;
+    h_[2] = 0x98BADCFE;
+    h_[3] = 0x10325476;
+    h_[4] = 0xC3D2E1F0;
+
+    block_byte_index_ = 0;
+    bit_count_low = 0;
+    bit_count_high = 0;
+}
+
+inline void sha1::process_byte(unsigned char byte)
+{
+    process_byte_impl(byte);
+
+    bit_count_low += 8;
+    if (bit_count_low == 0) {
+        ++bit_count_high;
+        if (bit_count_high == 0) {
+            BOOST_THROW_EXCEPTION(std::runtime_error("sha1 too many bytes"));
+        }
+    }
+}
+
+inline void sha1::process_byte_impl(unsigned char byte)
+{
+    block_[block_byte_index_++] = byte;
+
+    if (block_byte_index_ == 64) {
+        block_byte_index_ = 0;
+        process_block();
+    }
+}
+
+inline void sha1::process_block(void const* bytes_begin, void const* bytes_end)
+{
+    unsigned char const* begin = static_cast<unsigned char const*>(bytes_begin);
+    unsigned char const* end = static_cast<unsigned char const*>(bytes_end);
+    for(; begin != end; ++begin) {
+        process_byte(*begin);
+    }
+}
+
+inline void sha1::process_bytes(void const* buffer, std::size_t byte_count)
+{
+    unsigned char const* b = static_cast<unsigned char const*>(buffer);
+    process_block(b, b+byte_count);
+}
+
+inline void sha1::process_block()
+{
+    unsigned int w[80];
+    for (std::size_t i=0; i<16; ++i) {
+        w[i]  = (block_[i*4 + 0] << 24);
+        w[i] |= (block_[i*4 + 1] << 16);
+        w[i] |= (block_[i*4 + 2] << 8);
+        w[i] |= (block_[i*4 + 3]);
+    }
+    for (std::size_t i=16; i<80; ++i) {
+        w[i] = left_rotate((w[i-3] ^ w[i-8] ^ w[i-14] ^ w[i-16]), 1);
+    }
+
+    unsigned int a = h_[0];
+    unsigned int b = h_[1];
+    unsigned int c = h_[2];
+    unsigned int d = h_[3];
+    unsigned int e = h_[4];
+
+    for (std::size_t i=0; i<80; ++i) {
+        unsigned int f;
+        unsigned int k;
+
+        if (i<20) {
+            f = (b & c) | (~b & d);
+            k = 0x5A827999;
+        } else if (i<40) {
+            f = b ^ c ^ d;
+            k = 0x6ED9EBA1;
+        } else if (i<60) {
+            f = (b & c) | (b & d) | (c & d);
+            k = 0x8F1BBCDC;
+        } else {
+            f = b ^ c ^ d;
+            k = 0xCA62C1D6;
+        }
+
+        unsigned temp = left_rotate(a, 5) + f + e + k + w[i];
+        e = d;
+        d = c;
+        c = left_rotate(b, 30);
+        b = a;
+        a = temp;
+    }
+
+    h_[0] += a;
+    h_[1] += b;
+    h_[2] += c;
+    h_[3] += d;
+    h_[4] += e;
+}
+
+inline void sha1::get_digest(digest_type digest)
+{
+    // append the bit '1' to the message
+    process_byte_impl(0x80);
+
+    // append k bits '0', where k is the minimum number >= 0
+    // such that the resulting message length is congruent to 56 (mod 64)
+    // check if there is enough space for padding and bit_count
+    if (block_byte_index_ > 56) {
+        // finish this block
+        while (block_byte_index_ != 0) {
+            process_byte_impl(0);
+        }
+
+        // one more block
+        while (block_byte_index_ < 56) {
+            process_byte_impl(0);
+        }
+    } else {
+        while (block_byte_index_ < 56) {
+            process_byte_impl(0);
+        }
+    }
+
+    // append length of message (before pre-processing) 
+    // as a 64-bit big-endian integer
+    process_byte_impl( static_cast<unsigned char>((bit_count_high>>24) & 0xFF) );
+    process_byte_impl( static_cast<unsigned char>((bit_count_high>>16) & 0xFF) );
+    process_byte_impl( static_cast<unsigned char>((bit_count_high>>8 ) & 0xFF) );
+    process_byte_impl( static_cast<unsigned char>((bit_count_high)     & 0xFF) );
+    process_byte_impl( static_cast<unsigned char>((bit_count_low>>24) & 0xFF) );
+    process_byte_impl( static_cast<unsigned char>((bit_count_low>>16) & 0xFF) );
+    process_byte_impl( static_cast<unsigned char>((bit_count_low>>8 ) & 0xFF) );
+    process_byte_impl( static_cast<unsigned char>((bit_count_low)     & 0xFF) );
+
+    // get final digest
+    digest[0] = h_[0];
+    digest[1] = h_[1];
+    digest[2] = h_[2];
+    digest[3] = h_[3];
+    digest[4] = h_[4];
+}
+
+}}} // namespace boost::uuids::detail
+
+#endif

data/source/global/tdclatl/ConnectParams.cpp

@@ -22,11 +22,11 @@
 using namespace bzs::db::protocol::tdap::client;
 
 STDMETHODIMP CConnectParams::Init(BSTR protocol, BSTR hostOrIp, BSTR dbname,
-                                  BSTR schemaTable)
+                                  BSTR schemaTable, BSTR username, BSTR passwd)
 {
     if (m_param)
         delete m_param;
-    m_param = new connectParams(protocol, hostOrIp, dbname, schemaTable);
+    m_param = new connectParams(protocol, hostOrIp, dbname, schemaTable, username, passwd);
     return S_OK;
 }
 STDMETHODIMP CConnectParams::put_Uri(BSTR val)

data/source/global/tdclatl/ConnectParams.h

@@ -58,7 +58,7 @@ public:
 
 public:
     STDMETHOD(Init)(BSTR protocol, BSTR hostOrIp, BSTR dbname,
-                    BSTR schemaTable);
+                    BSTR schemaTable, BSTR username, BSTR passwd);
     STDMETHOD(put_Uri)(BSTR val);
     STDMETHOD(get_Uri)(BSTR* retVal);
     STDMETHOD(put_Mode)(short val);

data/source/global/tdclatl/Database.cpp

@@ -455,6 +455,12 @@ STDMETHODIMP CDatabase::get_RefCount(int* Value)
     return S_OK;
 }
 
+STDMETHODIMP CDatabase::AclReload(short* Value)
+{
+    *Value = m_db->aclReload();
+    return S_OK;
+}
+
 STDMETHODIMP CDatabase::get_TrnsactionFlushWaitStatus(VARIANT_BOOL* Value)
 {
     *Value = database::trnsactionFlushWaitStatus();
@@ -479,6 +485,18 @@ STDMETHODIMP CDatabase::get_MaxTables(int* Value)
     return S_OK;
 }
 
+STDMETHODIMP CDatabase::get_TrxIsolationServer(eSrvIsorationType* Value)
+{
+    *Value = (eSrvIsorationType)m_db->trxIsolationServer();
+    return S_OK;
+}
+
+STDMETHODIMP CDatabase::get_TrxLockWaitTimeoutServer(int* Value)
+{
+    *Value = m_db->trxLockWaitTimeoutServer();
+    return S_OK;
+}
+
 void __stdcall onCopyData(database* db, int recordCount, int count,
                           bool& cancel)
 {

data/source/global/tdclatl/Database.h

@@ -141,10 +141,15 @@ public:
     STDMETHOD(SwapTablename)(BSTR Uri1, BSTR Uri2);
     STDMETHOD(get_ClientID)(short* Value);
     STDMETHOD(get_RefCount)(int* Value);
+    STDMETHOD(AclReload)(short* Value);
     STDMETHOD(get_TrnsactionFlushWaitStatus)(VARIANT_BOOL* Value);
     STDMETHOD(put_ExecCodePage)(unsigned int Value);
     STDMETHOD(get_ExecCodePage)(unsigned int* Value);
     STDMETHOD(get_MaxTables)(int* Value);
+    STDMETHOD(get_TrxIsolationServer)(eSrvIsorationType* Value);
+    STDMETHOD(get_TrxLockWaitTimeoutServer)(int* Value);
+
+
 };
 
 OBJECT_ENTRY_AUTO(__uuidof(Database), CDatabase)

data/source/global/tdclatl/tdclatl.idl

@@ -180,6 +180,7 @@ enum eStatus
 	STATUS_INVALID_DATASIZE		= 22,
 	STATUS_INVALID_FIELDNAME	= 65,
 	ERROR_TD_INVALID_CLINETHOST	= 171,
+    ERROR_NO_DATABASE           = 172,
 	ERROR_NOSPECIFY_TABLE       = 176,
     ERROR_LOAD_CLIBRARY         = 200,
     ERROR_INDEX_RND_INIT        = 201,
@@ -292,6 +293,19 @@ enum eLockType
 
 }eLockType;
 
+typedef
+[
+  helpstring("Server isoration type")
+]
+enum eSrvIsorationType
+{
+  SRV_ISO_READ_UNCOMMITED  = 0,
+  SRV_ISO_READ_COMMITED    = 1,
+  SRV_ISO_REPEATABLE_READ  = 2,
+  SRV_ISO_SERIALIZABLE     = 3,
+
+}eSrvIsorationType;
+
 typedef
 [
   helpstring("Snapshot lock type Constants")
@@ -473,6 +487,12 @@ interface IDatabase : IDispatch
   HRESULT _stdcall ExecCodePage([out, retval] unsigned int* Value);
   [propget, id(0x000000F3)]
   HRESULT _stdcall MaxTables([out, retval]  int* Value);
+  [id(0x000000F4)]
+  HRESULT _stdcall AclReload([out, retval]  short* Value);
+  [propget, id(0x000000F5)]
+  HRESULT _stdcall TrxIsolationServer([out, retval]  eSrvIsorationType* Value);
+  [propget, id(0x000000F6)]
+  HRESULT _stdcall TrxLockWaitTimeoutServer([out, retval]  int* Value);
  
   
 };
@@ -1452,7 +1472,9 @@ interface IConnectParams : IDispatch
 {
   [id(1)]
   HRESULT _stdcall Init([in] BSTR protocol, [in] BSTR hostOrIp, [in] BSTR dbname,
-					[in] BSTR schemaTable);
+					[in] BSTR schemaTable,
+                    [in, defaultvalue("")] BSTR username,
+                    [in, defaultvalue("")] BSTR passwd);
   [propput, id(2)]
   HRESULT _stdcall Uri([in] BSTR val);
   [propget, id(2)]

data/source/linux/linuxTypes.h

@@ -21,8 +21,10 @@
 
 #ifndef WCHAR
 #if (!(__APPLE__ && (__BORLANDC__ || __clang__)))
+#if !defined(__GXX_EXPERIMENTAL_CXX0X__)
 typedef unsigned short char16_t;
 #endif
+#endif
 typedef char16_t WCHAR;
 
 #endif

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: transactd
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.2.0
 platform: ruby
 authors:
 - BizStation Corp.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-24 00:00:00.000000000 Z
+date: 2015-01-22 00:00:00.000000000 Z
 dependencies: []
 description: Transactd client for ruby gem
 email: transactd@bizstation.jp
@@ -19,8 +19,8 @@ extra_rdoc_files: []
 files:
 - CMakeLists.txt
 - build/tdclrb/bldgem/extconf.rb
-- bin/common/tdclc_32_2_1.dll
-- bin/common/tdclc_64_2_1.dll
+- bin/common/tdclc_32_2_2.dll
+- bin/common/tdclc_64_2_2.dll
 - source/bzs/db/blobBuffer.h
 - source/bzs/db/blobStructs.h
 - source/bzs/db/engine/mysql/bookmark.h
@@ -81,8 +81,6 @@ files:
 - source/bzs/db/protocol/tdap/client/indexDDF.h
 - source/bzs/db/protocol/tdap/client/memRecord.cpp
 - source/bzs/db/protocol/tdap/client/memRecord.h
-- source/bzs/db/protocol/tdap/client/memRecordset.cpp
-- source/bzs/db/protocol/tdap/client/memRecordset.h
 - source/bzs/db/protocol/tdap/client/nsDatabase.cpp
 - source/bzs/db/protocol/tdap/client/nsDatabase.h
 - source/bzs/db/protocol/tdap/client/nsTable.cpp
@@ -122,6 +120,7 @@ files:
 - source/bzs/db/protocol/tdap/tdapRequest.h
 - source/bzs/db/protocol/tdap/tdapSchema.cpp
 - source/bzs/db/protocol/tdap/tdapSchema.h
+- source/bzs/db/protocol/tdap/uri.h
 - source/bzs/db/transactd/appBuilderImple.h
 - source/bzs/db/transactd/appModule.cpp
 - source/bzs/db/transactd/appModule.h
@@ -210,6 +209,7 @@ files:
 - source/bzs/test/transactdBench/workerTransactdImple.h
 - source/bzs/test/trdclengn/test_blob.cpp
 - source/bzs/test/trdclengn/test_trdclengn.cpp
+- source/global/boost/sha1.hpp
 - source/global/ormsrcgen/confParam.h
 - source/global/ormsrcgen/fieldName.cpp
 - source/global/ormsrcgen/fieldName.h
@@ -295,6 +295,8 @@ files:
 - build/swig/referencecounter.h
 - build/swig/tdcl.i
 - build/swig/validatablepointer.h
+- build/swig/ruby/generate.cmd
+- build/swig/ruby/generate.sh
 - build/swig/ruby/ruby.swg
 - build/swig/ruby/tdclrb_wrap.cpp
 - build/swig/ruby/threadBlockRegionWrapper.h