开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 生物技术 > 查看源码
context.cpp
资源名称：ncbi_cxx_win--Jul_08_2004.zip　[点击查看]
上传用户：yhdzpy8989
上传日期：2007-06-13
资源大小：13604k
文件大小：31k
源码类别：

生物技术

开发平台：

C/C++

context.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: context.cpp,v $
  4.  * PRODUCTION Revision 1000.5  2004/06/01 19:19:38  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.32
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /* $Id: context.cpp,v 1000.5 2004/06/01 19:19:38 gouriano Exp $
  11.  * ===========================================================================
  12.  *
  13.  *                            PUBLIC DOMAIN NOTICE
  14.  *               National Center for Biotechnology Information
  15.  *
  16.  *  This software/database is a "United States Government Work" under the
  17.  *  terms of the United States Copyright Act.  It was written as part of
  18.  *  the author's official duties as a United States Government employee and
  19.  *  thus cannot be copyrighted.  This software/database is freely available
  20.  *  to the public for use. The National Library of Medicine and the U.S.
  21.  *  Government have not placed any restriction on its use or reproduction.
  22.  *
  23.  *  Although all reasonable efforts have been taken to ensure the accuracy
  24.  *  and reliability of the software and data, the NLM and the U.S.
  25.  *  Government do not and cannot warrant the performance or results that
  26.  *  may be obtained by using this software or data. The NLM and the U.S.
  27.  *  Government disclaim all warranties, express or implied, including
  28.  *  warranties of performance, merchantability or fitness for any particular
  29.  *  purpose.
  30.  *
  31.  *  Please cite the author in any work or product based on this material.
  32.  *
  33.  * ===========================================================================
  34.  *
  35.  * Author:  Vladimir Soussov
  36.  *
  37.  * File Description:  Driver for CTLib server
  38.  *
  39.  */
  41. #include <ncbi_pch.hpp>
  42. #include <dbapi/driver/ctlib/interfaces.hpp>
  43. #include <dbapi/driver/util/numeric_convert.hpp>
  45. #if defined(NCBI_OS_MSWIN)
  46. #  include <winsock.h>
  47. #else
  48. #  include <unistd.h>
  49. #endif
  52. BEGIN_NCBI_SCOPE
  55. /////////////////////////////////////////////////////////////////////////////
  56. //
  57. //  CTLibContext::
  58. //
  60. CS_START_EXTERN_C
  61.     CS_RETCODE CS_PUBLIC s_CTLIB_cserr_callback(CS_CONTEXT* context, CS_CLIENTMSG* msg)
  62.     {
  63.         return CTLibContext::CTLIB_cserr_handler(context, msg)
  64.             ? CS_SUCCEED : CS_FAIL;
  65.     }
  67.     CS_RETCODE CS_PUBLIC s_CTLIB_cterr_callback(CS_CONTEXT* context, CS_CONNECTION* con,
  68.                                       CS_CLIENTMSG* msg)
  69.     {
  70.         return CTLibContext::CTLIB_cterr_handler(context, con, msg)
  71.             ? CS_SUCCEED : CS_FAIL;
  72.     }
  74.     CS_RETCODE CS_PUBLIC s_CTLIB_srverr_callback(CS_CONTEXT* context, CS_CONNECTION* con,
  75.                                        CS_SERVERMSG* msg)
  76.     {
  77.         return CTLibContext::CTLIB_srverr_handler(context, con, msg)
  78.             ? CS_SUCCEED : CS_FAIL;
  79.     }
  80. CS_END_EXTERN_C
  82. CTLibContext::CTLibContext(bool reuse_context, CS_INT version)
  83. {
  84.     DEFINE_STATIC_FAST_MUTEX(xMutex);
  85.     CFastMutexGuard mg(xMutex);
  87.     m_Context         = 0;
  88.     m_AppName         = "CTLibDriver";
  89.     m_LoginRetryCount = 0;
  90.     m_LoginLoopDelay  = 0;
  91.     m_PacketSize      = 2048;
  93.     CS_RETCODE r = reuse_context ? cs_ctx_global(version, &m_Context) :
  94.         cs_ctx_alloc(version, &m_Context);
  95.     if (r != CS_SUCCEED) {
  96.         m_Context = 0;
  97.         throw CDB_ClientEx(eDB_Fatal, 100001, "CTLibContext::CTLibContext",
  98.                            "Can not allocate a context");
  99.     }
  101.     CS_VOID*     cb;
  102.     CS_INT       outlen;
  103.     CPointerPot* p_pot = 0;
  105.     // check if cs message callback is already installed
  106.     r = cs_config(m_Context, CS_GET, CS_MESSAGE_CB, &cb, CS_UNUSED, &outlen);
  107.     if (r != CS_SUCCEED) {
  108.         m_Context = 0;
  109.         throw CDB_ClientEx(eDB_Error, 100006, "CTLibContext::CTLibContext",
  110.                            "cs_config failed");
  111.     }
  113.     if (cb == (CS_VOID*)  s_CTLIB_cserr_callback) {
  114.         // we did use this context already
  115.         r = cs_config(m_Context, CS_GET, CS_USERDATA,
  116.                       (CS_VOID*) &p_pot, (CS_INT) sizeof(p_pot), &outlen);
  117.         if (r != CS_SUCCEED) {
  118.             m_Context = 0;
  119.             throw CDB_ClientEx(eDB_Error, 100006, "CTLibContext::CTLibContext",
  120.                                "cs_config failed");
  121.         }
  122.     }
  123.     else {
  124.         // this is a brand new context
  125.         r = cs_config(m_Context, CS_SET, CS_MESSAGE_CB,
  126.                       (CS_VOID*) s_CTLIB_cserr_callback, CS_UNUSED, NULL);
  127.         if (r != CS_SUCCEED) {
  128.             cs_ctx_drop(m_Context);
  129.             m_Context = 0;
  130.             throw CDB_ClientEx(eDB_Error, 100005, "CTLibContext::CTLibContext",
  131.                                "Can not install the cslib message callback");
  132.         }
  134.         p_pot = new CPointerPot;
  135.         r = cs_config(m_Context, CS_SET, CS_USERDATA,
  136.                       (CS_VOID*) &p_pot, (CS_INT) sizeof(p_pot), NULL);
  137.         if (r != CS_SUCCEED) {
  138.             cs_ctx_drop(m_Context);
  139.             m_Context = 0;
  140.             delete p_pot;
  141.             throw CDB_ClientEx(eDB_Error, 100007, "CTLibContext::CTLibContext",
  142.                                "Can not install the user data");
  143.         }
  145.         r = ct_init(m_Context, version);
  146.         if (r != CS_SUCCEED) {
  147.             cs_ctx_drop(m_Context);
  148.             m_Context = 0;
  149.             delete p_pot;   
  150.             throw CDB_ClientEx(eDB_Error, 100002, "CTLibContext::CTLibContext",
  151.                                "ct_init failed");
  152.         }
  154.         r = ct_callback(m_Context, NULL, CS_SET, CS_CLIENTMSG_CB,
  155.                         (CS_VOID*) s_CTLIB_cterr_callback);
  156.         if (r != CS_SUCCEED) {
  157.             ct_exit(m_Context, CS_FORCE_EXIT);
  158.             cs_ctx_drop(m_Context);
  159.             m_Context = 0;
  160.             delete p_pot;           
  161.             throw CDB_ClientEx(eDB_Error, 100003, "CTLibContext::CTLibContext",
  162.                                "Can not install the client message callback");
  163.         }
  165.         r = ct_callback(m_Context, NULL, CS_SET, CS_SERVERMSG_CB,
  166.                         (CS_VOID*) s_CTLIB_srverr_callback);
  167.         if (r != CS_SUCCEED) {
  168.             ct_exit(m_Context, CS_FORCE_EXIT);
  169.             cs_ctx_drop(m_Context);
  170.             m_Context = 0;
  171.             delete p_pot;           
  172.             throw CDB_ClientEx(eDB_Error, 100004, "CTLibContext::CTLibContext",
  173.                                "Can not install the server message callback");
  174.         }
  175.     }
  177.     if ( p_pot ) {
  178.         p_pot->Add((TPotItem) this);
  179.     }
  180. }
  183. bool CTLibContext::SetLoginTimeout(unsigned int nof_secs)
  184. {
  185.     CS_INT t_out = (CS_INT) nof_secs;
  186.     return ct_config(m_Context, CS_SET,
  187.                      CS_LOGIN_TIMEOUT, &t_out, CS_UNUSED, NULL) == CS_SUCCEED;
  188. }
  191. bool CTLibContext::SetTimeout(unsigned int nof_secs)
  192. {
  193.     CS_INT t_out = (CS_INT) nof_secs;
  194.     return ct_config(m_Context, CS_SET,
  195.                      CS_TIMEOUT, &t_out, CS_UNUSED, NULL) == CS_SUCCEED;
  196. }
  199. bool CTLibContext::SetMaxTextImageSize(size_t nof_bytes)
  200. {
  201.     CS_INT ti_size = (CS_INT) nof_bytes;
  202.     return ct_config(m_Context, CS_SET,
  203.                      CS_TEXTLIMIT, &ti_size, CS_UNUSED, NULL) == CS_SUCCEED;
  204. }
  207. CDB_Connection* CTLibContext::Connect(const string&   srv_name,
  208.                                       const string&   user_name,
  209.                                       const string&   passwd,
  210.                                       TConnectionMode mode,
  211.                                       bool            reusable,
  212.                                       const string&   pool_name)
  213. {
  214.     //DEFINE_STATIC_FAST_MUTEX(xMutex);
  215.     // CFastMutexGuard mg(xMutex);
  216.     CFastMutexGuard mg(m_Mtx);
  218.     if (reusable  &&  m_NotInUse.NofItems() > 0) {
  219.         // try to get a connection from the pot
  220.         if ( !pool_name.empty() ) {
  221.             // use a pool name
  222.             for (int i = m_NotInUse.NofItems();  i--; ) {
  223.                 CTL_Connection* t_con
  224.                     = static_cast<CTL_Connection*> (m_NotInUse.Get(i));
  226.                 if (pool_name.compare(t_con->PoolName()) == 0) {
  227.                     m_NotInUse.Remove(i);
  228.                     if(t_con->Refresh()) {
  229.                         m_InUse.Add((TPotItem) t_con);
  230.                         return Create_Connection(*t_con);
  231.                     }
  232.                     delete t_con;
  233.                 }
  234.             }
  235.         }
  236.         else { // using server name as a pool name
  238.             if ( srv_name.empty() )
  239.                 return 0;
  241.             // try to use a server name
  242.             for (int i = m_NotInUse.NofItems();  i--; ) {
  243.                 CTL_Connection* t_con
  244.                     = static_cast<CTL_Connection*> (m_NotInUse.Get(i));
  246.                 if (srv_name.compare(t_con->ServerName()) == 0) {
  247.                     m_NotInUse.Remove(i);
  248.                     if(t_con->Refresh()) {
  249.                         m_InUse.Add((TPotItem) t_con);
  250.                         return Create_Connection(*t_con);
  251.                     }
  252.                     delete t_con;
  253.                 }
  254.             }
  255.         }
  256.     }
  258.     if((mode & fDoNotConnect) != 0) return 0;
  260.     // new connection needed
  261.     if (srv_name.empty()  ||  user_name.empty()  ||  passwd.empty()) {
  262.         throw CDB_ClientEx(eDB_Error, 100010, "CTLibContext::Connect",
  263.                            "You have to provide server name, user name and "
  264.                            "password to connect to the server");
  265.     }
  267.     CS_CONNECTION* con = x_ConnectToServer(srv_name, user_name, passwd, mode);
  268.     if (con == 0) {
  269.         throw CDB_ClientEx(eDB_Error, 100011, "CTLibContext::Connect",
  270.                            "Can not connect to the server");
  271.     }
  273.     CTL_Connection* t_con = new CTL_Connection(this, con, reusable, pool_name);
  274.     t_con->m_MsgHandlers = m_ConnHandlers;
  276.     m_InUse.Add((TPotItem) t_con);
  278.     return Create_Connection(*t_con);
  279. }
  283. bool CTLibContext::IsAbleTo(ECapability cpb) const
  284. {
  285.     switch(cpb) {
  286.     case eBcp:
  287.     case eReturnITDescriptors:
  288.     case eReturnComputeResults:
  289.     return true;
  290.     default:
  291.     break;
  292.     }
  293.     return false;
  294. }
  296. CTLibContext::~CTLibContext()
  297. {
  298.     CFastMutexGuard mg(m_Mtx);
  300.     if ( !m_Context ) {
  301.         return;
  302.     }
  304.     // close all connections first
  305.     for (int i = m_NotInUse.NofItems();  i--; ) {
  306.         CTL_Connection* t_con = static_cast<CTL_Connection*>(m_NotInUse.Get(i));
  307.         delete t_con;
  308.     }
  310.     for (int i = m_InUse.NofItems();  i--; ) {
  311.         CTL_Connection* t_con = static_cast<CTL_Connection*> (m_InUse.Get(i));
  312.         delete t_con;
  313.     }
  315.     CS_INT       outlen;
  316.     CPointerPot* p_pot = 0;
  318.     if (cs_config(m_Context, CS_GET, CS_USERDATA,
  319.                   (void*) &p_pot, (CS_INT) sizeof(p_pot), &outlen) == CS_SUCCEED
  320.         &&  p_pot != 0) {
  321.         p_pot->Remove(this);
  322.         if (p_pot->NofItems() == 0) { // this is a last driver for this context
  323.             delete p_pot;
  324.             if (ct_exit(m_Context, CS_UNUSED) != CS_SUCCEED) {
  325.                 ct_exit(m_Context, CS_FORCE_EXIT);
  326.             }
  327.             cs_ctx_drop(m_Context);
  328.         }
  329.     }
  330. }
  333. void CTLibContext::CTLIB_SetApplicationName(const string& a_name)
  334. {
  335.     m_AppName = a_name;
  336. }
  339. void CTLibContext::CTLIB_SetHostName(const string& host_name)
  340. {
  341.     m_HostName = host_name;
  342. }
  345. void CTLibContext::CTLIB_SetPacketSize(CS_INT packet_size)
  346. {
  347.     m_PacketSize = packet_size;
  348. }
  351. void CTLibContext::CTLIB_SetLoginRetryCount(CS_INT n)
  352. {
  353.     m_LoginRetryCount = n;
  354. }
  357. void CTLibContext::CTLIB_SetLoginLoopDelay(CS_INT nof_sec)
  358. {
  359.     m_LoginLoopDelay = nof_sec;
  360. }
  363. CS_CONTEXT* CTLibContext::CTLIB_GetContext() const
  364. {
  365.     return m_Context;
  366. }
  369. bool CTLibContext::CTLIB_cserr_handler(CS_CONTEXT* context, CS_CLIENTMSG* msg)
  370. {
  371.     CS_INT       outlen;
  372.     CPointerPot* p_pot = 0;
  373.     CS_RETCODE   r;
  375.     r = cs_config(context, CS_GET, CS_USERDATA,
  376.                   (void*) &p_pot, (CS_INT) sizeof(p_pot), &outlen);
  378.     if (r == CS_SUCCEED  &&  p_pot != 0  &&  p_pot->NofItems() > 0) {
  379.         CTLibContext* drv = (CTLibContext*) p_pot->Get(0);
  380.         EDB_Severity sev = eDB_Error;
  381.         if (msg->severity == CS_SV_INFORM) {
  382.             sev = eDB_Info;
  383.         }
  384.         else if (msg->severity == CS_SV_FATAL) {
  385.             sev = eDB_Fatal;
  386.         }
  388.         CDB_ClientEx ex(sev, msg->msgnumber, "cslib", msg->msgstring);
  389.         drv->m_CntxHandlers.PostMsg(&ex);
  390.     }
  391.     else if (msg->severity != CS_SV_INFORM) {
  392.         // nobody can be informed, so put it to stderr
  393.         cerr << "CSLIB error handler detects the following error" << endl
  394.              << msg->msgstring << endl;
  395.     }
  397.     return true;
  398. }
  401. bool CTLibContext::CTLIB_cterr_handler(CS_CONTEXT* context, CS_CONNECTION* con,
  402.                                        CS_CLIENTMSG* msg)
  403. {
  404.     CS_INT           outlen;
  405.     CPointerPot*        p_pot = 0;
  406.     CTL_Connection*  link = 0;
  407.     CDBHandlerStack* hs;
  409.     if (con != 0  &&
  410.         ct_con_props(con, CS_GET, CS_USERDATA,
  411.                      (void*) &link, (CS_INT) sizeof(link),
  412.                      &outlen) == CS_SUCCEED  &&  link != 0) {
  413.         hs = &link->m_MsgHandlers;
  414.     }
  415.     else if (cs_config(context, CS_GET, CS_USERDATA,
  416.                        (void*) &p_pot, (CS_INT) sizeof(p_pot),
  417.                        &outlen) == CS_SUCCEED  &&
  418.              p_pot != 0  &&  p_pot->NofItems() > 0) {
  419.         CTLibContext* drv = (CTLibContext*) p_pot->Get(0);
  420.         hs = &drv->m_CntxHandlers;
  421.     }
  422.     else {
  423.         if (msg->severity != CS_SV_INFORM) {
  424.             // nobody can be informed, let's put it in stderr
  425.             cerr << "CTLIB error handler detects the following error" << endl
  426.                  << "Severity:" << msg->severity
  427.                  << " Msg # " << msg->msgnumber << endl
  428.                  << msg->msgstring << endl;
  429.             if (msg->osstringlen > 1) {
  430.                 cerr << "OS # "    << msg->osnumber
  431.                      << " OS msg " << msg->osstring << endl;
  432.             }
  433.             if (msg->sqlstatelen > 1  &&
  434.                 (msg->sqlstate[0] != 'Z'  ||  msg->sqlstate[1] != 'Z')) {
  435.                 cerr << "SQL: " << msg->sqlstate << endl;
  436.             }
  437.         }
  438.         return true;
  439.     }
  442.     switch (msg->severity) {
  443.     case CS_SV_INFORM: {
  444.         CDB_ClientEx info(eDB_Info,
  445.                           (int) msg->msgnumber, "ctlib", msg->msgstring);
  446.         hs->PostMsg(&info);
  447.         break;
  448.     }
  449.     case CS_SV_RETRY_FAIL: {
  450.         CDB_TimeoutEx to((int) msg->msgnumber, "ctlib", msg->msgstring);
  451.         hs->PostMsg(&to);
  452. if(con) {
  453.   CS_INT status;
  454.   if((ct_con_props(con, CS_GET, CS_LOGIN_STATUS, (CS_VOID*)&status, CS_UNUSED, NULL) != CS_SUCCEED) ||
  455.    (!status)) return false;
  457.   if(ct_cancel(con, (CS_COMMAND*)0, CS_CANCEL_ATTN) != CS_SUCCEED) return false;
  458. }
  459. else return false;
  460. break;
  461.     }
  462.     case CS_SV_CONFIG_FAIL:
  463.     case CS_SV_API_FAIL:
  464.     case CS_SV_INTERNAL_FAIL: {
  465.         CDB_ClientEx err(eDB_Error,
  466.                          (int) msg->msgnumber, "ctlib", msg->msgstring);
  467.         hs->PostMsg(&err);
  468.         break;
  469.     }
  470.     default: {
  471.         CDB_ClientEx ftl(eDB_Fatal,
  472.                          (int) msg->msgnumber, "ctlib", msg->msgstring);
  473.         hs->PostMsg(&ftl);
  474.         break;
  475.     }
  476.     }
  478.     return true;
  479. }
  482. bool CTLibContext::CTLIB_srverr_handler(CS_CONTEXT* context,
  483.                                         CS_CONNECTION* con,
  484.                                         CS_SERVERMSG* msg)
  485. {
  486.     if ((msg->severity == 0  &&  msg->msgnumber == 0)  ||
  487.         msg->msgnumber == 5701  ||  msg->msgnumber == 5703) {
  488.         return true;
  489.     }
  491.     CS_INT           outlen;
  492.     CPointerPot*     p_pot = 0;
  493.     CTL_Connection*  link = 0;
  494.     CDBHandlerStack* hs;
  496.     if (con != 0  &&  ct_con_props(con, CS_GET, CS_USERDATA,
  497.                                    (void*) &link, (CS_INT) sizeof(link),
  498.                                    &outlen) == CS_SUCCEED  &&
  499.         link != 0) {
  500.         hs = &link->m_MsgHandlers;
  501.     }
  502.     else if (cs_config(context, CS_GET, CS_USERDATA,
  503.                        (void*) &p_pot, (CS_INT) sizeof(p_pot),
  504.                        &outlen) == CS_SUCCEED  &&
  505.              p_pot != 0  &&  p_pot->NofItems() > 0) {
  506.         CTLibContext* drv = (CTLibContext*) p_pot->Get(0);
  507.         hs = &drv->m_CntxHandlers;
  508.     }
  509.     else {
  510.         cerr << "Message from the server ";
  511.         if (msg->svrnlen > 0) {
  512.             cerr << "<" << msg->svrname << "> ";
  513.         }
  514.         cerr << "msg # " << msg->msgnumber
  515.              << " severity: " << msg->severity << endl;
  516.         if (msg->proclen > 0) {
  517.             cerr << "Proc: " << msg->proc << " line: " << msg->line << endl;
  518.         }
  519.         if (msg->sqlstatelen > 1  &&
  520.             (msg->sqlstate[0] != 'Z'  ||  msg->sqlstate[1] != 'Z')) {
  521.             cerr << "SQL: " << msg->sqlstate << endl;
  522.         }
  523.         cerr << msg->text << endl;
  524.         return true;
  525.     }
  527.     if (msg->msgnumber == 1205 /*DEADLOCK*/) {
  528.         CDB_DeadlockEx dl(msg->svrname, msg->text);
  529.         hs->PostMsg(&dl);
  530.     }
  531.     else {
  532.         EDB_Severity sev =
  533.             msg->severity <  10 ? eDB_Info :
  534.             msg->severity == 10 ? eDB_Warning :
  535.             msg->severity <  16 ? eDB_Error :
  536.             msg->severity >  16 ? eDB_Fatal :
  537.             eDB_Unknown;
  539.         if (msg->proclen > 0) {
  540.             CDB_RPCEx rpc(sev, (int) msg->msgnumber, msg->svrname, msg->text,
  541.                           msg->proc, (int) msg->line);
  542.             hs->PostMsg(&rpc);
  543.         }
  544.         else if (msg->sqlstatelen > 1  &&
  545.                  (msg->sqlstate[0] != 'Z'  ||  msg->sqlstate[1] != 'Z')) {
  546.             CDB_SQLEx sql(sev, (int) msg->msgnumber, msg->svrname, msg->text,
  547.                           (const char*) msg->sqlstate, (int) msg->line);
  548.             hs->PostMsg(&sql);
  549.         }
  550.         else {
  551.             CDB_DSEx m(sev, (int) msg->msgnumber, msg->svrname, msg->text);
  552.             hs->PostMsg(&m);
  553.         }
  554.     }
  556.     return true;
  557. }
  561. CS_CONNECTION* CTLibContext::x_ConnectToServer(const string&   srv_name,
  562.                                                const string&   user_name,
  563.                                                const string&   passwd,
  564.                                                TConnectionMode mode)
  565. {
  566.     CS_CONNECTION* con;
  567.     if (ct_con_alloc(m_Context, &con) != CS_SUCCEED)
  568.         return 0;
  570.     ct_callback(NULL, con, CS_SET, CS_CLIENTMSG_CB,
  571.                 (CS_VOID*) s_CTLIB_cterr_callback);
  572.     
  573.     ct_callback(NULL, con, CS_SET, CS_SERVERMSG_CB,
  574.                 (CS_VOID*) s_CTLIB_srverr_callback);
  576.     char hostname[256];
  577.     if(gethostname(hostname, 256)) {
  578.       strcpy(hostname, "UNKNOWN");
  579.     }
  580.     else hostname[255]= '';
  581.     
  583.     if (ct_con_props(con, CS_SET, CS_USERNAME, (void*) user_name.c_str(),
  584.                      CS_NULLTERM, NULL) != CS_SUCCEED  ||
  585.         ct_con_props(con, CS_SET, CS_PASSWORD, (void*) passwd.c_str(),
  586.                      CS_NULLTERM, NULL) != CS_SUCCEED  ||
  587.         ct_con_props(con, CS_SET, CS_APPNAME, (void*) m_AppName.c_str(),
  588.                      CS_NULLTERM, NULL) != CS_SUCCEED ||
  589.         ct_con_props(con, CS_SET, CS_HOSTNAME, (void*) hostname,
  590.                      CS_NULLTERM, NULL) != CS_SUCCEED) {
  591.         ct_con_drop(con);
  592.         return 0;
  593.     }
  595.     if ( !m_HostName.empty() ) {
  596.         ct_con_props(con, CS_SET, CS_HOSTNAME,
  597.                      (void*) m_HostName.c_str(), CS_NULLTERM, NULL);
  598.     }
  600.     if (m_PacketSize > 0) {
  601.         ct_con_props(con, CS_SET, CS_PACKETSIZE,
  602.                      (void*) &m_PacketSize, CS_UNUSED, NULL);
  603.     }
  605.     if (m_LoginRetryCount > 0) {
  606.         ct_con_props(con, CS_SET, CS_RETRY_COUNT,
  607.                      (void*) &m_LoginRetryCount, CS_UNUSED, NULL);
  608.     }
  610.     if (m_LoginLoopDelay > 0) {
  611.         ct_con_props(con, CS_SET, CS_LOOP_DELAY,
  612.                      (void*) &m_LoginLoopDelay, CS_UNUSED, NULL);
  613.     }
  615.     CS_BOOL flag = CS_TRUE;
  616.     if ((mode & fBcpIn) != 0) {
  617.         ct_con_props(con, CS_SET, CS_BULK_LOGIN, &flag, CS_UNUSED, NULL);
  618.     }
  619.     if ((mode & fPasswordEncrypted) != 0) {
  620.         ct_con_props(con, CS_SET, CS_SEC_ENCRYPTION, &flag, CS_UNUSED, NULL);
  621.     }
  623.     if (ct_connect(con, const_cast<char*> (srv_name.c_str()), CS_NULLTERM)
  624.         != CS_SUCCEED) {
  625.         ct_con_drop(con);
  626.         return 0;
  627.     }
  629.     return con;
  630. }
  633. /////////////////////////////////////////////////////////////////////////////
  634. //
  635. //  Miscellaneous
  636. //
  638. void g_CTLIB_GetRowCount(CS_COMMAND* cmd, int* cnt)
  639. {
  640.     CS_INT n;
  641.     CS_INT outlen;
  642.     if (cnt  &&
  643.         ct_res_info(cmd, CS_ROW_COUNT, &n, CS_UNUSED, &outlen) == CS_SUCCEED
  644.         && n >= 0  &&  n != CS_NO_COUNT) {
  645.         *cnt = (int) n;
  646.     }
  647. }
  650. bool g_CTLIB_AssignCmdParam(CS_COMMAND*   cmd,
  651.                             CDB_Object&   param,
  652.                             const string& param_name,
  653.                             CS_DATAFMT&   param_fmt,
  654.                             CS_SMALLINT   indicator,
  655.                             bool          declare_only)
  656. {
  657.     {{
  658.         size_t l = param_name.copy(param_fmt.name, CS_MAX_NAME-1);
  659.         param_fmt.name[l] = '';
  660.     }}
  663.     CS_RETCODE ret_code;
  665.     switch ( param.GetType() ) {
  666.     case eDB_Int: {
  667.         CDB_Int& par = dynamic_cast<CDB_Int&> (param);
  668.         param_fmt.datatype = CS_INT_TYPE;
  669.         if ( declare_only )
  670.             break;
  672.         CS_INT value = (CS_INT) par.Value();
  673.         ret_code = ct_param(cmd, &param_fmt,
  674.                             (CS_VOID*) &value, CS_UNUSED, indicator);
  675.         break;
  676.     }
  677.     case eDB_SmallInt: {
  678.         CDB_SmallInt& par = dynamic_cast<CDB_SmallInt&> (param);
  679.         param_fmt.datatype = CS_SMALLINT_TYPE;
  680.         if ( declare_only )
  681.             break;
  683.         CS_SMALLINT value = (CS_SMALLINT) par.Value();
  684.         ret_code = ct_param(cmd, &param_fmt,
  685.                             (CS_VOID*) &value, CS_UNUSED, indicator);
  686.         break;
  687.     }
  688.     case eDB_TinyInt: {
  689.         CDB_TinyInt& par = dynamic_cast<CDB_TinyInt&> (param);
  690.         param_fmt.datatype = CS_TINYINT_TYPE;
  691.         if ( declare_only )
  692.             break;
  694.         CS_TINYINT value = (CS_TINYINT) par.Value();
  695.         ret_code = ct_param(cmd, &param_fmt,
  696.                             (CS_VOID*) &value, CS_UNUSED, indicator);
  697.         break;
  698.     }
  699.     case eDB_Bit: {
  700.         CDB_Bit& par = dynamic_cast<CDB_Bit&> (param);
  701.         param_fmt.datatype = CS_BIT_TYPE;
  702.         if ( declare_only )
  703.             break;
  705.         CS_BIT value = (CS_BIT) par.Value();
  706.         ret_code = ct_param(cmd, &param_fmt,
  707.                             (CS_VOID*) &value, CS_UNUSED, indicator);
  708.         break;
  709.     }
  710.     case eDB_BigInt: {
  711.         CDB_BigInt& par = dynamic_cast<CDB_BigInt&> (param);
  712.         param_fmt.datatype = CS_NUMERIC_TYPE;
  713.         if ( declare_only )
  714.             break;
  716.         CS_NUMERIC value;
  717.         Int8 v8 = par.Value();
  718.         memset(&value, 0, sizeof(value));
  719.         value.precision= 18;
  720.         if (longlong_to_numeric(v8, 18, value.array) == 0)
  721.             return false;
  723.         ret_code = ct_param(cmd, &param_fmt,
  724.                             (CS_VOID*) &value, CS_UNUSED, indicator);
  725.         break;
  726.     }
  727.     case eDB_Char: {
  728.         CDB_Char& par = dynamic_cast<CDB_Char&> (param);
  729.         param_fmt.datatype = CS_CHAR_TYPE;
  730.         if ( declare_only )
  731.             break;
  733.         ret_code = ct_param(cmd, &param_fmt, (CS_VOID*) par.Value(),
  734.                             (CS_INT) par.Size(), indicator);
  735.         break;
  736.     }
  737.     case eDB_LongChar: {
  738.         CDB_LongChar& par = dynamic_cast<CDB_LongChar&> (param);
  739.         param_fmt.datatype = CS_LONGCHAR_TYPE;
  740.         if ( declare_only )
  741.             break;
  743.         ret_code = ct_param(cmd, &param_fmt, (CS_VOID*) par.Value(),
  744.                             (CS_INT) par.Size(), indicator);
  745.         break;
  746.     }
  747.     case eDB_VarChar: {
  748.         CDB_VarChar& par = dynamic_cast<CDB_VarChar&> (param);
  749.         param_fmt.datatype = CS_CHAR_TYPE;
  750.         if ( declare_only )
  751.             break;
  753.         ret_code = ct_param(cmd, &param_fmt, (CS_VOID*) par.Value(),
  754.                             (CS_INT) par.Size(), indicator);
  755.         break;
  756.     }
  757.     case eDB_Binary: {
  758.         CDB_Binary& par = dynamic_cast<CDB_Binary&> (param);
  759.         param_fmt.datatype = CS_BINARY_TYPE;
  760.         if ( declare_only )
  761.             break;
  763.         ret_code = ct_param(cmd, &param_fmt, (CS_VOID*) par.Value(),
  764.                             (CS_INT) par.Size(), indicator);
  765.         break;
  766.     }
  767.     case eDB_LongBinary: {
  768.         CDB_LongBinary& par = dynamic_cast<CDB_LongBinary&> (param);
  769.         param_fmt.datatype = CS_LONGBINARY_TYPE;
  770.         if ( declare_only )
  771.             break;
  773.         ret_code = ct_param(cmd, &param_fmt, (CS_VOID*) par.Value(),
  774.                             (CS_INT) par.Size(), indicator);
  775.         break;
  776.     }
  777.     case eDB_VarBinary: {
  778.         CDB_VarBinary& par = dynamic_cast<CDB_VarBinary&> (param);
  779.         param_fmt.datatype = CS_BINARY_TYPE;
  780.         if ( declare_only )
  781.             break;
  783.         ret_code = ct_param(cmd, &param_fmt, (CS_VOID*) par.Value(),
  784.                             (CS_INT) par.Size(), indicator);
  785.         break;
  786.     }
  787.     case eDB_Float: {
  788.         CDB_Float& par = dynamic_cast<CDB_Float&> (param);
  789.         param_fmt.datatype = CS_REAL_TYPE;
  790.         if ( declare_only )
  791.             break;
  793.         CS_REAL value = (CS_REAL) par.Value();
  794.         ret_code = ct_param(cmd, &param_fmt,
  795.                             (CS_VOID*) &value, CS_UNUSED, indicator);
  796.         break;
  797.     }
  798.     case eDB_Double: {
  799.         CDB_Double& par = dynamic_cast<CDB_Double&> (param);
  800.         param_fmt.datatype = CS_FLOAT_TYPE;
  801.         if ( declare_only )
  802.             break;
  804.         CS_FLOAT value = (CS_FLOAT) par.Value();
  805.         ret_code = ct_param(cmd, &param_fmt,
  806.                             (CS_VOID*) &value, CS_UNUSED, indicator);
  807.         break;
  808.     }
  809.     case eDB_SmallDateTime: {
  810.         CDB_SmallDateTime& par = dynamic_cast<CDB_SmallDateTime&> (param);
  811.         param_fmt.datatype = CS_DATETIME4_TYPE;
  812.         if ( declare_only )
  813.             break;
  815.         CS_DATETIME4 dt;
  816.         dt.days    = par.GetDays();
  817.         dt.minutes = par.GetMinutes();
  818.         ret_code = ct_param(cmd, &param_fmt,
  819.                             (CS_VOID*) &dt, CS_UNUSED, indicator);
  820.         break;
  821.     }
  822.     case eDB_DateTime: {
  823.         CDB_DateTime& par = dynamic_cast<CDB_DateTime&> (param);
  824.         param_fmt.datatype = CS_DATETIME_TYPE;
  825.         if ( declare_only )
  826.             break;
  828.         CS_DATETIME dt;
  829.         dt.dtdays = par.GetDays();
  830.         dt.dttime = par.Get300Secs();
  831.         ret_code = ct_param(cmd, &param_fmt,
  832.                             (CS_VOID*) &dt, CS_UNUSED, indicator);
  833.         break;
  834.     }
  835.     default: {
  836.         return false;
  837.     }
  838.     }
  840.     if ( declare_only ) {
  841.         ret_code = ct_param(cmd, &param_fmt, 0, CS_UNUSED, 0);
  842.     }
  844.     return (ret_code == CS_SUCCEED);
  845. }
  849. ///////////////////////////////////////////////////////////////////////
  850. // Driver manager related functions
  851. //
  853. I_DriverContext* CTLIB_CreateContext(map<string,string>* attr = 0)
  854. {
  855.     bool reuse_context= true;
  856.     CS_INT version= CS_VERSION_110;
  858.     if(attr) {
  859.   reuse_context= (*attr)["reuse_context"] != "false";
  860.   string vers= (*attr)["version"];
  861.   if(vers.find("100") != string::npos) {
  862. version= CS_VERSION_100;
  863.   }
  864.   else {
  865. char* e;
  866. long v= strtol(vers.c_str(), &e, 10);
  867. if (v > 0 && (e == 0 || (!isalpha(*e)))) version= v;
  868.   }
  869. }
  870. CTLibContext* cntx= new CTLibContext(reuse_context, version);
  871. if(cntx && attr) {
  872.   string page_size= (*attr)["packet"];
  873.   if(!page_size.empty()) {
  874. CS_INT s= atoi(page_size.c_str());
  875. cntx->CTLIB_SetPacketSize(s);
  876.   }
  877.      string prog_name= (*attr)["prog_name"];
  878.      if(!prog_name.empty()) {
  879.          cntx->CTLIB_SetApplicationName(prog_name);
  880.      }
  881.      string host_name= (*attr)["host_name"];
  882.      if(!host_name.empty()) {
  883.          cntx->CTLIB_SetHostName(host_name);
  884.      }
  885. }
  886.     return cntx;
  887. }
  889. void DBAPI_RegisterDriver_CTLIB(I_DriverMgr& mgr)
  890. {
  891.     mgr.RegisterDriver("ctlib", CTLIB_CreateContext);
  892. }
  894. extern "C" {
  895.     NCBI_DBAPIDRIVER_CTLIB_EXPORT
  896.     void* DBAPI_E_ctlib()
  897.     {
  898.     return (void*)DBAPI_RegisterDriver_CTLIB;
  899.     }
  900. } 
  903. END_NCBI_SCOPE
  907. /*
  908.  * ===========================================================================
  909.  * $Log: context.cpp,v $
  910.  * Revision 1000.5  2004/06/01 19:19:38  gouriano
  911.  * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.32
  912.  *
  913.  * Revision 1.32  2004/05/17 21:12:03  gorelenk
  914.  * Added include of PCH ncbi_pch.hpp
  915.  *
  916.  * Revision 1.31  2004/04/07 13:41:47  gorelenk
  917.  * Added export prefix to implementations of DBAPI_E_* functions.
  918.  *
  919.  * Revision 1.30  2003/11/19 22:47:20  soussov
  920.  * adds code to setup client/server msg callbacks for each connection; adds 'prog_name' and 'host_name' attributes for create context
  921.  *
  922.  * Revision 1.29  2003/11/14 20:46:13  soussov
  923.  * implements DoNotConnect mode
  924.  *
  925.  * Revision 1.28  2003/10/29 21:45:54  soussov
  926.  * adds code which prevents repeated timeouts if server is hanging
  927.  *
  928.  * Revision 1.27  2003/10/27 17:00:20  soussov
  929.  * adds code to prevent the return of broken connection from the pool
  930.  *
  931.  * Revision 1.26  2003/07/21 22:00:36  soussov
  932.  * fixes bug whith pool name mismatch in Connect()
  933.  *
  934.  * Revision 1.25  2003/07/17 20:45:44  soussov
  935.  * connections pool improvements
  936.  *
  937.  * Revision 1.24  2003/05/27 21:12:03  soussov
  938.  * bit type param added
  939.  *
  940.  * Revision 1.23  2003/05/15 21:54:30  soussov
  941.  * fixed bug in timeout handling
  942.  *
  943.  * Revision 1.22  2003/04/29 21:15:35  soussov
  944.  * new datatypes CDB_LongChar and CDB_LongBinary added
  945.  *
  946.  * Revision 1.21  2003/04/01 21:49:55  soussov
  947.  * new attribute 'packet=XXX' (where XXX is a packet size) added to CTLIB_CreateContext
  948.  *
  949.  * Revision 1.20  2003/03/18 14:34:20  ivanov
  950.  * Fix for Rev 1.18-1.19 -- #include's for gethostname() on NCBI_OS_MSWIN platform
  951.  *
  952.  * Revision 1.19  2003/03/17 20:57:09  ivanov
  953.  * #include <unistd.h> everywhere except NCBI_OS_MSWIN platform
  954.  *
  955.  * Revision 1.18  2003/03/17 19:37:31  ucko
  956.  * #include <unistd.h> for gethostname()
  957.  *
  958.  * Revision 1.17  2003/03/17 15:29:02  soussov
  959.  * sets the default host name using gethostname()
  960.  *
  961.  * Revision 1.16  2002/12/20 17:53:56  soussov
  962.  * renames the members of ECapability enum
  963.  *
  964.  * Revision 1.15  2002/09/19 20:05:43  vasilche
  965.  * Safe initialization of static mutexes
  966.  *
  967.  * Revision 1.14  2002/06/28 22:49:02  garrett
  968.  * CTLIB now connects under Windows.
  969.  *
  970.  * Revision 1.13  2002/04/19 15:01:28  soussov
  971.  * adds static mutex to Connect
  972.  *
  973.  * Revision 1.12  2002/04/12 18:50:25  soussov
  974.  * static mutex in context constructor added
  975.  *
  976.  * Revision 1.11  2002/03/26 15:34:38  soussov
  977.  * new image/text operations added
  978.  *
  979.  * Revision 1.10  2002/01/17 22:07:10  soussov
  980.  * changes driver registration
  981.  *
  982.  * Revision 1.9  2002/01/11 20:24:33  soussov
  983.  * driver manager support added
  984.  *
  985.  * Revision 1.8  2001/11/06 18:02:00  lavr
  986.  * Added methods formely inline (moved from header files)
  987.  *
  988.  * Revision 1.7  2001/10/12 21:21:55  lavr
  989.  * Bugfix: Changed '=' -> '==' in severity parsing
  990.  *
  991.  * Revision 1.6  2001/10/11 16:30:44  soussov
  992.  * exclude ctlib dependencies from numeric conversion calls
  993.  *
  994.  * Revision 1.5  2001/10/01 20:09:30  vakatov
  995.  * Introduced a generic default user error handler and the means to
  996.  * alternate it. Added an auxiliary error handler class
  997.  * "CDB_UserHandler_Stream".
  998.  * Moved "{Push/Pop}{Cntx/Conn}MsgHandler()" to the generic code
  999.  * (in I_DriverContext).
  1000.  *
  1001.  * Revision 1.4  2001/09/27 20:08:33  vakatov
  1002.  * Added "DB_" (or "I_") prefix where it was missing
  1003.  *
  1004.  * Revision 1.3  2001/09/27 16:46:34  vakatov
  1005.  * Non-const (was const) exception object to pass to the user handler
  1006.  *
  1007.  * Revision 1.2  2001/09/26 23:23:31  vakatov
  1008.  * Moved the err.message handlers' stack functionality (generic storage
  1009.  * and methods) to the "abstract interface" level.
  1010.  *
  1011.  * Revision 1.1  2001/09/21 23:40:02  vakatov
  1012.  * -----  Initial (draft) revision.  -----
  1013.  * This is a major revamp (by Denis Vakatov, with help from Vladimir Soussov)
  1014.  * of the DBAPI "driver" libs originally written by Vladimir Soussov.
  1015.  * The revamp involved massive code shuffling and grooming, numerous local
  1016.  * API redesigns, adding comments and incorporating DBAPI to the C++ Toolkit.
  1017.  *
  1018.  * ===========================================================================
  1019.  */