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

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

生物技术

开发平台：

C/C++

mem.c：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: mem.c,v $
  4.  * PRODUCTION Revision 1000.0  2003/10/29 20:35:02  gouriano
  5.  * PRODUCTION PRODUCTION: IMPORTED [ORIGINAL] Dev-tree R1.2
  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. #ifdef NCBI_FTDS
  33. #if HAVE_ICONV
  34. #include <iconv.h>
  35. #endif
  37. #ifdef __cplusplus
  38. extern "C" {
  39. #endif
  41. typedef struct tdsiconvinfo {
  42. int use_iconv;
  43. #if HAVE_ICONV
  44.      iconv_t cdto;
  45.      iconv_t cdfrom;
  46. #endif
  47. } TDSICONVINFO;
  49. #ifdef __cplusplus
  50. }
  51. #endif 
  53. #else
  54. #include "tdsiconv.h"
  55. #endif
  56. #ifdef DMALLOC
  57. #include <dmalloc.h>
  58. #endif
  60. static char  software_version[]   = "$Id: mem.c,v 1000.0 2003/10/29 20:35:02 gouriano Exp $";
  61. static void *no_unused_var_warn[] = {software_version,
  62.                                      no_unused_var_warn};
  65. TDSENVINFO *tds_alloc_env(TDSSOCKET *tds);
  66. void tds_free_env(TDSSOCKET *tds);
  68. TDSDYNAMIC *tds_alloc_dynamic(TDSSOCKET *tds, char *id)
  69. {
  70. int i;
  72. /* if this is the first dynamic stmt */
  73. if (!tds->num_dyns) {
  74. tds->dyns = (TDSDYNAMIC **) malloc(sizeof(TDSDYNAMIC *));
  75. tds->dyns[0] = (TDSDYNAMIC *) malloc(sizeof(TDSDYNAMIC));
  76. memset(tds->dyns[0], 0, sizeof(TDSDYNAMIC));
  77. strncpy(tds->dyns[0]->id, id, TDS_MAX_DYNID_LEN);
  78. tds->dyns[0]->id[TDS_MAX_DYNID_LEN-1]='';
  79. tds->num_dyns++;
  80. return tds->dyns[0];
  81. }
  82. /* otherwise check to see if id already exists (shouldn't) */
  83. for (i=0;i<tds->num_dyns;i++) {
  84. if (!strcmp(tds->dyns[i]->id, id)) {
  85. /* id already exists! just return it */
  86. return(tds->dyns[i]);
  87. }
  88. }
  90. /* ok, we have a list and need to add another */
  91. tds->dyns = (TDSDYNAMIC **) 
  92. realloc(tds->dyns, sizeof(TDSDYNAMIC *) * tds->num_dyns);
  93. tds->dyns[tds->num_dyns] = (TDSDYNAMIC *) malloc(sizeof(TDSDYNAMIC));
  94. memset(tds->dyns[tds->num_dyns], 0, sizeof(TDSDYNAMIC));
  95. strncpy(tds->dyns[tds->num_dyns]->id, id, TDS_MAX_DYNID_LEN);
  96. tds->dyns[tds->num_dyns]->id[TDS_MAX_DYNID_LEN-1]='';
  97. tds->num_dyns++;
  99. return tds->dyns[tds->num_dyns-1];
  100. }
  102. TDSINPUTPARAM *tds_add_input_param(TDSDYNAMIC *dyn)
  103. {
  104. TDSINPUTPARAM *param;
  106. if (!dyn->num_params) {
  107. param = (TDSINPUTPARAM *) malloc(sizeof(TDSINPUTPARAM));
  108. memset(param,'',sizeof(TDSINPUTPARAM));
  109. dyn->num_params=1;
  110. dyn->params = (TDSINPUTPARAM **) 
  111. malloc(sizeof(TDSINPUTPARAM *));
  112. dyn->params[0] = param;
  113. } else {
  114. param = (TDSINPUTPARAM *) malloc(sizeof(TDSINPUTPARAM));
  115. memset(param,'',sizeof(TDSINPUTPARAM));
  116. dyn->num_params++;
  117. dyn->params = (TDSINPUTPARAM **) 
  118. realloc(dyn->params, 
  119. sizeof(TDSINPUTPARAM *) * dyn->num_params);
  120. dyn->params[dyn->num_params-1] = param;
  121. }
  122. return param;
  123. }
  124. void tds_free_input_params(TDSDYNAMIC *dyn)
  125. {
  126. int i;
  128. if (dyn->num_params) {
  129. for (i=0;i<dyn->num_params;i++) {
  130. free(dyn->params[i]);
  131. }
  132. free(dyn->params);
  133. dyn->num_params = 0;
  134. }
  135. }
  136. void tds_free_dynamic(TDSSOCKET *tds)
  137. {
  138. int i;
  139. TDSDYNAMIC *dyn;
  141. for (i=0;i<tds->num_dyns;i++) {
  142. dyn = tds->dyns[i];
  143. tds_free_input_params(dyn);
  144. free(dyn);
  145. }
  146. if (tds->dyns) TDS_ZERO_FREE(tds->dyns);
  147. tds->num_dyns = 0;
  149. return;
  150. }
  151. /*
  152. ** tds_alloc_param_result() works a bit differently than the other alloc result
  153. ** functions.  Output parameters come in individually with no total number 
  154. ** given in advance, so we simply call this func every time with get a
  155. ** TDS_PARAM_TOKEN and let it realloc the columns struct one bigger. 
  156. ** tds_free_all_results() usually cleans up after us.
  157. */
  158. TDSPARAMINFO *tds_alloc_param_result(TDSPARAMINFO *old_param)
  159. {
  160. TDSPARAMINFO *param_info;
  162. if (!old_param) {
  163. param_info = (TDSPARAMINFO *) malloc(sizeof(TDSPARAMINFO));
  164. memset(param_info,'',sizeof(TDSPARAMINFO));
  165. param_info->num_cols=1;
  166. param_info->columns = (TDSCOLINFO **) 
  167. malloc(sizeof(TDSCOLINFO *));
  168. param_info->columns[0] = (TDSCOLINFO *) malloc(sizeof(TDSCOLINFO));
  169. memset(param_info->columns[0],'',sizeof(TDSCOLINFO));
  170. } else {
  171. param_info = old_param;
  172. param_info->num_cols++;
  173. param_info->columns = (TDSCOLINFO **) 
  174. realloc(param_info->columns, 
  175. sizeof(TDSCOLINFO *) * param_info->num_cols);
  176. param_info->columns[param_info->num_cols-1] =
  177.         (TDSCOLINFO *) malloc(sizeof(TDSCOLINFO));
  178. memset(param_info->columns[param_info->num_cols-1],'',
  179. sizeof(TDSCOLINFO));
  180. }
  181. return param_info;
  182. }
  183. TDSCOMPUTEINFO *tds_alloc_compute_results(int num_cols)
  184. {
  185. /*TDSCOLINFO *curcol;
  186.  */
  187. TDSCOMPUTEINFO *comp_info;
  188. int col;
  190. comp_info = (TDSCOMPUTEINFO *) malloc(sizeof(TDSCOMPUTEINFO));
  191. memset(comp_info,'',sizeof(TDSCOMPUTEINFO));
  192. comp_info->columns = (TDSCOLINFO **) 
  193. malloc(sizeof(TDSCOLINFO *) * num_cols);
  194. for (col=0;col<num_cols;col++)  {
  195. comp_info->columns[col] = (TDSCOLINFO *) malloc(sizeof(TDSCOLINFO));
  196. memset(comp_info->columns[col],'',sizeof(TDSCOLINFO));
  197. }
  198. comp_info->num_cols = num_cols;
  199. return comp_info;
  200. }
  202. TDSRESULTINFO *tds_alloc_results(int num_cols)
  203. {
  204. /*TDSCOLINFO *curcol;
  205.  */
  206. TDSRESULTINFO *res_info;
  207. int col;
  208. int null_sz;
  210. res_info = (TDSRESULTINFO *) malloc(sizeof(TDSRESULTINFO));
  211. memset(res_info,'',sizeof(TDSRESULTINFO));
  212. res_info->columns = (TDSCOLINFO **) 
  213. malloc(sizeof(TDSCOLINFO *) * num_cols);
  214. for (col=0;col<num_cols;col++)  {
  215. res_info->columns[col] = (TDSCOLINFO *) malloc(sizeof(TDSCOLINFO));
  216. memset(res_info->columns[col],'',sizeof(TDSCOLINFO));
  217. }
  218. res_info->num_cols = num_cols;
  219. null_sz = (num_cols/8) + 1;
  220. /* 4 byte alignment fix -- should be ifdef'ed to only platforms that 
  221. ** need it */
  222. if (null_sz % 4) null_sz = ((null_sz/4)+1)*4;
  223. res_info->null_info_size = null_sz;
  224. /* set the initial row size to the size of the null info */
  225. res_info->row_size = res_info->null_info_size;
  226. return res_info;
  227. }
  229. void *tds_alloc_row(TDSRESULTINFO *res_info)
  230. {
  231. void *ptr;
  233. ptr = (void *) malloc(res_info->row_size);
  234. memset(ptr,'',res_info->row_size); 
  235. return ptr;
  236. }
  238. void tds_free_param_results(TDSPARAMINFO *param_info)
  239. {
  240. int i;
  242. if(param_info)
  243. {
  244. for (i=0;i<param_info->num_cols;i++)
  245. {
  246. if(param_info->columns[i])
  247. TDS_ZERO_FREE(param_info->columns[i]);
  248. }
  249. if (param_info->num_cols) TDS_ZERO_FREE(param_info->columns);
  250. if (param_info->current_row) TDS_ZERO_FREE(param_info->current_row);
  251. TDS_ZERO_FREE(param_info);
  252. }
  253. }
  254. void tds_free_compute_results(TDSCOMPUTEINFO *comp_info)
  255. {
  256. int i;
  258. if(comp_info)
  259. {
  260. for (i=0;i<comp_info->num_cols;i++)
  261. {
  262. if(comp_info->columns[i])
  263. TDS_ZERO_FREE(comp_info->columns[i]);
  264. }
  265. if (comp_info->num_cols) TDS_ZERO_FREE(comp_info->columns);
  266. if (comp_info->current_row) TDS_ZERO_FREE(comp_info->current_row);
  267. TDS_ZERO_FREE(comp_info);
  268. }
  269. }
  271. void tds_free_results(TDSRESULTINFO *res_info)
  272. {
  273. int i;
  276. if(res_info)
  277. {
  278. if (res_info->current_row) TDS_ZERO_FREE(res_info->current_row);
  279. for (i=0;i<res_info->num_cols;i++)
  280. {
  281. if(res_info->columns && res_info->columns[i])
  282. tds_free_column(res_info->columns[i]);
  283. }
  284. if (res_info->num_cols) TDS_ZERO_FREE(res_info->columns);
  285. TDS_ZERO_FREE(res_info);
  286. }
  288. }
  289. void tds_free_all_results(TDSSOCKET *tds)
  290. {
  291. tds_free_results(tds->res_info);
  292. tds->res_info = NULL;
  293. tds_free_param_results(tds->param_info);
  294. tds->param_info = NULL;
  295. tds_free_compute_results(tds->comp_info);
  296. tds->comp_info = NULL;
  297. }
  298. void tds_free_column(TDSCOLINFO *column)
  299. {
  300. if (column->column_textvalue) TDS_ZERO_FREE(column->column_textvalue);
  301. TDS_ZERO_FREE(column);
  302. }
  303. TDSCONTEXT *tds_alloc_context()
  304. {
  305. TDSCONTEXT *context;
  307. context = (TDSCONTEXT *) malloc(sizeof(TDSCONTEXT));
  308. memset(context, '', sizeof(TDSCONTEXT));
  309. context->locale = tds_get_locale();
  311. return context;
  312. }
  313. void tds_free_context(TDSCONTEXT *context)
  314. {
  315. if (context->locale) tds_free_locale(context->locale);
  316. TDS_ZERO_FREE(context);
  317. }
  318. TDSLOCINFO *tds_alloc_locale()
  319. {
  320. TDSLOCINFO *locale;
  322. locale = (TDSLOCINFO *) malloc(sizeof(TDSLOCINFO));
  323. memset(locale, '', sizeof(TDSLOCINFO));
  325. return locale;
  326. }
  327. TDSCONFIGINFO *tds_alloc_config(TDSLOCINFO *locale)
  328. {
  329. TDSCONFIGINFO *config;
  330. char hostname[30];
  332. config = (TDSCONFIGINFO *) malloc(sizeof(TDSCONFIGINFO));
  333. memset(config, '', sizeof(TDSCONFIGINFO));
  335. /* fill in all hardcoded defaults */
  336. config->server_name = strdup(TDS_DEF_SERVER);
  337. config->major_version = TDS_DEF_MAJOR;
  338. config->minor_version = TDS_DEF_MINOR;
  339. #ifdef NCBI_FTDS
  340. config->port[0] = TDS_DEF_PORT;
  341. #else
  342. config->port = TDS_DEF_PORT;
  343. #endif
  344. config->block_size = TDS_DEF_BLKSZ;
  345. if (locale) {
  346. if (locale->language) 
  347.          config->language = strdup(locale->language);
  348. else 
  349.          config->language = strdup(TDS_DEF_LANG);
  350. if (locale->char_set) 
  351.          config->char_set = strdup(locale->char_set);
  352. else 
  353.          config->char_set = strdup(TDS_DEF_CHARSET);
  354. }
  355. config->try_server_login = 1;
  356. memset(hostname,'', 30);
  357. gethostname(hostname,30);
  358. hostname[29]=''; /* make sure it's truncated */
  359. config->host_name = strdup(hostname);
  361. return config;
  362. }
  363. TDSLOGIN *tds_alloc_login()
  364. {
  365. TDSLOGIN *tds_login;
  366. static const unsigned char defaultcaps[] = {0x01,0x07,0x03,109,127,0xFF,0xFF,0xFF,0xFE,0x02,0x07,0x00,0x00,0x0A,104,0x00,0x00,0x00};
  367. char *tdsver;
  369. tds_login = (TDSLOGIN *) malloc(sizeof(TDSLOGIN));
  370. memset(tds_login, '', sizeof(TDSLOGIN));
  371. if ((tdsver=getenv("TDSVER"))) {
  372. if (!strcmp(tdsver,"42") || !strcmp(tdsver,"4.2")) {
  373. tds_login->major_version=4;
  374. tds_login->minor_version=2;
  375. } else if (!strcmp(tdsver,"46") || !strcmp(tdsver,"4.6")) {
  376. tds_login->major_version=4;
  377. tds_login->minor_version=6;
  378. } else if (!strcmp(tdsver,"50") || !strcmp(tdsver,"5.0")) {
  379. tds_login->major_version=5;
  380. tds_login->minor_version=0;
  381. } else if (!strcmp(tdsver,"70") || !strcmp(tdsver,"7.0")) {
  382. tds_login->major_version=7;
  383. tds_login->minor_version=0;
  384. } else if (!strcmp(tdsver,"80") || !strcmp(tdsver,"8.0")) {
  385. tds_login->major_version=8;
  386. tds_login->minor_version=0;
  387. }
  388. /* else unrecognized...use compile time default above */
  389. }
  390. memcpy(tds_login->capabilities,defaultcaps,TDS_MAX_CAPABILITY);
  391. return tds_login;
  392. }
  393. void tds_free_login(TDSLOGIN *login)
  394. {
  395. if (login) {
  396. /* for security reason clear memory */
  397. memset(login->password,0,sizeof(login->password));
  398. free(login);
  399. }
  400. }
  401. TDSSOCKET *tds_alloc_socket(TDSCONTEXT *context, int bufsize)
  402. {
  403. TDSSOCKET *tds_socket;
  404. TDSICONVINFO *iconv;
  406. tds_socket = (TDSSOCKET *) malloc(sizeof(TDSSOCKET));
  407. memset(tds_socket, '', sizeof(TDSSOCKET));
  408. tds_socket->tds_ctx = context;
  409. tds_socket->in_buf_max=0;
  410. tds_socket->out_buf = (unsigned char *) malloc(bufsize);
  411. tds_socket->msg_info = (TDSMSGINFO *) malloc(sizeof(TDSMSGINFO));
  412. memset(tds_socket->msg_info,'',sizeof(TDSMSGINFO));
  413. tds_socket->parent = (char*)NULL;
  414. tds_socket->env = tds_alloc_env(tds_socket);
  415. iconv = (TDSICONVINFO *) malloc(sizeof(TDSICONVINFO));
  416. tds_socket->iconv_info = (void *) iconv;
  417. memset(tds_socket->iconv_info,'',sizeof(TDSICONVINFO));
  418. #if HAVE_ICONV
  419. iconv->cdfrom = (iconv_t)-1;
  420. iconv->cdto = (iconv_t)-1;
  421. #endif
  422. /* Jeff's hack, init to no timeout */
  423. tds_socket->timeout = 0;                
  424. tds_init_write_buf(tds_socket);
  425. return tds_socket;
  426. }
  427. TDSSOCKET *tds_realloc_socket(int bufsize)
  428. {
  429.    return NULL; /* XXX */
  430. }
  431. void tds_free_socket(TDSSOCKET *tds)
  432. {
  433. TDSICONVINFO *iconv_info;
  435. if (tds) {
  436. tds_free_all_results(tds);
  437. tds_free_env(tds);
  438. tds_free_dynamic(tds);
  439. if (tds->msg_info) {
  440. tds_free_msg(tds->msg_info); /* dnr */
  441. TDS_ZERO_FREE(tds->msg_info);
  442. }
  443. if (tds->in_buf) TDS_ZERO_FREE(tds->in_buf);
  444. if (tds->out_buf) TDS_ZERO_FREE(tds->out_buf);
  445. if (tds->s) close(tds->s);
  446. if (tds->date_fmt) free(tds->date_fmt);
  447. if (tds->iconv_info) {
  448. iconv_info = (TDSICONVINFO *) tds->iconv_info;
  449. if (iconv_info->use_iconv) tds_iconv_close(tds);
  450. free(tds->iconv_info);
  451. }
  452. if (tds->date_fmt) free(tds->date_fmt);
  453. TDS_ZERO_FREE(tds);
  454. }
  455. }
  456. void tds_free_locale(TDSLOCINFO *locale)
  457. {
  458. if (locale->language) free(locale->language);
  459. if (locale->char_set) free(locale->char_set);
  460. if (locale->date_fmt) free(locale->date_fmt);
  461. TDS_ZERO_FREE(locale);
  462. }
  463. void tds_free_config(TDSCONFIGINFO *config)
  464. {
  465. if (config->server_name) free(config->server_name);
  466. if (config->host_name) free(config->host_name);
  467. #ifdef NCBI_FTDS
  468. {int i;
  469.     for(i= 0; i < NCBI_NUM_SERVERS; i++) {
  470.         if(config->ip_addr[i]) free(config->ip_addr[i]);
  471.     }
  472. }
  473. #else
  474. if (config->ip_addr) free(config->ip_addr);
  475. #endif
  476. if (config->language) free(config->language);
  477. if (config->char_set) free(config->char_set);
  478. if (config->database) free(config->database);
  479. if (config->dump_file) free(config->dump_file);
  480. if (config->default_domain) free(config->default_domain);
  481. if (config->client_charset) free(config->client_charset);
  482. /* dnr */
  483. if (config->host) free(config->host);
  484. if (config->app_name) free(config->app_name);
  485. if (config->user_name) free(config->user_name);
  486. if (config->password) {
  487. /* for security reason clear memory */
  488. memset(config->password,0,strlen(config->password));
  489. free(config->password);
  490. }
  491. if (config->library) free(config->library);
  492. /* !dnr */
  493. TDS_ZERO_FREE(config);
  494. }
  495. TDSENVINFO *tds_alloc_env(TDSSOCKET *tds)
  496. {
  497. TDSENVINFO *env;
  499. env = (TDSENVINFO *) malloc(sizeof(TDSENVINFO));
  500. memset(env,'',sizeof(TDSENVINFO));
  501. env->block_size = 512;
  503. return env;
  504. }
  505. void tds_free_env(TDSSOCKET *tds)
  506. {
  507. if (tds->env) {
  508. if (tds->env->language)
  509. TDS_ZERO_FREE(tds->env->language);
  510. if (tds->env->charset)
  511. TDS_ZERO_FREE(tds->env->charset);
  512. if (tds->env->database)
  513. TDS_ZERO_FREE(tds->env->database);
  514. TDS_ZERO_FREE(tds->env);
  515. }
  516. }
  517. void tds_free_msg(TDSMSGINFO *msg_info)
  518. {
  519. if (msg_info) {
  520. if(msg_info->message) TDS_ZERO_FREE(msg_info->message);
  521. if(msg_info->server) TDS_ZERO_FREE(msg_info->server);
  522. if(msg_info->proc_name) TDS_ZERO_FREE(msg_info->proc_name);
  523. if(msg_info->sql_state) TDS_ZERO_FREE(msg_info->sql_state);
  524. }
  525. }