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

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

生物技术

开发平台：

C/C++

token.c：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: token.c,v $
  4.  * PRODUCTION Revision 1000.1  2004/04/01 21:01:24  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [CORE_002] Dev-tree R1.5
  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 "tds.h"
  31. #include "tdsutil.h"
  32. #include "tdsconvert.h"
  33. #ifdef DMALLOC
  34. #include <dmalloc.h>
  35. #endif
  37. static char  software_version[]   = "$Id: token.c,v 1000.1 2004/04/01 21:01:24 gouriano Exp $";
  38. static void *no_unused_var_warn[] = {software_version,
  39.                                      no_unused_var_warn};
  41. static int tds_process_msg(TDSSOCKET *tds,int marker);
  42. static int tds_process_compute_result(TDSSOCKET *tds);
  43. static int tds_process_result(TDSSOCKET *tds);
  44. static int tds_process_col_name(TDSSOCKET *tds);
  45. static int tds_process_col_info(TDSSOCKET *tds);
  46. static int tds_process_compute(TDSSOCKET *tds);
  47. static int tds_process_row(TDSSOCKET *tds);
  48. static int tds_process_param_result(TDSSOCKET *tds);
  49. static int tds7_process_result(TDSSOCKET *tds);
  50. static int tds_process_param_result_tokens(TDSSOCKET *tds);
  51. static void tds_process_dyn_result(TDSSOCKET *tds);
  52. static int tds_process_dynamic(TDSSOCKET *tds);
  53. static int tds_process_auth(TDSSOCKET *tds);
  54. static int tds_get_varint_size(int datatype);
  55. static int tds_get_cardinal_type(int datatype);
  56. void tds_swap_datatype(int coltype, unsigned char *buf);
  58. /*
  59. ** The following little table is indexed by precision and will
  60. ** tell us the number of bytes required to store the specified
  61. ** precision.
  62. */
  63. extern const int g__numeric_bytes_per_prec[];
  66. /*
  67. ** tds_process_default_tokens() is a catch all function that is called to
  68. ** process tokens not known to other tds_process_* routines
  69. */
  70. int tds_process_default_tokens(TDSSOCKET *tds, int marker)
  71. {
  72. int order_len;
  73. int tok_size;
  74. int   more_results;
  75. int   cancelled;
  77.    tdsdump_log(TDS_DBG_FUNC, "%L inside tds_process_default_tokens() marker is %xn", marker);
  79.    if (!tds->s) {
  80.         tdsdump_log(TDS_DBG_FUNC, "%L leaving tds_process_default_tokens() connection deadn");
  81. tds->state=TDS_DEAD;
  82. return TDS_FAIL;
  83.    }
  85.    switch(marker) {
  86. case TDS_AUTH_TOKEN:
  87. tds_process_auth(tds);
  88. break;
  89. case TDS_ENV_CHG_TOKEN:
  90.       {
  91.          tds_process_env_chg(tds);
  92.          break;
  93.       }
  94.       case TDS_DONE_TOKEN:
  95.       case TDS_DONEPROC_TOKEN:
  96.       case TDS_DONEINPROC_TOKEN:
  97.       {
  98.          tds_process_end(tds, marker, &more_results, &cancelled);
  99.          if (!more_results) tds->state=TDS_COMPLETED;
  100.          break;
  101.       }
  102.       case TDS_124_TOKEN:
  103.          tds_get_n(tds,NULL,8);
  104.          break;
  105.       case TDS_RET_STAT_TOKEN:
  106. tds->has_status=1;
  107. tds->ret_status=tds_get_int(tds);
  108.         break;
  109.       case TDS_ERR_TOKEN:
  110.       case TDS_MSG_TOKEN:
  111.       case TDS_EED_TOKEN:
  112.          return tds_process_msg(tds,marker);
  113.          break;
  114.       case TDS_CAP_TOKEN:
  115.  tok_size = tds_get_smallint(tds);
  116.          tds_get_n(tds,tds->capabilities,tok_size > TDS_MAX_CAPABILITY ? TDS_MAX_CAPABILITY : tok_size);
  117.          break;
  118.       case TDS_LOGIN_ACK_TOKEN:
  119.          tds_get_n(tds,NULL,tds_get_smallint(tds));
  120.          break;
  121.       case TDS_ORDER_BY_TOKEN:
  122.          order_len = tds_get_smallint(tds);
  123.          tds_get_n(tds, NULL, order_len);
  124.          /* get the next token which is ROW_TOKEN (209)
  125. tds_get_byte(tds);
  126. if(orderLen > 1)
  127. tds_process_column_row(tds); */
  128.          break;
  129.       case TDS_168_TOKEN:
  130.          tds_process_compute_result(tds); 
  131.          break;
  132.       case TDS_PARAM_TOKEN: 
  133.  tds_unget_byte(tds);
  134.  tds_process_param_result_tokens(tds);
  135.          break;
  136.          /* 167 is somehow related to compute columns */
  137.       case TDS_167_TOKEN:
  138.       case TDS_174_TOKEN: 
  139.          tds_get_n(tds, NULL, tds_get_smallint(tds));
  140.          break;
  141.       case TDS7_RESULT_TOKEN:
  142.          tds7_process_result(tds); 
  143.          break;
  144.       case TDS_RESULT_TOKEN:
  145.          tds_process_result(tds); 
  146.          break;
  147.       case TDS_COL_NAME_TOKEN:
  148.          tds_process_col_name(tds); 
  149.          break;
  150.       case TDS_COL_INFO_TOKEN:
  151.          tds_process_col_info(tds); 
  152.          break;
  153.       case TDS_CMP_ROW_TOKEN:
  154.          tds_process_compute(tds); 
  155.          break;
  156.       case TDS_ROW_TOKEN:
  157.          tds_process_row(tds); 
  158.          break;
  159.       case TDS5_DYN_TOKEN:
  160.       case TDS5_DYNRES_TOKEN:
  161.       case TDS5_DYN3_TOKEN:
  162. #ifdef NCBI_FTDS
  163.    case TDS_COL_INFO_TOKEN2:
  164. #endif
  165.  tdsdump_log(TDS_DBG_WARN, "eating token %dn",marker);
  166.          tds_get_n(tds, NULL, tds_get_smallint(tds));
  167.          break;
  168.       default:
  169.  tdsdump_log(TDS_DBG_ERROR, "Unknown marker: %d(%x)!!n",marker,(unsigned char)marker); 
  170.          return TDS_FAIL;
  171.    }
  172.    return TDS_SUCCEED;
  173. }
  175. /*
  176. ** tds_process_login_tokens() is called after sending the login packet 
  177. ** to the server.  It returns the success or failure of the login 
  178. ** dependent on the protocol version. 4.2 sends an ACK token only when
  179. ** successful, TDS 5.0 sends it always with a success byte within
  180. */
  181. int tds_process_login_tokens(TDSSOCKET *tds)
  182. {
  183. int succeed=0;
  184. int marker;
  185. int len;
  186. unsigned char major_ver, minor_ver;
  187. unsigned char ack;
  188. #ifdef WORDS_BIGENDIAN
  189. char *tmpbuf;
  190. #endif
  192. tdsdump_log(TDS_DBG_FUNC, "%L inside tds_process_login_tokens()n");
  193. /* get_incoming(tds->s); */
  194. do {
  195. marker=tds_get_byte(tds);
  196. switch(marker) {
  197. case TDS_AUTH_TOKEN:
  198. tds_process_auth(tds);
  199. break;
  200. case TDS_LOGIN_ACK_TOKEN:
  201. len = tds_get_smallint(tds);
  202. ack = tds_get_byte(tds);
  203. major_ver = tds_get_byte(tds);
  204. minor_ver = tds_get_byte(tds);
  205. tds_get_n(tds, NULL, len-4);
  206. tds_get_byte(tds);
  207. #ifdef WORDS_BIGENDIAN
  208. /*
  209. if (major_ver==7) {
  210. tds->broken_dates=1;
  211. }
  212. */
  213. #endif
  214. /*
  215. tmpbuf = (char *) malloc(len);
  216. tds_get_n(tds, tmpbuf, len);
  217. tdsdump_log(TDS_DBG_INFO1, "%L login ack marker = %dn%Dn", marker, tmpbuf, len);
  218. free(tmpbuf);
  219. */
  220. /* TDS 5.0 reports 5 on success 6 on failure
  221. ** TDS 4.2 reports 1 on success and is not
  222. ** present on failure */
  223. if (ack==5 || ack==1) succeed=TDS_SUCCEED;
  224. break;
  225. default:
  226. if (tds_process_default_tokens(tds,marker)==TDS_FAIL)
  227. return TDS_FAIL;
  228. break;
  229. }
  230. } while (marker!=TDS_DONE_TOKEN);
  231. tdsdump_log(TDS_DBG_FUNC, "%L leaving tds_process_login_tokens() returning %dn",succeed);
  232. return succeed;
  233. }
  235. static int tds_process_auth(TDSSOCKET *tds)
  236. {
  237. int pdu_size, ntlm_size;
  238. char nonce[10];
  239. /* char domain[30]; */
  240. int where = 0;
  242. pdu_size = tds_get_smallint(tds);
  243. tdsdump_log(TDS_DBG_INFO1, "TDS_AUTH_TOKEN PDU size %dn", pdu_size);
  245. tds_get_n(tds, NULL, 8); /* NTLMSSP */ 
  246. where += 8;
  247. tds_get_int(tds); /* sequence -> 2 */
  248. where += 4;
  249. tds_get_n(tds, NULL, 4); /* domain len (2 time) */
  250. where += 4;
  251. ntlm_size = tds_get_int(tds); /* size of remainder of ntlmssp packet */
  252. where += 4;
  253. tdsdump_log(TDS_DBG_INFO1, "TDS_AUTH_TOKEN NTLMSSP size %dn", ntlm_size);
  254. tds_get_n(tds, NULL, 4); /* flags */
  255. where += 4;
  256. tds_get_n(tds, nonce, 8); 
  257. where += 8;
  258. tdsdump_log(TDS_DBG_INFO1, "TDS_AUTH_TOKEN noncen");
  259. tdsdump_dump_buf(nonce, 8);
  260. tds_get_n(tds, NULL, 8); 
  261. where += 8;
  263. /*
  264. tds_get_ntstring(tds, domain, 30); 
  265. tdsdump_log(TDS_DBG_INFO1, "TDS_AUTH_TOKEN domain %sn", domain);
  266. where += strlen(domain);
  267. */
  269. tds_get_n(tds, NULL, pdu_size - where); 
  270. tdsdump_log(TDS_DBG_INFO1,"%L Draining %d bytesn", pdu_size - where);
  272. tds7_send_auth(tds, nonce);
  274. return TDS_SUCCEED;
  275. }
  276. /*
  277. ** tds_process_result_tokens() is called after submitting a query with
  278. ** tds_submit_query() and is responsible for calling the routines to
  279. ** populate tds->res_info if appropriate (some query have no result sets)
  280. */
  281. int tds_process_result_tokens(TDSSOCKET *tds)
  282. {
  283. int result=0;
  284. int marker;
  285. int more_results = 0;
  286. int cancelled;
  287. int retcode=TDS_NO_MORE_RESULTS;
  288. int rc;
  290. if (tds->state==TDS_COMPLETED) {
  291. /* tds_process_row() now eats the end marker and sets
  292. ** state to TDS_COMPLETED
  293. */
  294. return TDS_NO_MORE_RESULTS;
  295. }
  297. /* get_incoming(tds->s); */
  298. do {
  299. marker=tds_get_byte(tds);
  300. tdsdump_log(TDS_DBG_INFO1, "%L processing result tokens.  marker is  %xn", marker);
  302. switch(marker) {
  303.        case TDS_ERR_TOKEN:
  304.        case TDS_MSG_TOKEN:
  305.        case TDS_EED_TOKEN:
  306. rc = tds_process_msg(tds,marker);
  307. /* don't fail until we get a DONE */
  308. if (rc == TDS_ERROR) 
  309. retcode=TDS_FAIL;
  310. break;
  311. case TDS7_RESULT_TOKEN:
  312. if (!result) {
  313. tds7_process_result(tds);
  314. result++;
  315. } else {
  316. tds_unget_byte(tds);
  317. return TDS_SUCCEED;
  318. }
  319. break;
  320. case TDS_RESULT_TOKEN:
  321. if (!result) {
  322. tds_process_result(tds);
  323. result++;
  324. } else {
  325. tds_unget_byte(tds);
  326. return TDS_SUCCEED;
  327. }
  328. break;
  329. case TDS_COL_NAME_TOKEN:
  330. if (!result) {
  331. tds_process_col_name(tds);
  332. result++;
  333. } else {
  334. tds_unget_byte(tds);
  335. return TDS_SUCCEED;
  336. }
  337. break;
  338. case TDS_ROW_TOKEN:
  339. if (!result) {
  340. } else {
  341. tds->res_info->rows_exist=1;
  342. tds_unget_byte(tds);
  343. return TDS_SUCCEED;
  344. }
  345. #ifdef NCBI_FTDS
  346.              break; /* <-- looks like it should be here (v. soussov) */
  347. #endif
  348.        case TDS_RET_STAT_TOKEN:
  349. tds->has_status=1;
  350. tds->ret_status=tds_get_int(tds);
  351. /* return TDS_SUCCEED; */
  352. break;
  353. case TDS5_DYN_TOKEN:
  354. tds->cur_dyn_elem = tds_process_dynamic(tds);
  355. break;
  356.        case TDS5_DYNRES_TOKEN:
  357. tds_process_dyn_result(tds);
  358. break;
  359. case TDS_DONE_TOKEN:
  360. case TDS_DONEPROC_TOKEN:
  361. case TDS_DONEINPROC_TOKEN:
  362. tds_process_end(tds, marker, 
  363. &more_results, 
  364. &cancelled);
  365. break;
  366. default:
  367. if (tds_process_default_tokens(tds, marker)==TDS_FAIL) 
  368. return TDS_FAIL;
  369. break;
  370. }
  371. } while (!is_end_token(marker) || more_results);
  373. tds->state=TDS_COMPLETED;
  375. return retcode;
  376. }
  378. /* 
  379. ** tds_process_row_tokens() is called once a result set has been obtained
  380. ** with tds_process_result_tokens(). It calls tds_process_row() to copy
  381. ** data into the row buffer.
  382. */
  383. int tds_process_row_tokens(TDSSOCKET *tds)
  384. {
  385. int marker;
  386. int   more_results;
  387. int   cancelled;
  389. if (tds->state==TDS_COMPLETED) {
  390. return TDS_NO_MORE_ROWS;
  391. }
  393. while (1) {
  394. marker=tds_get_byte(tds);
  395.         tdsdump_log(TDS_DBG_INFO1, "%L processing row tokens.  marker is  %xn", marker);
  396. switch(marker) {
  397. case TDS_RESULT_TOKEN:
  398. case TDS7_RESULT_TOKEN:
  399. tds_unget_byte(tds);
  400. return TDS_NO_MORE_ROWS;
  401. case TDS_ROW_TOKEN:
  402. tds_process_row(tds);
  403. return TDS_SUCCEED;
  404. case TDS_DONE_TOKEN:
  405. case TDS_DONEPROC_TOKEN:
  406. case TDS_DONEINPROC_TOKEN:
  407. tds_process_end(tds, marker, 
  408. &more_results, 
  409. &cancelled);
  410. tds->res_info->more_results = more_results;
  411. return TDS_NO_MORE_ROWS;
  412. default:
  413. if (tds_process_default_tokens(tds,marker)==TDS_FAIL)
  414. return TDS_FAIL;
  415. break;
  416. }
  417. } 
  418. return TDS_SUCCEED;
  419. }
  421. /* 
  422. ** tds_process_col_name() is one half of the result set under TDS 4.2
  423. ** it contains all the column names, a TDS_COLINFO_TOKEN should 
  424. ** immediately follow this token with the datatype/size information
  425. ** This is a 4.2 only function
  426. */
  427. static int tds_process_col_name(TDSSOCKET *tds)
  428. {
  429. int hdrsize, len=0;
  430. int col,num_cols=0;
  431. struct tmp_col_struct {
  432. char *column_name;
  433. int column_namelen;
  434. struct tmp_col_struct *next;
  435. };
  436. struct tmp_col_struct *head=NULL, *cur=NULL, *prev;
  437. TDSCOLINFO *curcol;
  438. TDSRESULTINFO *info;
  440. hdrsize = tds_get_smallint(tds);
  442. /* this is a little messy...TDS 5.0 gives the number of columns
  443. ** upfront, while in TDS 4.2, you're expected to figure it out
  444. ** by the size of the message. So, I use a link list to get the
  445. ** colum names and then allocate the result structure, copy
  446. ** and delete the linked list */
  447. while (len<hdrsize) {
  448. prev = cur;
  449. cur = (struct tmp_col_struct *) 
  450. malloc(sizeof (struct tmp_col_struct));
  451. if (prev) prev->next=cur;
  452. if (!head) head = cur;
  454. cur->column_namelen = tds_get_byte(tds);
  455. cur->column_name = (char *) malloc(cur->column_namelen+1);
  456. tds_get_n(tds,cur->column_name, cur->column_namelen);
  457. cur->column_name[cur->column_namelen]='';
  458. cur->next=NULL;
  460. len += cur->column_namelen + 1;
  461. num_cols++;
  462. }
  464. /* free results/computes/params etc... */
  465. tds_free_all_results(tds);
  467. tds->res_info = tds_alloc_results(num_cols);
  468. info = tds->res_info;
  469. /* tell the upper layers we are processing results */
  470. tds->state = TDS_PENDING; 
  471. cur=head;
  472. for (col=0;col<info->num_cols;col++) 
  473. {
  474. curcol=info->columns[col];
  475. curcol->column_namelen = cur->column_namelen;
  476. strncpy(curcol->column_name, cur->column_name, 
  477. sizeof(curcol->column_name));
  478. prev=cur; cur=cur->next;
  479. free(prev->column_name);
  480. free(prev);
  481. }
  482. return TDS_SUCCEED;
  483. } 
  485. /* 
  486. ** tds_process_col_info() is the other half of result set processing
  487. ** under TDS 4.2. It follows tds_process_col_name(). It contains all the 
  488. ** column type and size information.
  489. ** This is a 4.2 only function
  490. */
  491. static int tds_process_col_info(TDSSOCKET *tds)
  492. {
  493. int col,hdrsize;
  494. TDSCOLINFO *curcol;
  495. TDSRESULTINFO *info;
  496. TDS_SMALLINT tabnamesize;
  497. int bytes_read = 0;
  498. int rest;
  499. /* XXX do a best check for alignment than this */
  500. union { void *p; int i; } align_struct;
  501. const int align = sizeof(align_struct);
  502. int remainder;
  503. char ci_flags[4];
  505. hdrsize = tds_get_smallint(tds);
  507. info = tds->res_info;
  508. for (col=0; col<info->num_cols; col++) 
  509. {
  510. curcol=info->columns[col];
  511. /* Used to ignore next 4 bytes, now we'll actually parse (some of)
  512. the data in them. (mlilback, 11/7/01) */
  513. tds_get_n(tds, ci_flags, 4);
  514. curcol->column_nullable = ci_flags[3] & 0x01;
  515. curcol->column_writeable = (ci_flags[3] & 0x08) > 0;
  516. curcol->column_identity = (ci_flags[3] & 0x10) > 0;
  517. /* on with our regularly scheduled code (mlilback, 11/7/01) */
  518. curcol->column_type = tds_get_byte(tds);
  520. curcol->column_varint_size  = tds_get_varint_size(curcol->column_type);
  521.         tdsdump_log(TDS_DBG_INFO1, "%L processing result. type = %d, varint_size %dn", 
  522.                     curcol->column_type, curcol->column_varint_size);
  524. switch(curcol->column_varint_size) {
  525. case 4: 
  526. curcol->column_size = tds_get_int(tds);
  527. /* junk the table name -- for now */
  528.     tabnamesize = tds_get_smallint(tds);
  529. #ifdef NCBI_FTDS
  530.              tds_get_n(tds,curcol->full_column_name,tabnamesize);
  531.              curcol->full_column_name[tabnamesize]='.';
  532.              strcpy(curcol->full_column_name+tabnamesize+1,curcol->column_name);
  533. #else             
  534.     tds_get_n(tds,NULL,tabnamesize);
  535. #endif
  536.     bytes_read += 5+4+2+tabnamesize;
  537. break;
  538. case 1: 
  539. curcol->column_size = tds_get_byte(tds);
  540.     bytes_read += 5+1;
  541. break;
  542. case 0: 
  543. curcol->column_size = get_size_by_type(curcol->column_type);
  544.     bytes_read += 5+0;
  545. break;
  546. }
  548. if (is_blob_type(curcol->column_type)) {
  549. curcol->column_offset = info->row_size;
  550. } else {
  551. curcol->column_offset = info->row_size;
  552. info->row_size += curcol->column_size + 1;
  553. }
  554. if (IS_TDS42(tds)) {
  555. remainder = info->row_size % align; 
  556. if (remainder)
  557. info->row_size += (align - remainder);
  558. }
  559. }
  561. /* get the rest of the bytes */
  562. rest = hdrsize - bytes_read;
  563. if (rest > 0) {
  564. tdsdump_log(TDS_DBG_INFO1,"NOTE:tds_process_col_info: draining %d bytesn", rest);
  565. tds_get_n(tds, NULL, rest);
  566. }
  568. info->current_row = tds_alloc_row(info);
  570. return TDS_SUCCEED;
  571. }
  573. /*
  574. ** tds_process_param_result() processes output parameters of a stored 
  575. ** procedure. This differs from regular row/compute results in that there
  576. ** is no total number of parameters given, they just show up singley.
  577. */
  578. static int tds_process_param_result(TDSSOCKET *tds)
  579. {
  580. int hdrsize;
  581. int column_type;
  582. int column_size, actual_size;
  584. hdrsize = tds_get_smallint(tds);
  585. tds_get_string(tds, NULL, tds_get_byte(tds)); /* column name */
  586. tds_get_n(tds, NULL, 5); /* unknown */
  587. column_type = tds_get_byte(tds); /* datatype */
  588. if (!is_fixed_type(column_type)) {
  589. column_size = tds_get_byte(tds);
  590. actual_size = tds_get_byte(tds);
  591. tds_get_n(tds, NULL, actual_size);
  592. } else { 
  593. column_size = get_size_by_type(column_type);
  594. tds_get_n(tds, NULL, column_size);
  595. }
  596. return TDS_SUCCEED;
  597. }
  598. static int tds_process_param_result_tokens(TDSSOCKET *tds)
  599. {
  600. int marker;
  602. while ((marker=tds_get_byte(tds))==TDS_PARAM_TOKEN) {
  603. tds_process_param_result(tds);
  604. }
  605. tds_unget_byte(tds);
  606. return TDS_SUCCEED;
  607. }
  608. /*
  609. ** tds_process_compute_result() processes compute result sets.  These functions
  610. ** need work but since they get little use, nobody has complained!
  611. ** It is very similar to normal result sets.
  612. */
  613. static int tds_process_compute_result(TDSSOCKET *tds)
  614. {
  615. int hdrsize;
  616. int col, num_cols;
  617. TDSCOLINFO *curcol;
  618. TDSCOMPUTEINFO *info;
  619. int remainder;
  621. info = tds->comp_info;
  623. /* should not occur...but just in case */
  624. if (info) tds_free_compute_results(info);
  626. hdrsize = tds_get_smallint(tds);
  627. /* unknown always 1 ? */
  628. tds_get_smallint(tds); 
  629. num_cols = tds_get_byte(tds);
  630. tds->comp_info = tds_alloc_compute_results(num_cols);
  631. info = tds->comp_info;
  633. for (col=0;col<num_cols;col++) 
  634. {
  635. curcol=info->columns[col];
  636. /* user type and some other stuff? */
  637. tds_get_n(tds,NULL,6);
  638. /* column type */
  639. curcol->column_type = tds_get_byte(tds);
  640. /* column size */
  641. if (!is_fixed_type(curcol->column_type)) {
  642. curcol->column_size = tds_get_byte(tds);
  643. } else { 
  644. curcol->column_size = get_size_by_type(curcol->column_type);
  645. }
  646. curcol->column_offset = info->row_size;
  647. info->row_size += curcol->column_size + 1;
  648. /* actually this 4 should be a machine dependent #define */
  649. remainder = info->row_size & 0x3; 
  650. if (remainder) info->row_size += (4 - remainder);
  652. tds_get_byte(tds);
  653. }
  654. tds_get_n(tds,NULL,tds_get_smallint(tds));
  656. return TDS_SUCCEED;
  657. }
  659. /*
  660. ** tds7_process_result() is the TDS 7.0 result set processing routine.  It 
  661. ** is responsible for populating the tds->res_info structure.
  662. ** This is a TDS 7.0 only function
  663. */
  664. static int tds7_process_result(TDSSOCKET *tds)
  665. {
  666. int col, num_cols;
  667. int colnamelen;
  668. TDS_SMALLINT tabnamelen;
  669. TDSCOLINFO *curcol;
  670. TDSRESULTINFO *info;
  671. TDS_SMALLINT collate_type;
  672. int remainder;
  674. tds_free_all_results(tds);
  676. /* read number of columns and allocate the columns structure */
  677. num_cols = tds_get_smallint(tds);
  678. tds->res_info = tds_alloc_results(num_cols);
  679. info = tds->res_info;
  681. /* tell the upper layers we are processing results */
  682. tds->state = TDS_PENDING; 
  684. /* loop through the columns populating COLINFO struct from
  685. ** server response */
  686. for (col=0;col<num_cols;col++) {
  688. curcol = info->columns[col];
  690. /*  User defined data type of the column */
  691. curcol->column_usertype = tds_get_smallint(tds);  
  693.         curcol->column_flags = tds_get_smallint(tds);     /*  Flags */
  695.         curcol->column_nullable  =  curcol->column_flags & 0x01;
  696.         curcol->column_writeable = (curcol->column_flags & 0x08) > 0;
  697. curcol->column_identity  = (curcol->column_flags & 0x10) > 0;
  699. curcol->column_type = tds_get_byte(tds); 
  701.         curcol->column_type_save = curcol->column_type;
  702. collate_type = (curcol->column_flags & 0x2) || is_collate_type(curcol->column_type);
  703. curcol->column_varint_size  = tds_get_varint_size(curcol->column_type);
  705. switch(curcol->column_varint_size) {
  706. case 4: 
  707. curcol->column_size = tds_get_int(tds);
  708. break;
  709. case 2: 
  710. curcol->column_size = tds_get_smallint(tds);
  711. break;
  712. case 1: 
  713. curcol->column_size = tds_get_byte(tds);
  714. break;
  715. case 0: 
  716. curcol->column_size = get_size_by_type(curcol->column_type);
  717. break;
  718. }
  720. curcol->column_unicodedata = 0;
  722. if (is_unicode(curcol->column_type))
  723. curcol->column_unicodedata = 1;
  725. curcol->column_type = tds_get_cardinal_type(curcol->column_type);
  727. /* numeric and decimal have extra info */
  728. if (is_numeric_type(curcol->column_type)) {
  729. curcol->column_prec = tds_get_byte(tds); /* precision */
  730. curcol->column_scale = tds_get_byte(tds); /* scale */
  731. }
  733. if (IS_TDS80(tds)) {
  734. if (collate_type) 
  735. tds_get_n(tds, curcol->collation, 5);
  736. }
  738. if (is_blob_type(curcol->column_type)) {
  739. tabnamelen = tds_get_smallint(tds);
  740. #ifdef NCBI_FTDS
  741.   tds_get_string(tds,curcol->full_column_name,tabnamelen);
  742.   curcol->full_column_name[tabnamelen]='.';
  743. #else
  744. tds_get_string(tds, NULL, tabnamelen);
  745. #endif
  746. }
  748. /* under 7.0 lengths are number of characters not 
  749. ** number of bytes...tds_get_string handles this */
  750. colnamelen = tds_get_byte(tds);
  751. tds_get_string(tds,curcol->column_name, colnamelen);
  753. /* the column_offset is the offset into the row buffer
  754. ** where this column begins, text types are no longer
  755. ** stored in the row buffer because the max size can
  756. ** be too large (2gig) to allocate */
  757. curcol->column_offset = info->row_size;
  758. if (!is_blob_type(curcol->column_type)) {
  759. info->row_size += curcol->column_size + 1;
  760. }
  761. #ifdef NCBI_FTDS
  762.       else {
  763.           strcpy(curcol->full_column_name+tabnamelen+1,curcol->column_name);
  764.       }
  765. #endif
  766. if (is_numeric_type(curcol->column_type)) {
  767.                        info->row_size += sizeof(TDS_NUMERIC) + 1;
  768. }
  769. #ifdef NCBI_FTDS
  770. else if(curcol->column_type == SYBVARBINARY) {
  771.   info->row_size+= sizeof(TDS_INT); /* to prevent memory corruption */
  772. }
  773. #endif
  775. /* actually this 4 should be a machine dependent #define */
  776. if(remainder = info->row_size & 0x3) {
  777.           info->row_size += (4 - remainder);
  778.       }
  780. }
  782. /* all done now allocate a row for tds_process_row to use */
  783. info->current_row = tds_alloc_row(info);
  785. return TDS_SUCCEED;
  787. }
  789. /*
  790. ** tds_process_result() is the TDS 5.0 result set processing routine.  It 
  791. ** is responsible for populating the tds->res_info structure.
  792. ** This is a TDS 5.0 only function
  793. */
  794. static int tds_process_result(TDSSOCKET *tds)
  795. {
  796. int hdrsize;
  797. int colnamelen;
  798. int col, num_cols;
  799. TDSCOLINFO *curcol;
  800. TDSRESULTINFO *info;
  801. int remainder;
  803. tds_free_all_results(tds);
  805. hdrsize = tds_get_smallint(tds);
  807. /* read number of columns and allocate the columns structure */
  808. num_cols = tds_get_smallint(tds);
  809. tds->res_info = tds_alloc_results(num_cols);
  810. info = tds->res_info;
  812. /* tell the upper layers we are processing results */
  813. tds->state = TDS_PENDING; 
  815. /* loop through the columns populating COLINFO struct from
  816. ** server response */
  817. for (col=0;col<info->num_cols;col++) 
  818. {
  819. curcol=info->columns[col];
  821. colnamelen = tds_get_byte(tds);
  822. tds_get_n(tds,curcol->column_name, colnamelen);
  823. curcol->column_name[colnamelen]='';
  825.         curcol->column_flags = tds_get_byte(tds);     /*  Flags */
  826.         curcol->column_nullable  = (curcol->column_flags & 0x20) > 1;
  828. curcol->column_usertype = tds_get_smallint(tds);
  829. tds_get_smallint(tds);  /* another unknown */
  830. curcol->column_type = tds_get_byte(tds);
  832. curcol->column_varint_size  = tds_get_varint_size(curcol->column_type);
  834.         tdsdump_log(TDS_DBG_INFO1, "%L processing result. type = %d, varint_size %dn", curcol->column_type, curcol->column_varint_size);
  835. switch(curcol->column_varint_size) {
  836. case 4: 
  837. curcol->column_size = tds_get_int(tds);
  838. /* junk the table name -- for now */
  839. tds_get_n(tds,NULL,tds_get_smallint(tds));
  840. break;
  841. case 1: 
  842. curcol->column_size = tds_get_byte(tds);
  843. break;
  844. case 0: 
  845. curcol->column_size = get_size_by_type(curcol->column_type);
  846. break;
  847. /* FIXME can varint_size be 2 ?? */
  848. }
  849.         tdsdump_log(TDS_DBG_INFO1, "%L processing result. column_size %dn", curcol->column_size);
  851. /* numeric and decimal have extra info */
  852. if (is_numeric_type(curcol->column_type)) {
  853. curcol->column_prec = tds_get_byte(tds); /* precision */
  854. curcol->column_scale = tds_get_byte(tds); /* scale */
  855. }
  857. curcol->column_offset = info->row_size;
  858. if (is_numeric_type(curcol->column_type)) {
  859. info->row_size += sizeof(TDS_NUMERIC) + 1;
  860. } else if (!is_blob_type(curcol->column_type)) {
  861. info->row_size += curcol->column_size + 1;
  862. }
  863. #ifdef NCBI_FTDS
  864. else if(curcol->column_type == SYBVARBINARY) {
  865.   info->row_size+= sizeof(TDS_INT); /* to prevent memory corruption */
  866. }
  867. #endif
  871. /* actually this 4 should be a machine dependent #define */
  872. remainder = info->row_size & 0x3; 
  873. if (remainder) info->row_size += (4 - remainder);
  875. tds_get_byte(tds); /* ? */
  876. }
  877. info->current_row = tds_alloc_row(info);
  879. return TDS_SUCCEED;
  880. }
  882. /*
  883. ** tds_process_compute() processes compute rows and places them in the row
  884. ** buffer.  It's in a bit of disrepair and may not have tracked the row
  885. ** buffer changes completely.
  886. */
  887. static int tds_process_compute(TDSSOCKET *tds)
  888. {
  889. int colsize, i;
  890. TDSCOLINFO *curcol;
  891. TDSCOMPUTEINFO *info;
  892. int compid;
  893. unsigned char *dest;
  895. info = tds->comp_info;
  897. compid = tds_get_smallint(tds); /* compute id? */
  898. for (i=0;i<info->num_cols;i++)
  899. {
  900. curcol = info->columns[i];
  901. if (!is_fixed_type(curcol->column_type)) {
  902. colsize = tds_get_byte(tds);
  903. } else {
  904. colsize = get_size_by_type(curcol->column_type);
  905. }
  906. dest = &(info->current_row[curcol->column_offset]);
  907. tds_get_n(tds,dest,colsize);
  908. #ifndef NCBI_FTDS
  909. dest[colsize]='';
  910. #endif
  911. }
  912. return TDS_SUCCEED;
  913. }
  915. /*
  916. ** tds_process_row() processes rows and places them in the row buffer.  There
  917. ** is also some special handling for some of the more obscure datatypes here.
  918. */
  919. static int tds_process_row(TDSSOCKET *tds)
  920. {
  921. int colsize, i;
  922. TDSCOLINFO *curcol;
  923. TDSRESULTINFO *info;
  924. unsigned char *dest;
  925. TDS_NUMERIC *num;
  926. TDS_VARBINARY *varbin;
  927. int len;
  928.  TDS_SMALLINT cur_col_type;
  930. info = tds->res_info;
  931. if (!info)
  932. return TDS_FAIL;
  934. info->row_count++;
  936. #ifdef NCBI_FTDS
  937.   memset(info->current_row,'',info->null_info_size); /*** clear nulls ***/
  938. #endif
  940. for (i=0;i<info->num_cols;i++) {
  941. curcol = info->columns[i];
  942. cur_col_type= curcol->column_type;
  943.         tdsdump_log(TDS_DBG_INFO1, "%L processing row.  column is %d varint size = %dn", i, curcol->column_varint_size);
  944. switch (curcol->column_varint_size) {
  945. case 4: /* Its a BLOB... */
  946. len = tds_get_byte(tds);
  947. if (len == 16) { /*  Jeff's hack */
  948. tds_get_n(tds,curcol->column_textptr,16);
  949. tds_get_n(tds,curcol->column_timestamp,8);
  950. colsize = tds_get_int(tds);
  951. } else {
  952. colsize = 0;
  953. }
  954. break;
  955. case 2: 
  956. /* FIXME add support for empty no-NULL string*/
  957. colsize = tds_get_smallint(tds);
  958. if (colsize == -1)
  959. colsize=0;
  960. break;
  961. case 1: 
  962. colsize = tds_get_byte(tds);
  963. break;
  964. case 0: 
  965. colsize = get_size_by_type(cur_col_type);
  966. break;
  967. }
  969.         tdsdump_log(TDS_DBG_INFO1, "%L processing row.  column size is %d n", colsize);
  970. /* set NULL flag in the row buffer */
  971. if (colsize==0) {
  972. tds_set_null(info->current_row, i);
  973. } else {
  974. tds_clr_null(info->current_row, i);
  976. if (is_numeric_type(cur_col_type)) {
  978. /* 
  979. ** handling NUMERIC datatypes: 
  980. ** since these can be passed around independent
  981. ** of the original column they were from, I decided
  982. ** to embed the TDS_NUMERIC datatype in the row buffer
  983. ** instead of using the wire representation even though
  984. ** it uses a few more bytes
  985. */
  986. num = (TDS_NUMERIC *) &(info->current_row[curcol->column_offset]);
  987.                 memset(num, '', sizeof(TDS_NUMERIC));
  988. num->precision = curcol->column_prec;
  989. num->scale = curcol->column_scale;
  991. tds_get_n(tds,num->array,colsize);
  992. /* corrected colsize for cur_row_size */
  993. colsize = sizeof(TDS_NUMERIC);
  994.         if (IS_TDS70(tds) || IS_TDS80(tds)) 
  995.                 {
  996.    tdsdump_log(TDS_DBG_INFO1, "%L swapping numeric data...n");
  997.                    tds_swap_datatype(tds_get_conversion_type(cur_col_type, colsize), (unsigned char *)num );
  998.                 }
  1000. } else if (cur_col_type == SYBVARBINARY) {
  1001. varbin = (TDS_VARBINARY *) &(info->current_row[curcol->column_offset]);
  1002. varbin->len = colsize;
  1003.                             /*  It is important to re-zero out the whole
  1004.                                 column_size varbin array here because the result
  1005.                                 of the query ("colsize") may be any number of
  1006.                                 bytes <= column_size (because the result
  1007.                                 will be truncated if the rest of the data
  1008.                                 in the column would be all zeros).  */
  1009.                                 memset(varbin->array,'',curcol->column_size);
  1011. tds_get_n(tds,varbin->array,colsize);
  1012. } else if (is_blob_type(cur_col_type)) {
  1013. if (curcol->column_unicodedata) colsize /= 2;
  1014. curcol->column_textvalue = realloc(curcol->column_textvalue,colsize+1); /* FIXME +1 needed by tds_get_string */
  1015. curcol->column_textsize = colsize;
  1016. if (curcol->column_unicodedata) {
  1017. tds_get_string(tds,curcol->column_textvalue,colsize);
  1018. } else {
  1019. tds_get_n(tds,curcol->column_textvalue,colsize);
  1020. }
  1021. } else {
  1022. dest = &(info->current_row[curcol->column_offset]);
  1023. if (curcol->column_unicodedata) {
  1024. tds_get_string(tds,dest,colsize/2);
  1025. colsize /= 2;
  1026. } else {
  1027. tds_get_n(tds,dest,colsize);
  1028. }
  1029. /* FIXME correct for unicode ? */
  1030. #ifdef NCBI_FTDS
  1031.             if(cur_col_type == SYBVARCHAR)
  1032. #endif
  1033.                 dest[colsize]='';
  1034. if (cur_col_type == SYBDATETIME4) {
  1035. tdsdump_log(TDS_DBG_INFO1, "%L datetime4 %d %d %d %dn", dest[0], dest[1], dest[2], dest[3]);
  1036. }
  1037. }
  1039. /* Value used to properly know value in dbdatlen. (mlilback, 11/7/01) */
  1040. curcol->cur_row_size = colsize;
  1042. #ifdef WORDS_BIGENDIAN
  1043. /* MS SQL Server 7.0 has broken date types from big endian 
  1044. ** machines, this swaps the low and high halves of the 
  1045. ** affected datatypes
  1046. **
  1047. ** Thought - this might be because we don't have the
  1048. ** right flags set on login.  -mjs
  1049. **
  1050. ** Nope its an actual MS SQL bug -bsb
  1051. */
  1052. if (tds->broken_dates &&
  1053. (cur_col_type == SYBDATETIME ||
  1054. cur_col_type == SYBDATETIME4 ||
  1055. cur_col_type == SYBDATETIMN ||
  1056. cur_col_type == SYBMONEY ||
  1057. cur_col_type == SYBMONEY4 ||
  1058. (cur_col_type == SYBMONEYN && curcol->column_size > 4))) 
  1059. /* above line changed -- don't want this for 4 byte SYBMONEYN 
  1060. values (mlilback, 11/7/01) */
  1061. {
  1062. unsigned char temp_buf[8];
  1064. memcpy(temp_buf,dest,colsize/2);
  1065. memcpy(dest,&dest[colsize/2],colsize/2);
  1066. memcpy(&dest[colsize/2],temp_buf,colsize/2);
  1067. }
  1068.             if (tds->emul_little_endian && !is_numeric_type(cur_col_type)) {
  1069.                 tdsdump_log(TDS_DBG_INFO1, "%L swapping coltype %dn",
  1070.                             tds_get_conversion_type(cur_col_type,colsize));
  1071.                 tds_swap_datatype(tds_get_conversion_type(cur_col_type, colsize),
  1072.                                   &(info->current_row[curcol->column_offset])
  1073.                                  );
  1074.             }
  1075. #endif
  1076. }
  1077. }
  1078. return TDS_SUCCEED;
  1079. }
  1082. /*
  1083. ** tds_process_end() processes any of the DONE, DONEPROC, or DONEINPROC
  1084. ** tokens.
  1085. */
  1086. TDS_INT tds_process_end(
  1087.    TDSSOCKET     *tds,
  1088.    int            marker,
  1089.    int           *more_results_parm,
  1090.    int           *was_cancelled_parm)
  1091. {
  1092. int more_results, was_cancelled;
  1093. int tmp = tds_get_smallint(tds);
  1095.    more_results = (tmp & 0x1) != 0;
  1096.    was_cancelled = (tmp & 0x20) != 0;
  1097.    if (tds->res_info)  {
  1098.       tds->res_info->more_results=more_results;
  1099.       if (was_cancelled || !(more_results)) {
  1100.           tds->state = TDS_COMPLETED;
  1101.       }
  1102.    }
  1103.    if (more_results_parm)
  1104. *more_results_parm = more_results;
  1105.    if (was_cancelled_parm)
  1106. *was_cancelled_parm = was_cancelled;
  1107.    tds_get_smallint(tds);
  1108.    /* rows affected is in the tds struct because a query may affect rows but
  1109.    ** have no result set. */
  1110.    tds->rows_affected = tds_get_int(tds);
  1111.    return tds->rows_affected;
  1112. }
  1114. /*
  1115. ** tds_client_msg() sends a message to the client application from the CLI or
  1116. ** TDS layer. A client message is one that is generated from with the library
  1117. ** and not from the server.  The message is sent to the CLI (the 
  1118. ** err_handler) so that it may forward it to the client application or
  1119. ** discard it if no msg handler has been by the application. tds->parent
  1120. ** contains a void pointer to the parent of the tds socket. This can be cast
  1121. ** back into DBPROCESS or CS_CONNECTION by the CLI and used to determine the
  1122. ** proper recipient function for this message.
  1123. */
  1124. int tds_client_msg(TDSCONTEXT *tds_ctx, TDSSOCKET *tds, int msgnum, int level, int state, int line, char *message)
  1125. {
  1126. int ret;
  1127. TDSMSGINFO msg_info;
  1129.         if(tds_ctx->err_handler) {
  1130. memset(&msg_info, 0, sizeof(TDSMSGINFO));
  1131. msg_info.msg_number=msgnum;
  1132.          msg_info.msg_level=level; /* severity? */
  1133.          msg_info.msg_state=state;
  1134.          msg_info.server=strdup("OpenClient");
  1135.          msg_info.line_number=line;
  1136.          msg_info.message=strdup(message);
  1137.          ret = tds_ctx->err_handler(tds_ctx, tds, &msg_info);
  1138. /* message handler returned FAIL/CS_FAIL
  1139. ** mark socket as dead */
  1140. if (ret && tds) {
  1141. tds->state=TDS_DEAD;
  1142. }
  1143. }
  1144. return 0;
  1145. }
  1147. /*
  1148. ** tds_process_env_chg() 
  1149. ** when ever certain things change on the server, such as database, character
  1150. ** set, language, or block size.  A environment change message is generated
  1151. ** There is no action taken currently, but certain functions at the CLI level
  1152. ** that return the name of the current database will need to use this.
  1153. */
  1154. #ifdef NCBI_FTDS
  1155. extern int tds_process_env_chg(TDSSOCKET *tds)
  1156. {
  1157. int size, type,env_left;
  1158. char oldval[1024], newval[1024];
  1159. int  new_block_size;
  1160. TDSENVINFO *env = tds->env;
  1162. env_left = tds_get_smallint(tds);
  1163. /* this came in a patch, apparently someone saw an env message
  1164. ** that was different from what we are handling? -- brian
  1165. ** changed back because it won't handle multibyte chars -- 7.0
  1166. */
  1167. /* tds_get_n(tds,NULL,size); */
  1169. type = tds_get_byte(tds);
  1170. env_left--;
  1172. switch(type){
  1173.  case TDS_ENV_BLOCKSIZE:
  1174. /* fetch the new value */
  1175. size = tds_get_byte(tds);
  1176. if(size) tds_get_string(tds,newval,size);
  1177. newval[size]='';
  1179. /* fetch the old value */
  1180. size = tds_get_byte(tds);
  1181. if(size) tds_get_string(tds,oldval,size);
  1182. oldval[size]='';
  1184. new_block_size = atoi(newval);
  1185. if (new_block_size > env->block_size) {
  1186. tdsdump_log(TDS_DBG_INFO1, "%L increasing block size from %d to %dn",
  1187. env->block_size, new_block_size);
  1188. /* 
  1189. ** I'm not aware of any way to shrink the 
  1190. ** block size but if it is possible, we don't 
  1191. ** handle it.
  1192. */
  1193. tds->out_buf = (unsigned char*) realloc(tds->out_buf, new_block_size);
  1194. env->block_size = new_block_size;
  1195. }
  1196. break;
  1197.  case TDS_ENV_DATABASE:
  1198.    case TDS_ENV_CHARSET: 
  1199.        tds_get_n(tds,NULL,env_left);
  1200. break;
  1201.  default:
  1202. tdsdump_log(TDS_DBG_INFO1, "%L unknown TDS_ENV type %d, skipping %d bytes blockn", type, env_left);
  1203. tds_get_n(tds,NULL,env_left);
  1204. break;
  1205. }
  1206. return TDS_SUCCEED;
  1207. }
  1208. #else
  1209. int tds_process_env_chg(TDSSOCKET *tds)
  1210. {
  1211. int size, type;
  1212. char *oldval, *newval;
  1213. int  new_block_size;
  1214. TDSENVINFO *env = tds->env;
  1216. size = tds_get_smallint(tds);
  1217. /* this came in a patch, apparently someone saw an env message
  1218. ** that was different from what we are handling? -- brian
  1219. ** changed back because it won't handle multibyte chars -- 7.0
  1220. */
  1221. /* tds_get_n(tds,NULL,size); */
  1223. type = tds_get_byte(tds);
  1225. if (type==0x07) {
  1226. size = tds_get_byte(tds);
  1227. if (size) tds_get_n(tds, NULL, size);
  1228. size = tds_get_byte(tds);
  1229. if (size) tds_get_n(tds, NULL, size);
  1230. return TDS_SUCCEED;
  1231. }
  1233. /* fetch the new value */
  1234. size = tds_get_byte(tds);
  1235. newval = (char *) malloc((size+1)*2);
  1236. tds_get_string(tds,newval,size);
  1237. newval[size]='';
  1239. /* fetch the old value */
  1240. size = tds_get_byte(tds);
  1241. oldval = (char *) malloc((size+1)*2); /* may be a unicode string */
  1242. tds_get_string(tds,oldval,size);
  1243. oldval[size]='';
  1245. switch (type) {
  1246. case TDS_ENV_BLOCKSIZE:
  1247. new_block_size = atoi(newval);
  1248. if (new_block_size > env->block_size) {
  1249. tdsdump_log(TDS_DBG_INFO1, "%L increasing block size from %s to %dn", oldval, new_block_size);
  1250. /* 
  1251. ** I'm not aware of any way to shrink the 
  1252. ** block size but if it is possible, we don't 
  1253. ** handle it.
  1254. */
  1255. tds->out_buf = (unsigned char*) realloc(tds->out_buf, new_block_size);
  1256. env->block_size = new_block_size;
  1257. }
  1258. break;
  1259. }
  1260. free(oldval);
  1261. free(newval);
  1263. return TDS_SUCCEED;
  1264. }
  1265. #endif
  1266. int tds_process_column_row(TDSSOCKET *tds)
  1267. {
  1268. int colsize, i;
  1269. TDSCOLINFO *curcol;
  1270. TDSRESULTINFO *info;
  1271. unsigned char *dest;
  1274.       info = tds->res_info;
  1275.       info->row_count++;
  1277.       for (i=0;i<(info->num_cols -1);i++)
  1278.       {
  1279.               curcol = info->columns[i];
  1280.               if (!is_fixed_type(curcol->column_type)) {
  1281.                       colsize = tds_get_byte(tds);
  1282.               } else {
  1283.                       colsize = get_size_by_type(curcol->column_type);
  1284.               }
  1285. dest = &(info->current_row[curcol->column_offset]);
  1286. tds_get_n(tds,dest,colsize);
  1287. #ifndef NCBI_FTDS
  1288. dest[colsize]='';
  1289. #endif
  1290.               /* printf("%sn",curcol->column_value); */
  1291. }
  1293. /* now skip over some stuff and get the rest of the columns */
  1294. tds_get_n(tds,NULL,25);
  1295. colsize = tds_get_byte(tds);
  1296. tds_get_n(tds,NULL,3);
  1297. curcol = info->columns[i];
  1298. dest = &(info->current_row[curcol->column_offset]);
  1299. tds_get_n(tds,dest,colsize);
  1300. #ifndef NCBI_FTDS
  1301. dest[colsize]='';
  1302. #endif
  1304. return TDS_SUCCEED;
  1305. }
  1307. /*
  1308. ** tds_process_msg() is called for MSG, ERR, or EED tokens and is responsible
  1309. ** for calling the CLI's message handling routine
  1310. ** returns TDS_SUCCEED if informational, TDS_ERROR if error.
  1311. **
  1312. ** Note: the called function is responsible for calling tds_reset_msg on the 
  1313. ** passed structure.
  1314. */
  1315. static int tds_process_msg(TDSSOCKET *tds,int marker)
  1316. {
  1317. int rc;
  1318. int len;
  1319. int len_msg;
  1320. int len_svr;
  1321. int len_sqlstate;
  1323. /* make sure message has been freed */
  1324. tds_free_msg(tds->msg_info);
  1326. /* packet length */
  1327. len = tds_get_smallint(tds);
  1329. /* message number */
  1330. rc = tds_get_int(tds);
  1331. tds->msg_info->msg_number = rc;
  1333. /* msg state */
  1334. tds->msg_info->msg_state = tds_get_byte(tds);
  1336. /* msg level */
  1337. tds->msg_info->msg_level = tds_get_byte(tds);
  1339. /* determine if msg or error */
  1340. if (marker==TDS_EED_TOKEN) {
  1341. if (tds->msg_info->msg_level<=10) 
  1342.                     tds->msg_info->priv_msg_type = 0;
  1343. else 
  1344.                     tds->msg_info->priv_msg_type = 1;
  1345. /* junk this info for now */
  1346. len_sqlstate = tds_get_byte(tds);
  1347. tds->msg_info->sql_state = (char*)malloc(len_sqlstate+1);
  1348. tds_get_n(tds, tds->msg_info->sql_state,len_sqlstate);
  1349. tds->msg_info->sql_state[len_sqlstate] = '';
  1351. /* unknown values */
  1352. tds_get_byte(tds);
  1353. tds_get_smallint(tds);
  1354. } 
  1355. else if (marker==TDS_MSG_TOKEN) {
  1356. tds->msg_info->priv_msg_type = 0;
  1357. } else if (marker==TDS_ERR_TOKEN) {
  1358. tds->msg_info->priv_msg_type = 1;
  1359. } else {
  1360. tdsdump_log(TDS_DBG_ERROR,"tds_process_msg() called with unknown marker!n");
  1361. return TDS_FAIL;
  1362. }
  1364. /* the message */
  1365. len_msg = tds_get_smallint(tds);
  1366. tds->msg_info->message = (char*)malloc(len_msg+1);
  1367. tds_get_string(tds, tds->msg_info->message, len_msg);
  1368. tds->msg_info->message[len_msg] = '';
  1370. /* server name */
  1371. len_svr = tds_get_byte(tds);
  1372. tds->msg_info->server = (char*)malloc(len_svr+1);
  1373. tds_get_string(tds, tds->msg_info->server, len_svr);
  1374. tds->msg_info->server[len_svr] = '';
  1376. /* stored proc name if available */
  1377. rc = tds_get_byte(tds);
  1378. if (rc) {
  1379. tds_unget_byte(tds);
  1380. tds->msg_info->proc_name=tds_msg_get_proc_name(tds);
  1381. } else {
  1382. tds->msg_info->proc_name=strdup("");
  1383. }
  1385. /* line number in the sql statement where the problem occurred */
  1386. tds->msg_info->line_number = tds_get_smallint(tds);
  1388. if (tds->msg_info->priv_msg_type)  {
  1389. rc = TDS_ERROR;
  1390. } else {
  1391. rc = TDS_SUCCEED;
  1392. }
  1393. /* call the global_tds_msg_handler that was set by an upper layer 
  1394. ** (dblib, ctlib or some other one).  Call it with the pointer to 
  1395. ** the "parent" structure.
  1396. */
  1398. if(tds->msg_info->priv_msg_type
  1399.                    ? tds->tds_ctx->err_handler : tds->tds_ctx->msg_handler) {
  1400. if (tds->msg_info->priv_msg_type)
  1401. tds->tds_ctx->err_handler(tds->tds_ctx, tds, tds->msg_info);
  1402. else
  1403. tds->tds_ctx->msg_handler(tds->tds_ctx, tds, tds->msg_info);
  1404. } else {
  1405. if(tds->msg_info->msg_number)
  1406. tdsdump_log(TDS_DBG_WARN,
  1407. "%L Msg %d, Level %d, State %d, Server %s, Line %dn%sn",
  1408. tds->msg_info->msg_number,
  1409. tds->msg_info->msg_level,
  1410. tds->msg_info->msg_state,
  1411. tds->msg_info->server,
  1412. tds->msg_info->line_number,
  1413. tds->msg_info->message);
  1414. tds_free_msg(tds->msg_info);
  1415. }
  1416. return rc;
  1417. }
  1419. char *tds_msg_get_proc_name(TDSSOCKET *tds)
  1420. {
  1421. int len_proc;
  1422. char *proc_name;
  1424. len_proc = tds_get_byte(tds);
  1426. if (len_proc < 0) {
  1427. len_proc = 0;
  1428. }
  1429.         proc_name = (char*)malloc(len_proc+1);
  1430. if (len_proc > 0) {
  1431.               tds_get_string(tds, proc_name, len_proc);
  1432. }
  1433.         proc_name[len_proc] = '';
  1435. return proc_name;
  1437. }
  1439. int tds_reset_msg_info(TDSMSGINFO *msg_info)
  1440. {
  1441. if (!msg_info) 
  1442. return 0;
  1444. msg_info->priv_msg_type = 0;
  1445. msg_info->msg_number = 0;
  1446. msg_info->msg_state = 0;
  1447. msg_info->msg_level = 0;
  1448. msg_info->line_number = 0;
  1450. if( msg_info->message)
  1451. TDS_ZERO_FREE(msg_info->message);
  1452. if(msg_info->server)
  1453. TDS_ZERO_FREE(msg_info->server);
  1454. if(msg_info->proc_name)
  1455. TDS_ZERO_FREE(msg_info->proc_name);
  1457. return 0;
  1458. }
  1460. /*
  1461. ** tds_process_cancel() processes the incoming token stream until it finds
  1462. ** an end token (DONE, DONEPROC, DONEINPROC) with the cancel flag set.
  1463. ** a that point the connetion should be ready to handle a new query.
  1464. */
  1465. int tds_process_cancel(TDSSOCKET *tds)
  1466. {
  1467. int marker, cancelled=0;
  1469. do {
  1470. marker=tds_get_byte(tds);
  1471. if (marker==TDS_DONE_TOKEN) {
  1472. tds_process_end(tds, marker, NULL, &cancelled);
  1473. } else if (marker==0) {
  1474. cancelled = 1;
  1475. } else {
  1476. tds_process_default_tokens(tds,marker);
  1477. }
  1478. } while (!cancelled);
  1479. tds->state = TDS_COMPLETED;
  1481. return 0;
  1482. }
  1483. /* =========================== tds_is_result_row() ===========================
  1484.  * 
  1485.  * Def:  does the next token in stream signify a result row?
  1486.  * 
  1487.  * Ret:  true if stream is positioned at a row, false otherwise
  1488.  * 
  1489.  * ===========================================================================
  1490.  */
  1491. int tds_is_result_row(TDSSOCKET *tds)
  1492. {
  1493.    const int  marker = tds_peek(tds);
  1494.    int        result = 0;
  1496.    if (marker==TDS_ROW_TOKEN)
  1497.    {
  1498.       result = 1;
  1499.    }
  1500.    return result;
  1501. } /* tds_is_result_row()  */
  1504. int tds_is_result_set(TDSSOCKET *tds)
  1505. {
  1506.    const int  marker = tds_peek(tds);
  1507.    int        result = 0;
  1509.    result = (marker==TDS_COL_NAME_TOKEN 
  1510.              || marker==TDS_COL_INFO_TOKEN 
  1511.              || marker==TDS_RESULT_TOKEN
  1512.              || marker==TDS7_RESULT_TOKEN);
  1513.    return result;
  1514. } /* tds_is_result_set()  */
  1517. int tds_is_end_of_results(TDSSOCKET *tds)
  1518. {
  1519.    const int  marker = tds_peek(tds);
  1520.    int        result = 0;
  1522.    result = marker==TDS_DONE_TOKEN || marker==TDS_DONEPROC_TOKEN;
  1523.    return result;
  1524. } /* tds_is_end_of_results()  */
  1527. int tds_is_doneinproc(TDSSOCKET *tds)
  1528. {
  1529.    const int  marker = tds_peek(tds);
  1530.    int        result = 0;
  1532.    result = marker==TDS_DONEINPROC_TOKEN;
  1533.    return result;
  1534. } /* tds_is_end_of_results()  */
  1537. int tds_is_error(TDSSOCKET *tds)
  1538. {
  1539.    const int  marker = tds_peek(tds);
  1540.    int        result = 0;
  1542.    result = marker==TDS_ERR_TOKEN;
  1543.    return result;
  1544. } /* tds_is_error()  */
  1546. int tds_is_message(TDSSOCKET *tds)
  1547. {
  1548.    const int  marker = tds_peek(tds);
  1549.    int        result = 0;
  1551.    result = marker==TDS_MSG_TOKEN;
  1552.    return result;
  1553. } /* tds_is_message()  */
  1554. int tds_is_control(TDSSOCKET *tds)
  1555. {
  1556.    const int  marker = tds_peek(tds);
  1557.    int        result = 0;
  1559.    result = (marker==TDS_174_TOKEN || marker==TDS_167_TOKEN);
  1560.    return result;
  1561. }
  1562. /*
  1563. ** set the null bit for the given column in the row buffer
  1564. */
  1565. #ifdef NCBI_FTDS
  1566. static unsigned char s_null_mask[8]= {0x1,0x2,0x4,0x8,0x10,0x20,0x40,0x80};
  1567. void tds_set_null(unsigned char *current_row, int column)
  1568. {
  1569.     current_row[column >> 3]|= s_null_mask[column & 0x7];
  1570. }
  1572. /*
  1573. ** clear the null bit for the given column in the row buffer
  1574. */
  1575. void tds_clr_null(unsigned char *current_row, int column)
  1576. {
  1577.     current_row[column >> 3]&= ~s_null_mask[column & 0x7];
  1578. }
  1580. /*
  1581. ** return the null bit for the given column in the row buffer
  1582. */
  1583. int tds_get_null(unsigned char *current_row, int column)
  1584. {
  1585.  return (current_row[column >> 3] & s_null_mask[column & 0x7])? 1 : 0;
  1586. }
  1587. #else
  1588. void tds_set_null(unsigned char *current_row, int column)
  1589. {
  1590. int bytenum = column >> 3;
  1591. int bit = column & 0x7;
  1592. unsigned char mask = 1 << bit;
  1594. tdsdump_log(TDS_DBG_INFO1,"%L setting column %d NULL bitn", column);
  1595. current_row[bytenum] |= mask;
  1596. }
  1597. /*
  1598. ** clear the null bit for the given column in the row buffer
  1599. */
  1600. void tds_clr_null(unsigned char *current_row, int column)
  1601. {
  1602. int bytenum = column  >> 3;
  1603. int bit = column & 0x7;
  1604. unsigned char mask = ~(1 << bit);
  1606. tdsdump_log(TDS_DBG_INFO1, "%L clearing column %d NULL bitn", column);
  1607. current_row[bytenum] &= mask;
  1608. }
  1609. /*
  1610. ** return the null bit for the given column in the row buffer
  1611. */
  1612. int tds_get_null(unsigned char *current_row, int column)
  1613. {
  1614. int bytenum = column >> 3;
  1615. int bit = column & 0x7;
  1616. unsigned char mask = 1 << bit;
  1618. return (current_row[bytenum] & mask) ? 1 : 0;
  1619. }
  1620. #endif
  1622. int tds_lookup_dynamic(TDSSOCKET *tds, char *id)
  1623. {
  1624. int i;
  1626. for (i=0;i<tds->num_dyns;i++) {
  1627. if (!strcmp(tds->dyns[i]->id, id)) {
  1628. return i;
  1629. }
  1630. }
  1631. return -1;
  1632. }
  1633. /*
  1634. ** tds_process_dynamic()
  1635. ** finds the element of the dyns array for the id
  1636. */
  1637. static int tds_process_dynamic(TDSSOCKET *tds)
  1638. {
  1639. int token_sz;
  1640. char subtoken[2];
  1641. int id_len;
  1642. char id[TDS_MAX_DYNID_LEN+1];
  1643. int drain = 0;
  1645. token_sz = tds_get_smallint(tds);
  1646. subtoken[0] = tds_get_byte(tds);
  1647. subtoken[1] = tds_get_byte(tds);
  1648. if (subtoken[0]!=0x20 || subtoken[1]!=0x00) {
  1649. tdsdump_log(TDS_DBG_ERROR,"Unrecognized TDS5_DYN subtoken %x,%xn",
  1650.         subtoken[0], subtoken[1]);
  1651. tds_get_n(tds, NULL, token_sz-2);
  1652. return -1;
  1653. }
  1654. id_len = tds_get_byte(tds);
  1655. if (id_len > TDS_MAX_DYNID_LEN) {
  1656. drain = id_len - TDS_MAX_DYNID_LEN;
  1657. id_len = TDS_MAX_DYNID_LEN;
  1658. }
  1659. tds_get_string(tds, id, id_len);
  1660. id[id_len]='';
  1661. if (drain) { 
  1662. tds_get_string(tds, NULL, drain);
  1663. }
  1664. return tds_lookup_dynamic(tds,id);
  1665. }
  1667. static void tds_process_dyn_result(TDSSOCKET *tds)
  1668. {
  1669. int hdrsize;
  1670. int col, num_cols;
  1671. TDSCOLINFO *curcol;
  1672. TDSRESULTINFO *info;
  1673. TDSDYNAMIC *dyn;
  1675. hdrsize = tds_get_smallint(tds);
  1676. num_cols = tds_get_smallint(tds);
  1678. if (tds->cur_dyn_elem) {
  1679. dyn = tds->dyns[tds->cur_dyn_elem];
  1680. tds_free_results(dyn->res_info);
  1681. /* read number of columns and allocate the columns structure */
  1682. dyn->res_info = tds_alloc_results(num_cols);
  1683. info = dyn->res_info;
  1684. } else {
  1685. tds_free_results(tds->res_info);
  1686. tds->res_info = tds_alloc_results(num_cols);
  1687. info = tds->res_info;
  1688. }
  1690. for (col=0;col<info->num_cols;col++) {
  1691. curcol=info->columns[col];
  1692. tds_get_n(tds,NULL,6);
  1693. /* column type */
  1694. curcol->column_type = tds_get_byte(tds);
  1695. /* column size */
  1696. if (!is_fixed_type(curcol->column_type)) {
  1697. curcol->column_size = tds_get_byte(tds);
  1698. } else { 
  1699. curcol->column_size = get_size_by_type(curcol->column_type);
  1700. }
  1701. tds_get_byte(tds);
  1702. /* fprintf(stderr,"elem %d coltype %d size %dn",tds->cur_dyn_elem, curcol->column_type, curcol->column_size); */
  1703. }
  1704. }
  1706. /* 
  1707. ** tds_is_fixed_token()
  1708. ** some tokens are fixed length while others are variable.  This function is 
  1709. ** used by tds_process_cancel() to determine how to read past a token
  1710. */
  1711. int tds_is_fixed_token(int marker)
  1712. {
  1713. switch (marker) {
  1714. case TDS_DONE_TOKEN:
  1715. case TDS_DONEPROC_TOKEN:
  1716. case TDS_DONEINPROC_TOKEN:
  1717. case TDS_RET_STAT_TOKEN:
  1718. return 1;
  1719. default:
  1720. return 0;
  1721. }
  1722. }
  1724. /* 
  1725. ** tds_get_token_size() returns the size of a fixed length token
  1726. ** used by tds_process_cancel() to determine how to read past a token
  1727. */
  1728. int tds_get_token_size(int marker)
  1729. {
  1730. switch(marker) {
  1731. case TDS_DONE_TOKEN:
  1732. case TDS_DONEPROC_TOKEN:
  1733. case TDS_DONEINPROC_TOKEN:
  1734. return 8;
  1735. case TDS_RET_STAT_TOKEN:
  1736. return 4;
  1737. case TDS_124_TOKEN:
  1738. return 8;
  1739. default:
  1740. return 0;
  1741. }
  1742. }
  1744. void tds_swap_datatype(int coltype, unsigned char *buf)
  1745. {
  1746. TDS_NUMERIC *num;
  1748. switch(coltype) {
  1749. #ifdef NCBI_FTDS
  1750. case SYBINT2:
  1751. tds_swap_2bytes(buf); break;
  1752. case SYBINT4:
  1753. tds_swap_4bytes(buf); break;
  1754. case SYBINT8:
  1755. tds_swap_8bytes(buf); break;
  1756. case SYBREAL:
  1757. tds_swap_4bytes(buf); break;
  1758. case SYBFLT8:
  1759. tds_swap_8bytes(buf); break;
  1760. case SYBMONEY4:
  1761. tds_swap_4bytes(buf); break;
  1762. case SYBMONEY:
  1763. tds_swap_4bytes(buf);
  1764. tds_swap_4bytes(&buf[4]); break;
  1765. case SYBDATETIME4:
  1766. tds_swap_2bytes(buf);
  1767. tds_swap_2bytes(&buf[2]); break;
  1768. case SYBDATETIME:
  1769. tds_swap_4bytes(buf);
  1770. tds_swap_4bytes(&buf[4]); break;
  1771. case SYBNUMERIC:
  1772. case SYBDECIMAL:
  1773. num = (TDS_NUMERIC *) buf;
  1774.             /* swap the sign */
  1775.             num->array[0] = (num->array[0] == 0) ? 1 : 0;
  1776.             /* swap the data */
  1777.             tds_swap_bytes(&(num->array[1]),
  1778.                            g__numeric_bytes_per_prec[num->precision] - 1); break;
  1780.         case SYBUNIQUE:
  1781. tds_swap_4bytes(buf);
  1782. tds_swap_2bytes(&buf[4]); 
  1783. tds_swap_2bytes(&buf[6]); break;
  1784. #else
  1785. case SYBINT2:
  1786. tds_swap_bytes(buf,2); break;
  1787. case SYBINT4:
  1788. tds_swap_bytes(buf,4); break;
  1789. case SYBINT8:
  1790. tds_swap_bytes(buf,8); break;
  1791. case SYBREAL:
  1792. tds_swap_bytes(buf,4); break;
  1793. case SYBFLT8:
  1794. tds_swap_bytes(buf,8); break;
  1795. case SYBMONEY4:
  1796. tds_swap_bytes(buf,4); break;
  1797. case SYBMONEY:
  1798. tds_swap_bytes(buf,4);
  1799. tds_swap_bytes(&buf[4],4); break;
  1800. case SYBDATETIME4:
  1801. tds_swap_bytes(buf,2);
  1802. tds_swap_bytes(&buf[2],2); break;
  1803. case SYBDATETIME:
  1804. tds_swap_bytes(buf,4);
  1805. tds_swap_bytes(&buf[4],4); break;
  1806. case SYBNUMERIC:
  1807. case SYBDECIMAL:
  1808. num = (TDS_NUMERIC *) buf;
  1809.             /* swap the sign */
  1810.             num->array[0] = (num->array[0] == 0) ? 1 : 0;
  1811.             /* swap the data */
  1812.             tds_swap_bytes(&(num->array[1]),
  1813.                            g__numeric_bytes_per_prec[num->precision] - 1); break;
  1815.         case SYBUNIQUE:
  1816. tds_swap_bytes(buf,4);
  1817. tds_swap_bytes(&buf[4],2); 
  1818. tds_swap_bytes(&buf[6],2); break;
  1819. #endif
  1821. }
  1822. }
  1823. /*
  1824. ** tds_get_varint_size() returns the size of a variable length integer
  1825. ** returned in a TDS 7.0 result string
  1826. */
  1827. static int tds_get_varint_size(int datatype)
  1828. {
  1829. switch(datatype) {
  1830. case SYBTEXT:
  1831. case SYBNTEXT:
  1832. case SYBIMAGE:
  1833. case SYBVARIANT:
  1834. return 4;
  1835. case SYBVOID:
  1836. case SYBINT1:
  1837. case SYBBIT:
  1838. case SYBINT2:
  1839. case SYBINT4:
  1840. case SYBDATETIME4:
  1841. case SYBREAL:
  1842. case SYBMONEY:
  1843. case SYBDATETIME:
  1844. case SYBFLT8:
  1845. case SYBMONEY4:
  1846. case SYBINT8:
  1847. return 0;
  1848. case XSYBNCHAR:
  1849. case XSYBNVARCHAR:
  1850. case XSYBCHAR:
  1851. case XSYBVARCHAR:
  1852. case XSYBBINARY:
  1853. case XSYBVARBINARY:
  1854. return 2;
  1855. default:
  1856. return 1;
  1857. }
  1858. }
  1860. static int tds_get_cardinal_type(int datatype)
  1861. {
  1862. switch(datatype) {
  1863. case XSYBVARBINARY: 
  1864. return SYBVARBINARY;
  1865. case XSYBBINARY: 
  1866. return SYBBINARY;
  1867. case SYBNTEXT:
  1868. return SYBTEXT;
  1869. case XSYBNVARCHAR: 
  1870. case XSYBVARCHAR: 
  1871. return SYBVARCHAR;
  1872. case XSYBNCHAR: 
  1873. case XSYBCHAR: 
  1874. return SYBCHAR;
  1875. }
  1876. return datatype;
  1877. }