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

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

生物技术

开发平台：

C/C++

ct.c：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: ct.c,v $
  4.  * PRODUCTION Revision 1000.0  2003/10/29 20:33:11  gouriano
  5.  * PRODUCTION PRODUCTION: IMPORTED [ORIGINAL] Dev-tree R1.1
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /* FreeTDS - Library of routines accessing Sybase and Microsoft databases
  11.  * Copyright (C) 1998-1999  Brian Bruns
  12.  *
  13.  * This library is free software; you can redistribute it and/or
  14.  * modify it under the terms of the GNU Library General Public
  15.  * License as published by the Free Software Foundation; either
  16.  * version 2 of the License, or (at your option) any later version.
  17.  *
  18.  * This library is distributed in the hope that it will be useful,
  19.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  21.  * Library General Public License for more details.
  22.  *
  23.  * You should have received a copy of the GNU Library General Public
  24.  * License along with this library; if not, write to the
  25.  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  26.  * Boston, MA 02111-1307, USA.
  27.  */
  29. #include <tds_config.h>
  30. #include <stdlib.h>
  31. #include <unistd.h>
  32. #include <ctpublic.h>
  33. #include <ctlib.h>
  34. #include "tdsutil.h"
  36. static char  software_version[]   = "$Id: ct.c,v 1000.0 2003/10/29 20:33:11 gouriano Exp $";
  37. static void *no_unused_var_warn[] = {software_version,
  38.                                      no_unused_var_warn};
  41. /**
  42.  * Read a row of data
  43.  * @return 0 on success
  44.  */
  45. static int _ct_bind_data(CS_COMMAND *cmd);
  46. static int _ct_get_client_type(int datatype, int size);
  49. CS_RETCODE ct_exit(CS_CONTEXT *ctx, CS_INT unused)
  50. {
  51. tdsdump_log(TDS_DBG_FUNC, "%L inside ct_exit()n");
  52. return CS_SUCCEED;
  53. }
  54. CS_RETCODE ct_init(CS_CONTEXT *ctx, CS_INT version)
  55. {
  56. /* uncomment the next line to get pre-login trace */
  57. /* tdsdump_open("/tmp/tds2.log"); */
  58. tdsdump_log(TDS_DBG_FUNC, "%L inside ct_init()n");
  59. ctx->tds_ctx->msg_handler = ctlib_handle_info_message;
  60. ctx->tds_ctx->err_handler = ctlib_handle_err_message;
  61. return CS_SUCCEED;
  62. }
  63. CS_RETCODE ct_con_alloc(CS_CONTEXT *ctx, CS_CONNECTION **con)
  64. {
  65. tdsdump_log(TDS_DBG_FUNC, "%L inside ct_con_alloc()n");
  66. *con = (CS_CONNECTION *) malloc(sizeof(CS_CONNECTION));
  67. memset(*con,'',sizeof(CS_CONNECTION));
  68. (*con)->tds_login = (void *) tds_alloc_login();
  70. /* so we know who we belong to */
  71. (*con)->ctx = ctx;
  73. /* set default values */
  74. tds_set_library((*con)->tds_login, "CT-Library");
  75. /* tds_set_charset((*con)->tds_login, "iso_1"); */
  76. /* tds_set_packet((*con)->tds_login, TDS_DEF_BLKSZ); */
  77. return CS_SUCCEED;
  78. }
  79. CS_RETCODE ct_callback(CS_CONTEXT *ctx, CS_CONNECTION *con, CS_INT action, CS_INT type, CS_VOID *func)
  80. {
  81. int (*funcptr)(void*,void*,void*)=(int (*)(void*,void*,void*))func;
  83. tdsdump_log(TDS_DBG_FUNC, "%L inside ct_callback() action = %sn",
  84. CS_GET ? "CS_GET" : "CS_SET");
  85. /* one of these has to be defined */
  86. if (!ctx && !con) 
  87. return CS_FAIL;
  89. if (action==CS_GET) {
  90. switch(type) {
  91. case CS_CLIENTMSG_CB:
  92. *(void **)func = (CS_VOID *) (con ? con->_clientmsg_cb : ctx->_clientmsg_cb);
  93. return CS_SUCCEED;
  94. case CS_SERVERMSG_CB:
  95. *(void **)func = (CS_VOID *) (con ? con->_servermsg_cb : ctx->_servermsg_cb);
  96. return CS_SUCCEED;
  97. default:
  98. fprintf(stderr,"Unknown callback %dn",type);
  99. *(void **)func = (CS_VOID *) NULL;
  100. return CS_SUCCEED;
  101. }
  102. }
  103. /* CS_SET */
  104. switch(type) {
  105. case CS_CLIENTMSG_CB:
  106. if (con) 
  107. con->_clientmsg_cb = funcptr;
  108. else 
  109. ctx->_clientmsg_cb = funcptr;
  110. break;
  111. case CS_SERVERMSG_CB:
  112. if (con) 
  113. con->_servermsg_cb = funcptr;
  114. else 
  115. ctx->_servermsg_cb = funcptr;
  116. break;
  117. }
  118. return CS_SUCCEED;
  119. }
  121. CS_RETCODE ct_con_props(CS_CONNECTION *con, CS_INT action, CS_INT property,
  122. CS_VOID *buffer, CS_INT buflen, CS_INT *out_len)
  123. {
  124. CS_INT intval = 0, maxcp;
  125. TDSSOCKET *tds;
  126. TDSLOGIN *tds_login;
  127. char *set_buffer = NULL;
  129. tdsdump_log(TDS_DBG_FUNC, "%L inside ct_con_props() action = %s property = %dn",
  130. CS_GET ? "CS_GET" : "CS_SET", property);
  132. tds = con->tds_socket;
  133. tds_login = con->tds_login;
  135. if (action==CS_SET) {
  136. if (property == CS_USERNAME || property == CS_PASSWORD
  137.  || property == CS_APPNAME  || property == CS_HOSTNAME) {
  138. if (buflen == CS_NULLTERM) {
  139. maxcp = strlen(buffer);
  140. set_buffer = (char *)malloc(maxcp + 1);
  141. strcpy(set_buffer, buffer);
  142. } else if (buflen == CS_UNUSED) {
  143. return CS_SUCCEED;
  144. } else {
  145. set_buffer = (char *)malloc(buflen + 1);
  146. strncpy(set_buffer, buffer, buflen);
  147. set_buffer[buflen] = '';
  148. }
  149. }
  151. /* XXX "login" properties shouldn't be set after
  152.  * login.  I don't know if it should fail silently
  153.  * or return an error.
  154.  */
  155. switch (property) {
  156. case CS_USERNAME:
  157. tds_set_user(tds_login, set_buffer);
  158. break;
  159. case CS_PASSWORD:
  160. tds_set_passwd(tds_login, set_buffer);
  161. break;
  162. case CS_APPNAME:
  163. tds_set_app(tds_login, set_buffer);
  164. break;
  165. case CS_HOSTNAME:
  166. tds_set_host(tds_login, set_buffer);
  167. break;
  168. case CS_LOC_PROP:
  169. con->locale = (CS_LOCALE *)buffer;
  170. break;
  171. case CS_USERDATA:
  172. if (con->userdata) {
  173. free(con->userdata);
  174. }
  175. con->userdata = (void *)malloc(buflen+1);
  176. tdsdump_log(TDS_DBG_INFO2, "%L setting userdata orig %d new %dn",buffer,con->userdata);
  177. con->userdata_len = buflen;
  178. memcpy(con->userdata, buffer, buflen);
  179. break;
  180. case CS_BULK_LOGIN:
  181. memcpy(&intval, buffer, sizeof(intval));
  182. if (intval) 
  183. tds_set_bulk(tds_login,1);
  184. else 
  185. tds_set_bulk(tds_login,0);
  186. break;
  187. case CS_PACKETSIZE:
  188. memcpy(&intval, buffer, sizeof(intval));
  189. tds_set_packet(tds_login, (short)intval);
  190. break;
  191. case CS_TDS_VERSION:
  192. /* FIX ME
  193.  * (a) We don't support all versions in tds/login.c -
  194.  *     I tried to pick reasonable versions.
  195.  * (b) Might need support outside of tds/login.c
  196.  * (c) It's a "negotiated" property so probably
  197.  *     needs tds_process_env_chg() support
  198.  * (d) Minor - we don't check against context
  199.  *     which should limit the acceptable values
  200.  */
  201. if (*(int *)buffer == CS_TDS_40) {
  202. tds_set_version(tds_login, 4, 2);
  203. } else if (*(int *)buffer == CS_TDS_42) {
  204. tds_set_version(tds_login, 4, 2);
  205. } else if (*(int *)buffer == CS_TDS_46) {
  206. tds_set_version(tds_login, 4, 6);
  207. } else if (*(int *)buffer == CS_TDS_495) {
  208. tds_set_version(tds_login, 4, 6);
  209. } else if (*(int *)buffer == CS_TDS_50) {
  210. tds_set_version(tds_login, 5, 0);
  211. } else if (*(int *)buffer == CS_TDS_70) {
  212. tds_set_version(tds_login, 7, 0);
  213. } else {
  214. return CS_FAIL;
  215. }
  216. break;
  217. default:
  218. tdsdump_log(TDS_DBG_ERROR, "%L Unknown property %dn",property);
  219. break;
  220. }
  221. if (set_buffer) free(set_buffer);
  222. } else if (action==CS_GET) {
  223. switch (property) {
  224. case CS_USERNAME:
  225. maxcp = strlen(tds_login->user_name);
  226. if (out_len) *out_len=maxcp;
  227. if (maxcp>=buflen) maxcp = buflen-1;
  228. strncpy(buffer,tds_login->user_name,maxcp);
  229. ((char *)buffer)[maxcp]='';
  230. break;
  231. case CS_PASSWORD:
  232. maxcp = strlen(tds_login->password);
  233. if (out_len) *out_len=maxcp;
  234. if (maxcp>=buflen) maxcp = buflen-1;
  235. strncpy(buffer,tds_login->password,maxcp);
  236. ((char *)buffer)[maxcp]='';
  237. break;
  238. case CS_APPNAME:
  239. maxcp = strlen(tds_login->app_name);
  240. if (out_len) *out_len=maxcp;
  241. if (maxcp>=buflen) maxcp = buflen-1;
  242. strncpy(buffer,tds_login->app_name,maxcp);
  243. ((char *)buffer)[maxcp]='';
  244. break;
  245. case CS_HOSTNAME:
  246. maxcp = strlen(tds_login->host_name);
  247. if (out_len) *out_len=maxcp;
  248. if (maxcp>=buflen) maxcp = buflen-1;
  249. strncpy(buffer,tds_login->host_name,maxcp);
  250. ((char *)buffer)[maxcp]='';
  251. break;
  252. case CS_LOC_PROP:
  253. buffer = (CS_VOID *)con->locale;
  254. break;
  255. case CS_USERDATA:
  256. tdsdump_log(TDS_DBG_INFO2, "%L fetching userdata %dn",con->userdata);
  257. maxcp = con->userdata_len;
  258. if (out_len) *out_len=maxcp;
  259. if (maxcp>buflen) maxcp = buflen;
  260. memcpy(buffer, con->userdata, maxcp);
  261. break;
  262. case CS_CON_STATUS:
  263. if (tds && tds->s) 
  264. intval |= CS_CONSTAT_CONNECTED;
  265. else 
  266. intval &= ~CS_CONSTAT_CONNECTED;
  267. if (tds && tds->state==TDS_DEAD) 
  268. intval |= CS_CONSTAT_DEAD;
  269. else
  270. intval &= ~CS_CONSTAT_DEAD;
  271. memcpy(buffer, &intval, sizeof(intval));
  272. break;
  273. case CS_BULK_LOGIN:
  274. if (tds_login->bulk_copy)
  275. intval=CS_FALSE;
  276. else 
  277. intval=CS_TRUE;
  278. memcpy(buffer, &intval, sizeof(intval));
  279. break;
  280. case CS_PACKETSIZE:
  281. if (tds && tds->env)
  282. intval = tds->env->block_size;
  283. else
  284. intval = tds_login->block_size;
  285. memcpy(buffer, &intval, sizeof(intval));
  286. if (out_len) *out_len=sizeof(intval);
  287. break;
  288. default:
  289. tdsdump_log(TDS_DBG_ERROR, "%L Unknown property %dn",property);
  290. break;
  291. }
  292. }
  293. return CS_SUCCEED;
  294. }
  296. CS_RETCODE ct_connect(CS_CONNECTION *con, CS_CHAR *servername, CS_INT snamelen)
  297. {
  298. char *server;
  299. int needfree=0;
  300. CS_CONTEXT *ctx;
  302. tdsdump_log(TDS_DBG_FUNC, "%L inside ct_connect() servername = %sn", servername);
  304. if (snamelen==0 || snamelen==CS_UNUSED) {
  305. server=NULL;
  306. } else if (snamelen==CS_NULLTERM) {
  307. server=(char *)servername;
  308. } else {
  309. server = (char *) malloc(snamelen+1);
  310. needfree++;
  311. strncpy(server,servername,snamelen);
  312. server[snamelen]='';
  313. }
  314.         tds_set_server(con->tds_login,server);
  315.    ctx = con->ctx;
  316.         if (!(con->tds_socket = (void *) tds_connect(con->tds_login, ctx->tds_ctx, (void *) con))) {
  317. if (needfree) free(server);
  318. tdsdump_log(TDS_DBG_FUNC, "%L leaving ct_connect() returning %dn", CS_FAIL);
  319. return CS_FAIL;
  320. }
  322.         /* tds_set_parent( con->tds_socket, con); */
  324. if (needfree) free(server);
  326. tdsdump_log(TDS_DBG_FUNC, "%L leaving ct_connect() returning %dn", CS_SUCCEED);
  327. return CS_SUCCEED;
  328. }
  329. CS_RETCODE ct_cmd_alloc(CS_CONNECTION *con, CS_COMMAND **cmd)
  330. {
  332. tdsdump_log(TDS_DBG_FUNC, "%L inside ct_cmd_alloc()n");
  334. *cmd = (CS_COMMAND *) malloc(sizeof(CS_COMMAND));
  335. memset(*cmd,'',sizeof(CS_COMMAND));
  337. /* so we know who we belong to */
  338. (*cmd)->con = con;
  340. return CS_SUCCEED;
  341. }
  342. CS_RETCODE ct_command(CS_COMMAND *cmd, CS_INT type, CS_VOID *buffer, CS_INT buflen, CS_INT option)
  343. {
  344. int query_len;
  346. tdsdump_log(TDS_DBG_FUNC, "%L inside ct_command()n");
  347. /* FIX ME -- will only work for type CS_LANG_CMD */
  348. if (buflen==CS_NULLTERM) {
  349. query_len = strlen(buffer);
  350. } else {
  351. query_len = buflen;
  352. }
  353. if (cmd->query) free(cmd->query);
  354. cmd->query = (char *) malloc(query_len + 1);
  355. strncpy(cmd->query,(char *)buffer,query_len);
  356. cmd->query[query_len]='';
  358. return CS_SUCCEED;
  359. }
  360. CS_RETCODE ct_send_dyn(CS_COMMAND *cmd)
  361. {
  362. if (cmd->dynamic_cmd==CS_PREPARE) {
  363. cmd->dynamic_cmd=0;
  364. if (tds_submit_prepare(cmd->con->tds_socket, cmd->query, cmd->dyn_id)==TDS_FAIL)
  365. return CS_FAIL;
  366. else 
  367. return CS_SUCCEED;
  368. } else if (cmd->dynamic_cmd==CS_EXECUTE) {
  369. cmd->dynamic_cmd=0;
  370. if (tds_submit_execute(cmd->con->tds_socket, cmd->dyn_id)==TDS_FAIL)
  371. return CS_FAIL;
  372. else 
  373. return CS_SUCCEED;
  374. }
  375. return CS_FAIL;
  376. }
  377. CS_RETCODE ct_send(CS_COMMAND *cmd)
  378. {
  379. tdsdump_log(TDS_DBG_FUNC, "%L inside ct_send()n");
  380. if (cmd->dynamic_cmd) 
  381. return ct_send_dyn(cmd);
  383. if (tds_submit_query(cmd->con->tds_socket, cmd->query)==TDS_FAIL) {
  384. tdsdump_log(TDS_DBG_WARN, "%L ct_send() failedn");
  385. return CS_FAIL;
  386. } else {
  387. tdsdump_log(TDS_DBG_INFO2, "%L ct_send() succeededn");
  388. return CS_SUCCEED;
  389. }
  390. }
  391. CS_RETCODE ct_results_dyn(CS_COMMAND *cmd, CS_INT *result_type)
  392. {
  393. TDSRESULTINFO *resinfo;
  394. TDSSOCKET *tds;
  395. TDSDYNAMIC *dyn;
  397. tds = cmd->con->tds_socket;
  399. if (cmd->dynamic_cmd==CS_DESCRIBE_INPUT) {
  400. dyn = tds->dyns[tds->cur_dyn_elem];
  401. if (dyn->dyn_state) {
  402. dyn->dyn_state = 0;
  403. return CS_END_RESULTS;
  404. } else {
  405. dyn->dyn_state++;
  406. *result_type = CS_DESCRIBE_RESULT;
  407. return CS_SUCCEED;
  408. }
  409. }
  410. return CS_FAIL;
  411. }
  412. CS_RETCODE ct_results(CS_COMMAND *cmd, CS_INT *result_type)
  413. {
  414. TDSRESULTINFO *resinfo;
  415. TDSSOCKET *tds;
  416. int ret;
  418. tdsdump_log(TDS_DBG_FUNC, "%L inside ct_results()n");
  420. if (cmd->dynamic_cmd) {
  421. return ct_results_dyn(cmd, result_type);
  422. }
  424. if (cmd->cmd_done) {
  425. cmd->cmd_done = 0;
  426. *result_type = CS_CMD_DONE;
  427. return CS_SUCCEED;
  428. } 
  430. tds = cmd->con->tds_socket;
  432. switch (ret = tds_process_result_tokens(tds)) {
  433. case TDS_SUCCEED:
  434. resinfo = tds->res_info;
  435. if (resinfo->rows_exist) {
  436. *result_type = CS_ROW_RESULT;
  437. cmd->cmd_done = 1;
  438. } else {
  439. *result_type = CS_CMD_SUCCEED;
  440. }
  441. return CS_SUCCEED;
  442. case TDS_NO_MORE_RESULTS:
  443. if (! tds->res_info) {
  444. if (cmd->empty_res_hack) {
  445. cmd->empty_res_hack=0;
  446. *result_type = CS_CMD_DONE;
  447. return CS_END_RESULTS;
  448. } else {
  449. cmd->empty_res_hack=1;
  450. *result_type = CS_CMD_SUCCEED;
  451. return CS_SUCCEED;
  452. }
  453. }
  454. if (tds->res_info && !tds->res_info->rows_exist) {
  455. if (cmd->empty_res_hack) {
  456. cmd->empty_res_hack=0;
  457. *result_type = CS_CMD_DONE;
  458. return CS_END_RESULTS;
  459. } else {
  460. cmd->empty_res_hack=1;
  461. *result_type = CS_ROW_RESULT;
  462. return CS_SUCCEED;
  463. }
  464. } else {
  465. *result_type = CS_CMD_DONE;
  466. return CS_END_RESULTS;
  467. }
  468. case TDS_FAIL:
  469. if (tds->state == TDS_DEAD) {
  470. return CS_FAIL;
  471. } else {
  472. *result_type = CS_CMD_FAIL;
  473. return CS_SUCCEED;
  474. }
  475. default:
  476. return CS_FAIL;
  477. }
  478. return CS_FAIL;
  479. }
  480. CS_RETCODE ct_bind(CS_COMMAND *cmd, CS_INT item, CS_DATAFMT *datafmt, CS_VOID *buffer, CS_INT *copied, CS_SMALLINT *indicator)
  481. {
  482. TDSCOLINFO * colinfo;
  483. CT_COLINFO *ctcolinfo; /* additional information about columns used by ctlib */
  484. TDSRESULTINFO * resinfo;
  485. TDSSOCKET * tds;
  487.    tdsdump_log(TDS_DBG_FUNC, "%L inside ct_bind()n");
  489.    tds = (TDSSOCKET *) cmd->con->tds_socket;
  490.    resinfo = tds->res_info;
  491.    /* FIXME check item value */
  492.    colinfo = resinfo->columns[item-1];
  493.    colinfo->varaddr = (char *)buffer;
  494.    colinfo->column_bindtype = datafmt->datatype;
  495.    colinfo->column_bindfmt = datafmt->format;
  496.    tdsdump_log(TDS_DBG_INFO1, "%L inside ct_bind() item = %d datafmt->datatype = %dn", item, datafmt->datatype);
  497.    colinfo->column_bindlen = datafmt->maxlength;
  498.    if (indicator) {
  499.     colinfo->column_nullbind = (TDS_CHAR *) indicator;
  500.    }
  501.    if (copied) {
  502.     colinfo->column_lenbind = (TDS_CHAR *) copied;
  503.    }
  504.    return CS_SUCCEED;
  505. }
  507. CS_RETCODE ct_fetch(CS_COMMAND *cmd, CS_INT type, CS_INT offset, CS_INT option, CS_INT *rows_read)
  508. {
  509.    tdsdump_log(TDS_DBG_FUNC, "%L inside ct_fetch()n");
  511.    if (rows_read) *rows_read = 0;
  512.    switch (tds_process_row_tokens(cmd->con->tds_socket)) {
  513.       case TDS_SUCCEED:
  514. if (_ct_bind_data(cmd))
  515. return CS_ROW_FAIL;
  516.        if (rows_read) *rows_read = 1;
  517.        return TDS_SUCCEED;
  518.       case TDS_NO_MORE_ROWS:
  519.        return CS_END_DATA;
  520.       default:
  521.        return CS_FAIL;
  522.    }
  523.    return CS_SUCCEED;
  524. }
  526. static int _ct_bind_data(CS_COMMAND *cmd)
  527. {
  528. int i;
  529. TDSCOLINFO *curcol;
  530. TDSSOCKET *tds = cmd->con->tds_socket;
  531. TDSRESULTINFO *resinfo = tds->res_info;
  532. unsigned char *src;
  533. unsigned char *dest;
  534. int result = 0;
  535. TDS_INT srctype, srclen, desttype, destlen, len;
  536. CS_CONTEXT *ctx = cmd->con->ctx;
  538. CS_DATAFMT srcfmt, destfmt;
  540.    tdsdump_log(TDS_DBG_FUNC, "%L inside _ct_bind_data()n");
  542.    for (i=0; i<resinfo->num_cols; i++) {
  543.       curcol = resinfo->columns[i];
  545.       if (curcol->column_nullbind) {
  546.        if (tds_get_null(resinfo->current_row,i)) {
  547.           *((CS_SMALLINT *)curcol->column_nullbind) = -1;
  548.        } else {
  549.           *((CS_SMALLINT *)curcol->column_nullbind) = 0;
  550.        }
  551.  }
  552.       /* printf("%d %sn",i,resinfo->columns[i]->column_value); */
  553.    
  554.       srctype = curcol->column_type;
  555.       desttype = _ct_get_server_type(curcol->column_bindtype);
  556.       dest = (unsigned char *)curcol->varaddr;
  557.   
  558.       if (dest && !tds_get_null(resinfo->current_row,i)) {
  560.          srctype = _ct_get_client_type(curcol->column_type, curcol->column_size);
  562.          if (is_blob_type(curcol->column_type)) {
  563.             src = (unsigned char *)curcol->column_textvalue;
  564.             srclen = curcol->column_textsize;
  565.          } else {
  566.             src = &(resinfo->current_row[curcol->column_offset]);
  567.     srclen = curcol->cur_row_size;
  568.          }
  570.          tdsdump_log(TDS_DBG_INFO1, "%L inside _ct_bind_data() setting source length for %d = %d destlen = %dn", i, srclen, curcol->column_bindlen);
  572.          srcfmt.datatype  = srctype;
  573.          srcfmt.maxlength = srclen;
  574.          srcfmt.locale    = cmd->con->locale;
  576.          destfmt.datatype  = curcol->column_bindtype;
  577.          destfmt.maxlength = curcol->column_bindlen;
  578.          destfmt.locale    = cmd->con->locale;
  579.          destfmt.format    = curcol->column_bindfmt;
  581.  /* if convert return FAIL mark error but process other columns */
  582.          if (cs_convert(ctx, &srcfmt, (CS_VOID *)src, &destfmt, (CS_VOID *)dest, &len) != CS_SUCCEED) {
  583.  result = 1;
  584.  len = 0;
  585.  }
  587.          if (curcol->column_lenbind) {
  588.             tdsdump_log(TDS_DBG_INFO1, "%L inside _ct_bind_data() length binding len = %dn", len);
  589.             *((CS_INT *)curcol->column_lenbind) = len;
  590.          }
  592.       }
  593.    }
  594.    return result;
  595. }
  597. CS_RETCODE ct_cmd_drop(CS_COMMAND *cmd)
  598. {
  599. tdsdump_log(TDS_DBG_FUNC, "%L inside ct_cmd_drop()n");
  600. if (cmd) {
  601. if (cmd->query) free(cmd->query);
  602. free(cmd);
  603. }
  604. return CS_SUCCEED;
  605. }
  606. CS_RETCODE ct_close(CS_CONNECTION *con, CS_INT option)
  607. {
  608. tdsdump_log(TDS_DBG_FUNC, "%L inside ct_close()n");
  609. tds_free_socket(con->tds_socket);
  610. return CS_SUCCEED;
  611. }
  614. CS_RETCODE ct_con_drop(CS_CONNECTION *con)
  615. {
  616.    tdsdump_log(TDS_DBG_FUNC, "%L inside ct_con_drop()n");
  617.    if (con) {
  618.       if (con->userdata)   free(con->userdata);
  619.       if (con->tds_login)  tds_free_login(con->tds_login);
  620.       free(con);
  621.    }
  622.    return CS_SUCCEED;
  623. }
  626. static int _ct_get_client_type(int datatype, int size)
  627. {
  628.    tdsdump_log(TDS_DBG_FUNC, "%L inside _ct_get_client_type(type %d, size %d)n",
  629.                              datatype, size);
  630.    switch (datatype) {
  631.          case SYBBIT:
  632.          case SYBBITN:
  633. return CS_BIT_TYPE;
  634. break;
  635.          case SYBCHAR:
  636.          case SYBVARCHAR:
  637. return CS_CHAR_TYPE;
  638. break;
  639.          case SYBINT4:
  640.        return CS_INT_TYPE;
  641. break;
  642.          case SYBINT2:
  643.        return CS_SMALLINT_TYPE;
  644. break;
  645.          case SYBINT1:
  646.        return CS_TINYINT_TYPE;
  647. break;
  648.  case SYBINTN:
  649. if (size==4) {
  650. return CS_INT_TYPE;
  651. } else if (size==2) {
  652.        return CS_SMALLINT_TYPE;
  653. } else if (size==1) {
  654.        return CS_TINYINT_TYPE;
  655. } else {
  656. fprintf(stderr,"Unknown size %d for SYBINTNn", size);
  657. }
  658. break;
  659.          case SYBREAL:
  660.        return CS_REAL_TYPE;
  661. break;
  662.          case SYBFLT8:
  663.        return CS_FLOAT_TYPE;
  664. break;
  665.  case SYBFLTN:
  666.        if (size==4) {
  667. return CS_REAL_TYPE;
  668. } else if (size==8) {
  669. return CS_FLOAT_TYPE;
  670. } else {
  671. fprintf(stderr,"Error! unknown float size of %dn",size);
  672. }
  673.          case SYBMONEY:
  674.        return CS_MONEY_TYPE;
  675. break;
  676.          case SYBMONEY4:
  677.        return CS_MONEY4_TYPE;
  678. break;
  679.  case SYBMONEYN:
  680.        if (size==4) {
  681. return CS_MONEY4_TYPE;
  682. } else if (size==8) {
  683. return CS_MONEY_TYPE;
  684. } else {
  685. fprintf(stderr,"Error! unknown money size of %dn",size);
  686. }
  687.          case SYBDATETIME:
  688.        return CS_DATETIME_TYPE;
  689. break;
  690.          case SYBDATETIME4:
  691.        return CS_DATETIME4_TYPE;
  692. break;
  693.  case SYBDATETIMN:
  694.        if (size==4) {
  695. return CS_DATETIME4_TYPE;
  696. } else if (size==8) {
  697. return CS_DATETIME_TYPE;
  698. } else {
  699. fprintf(stderr,"Error! unknown date size of %dn",size);
  700. }
  701. break;
  702.          case SYBNUMERIC:
  703.        return CS_NUMERIC_TYPE;
  704. break;
  705.          case SYBDECIMAL:
  706.        return CS_DECIMAL_TYPE;
  707. break;
  708.          case SYBBINARY:
  709.        return CS_BINARY_TYPE;
  710. break;
  711.          case SYBIMAGE:
  712.        return CS_IMAGE_TYPE;
  713. break;
  714.          case SYBVARBINARY:
  715.        return CS_VARBINARY_TYPE;
  716. break;
  717.          case SYBTEXT:
  718.        return CS_TEXT_TYPE;
  719. break;
  720.          case SYBUNIQUE:
  721.        return CS_UNIQUE_TYPE;
  722. break;
  723.    }
  725.    return CS_FAIL;
  726. }
  727. int _ct_get_server_type(int datatype)
  728. {
  729.    tdsdump_log(TDS_DBG_FUNC, "%L inside _ct_get_server_type(%d)n", datatype);
  730.    switch (datatype) {
  731.       case CS_IMAGE_TYPE:
  732.  return SYBIMAGE;
  733.  break;
  734.       case CS_BINARY_TYPE:
  735.  return SYBBINARY;
  736.  break;
  737.       case CS_BIT_TYPE:
  738.          return SYBBIT;
  739.          break;
  740.       case CS_CHAR_TYPE:
  741.          return SYBCHAR;
  742.          break;
  743.       case CS_INT_TYPE:
  744.          return SYBINT4;
  745.          break;
  746.       case CS_SMALLINT_TYPE:
  747.          return SYBINT2;
  748.          break;
  749.       case CS_TINYINT_TYPE:
  750.          return SYBINT1;
  751.          break;
  752.       case CS_REAL_TYPE:
  753.          return SYBREAL;
  754.          break;
  755.       case CS_FLOAT_TYPE:
  756.          return SYBFLT8;
  757.          break;
  758.       case CS_MONEY_TYPE:
  759.          return SYBMONEY;
  760.          break;
  761.       case CS_MONEY4_TYPE:
  762.          return SYBMONEY4;
  763.          break;
  764.       case CS_DATETIME_TYPE:
  765.          return SYBDATETIME;
  766.          break;
  767.       case CS_DATETIME4_TYPE:
  768.          return SYBDATETIME4;
  769.          break;
  770.       case CS_NUMERIC_TYPE:
  771.          return SYBNUMERIC;
  772.          break;
  773.       case CS_DECIMAL_TYPE:
  774.          return SYBDECIMAL;
  775.          break;
  776.       case CS_VARBINARY_TYPE:
  777.          return SYBVARBINARY;
  778.  break;
  779.       case CS_TEXT_TYPE:
  780.          return SYBTEXT;
  781.  break;
  782.       case CS_UNIQUE_TYPE:
  783.          return SYBUNIQUE;
  784.  break;
  785.       default:
  786.          return -1;
  787.          break;
  788.    }
  789. }
  791. CS_RETCODE ct_cancel(CS_CONNECTION *conn, CS_COMMAND *cmd, CS_INT type)
  792. {
  793.    CS_RETCODE ret;
  795.    tdsdump_log(TDS_DBG_FUNC, "%L inside ct_cancel()n");
  796.    if (type == CS_CANCEL_CURRENT) {
  797.       if (conn || !cmd)  return CS_FAIL;
  798.       while (1) {
  799.          ret = ct_fetch(cmd, CS_UNUSED, CS_UNUSED, CS_UNUSED, NULL);
  800.          if ((ret != CS_SUCCEED) && (ret != CS_ROW_FAIL)) {
  801.             break;
  802.          }
  803.       }
  804.       if (cmd->con->tds_socket) {
  805.          tds_free_all_results(cmd->con->tds_socket);
  806.       }
  807.       return ret;
  808.    }
  810.    if ((conn && cmd) || (!conn && !cmd)) {
  811.       return CS_FAIL;
  812.    }
  813.    if (cmd)  conn = cmd->con;
  814.    tds_send_cancel(conn->tds_socket);
  815.    tds_process_cancel(conn->tds_socket);
  816.    return CS_SUCCEED;
  817. }
  819. CS_RETCODE ct_describe(CS_COMMAND *cmd, CS_INT item, CS_DATAFMT *datafmt)
  820. {
  821. TDSSOCKET *tds;
  822. TDSRESULTINFO *resinfo;
  823. TDSCOLINFO *curcol;
  825. tdsdump_log(TDS_DBG_FUNC, "%L inside ct_describe()n");
  826. tds = cmd->con->tds_socket;
  828. if (cmd->dynamic_cmd) {
  829. resinfo = tds->dyns[tds->cur_dyn_elem]->res_info;
  830. } else {
  831.   resinfo = cmd->con->tds_socket->res_info;
  832. }
  834. if (item<1 || item>resinfo->num_cols) return CS_FAIL;
  835. curcol=resinfo->columns[item-1];
  836. strncpy(datafmt->name, curcol->column_name, CS_MAX_NAME);
  837. datafmt->namelen = strlen(curcol->column_name);
  838. /* need to turn the SYBxxx into a CS_xxx_TYPE */
  839. datafmt->datatype = _ct_get_client_type(curcol->column_type, curcol->column_size); 
  840. tdsdump_log(TDS_DBG_INFO1, "%L inside ct_describe() datafmt->datatype = %d server type %dn", datafmt->datatype, curcol->column_type);
  841. datafmt->maxlength = curcol->column_size;
  842. datafmt->usertype = curcol->column_usertype; 
  843. datafmt->precision = curcol->column_prec; 
  844. datafmt->scale = curcol->column_scale; 
  845. /* FIX ME -- TDS 5.0 has status information in the results 
  846. ** however, this will work for 4.2 as well */
  847. if (is_nullable_type(curcol->column_type)) 
  848. datafmt->status |= CS_CANBENULL;
  849. datafmt->count = 1;
  850. datafmt->locale = NULL;
  852. return CS_SUCCEED;
  853. }
  854. CS_RETCODE ct_res_info_dyn(CS_COMMAND *cmd, CS_INT type, CS_VOID *buffer, CS_INT buflen, CS_INT *out_len)
  855. {
  856. TDSSOCKET *tds = cmd->con->tds_socket;
  857. TDSDYNAMIC *dyn;
  858. CS_INT int_val;
  860. switch(type) {
  861. case CS_NUMDATA:
  862. dyn = tds->dyns[tds->cur_dyn_elem];
  863. int_val = dyn->res_info->num_cols;
  864. memcpy(buffer, &int_val, sizeof(CS_INT));
  865. break;
  866. default:
  867. fprintf(stderr,"Unknown type in ct_res_info_dyn: %dn",type);
  868. return CS_FAIL;
  869. }
  870. return CS_SUCCEED;
  871. }
  872. CS_RETCODE ct_res_info(CS_COMMAND *cmd, CS_INT type, CS_VOID *buffer, CS_INT buflen, CS_INT *out_len)
  873. {
  874. TDSSOCKET *tds = cmd->con->tds_socket;
  875. TDSRESULTINFO *resinfo = tds->res_info;
  876. CS_INT int_val;
  878. tdsdump_log(TDS_DBG_FUNC, "%L inside ct_res_info()n");
  879. if (cmd->dynamic_cmd) {
  880. return ct_res_info_dyn(cmd, type, buffer, buflen, out_len);
  881. }
  882. switch(type) {
  883. case CS_NUMDATA:
  884. if (!resinfo) {
  885. int_val = 0;
  886. } else {
  887. int_val = resinfo->num_cols;
  888. }
  889. memcpy(buffer, &int_val, sizeof(CS_INT));
  890. break;
  891. case CS_ROW_COUNT:
  892. /* resinfo check by kostya@warmcat.excom.spb.su */
  893. if (resinfo) {
  894. int_val = resinfo->row_count;
  895. } else {
  896. int_val = tds->rows_affected;
  897. }
  898. memcpy(buffer, &int_val, sizeof(CS_INT));
  899. break;
  900. default:
  901. fprintf(stderr,"Unknown type in ct_res_info: %dn",type);
  902. return CS_FAIL;
  903. break;
  904. }
  905. return CS_SUCCEED;
  906. }
  907. CS_RETCODE ct_config(CS_CONTEXT *ctx, CS_INT action, CS_INT property, CS_VOID *buffer, CS_INT buflen, CS_INT *outlen)
  908. {
  909. tdsdump_log(TDS_DBG_FUNC, "%L inside ct_config() action = %s property = %dn",
  910. CS_GET ? "CS_GET" : "CS_SET", property);
  911. return CS_SUCCEED;
  912. }
  913. CS_RETCODE ct_cmd_props(CS_COMMAND *cmd, CS_INT action, CS_INT property, CS_VOID *buffer, CS_INT buflen, CS_INT *outlen)
  914. {
  915. tdsdump_log(TDS_DBG_FUNC, "%L inside ct_cmd_props() action = %s property = %dn",
  916. CS_GET ? "CS_GET" : "CS_SET", property);
  917. return CS_SUCCEED;
  918. }
  919. CS_RETCODE ct_compute_info(CS_COMMAND *cmd, CS_INT type, CS_INT colnum, CS_VOID *buffer, CS_INT buflen, CS_INT *outlen)
  920. {
  921. tdsdump_log(TDS_DBG_FUNC, "%L inside ct_compute_info()n");
  922. return CS_SUCCEED;
  923. }
  924. CS_RETCODE ct_get_data(CS_COMMAND *cmd, CS_INT item, CS_VOID *buffer, CS_INT buflen, CS_INT *outlen)
  925. {
  926. tdsdump_log(TDS_DBG_FUNC, "%L inside ct_get_data()n");
  927. return CS_SUCCEED;
  928. }
  929. CS_RETCODE ct_send_data(CS_COMMAND *cmd, CS_VOID *buffer, CS_INT buflen)
  930. {
  931. tdsdump_log(TDS_DBG_FUNC, "%L inside ct_send_data()n");
  932. return CS_SUCCEED;
  933. }
  934. CS_RETCODE ct_data_info(CS_COMMAND *cmd, CS_INT action, CS_INT colnum,
  935. CS_IODESC *iodesc)
  936. {
  937. tdsdump_log(TDS_DBG_FUNC, "%L inside ct_data_info()n");
  938. return CS_SUCCEED;
  939. }
  940. CS_RETCODE ct_capability(CS_CONNECTION *con, CS_INT action, CS_INT type, CS_INT capability, CS_VOID *value)
  941. {
  942. TDSLOGIN *login;
  943. unsigned char *mask;
  945. tdsdump_log(TDS_DBG_FUNC, "%L inside ct_capability()n");
  946. login = (TDSLOGIN *) con->tds_login;
  947. mask = login->capabilities;
  949. if (action==CS_SET && type==CS_CAP_RESPONSE) {
  950. if (*((CS_BOOL *)value)==CS_TRUE) {
  951. switch(capability) {
  952. case CS_DATA_NOBOUNDARY:
  953. mask[13]|=0x01;break;
  954. case CS_DATA_NOTDSDEBUG:
  955. mask[13]|=0x02;break;
  956. case CS_RES_NOSTRIPBLANKS:
  957. mask[13]|=0x04;break;
  958. case CS_DATA_NOINT8:
  959. mask[13]|=0x08;break;
  960. case CS_DATA_NOINTN:
  961. mask[14]|=0x01;break;
  962. case CS_DATA_NODATETIMEN:
  963. mask[14]|=0x02;break;
  964. case CS_DATA_NOMONEYN:
  965. mask[14]|=0x04;break;
  966. case CS_CON_NOOOB:
  967. mask[14]|=0x08;break;
  968. case CS_CON_NOINBAND:
  969. mask[14]|=0x10;break;
  970. case CS_PROTO_NOTEXT:
  971. mask[14]|=0x20;break;
  972. case CS_PROTO_NOBULK:
  973. mask[14]|=0x40;break;
  974. case CS_DATA_NOSENSITIVITY:
  975. mask[14]|=0x80;break;
  976. case CS_DATA_NOFLT4:
  977. mask[15]|=0x01;break;
  978. case CS_DATA_NOFLT8:
  979. mask[15]|=0x02;break;
  980. case CS_DATA_NONUM:
  981. mask[15]|=0x04;break;
  982. case CS_DATA_NOTEXT:
  983. mask[15]|=0x08;break;
  984. case CS_DATA_NOIMAGE:
  985. mask[15]|=0x10;break;
  986. case CS_DATA_NODEC:
  987. mask[15]|=0x20;break;
  988. case CS_DATA_NOLCHAR:
  989. mask[15]|=0x40;break;
  990. case CS_DATA_NOLBIN:
  991. mask[15]|=0x80;break;
  992. case CS_DATA_NOCHAR:
  993. mask[16]|=0x01;break;
  994. case CS_DATA_NOVCHAR:
  995. mask[16]|=0x02;break;
  996. case CS_DATA_NOBIN:
  997. mask[16]|=0x04;break;
  998. case CS_DATA_NOVBIN:
  999. mask[16]|=0x08;break;
  1000. case CS_DATA_NOMNY8:
  1001. mask[16]|=0x10;break;
  1002. case CS_DATA_NOMNY4:
  1003. mask[16]|=0x20;break;
  1004. case CS_DATA_NODATE8:
  1005. mask[16]|=0x40;break;
  1006. case CS_DATA_NODATE4:
  1007. mask[16]|=0x80;break;
  1008. case CS_RES_NOMSG:
  1009. mask[17]|=0x02;break;
  1010. case CS_RES_NOEED:
  1011. mask[17]|=0x04;break;
  1012. case CS_RES_NOPARAM:
  1013. mask[17]|=0x08;break;
  1014. case CS_DATA_NOINT1:
  1015. mask[17]|=0x10;break;
  1016. case CS_DATA_NOINT2:
  1017. mask[17]|=0x20;break;
  1018. case CS_DATA_NOINT4:
  1019. mask[17]|=0x40;break;
  1020. case CS_DATA_NOBIT:
  1021. mask[17]|=0x80;break;
  1022. }
  1023. } else {
  1024. switch(capability) {
  1025. case CS_DATA_NOBOUNDARY:
  1026. mask[13]&=(!0x01);break;
  1027. case CS_DATA_NOTDSDEBUG:
  1028. mask[13]&=(!0x02);break;
  1029. case CS_RES_NOSTRIPBLANKS:
  1030. mask[13]&=(!0x04);break;
  1031. case CS_DATA_NOINT8:
  1032. mask[13]&=(!0x08);break;
  1033. case CS_DATA_NOINTN:
  1034. mask[14]&=(!0x01);break;
  1035. case CS_DATA_NODATETIMEN:
  1036. mask[14]&=(!0x02);break;
  1037. case CS_DATA_NOMONEYN:
  1038. mask[14]&=(!0x04);break;
  1039. case CS_CON_NOOOB:
  1040. mask[14]&=(!0x08);break;
  1041. case CS_CON_NOINBAND:
  1042. mask[14]&=(!0x10);break;
  1043. case CS_PROTO_NOTEXT:
  1044. mask[14]&=(!0x20);break;
  1045. case CS_PROTO_NOBULK:
  1046. mask[14]&=(!0x40);break;
  1047. case CS_DATA_NOSENSITIVITY:
  1048. mask[14]&=(!0x80);break;
  1049. case CS_DATA_NOFLT4:
  1050. mask[15]&=(!0x01);break;
  1051. case CS_DATA_NOFLT8:
  1052. mask[15]&=(!0x02);break;
  1053. case CS_DATA_NONUM:
  1054. mask[15]&=(!0x04);break;
  1055. case CS_DATA_NOTEXT:
  1056. mask[15]&=(!0x08);break;
  1057. case CS_DATA_NOIMAGE:
  1058. mask[15]&=(!0x10);break;
  1059. case CS_DATA_NODEC:
  1060. mask[15]&=(!0x20);break;
  1061. case CS_DATA_NOLCHAR:
  1062. mask[15]&=(!0x40);break;
  1063. case CS_DATA_NOLBIN:
  1064. mask[15]&=(!0x80);break;
  1065. case CS_DATA_NOCHAR:
  1066. mask[16]&=(!0x01);break;
  1067. case CS_DATA_NOVCHAR:
  1068. mask[16]&=(!0x02);break;
  1069. case CS_DATA_NOBIN:
  1070. mask[16]&=(!0x04);break;
  1071. case CS_DATA_NOVBIN:
  1072. mask[16]&=(!0x08);break;
  1073. case CS_DATA_NOMNY8:
  1074. mask[16]&=(!0x10);break;
  1075. case CS_DATA_NOMNY4:
  1076. mask[16]&=(!0x20);break;
  1077. case CS_DATA_NODATE8:
  1078. mask[16]&=(!0x40);break;
  1079. case CS_DATA_NODATE4:
  1080. mask[16]&=(!0x80);break;
  1081. case CS_RES_NOMSG:
  1082. mask[17]&=(!0x02);break;
  1083. case CS_RES_NOEED:
  1084. mask[17]&=(!0x04);break;
  1085. case CS_RES_NOPARAM:
  1086. mask[17]&=(!0x08);break;
  1087. case CS_DATA_NOINT1:
  1088. mask[17]&=(!0x10);break;
  1089. case CS_DATA_NOINT2:
  1090. mask[17]&=(!0x20);break;
  1091. case CS_DATA_NOINT4:
  1092. mask[17]&=(!0x40);break;
  1093. case CS_DATA_NOBIT:
  1094. mask[17]&=(!0x80);break;
  1095. }
  1096. }
  1097. } else if (action==CS_GET && type==CS_CAP_RESPONSE) {
  1098. switch (capability) {
  1099. case CS_DATA_NOBOUNDARY:
  1100. *((CS_BOOL *)value)=mask[13]&0x01 ? CS_TRUE : CS_FALSE;break;
  1101. case CS_DATA_NOTDSDEBUG:
  1102. *((CS_BOOL *)value)=mask[13]&0x02 ? CS_TRUE : CS_FALSE;break;
  1103. case CS_RES_NOSTRIPBLANKS:
  1104. *((CS_BOOL *)value)=mask[13]&0x04 ? CS_TRUE : CS_FALSE;break;
  1105. case CS_DATA_NOINT8:
  1106. *((CS_BOOL *)value)=mask[13]&0x08 ? CS_TRUE : CS_FALSE;break;
  1107. case CS_DATA_NOINTN:
  1108. *((CS_BOOL *)value)=mask[14]&0x01 ? CS_TRUE : CS_FALSE;break;
  1109. case CS_DATA_NODATETIMEN:
  1110. *((CS_BOOL *)value)=mask[14]&0x02 ? CS_TRUE : CS_FALSE;break;
  1111. case CS_DATA_NOMONEYN:
  1112. *((CS_BOOL *)value)=mask[14]&0x04 ? CS_TRUE : CS_FALSE;break;
  1113. case CS_CON_NOOOB:
  1114. *((CS_BOOL *)value)=mask[14]&0x08 ? CS_TRUE : CS_FALSE;break;
  1115. case CS_CON_NOINBAND:
  1116. *((CS_BOOL *)value)=mask[14]&0x10 ? CS_TRUE : CS_FALSE;break;
  1117. case CS_PROTO_NOTEXT:
  1118. *((CS_BOOL *)value)=mask[14]&0x20 ? CS_TRUE : CS_FALSE;break;
  1119. case CS_PROTO_NOBULK:
  1120. *((CS_BOOL *)value)=mask[14]&0x40 ? CS_TRUE : CS_FALSE;break;
  1121. case CS_DATA_NOSENSITIVITY:
  1122. *((CS_BOOL *)value)=mask[14]&0x80 ? CS_TRUE : CS_FALSE;break;
  1123. case CS_DATA_NOFLT4:
  1124. *((CS_BOOL *)value)=mask[15]&0x01 ? CS_TRUE : CS_FALSE;break;
  1125. case CS_DATA_NOFLT8:
  1126. *((CS_BOOL *)value)=mask[15]&0x02 ? CS_TRUE : CS_FALSE;break;
  1127. case CS_DATA_NONUM:
  1128. *((CS_BOOL *)value)=mask[15]&0x04 ? CS_TRUE : CS_FALSE;break;
  1129. case CS_DATA_NOTEXT:
  1130. *((CS_BOOL *)value)=mask[15]&0x08 ? CS_TRUE : CS_FALSE;break;
  1131. case CS_DATA_NOIMAGE:
  1132. *((CS_BOOL *)value)=mask[15]&0x10 ? CS_TRUE : CS_FALSE;break;
  1133. case CS_DATA_NODEC:
  1134. *((CS_BOOL *)value)=mask[15]&0x20 ? CS_TRUE : CS_FALSE;break;
  1135. case CS_DATA_NOLCHAR:
  1136. *((CS_BOOL *)value)=mask[15]&0x40 ? CS_TRUE : CS_FALSE;break;
  1137. case CS_DATA_NOLBIN:
  1138. *((CS_BOOL *)value)=mask[15]&0x80 ? CS_TRUE : CS_FALSE;break;
  1139. case CS_DATA_NOCHAR:
  1140. *((CS_BOOL *)value)=mask[16]&0x01 ? CS_TRUE : CS_FALSE;break;
  1141. case CS_DATA_NOVCHAR:
  1142. *((CS_BOOL *)value)=mask[16]&0x02 ? CS_TRUE : CS_FALSE;break;
  1143. case CS_DATA_NOBIN:
  1144. *((CS_BOOL *)value)=mask[16]&0x04 ? CS_TRUE : CS_FALSE;break;
  1145. case CS_DATA_NOVBIN:
  1146. *((CS_BOOL *)value)=mask[16]&0x08 ? CS_TRUE : CS_FALSE;break;
  1147. case CS_DATA_NOMNY8:
  1148. *((CS_BOOL *)value)=mask[16]&0x10 ? CS_TRUE : CS_FALSE;break;
  1149. case CS_DATA_NOMNY4:
  1150. *((CS_BOOL *)value)=mask[16]&0x20 ? CS_TRUE : CS_FALSE;break;
  1151. case CS_DATA_NODATE8:
  1152. *((CS_BOOL *)value)=mask[16]&0x40 ? CS_TRUE : CS_FALSE;break;
  1153. case CS_DATA_NODATE4:
  1154. *((CS_BOOL *)value)=mask[16]&0x80 ? CS_TRUE : CS_FALSE;break;
  1155. case CS_RES_NOMSG:
  1156. *((CS_BOOL *)value)=mask[17]&0x02 ? CS_TRUE : CS_FALSE;break;
  1157. case CS_RES_NOEED:
  1158. *((CS_BOOL *)value)=mask[17]&0x04 ? CS_TRUE : CS_FALSE;break;
  1159. case CS_RES_NOPARAM:
  1160. *((CS_BOOL *)value)=mask[17]&0x08 ? CS_TRUE : CS_FALSE;break;
  1161. case CS_DATA_NOINT1:
  1162. *((CS_BOOL *)value)=mask[17]&0x10 ? CS_TRUE : CS_FALSE;break;
  1163. case CS_DATA_NOINT2:
  1164. *((CS_BOOL *)value)=mask[17]&0x20 ? CS_TRUE : CS_FALSE;break;
  1165. case CS_DATA_NOINT4:
  1166. *((CS_BOOL *)value)=mask[17]&0x40 ? CS_TRUE : CS_FALSE;break;
  1167. case CS_DATA_NOBIT:
  1168. *((CS_BOOL *)value)=mask[17]&0x80 ? CS_TRUE : CS_FALSE;break;
  1169. }
  1170. } else if (action==CS_GET && type==CS_CAP_REQUEST) {
  1171. switch (capability) {
  1172. case CS_PROTO_DYNPROC:
  1173. *((CS_BOOL *)value)=mask[2]&0x01 ? CS_TRUE : CS_FALSE;break;
  1174. case CS_DATA_FLTN:
  1175. *((CS_BOOL *)value)=mask[2]&0x02 ? CS_TRUE : CS_FALSE;break;
  1176. case CS_DATA_BITN:
  1177. *((CS_BOOL *)value)=mask[2]&0x04 ? CS_TRUE : CS_FALSE;break;
  1178. case CS_DATA_INT8:
  1179. *((CS_BOOL *)value)=mask[2]&0x08 ? CS_TRUE : CS_FALSE;break;
  1180. case CS_DATA_VOID:
  1181. *((CS_BOOL *)value)=mask[2]&0x10 ? CS_TRUE : CS_FALSE;break;
  1182. case CS_CON_INBAND:
  1183. *((CS_BOOL *)value)=mask[3]&0x01 ? CS_TRUE : CS_FALSE;break;
  1184. case CS_CON_LOGICAL:
  1185. *((CS_BOOL *)value)=mask[3]&0x02 ? CS_TRUE : CS_FALSE;break;
  1186. case CS_PROTO_TEXT:
  1187. *((CS_BOOL *)value)=mask[3]&0x04 ? CS_TRUE : CS_FALSE;break;
  1188. case CS_PROTO_BULK:
  1189. *((CS_BOOL *)value)=mask[3]&0x08 ? CS_TRUE : CS_FALSE;break;
  1190. case CS_REQ_URGNOTIF:
  1191. *((CS_BOOL *)value)=mask[3]&0x10 ? CS_TRUE : CS_FALSE;break;
  1192. case CS_DATA_SENSITIVITY:
  1193. *((CS_BOOL *)value)=mask[3]&0x20 ? CS_TRUE : CS_FALSE;break;
  1194. case CS_DATA_BOUNDARY:
  1195. *((CS_BOOL *)value)=mask[3]&0x40 ? CS_TRUE : CS_FALSE;break;
  1196. case CS_PROTO_DYNAMIC:
  1197. *((CS_BOOL *)value)=mask[3]&0x80 ? CS_TRUE : CS_FALSE;break;
  1198. case CS_DATA_MONEYN:
  1199. *((CS_BOOL *)value)=mask[4]&0x01 ? CS_TRUE : CS_FALSE;break;
  1200. case CS_CSR_PREV:
  1201. *((CS_BOOL *)value)=mask[4]&0x02 ? CS_TRUE : CS_FALSE;break;
  1202. case CS_CSR_FIRST:
  1203. *((CS_BOOL *)value)=mask[4]&0x04 ? CS_TRUE : CS_FALSE;break;
  1204. case CS_CSR_LAST:
  1205. *((CS_BOOL *)value)=mask[4]&0x08 ? CS_TRUE : CS_FALSE;break;
  1206. case CS_CSR_ABS:
  1207. *((CS_BOOL *)value)=mask[4]&0x10 ? CS_TRUE : CS_FALSE;break;
  1208. case CS_CSR_REL:
  1209. *((CS_BOOL *)value)=mask[4]&0x20 ? CS_TRUE : CS_FALSE;break;
  1210. case CS_CSR_MULTI:
  1211. *((CS_BOOL *)value)=mask[4]&0x40 ? CS_TRUE : CS_FALSE;break;
  1212. case CS_CON_OOB:
  1213. *((CS_BOOL *)value)=mask[4]&0x80 ? CS_TRUE : CS_FALSE;break;
  1214. case CS_DATA_NUM:
  1215. *((CS_BOOL *)value)=mask[5]&0x01 ? CS_TRUE : CS_FALSE;break;
  1216. case CS_DATA_TEXT:
  1217. *((CS_BOOL *)value)=mask[5]&0x02 ? CS_TRUE : CS_FALSE;break;
  1218. case CS_DATA_IMAGE:
  1219. *((CS_BOOL *)value)=mask[5]&0x04 ? CS_TRUE : CS_FALSE;break;
  1220. case CS_DATA_DEC:
  1221. *((CS_BOOL *)value)=mask[5]&0x08 ? CS_TRUE : CS_FALSE;break;
  1222. case CS_DATA_LCHAR:
  1223. *((CS_BOOL *)value)=mask[5]&0x10 ? CS_TRUE : CS_FALSE;break;
  1224. case CS_DATA_LBIN:
  1225. *((CS_BOOL *)value)=mask[5]&0x20 ? CS_TRUE : CS_FALSE;break;
  1226. case CS_DATA_INTN:
  1227. *((CS_BOOL *)value)=mask[5]&0x40 ? CS_TRUE : CS_FALSE;break;
  1228. case CS_DATA_DATETIMEN:
  1229. *((CS_BOOL *)value)=mask[5]&0x80 ? CS_TRUE : CS_FALSE;break;
  1230. case CS_DATA_BIN:
  1231. *((CS_BOOL *)value)=mask[6]&0x01 ? CS_TRUE : CS_FALSE;break;
  1232. case CS_DATA_VBIN:
  1233. *((CS_BOOL *)value)=mask[6]&0x02 ? CS_TRUE : CS_FALSE;break;
  1234. case CS_DATA_MNY8:
  1235. *((CS_BOOL *)value)=mask[6]&0x04 ? CS_TRUE : CS_FALSE;break;
  1236. case CS_DATA_MNY4:
  1237. *((CS_BOOL *)value)=mask[6]&0x08 ? CS_TRUE : CS_FALSE;break;
  1238. case CS_DATA_DATE8:
  1239. *((CS_BOOL *)value)=mask[6]&0x10 ? CS_TRUE : CS_FALSE;break;
  1240. case CS_DATA_DATE4:
  1241. *((CS_BOOL *)value)=mask[6]&0x20 ? CS_TRUE : CS_FALSE;break;
  1242. case CS_DATA_FLT4:
  1243. *((CS_BOOL *)value)=mask[6]&0x40 ? CS_TRUE : CS_FALSE;break;
  1244. case CS_DATA_FLT8:
  1245. *((CS_BOOL *)value)=mask[6]&0x80 ? CS_TRUE : CS_FALSE;break;
  1246. case CS_REQ_MSG:
  1247. *((CS_BOOL *)value)=mask[7]&0x01 ? CS_TRUE : CS_FALSE;break;
  1248. case CS_REQ_PARAM:
  1249. *((CS_BOOL *)value)=mask[7]&0x02 ? CS_TRUE : CS_FALSE;break;
  1250. case CS_DATA_INT1:
  1251. *((CS_BOOL *)value)=mask[7]&0x04 ? CS_TRUE : CS_FALSE;break;
  1252. case CS_DATA_INT2:
  1253. *((CS_BOOL *)value)=mask[7]&0x08 ? CS_TRUE : CS_FALSE;break;
  1254. case CS_DATA_INT4:
  1255. *((CS_BOOL *)value)=mask[7]&0x10 ? CS_TRUE : CS_FALSE;break;
  1256. case CS_DATA_BIT:
  1257. *((CS_BOOL *)value)=mask[7]&0x20 ? CS_TRUE : CS_FALSE;break;
  1258. case CS_DATA_CHAR:
  1259. *((CS_BOOL *)value)=mask[7]&0x40 ? CS_TRUE : CS_FALSE;break;
  1260. case CS_DATA_VCHAR:
  1261. *((CS_BOOL *)value)=mask[7]&0x80 ? CS_TRUE : CS_FALSE;break;
  1262. case CS_REQ_LANG:
  1263. *((CS_BOOL *)value)=mask[8]&0x02 ? CS_TRUE : CS_FALSE;break;
  1264. case CS_REQ_RPC:
  1265. *((CS_BOOL *)value)=mask[8]&0x04 ? CS_TRUE : CS_FALSE;break;
  1266. case CS_REQ_NOTIF:
  1267. *((CS_BOOL *)value)=mask[8]&0x08 ? CS_TRUE : CS_FALSE;break;
  1268. case CS_REQ_MSTMT:
  1269. *((CS_BOOL *)value)=mask[8]&0x10 ? CS_TRUE : CS_FALSE;break;
  1270. case CS_REQ_BCP:
  1271. *((CS_BOOL *)value)=mask[8]&0x20 ? CS_TRUE : CS_FALSE;break;
  1272. case CS_REQ_CURSOR:
  1273. *((CS_BOOL *)value)=mask[8]&0x40 ? CS_TRUE : CS_FALSE;break;
  1274. case CS_REQ_DYN:
  1275. *((CS_BOOL *)value)=mask[8]&0x80 ? CS_TRUE : CS_FALSE;break;
  1276. /* *((CS_BOOL *)value)=CS_FALSE; */
  1277. }
  1278. } else {
  1279. /* bad values */
  1280. return CS_FAIL;
  1281. }
  1282. return CS_SUCCEED;
  1283. }
  1284. CS_RETCODE ct_dynamic(CS_COMMAND *cmd, CS_INT type, CS_CHAR *id, CS_INT idlen, CS_CHAR *buffer, CS_INT buflen)
  1285. {
  1286. static int stmt_no=1;
  1287. int query_len, id_len;
  1288. TDSDYNAMIC *dyn;
  1289. TDSSOCKET *tds;
  1290. int elem;
  1292. cmd->dynamic_cmd=type;
  1293. switch(type) {
  1294. case CS_PREPARE:
  1295. /* store away the id */
  1296.      if (idlen==CS_NULLTERM) {
  1297. id_len = strlen(id);
  1298.          } else {
  1299. id_len = idlen;
  1300. }
  1301. if (cmd->dyn_id) free(cmd->dyn_id);
  1302. cmd->dyn_id = (char *) malloc(id_len + 1);
  1303. strncpy(cmd->dyn_id,(char *)id,id_len);
  1304. cmd->dyn_id[id_len]='';
  1306. /* now the query */
  1307.         if (buflen==CS_NULLTERM) {
  1308. query_len = strlen(buffer);
  1309.          } else {
  1310. query_len = buflen;
  1311. }
  1312. if (cmd->query) free(cmd->query);
  1313. cmd->query = (char *) malloc(query_len + 1);
  1314. strncpy(cmd->query,(char *)buffer,query_len);
  1315. cmd->query[query_len]='';
  1317. break;
  1318. case CS_DEALLOC:
  1319. break;
  1320. case CS_DESCRIBE_INPUT:
  1321. break;
  1322. case CS_EXECUTE:
  1323. /* store away the id */
  1324.      if (idlen==CS_NULLTERM) {
  1325. id_len = strlen(id);
  1326.          } else {
  1327. id_len = idlen;
  1328. }
  1329. if (cmd->dyn_id) free(cmd->dyn_id);
  1330. cmd->dyn_id = (char *) malloc(id_len + 1);
  1331. strncpy(cmd->dyn_id,(char *)id,id_len);
  1332. cmd->dyn_id[id_len]='';
  1334. /* free any input parameters */
  1335. tds = cmd->con->tds_socket;
  1336. elem = tds_lookup_dynamic(tds, cmd->dyn_id);
  1337. dyn = tds->dyns[elem];
  1338. break;
  1339. }
  1340. tdsdump_log(TDS_DBG_FUNC, "%L inside ct_dynamic()n");
  1341. return CS_SUCCEED;
  1342. }
  1343. CS_RETCODE ct_param(CS_COMMAND *cmd, CS_DATAFMT *datafmt, CS_VOID *data, CS_INT datalen, CS_SMALLINT indicator)
  1344. {
  1345. TDSSOCKET *tds;
  1346. TDSDYNAMIC *dyn;
  1347. TDSINPUTPARAM *param;
  1348. int elem;
  1350. tdsdump_log(TDS_DBG_FUNC, "%L inside ct_param()n");
  1351. tdsdump_log(TDS_DBG_INFO1, "%L ct_param() data addr = %d data length = %dn", data, datalen);
  1353. tds = cmd->con->tds_socket;
  1355. elem = tds_lookup_dynamic(tds, cmd->dyn_id);
  1356. dyn = tds->dyns[elem];
  1357. param = tds_add_input_param(dyn);
  1358. param->column_type = _ct_get_server_type(datafmt->datatype);
  1359. param->varaddr = data;
  1360. if (datalen==CS_NULLTERM) {
  1361. param->column_bindlen = 0;
  1362. } else {
  1363. param->column_bindlen = datalen;
  1364. }
  1365. param->is_null = indicator;
  1367. return CS_SUCCEED;
  1368. }
  1369. CS_RETCODE ct_options(CS_CONNECTION *con, CS_INT action, CS_INT option, CS_VOID *param, CS_INT paramlen, CS_INT *outlen)
  1370. {
  1371. tdsdump_log(TDS_DBG_FUNC, "%L inside ct_options() action = %s option = %dn",
  1372. CS_GET ? "CS_GET" : "CS_SET", option);
  1373. return CS_SUCCEED;
  1374. }