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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
gen_client_ret.c
资源名称：mysql-3.23.35.tar.gz　[点击查看]
上传用户：tsgydb
上传日期：2007-04-14
资源大小：10674k
文件大小：10k
源码类别：

MySQL数据库

开发平台：

Visual C++

gen_client_ret.c：源码内容
  1. /*-
  2.  * See the file LICENSE for redistribution information.
  3.  *
  4.  * Copyright (c) 2000
  5.  *      Sleepycat Software.  All rights reserved.
  6.  */
  8. #include "db_config.h"
  10. #ifndef lint
  11. static const char revid[] = "$Id: gen_client_ret.c,v 1.29 2000/12/31 19:26:23 bostic Exp $";
  12. #endif /* not lint */
  14. #ifdef HAVE_RPC
  15. #ifndef NO_SYSTEM_INCLUDES
  16. #include <sys/types.h>
  18. #include <rpc/rpc.h>
  20. #include <string.h>
  21. #endif
  22. #include "db_server.h"
  24. #include "db_int.h"
  25. #include "db_page.h"
  26. #include "txn.h"
  27. #include "db_ext.h"
  28. #include "rpc_client_ext.h"
  30. static void __db_db_stat_statsfree __P((u_int32_t *));
  31. static int __db_db_stat_statslist __P((__db_stat_statsreplist *, u_int32_t **));
  33. int
  34. __dbcl_env_close_ret(dbenv, flags, replyp)
  35. DB_ENV *dbenv;
  36. u_int32_t flags;
  37. __env_close_reply *replyp;
  38. {
  39. int ret;
  41. COMPQUIET(flags, 0);
  43. ret = __dbcl_refresh(dbenv);
  44. __os_free(dbenv, sizeof(*dbenv));
  45. if (replyp->status == 0 && ret != 0)
  46. return (ret);
  47. else
  48. return (replyp->status);
  49. }
  51. int
  52. __dbcl_env_open_ret(dbenv, home, flags, mode, replyp)
  53. DB_ENV *dbenv;
  54. const char *home;
  55. u_int32_t flags;
  56. int mode;
  57. __env_open_reply *replyp;
  58. {
  59. DB_TXNMGR *tmgrp;
  60. int ret;
  62. COMPQUIET(home, NULL);
  63. COMPQUIET(mode, 0);
  65. /*
  66.  * If error, return it.
  67.  */
  68. if (replyp->status != 0)
  69. return (replyp->status);
  71. /*
  72.  * If the user requested transactions, then we have some
  73.  * local client-side setup to do also.
  74.  */
  75. if (LF_ISSET(DB_INIT_TXN)) {
  76. if ((ret = __os_calloc(dbenv,
  77.     1, sizeof(DB_TXNMGR), &tmgrp)) != 0)
  78. return (ret);
  79. TAILQ_INIT(&tmgrp->txn_chain);
  80. tmgrp->dbenv = dbenv;
  81. dbenv->tx_handle = tmgrp;
  82. }
  84. return (replyp->status);
  85. }
  87. int
  88. __dbcl_env_remove_ret(dbenv, home, flags, replyp)
  89. DB_ENV *dbenv;
  90. const char *home;
  91. u_int32_t flags;
  92. __env_remove_reply *replyp;
  93. {
  94. int ret;
  96. COMPQUIET(home, NULL);
  97. COMPQUIET(flags, 0);
  99. ret = __dbcl_refresh(dbenv);
  100. __os_free(dbenv, sizeof(*dbenv));
  101. if (replyp->status == 0 && ret != 0)
  102. return (ret);
  103. else
  104. return (replyp->status);
  105. }
  107. int
  108. __dbcl_txn_abort_ret(txnp, replyp)
  109. DB_TXN *txnp;
  110. __txn_abort_reply *replyp;
  111. {
  112. __dbcl_txn_end(txnp);
  113. return (replyp->status);
  114. }
  116. int
  117. __dbcl_txn_begin_ret(envp, parent, txnpp, flags, replyp)
  118. DB_ENV *envp;
  119. DB_TXN *parent, **txnpp;
  120. u_int32_t flags;
  121. __txn_begin_reply *replyp;
  122. {
  123. DB_TXN *txn;
  124. int ret;
  126. COMPQUIET(flags, 0);
  128. if (replyp->status != 0)
  129. return (replyp->status);
  131. if ((ret = __os_calloc(envp, 1, sizeof(DB_TXN), &txn)) != 0)
  132. return (ret);
  133. txn->txnid = replyp->txnidcl_id;
  134. txn->mgrp = envp->tx_handle;
  135. txn->parent = parent;
  136. TAILQ_INIT(&txn->kids);
  137. txn->flags = TXN_MALLOC;
  138. if (parent != NULL)
  139. TAILQ_INSERT_HEAD(&parent->kids, txn, klinks);
  141. /*
  142.  * XXX
  143.  * In DB library the txn_chain is protected by the mgrp->mutexp.
  144.  * However, that mutex is implemented in the environments shared
  145.  * memory region.  The client library does not support all of the
  146.  * region - that just get forwarded to the server.  Therefore,
  147.  * the chain is unprotected here, but properly protected on the
  148.  * server.
  149.  */
  150. TAILQ_INSERT_TAIL(&txn->mgrp->txn_chain, txn, links);
  152. *txnpp = txn;
  153. return (replyp->status);
  154. }
  156. int
  157. __dbcl_txn_commit_ret(txnp, flags, replyp)
  158. DB_TXN *txnp;
  159. u_int32_t flags;
  160. __txn_commit_reply *replyp;
  161. {
  162. COMPQUIET(flags, 0);
  164. __dbcl_txn_end(txnp);
  165. return (replyp->status);
  166. }
  168. int
  169. __dbcl_db_close_ret(dbp, flags, replyp)
  170. DB *dbp;
  171. u_int32_t flags;
  172. __db_close_reply *replyp;
  173. {
  174. int ret;
  176. COMPQUIET(flags, 0);
  178. ret = __dbcl_dbclose_common(dbp);
  180. if (replyp->status != 0)
  181. return (replyp->status);
  182. else
  183. return (ret);
  184. }
  186. int
  187. __dbcl_db_get_ret(dbp, txnp, key, data, flags, replyp)
  188. DB *dbp;
  189. DB_TXN *txnp;
  190. DBT *key, *data;
  191. u_int32_t flags;
  192. __db_get_reply *replyp;
  193. {
  194. DB_ENV *dbenv;
  195. int ret;
  196. void *oldkey;
  198. COMPQUIET(txnp, NULL);
  199. COMPQUIET(flags, 0);
  201. ret = 0;
  202. if (replyp->status != 0)
  203. return (replyp->status);
  205. dbenv = dbp->dbenv;
  207. oldkey = key->data;
  208. ret = __dbcl_retcopy(dbenv, key, replyp->keydata.keydata_val,
  209.     replyp->keydata.keydata_len);
  210. if (ret)
  211. return (ret);
  212. ret = __dbcl_retcopy(dbenv, data, replyp->datadata.datadata_val,
  213.     replyp->datadata.datadata_len);
  214. /*
  215.  * If an error on copying 'data' and we allocated for 'key'
  216.  * free it before returning the error.
  217.  */
  218. if (ret && oldkey != NULL)
  219. __os_free(key->data, key->size);
  220. return (ret);
  221. }
  223. int
  224. __dbcl_db_key_range_ret(dbp, txnp, key, range, flags, replyp)
  225. DB *dbp;
  226. DB_TXN *txnp;
  227. DBT *key;
  228. DB_KEY_RANGE *range;
  229. u_int32_t flags;
  230. __db_key_range_reply *replyp;
  231. {
  232. COMPQUIET(dbp, NULL);
  233. COMPQUIET(txnp, NULL);
  234. COMPQUIET(key, NULL);
  235. COMPQUIET(flags, 0);
  237. if (replyp->status != 0)
  238. return (replyp->status);
  239. range->less = replyp->less;
  240. range->equal = replyp->equal;
  241. range->greater = replyp->greater;
  242. return (replyp->status);
  243. }
  245. int
  246. __dbcl_db_open_ret(dbp, name, subdb, type, flags, mode, replyp)
  247. DB *dbp;
  248. const char *name, *subdb;
  249. DBTYPE type;
  250. u_int32_t flags;
  251. int mode;
  252. __db_open_reply *replyp;
  253. {
  254. COMPQUIET(name, NULL);
  255. COMPQUIET(subdb, NULL);
  256. COMPQUIET(type, 0);
  257. COMPQUIET(flags, 0);
  258. COMPQUIET(mode, 0);
  260. dbp->type = replyp->type;
  262. /*
  263.  * XXX
  264.  * This is only for Tcl which peeks at the dbp flags.
  265.  * When dbp->get_flags exists, this should go away.
  266.  */
  267. dbp->flags = replyp->dbflags;
  268. return (replyp->status);
  269. }
  271. int
  272. __dbcl_db_put_ret(dbp, txnp, key, data, flags, replyp)
  273. DB *dbp;
  274. DB_TXN *txnp;
  275. DBT *key, *data;
  276. u_int32_t flags;
  277. __db_put_reply *replyp;
  278. {
  279. int ret;
  281. COMPQUIET(dbp, NULL);
  282. COMPQUIET(txnp, NULL);
  283. COMPQUIET(data, NULL);
  285. ret = replyp->status;
  286. if (replyp->status == 0 && (flags == DB_APPEND))
  287. *(db_recno_t *)key->data =
  288.     *(db_recno_t *)replyp->keydata.keydata_val;
  289. return (ret);
  290. }
  292. int
  293. __dbcl_db_remove_ret(dbp, name, subdb, flags, replyp)
  294. DB *dbp;
  295. const char *name, *subdb;
  296. u_int32_t flags;
  297. __db_remove_reply *replyp;
  298. {
  299. int ret;
  301. COMPQUIET(name, 0);
  302. COMPQUIET(subdb, 0);
  303. COMPQUIET(flags, 0);
  305. ret = __dbcl_dbclose_common(dbp);
  307. if (replyp->status != 0)
  308. return (replyp->status);
  309. else
  310. return (ret);
  311. }
  313. int
  314. __dbcl_db_rename_ret(dbp, name, subdb, newname, flags, replyp)
  315. DB *dbp;
  316. const char *name, *subdb, *newname;
  317. u_int32_t flags;
  318. __db_remove_reply *replyp;
  319. {
  320. int ret;
  322. COMPQUIET(name, 0);
  323. COMPQUIET(subdb, 0);
  324. COMPQUIET(newname, 0);
  325. COMPQUIET(flags, 0);
  327. ret = __dbcl_dbclose_common(dbp);
  329. if (replyp->status != 0)
  330. return (replyp->status);
  331. else
  332. return (ret);
  333. }
  335. int
  336. __dbcl_db_stat_ret(dbp, sp, func, flags, replyp)
  337. DB *dbp;
  338. void *sp;
  339. void *(*func) __P((size_t));
  340. u_int32_t flags;
  341. __db_stat_reply *replyp;
  342. {
  343. int ret;
  344. u_int32_t *__db_statslist;
  346. COMPQUIET(dbp, NULL);
  347. COMPQUIET(func, NULL);
  348. COMPQUIET(flags, 0);
  350. if (replyp->status != 0)
  351. return (replyp->status);
  353. if ((ret =
  354.     __db_db_stat_statslist(replyp->statslist, &__db_statslist)) != 0)
  355. return (ret);
  357. if (sp == NULL)
  358. __db_db_stat_statsfree(__db_statslist);
  359. else
  360. *(u_int32_t **)sp = __db_statslist;
  361. return (replyp->status);
  362. }
  364. static int
  365. __db_db_stat_statslist(locp, ppp)
  366. __db_stat_statsreplist *locp;
  367. u_int32_t **ppp;
  368. {
  369. u_int32_t *pp;
  370. int cnt, ret, size;
  371. __db_stat_statsreplist *nl;
  373. for (cnt = 0, nl = locp; nl != NULL; cnt++, nl = nl->next)
  374. ;
  376. if (cnt == 0) {
  377. *ppp = NULL;
  378. return (0);
  379. }
  380. size = sizeof(*pp) * cnt;
  381. if ((ret = __os_malloc(NULL, size, NULL, ppp)) != 0)
  382. return (ret);
  383. memset(*ppp, 0, size);
  384. for (pp = *ppp, nl = locp; nl != NULL; nl = nl->next, pp++) {
  385. *pp = *(u_int32_t *)nl->ent.ent_val;
  386. }
  387. return (0);
  388. }
  390. static void
  391. __db_db_stat_statsfree(pp)
  392. u_int32_t *pp;
  393. {
  394. size_t size;
  395. u_int32_t *p;
  397. if (pp == NULL)
  398. return;
  399. size = sizeof(*p);
  400. for (p = pp; *p != 0; p++)
  401. size += sizeof(*p);
  403. __os_free(pp, size);
  404. }
  406. int
  407. __dbcl_db_cursor_ret(dbp, txnp, dbcpp, flags, replyp)
  408. DB *dbp;
  409. DB_TXN *txnp;
  410. DBC **dbcpp;
  411. u_int32_t flags;
  412. __db_cursor_reply *replyp;
  413. {
  414. COMPQUIET(txnp, NULL);
  415. COMPQUIET(flags, 0);
  417. if (replyp->status != 0)
  418. return (replyp->status);
  420. return (__dbcl_c_setup(replyp->dbcidcl_id, dbp, dbcpp));
  421. }
  423. int
  424. __dbcl_db_join_ret(dbp, curs, dbcpp, flags, replyp)
  425. DB *dbp;
  426. DBC **curs, **dbcpp;
  427. u_int32_t flags;
  428. __db_join_reply *replyp;
  429. {
  430. COMPQUIET(curs, NULL);
  431. COMPQUIET(flags, 0);
  433. if (replyp->status != 0)
  434. return (replyp->status);
  436. /*
  437.  * We set this up as a normal cursor.  We do not need
  438.  * to treat a join cursor any differently than a normal
  439.  * cursor, even though DB itself must.  We only need the
  440.  * client-side cursor/db relationship to know what cursors
  441.  * are open in the db, and to store their ID.  Nothing else.
  442.  */
  443. return (__dbcl_c_setup(replyp->dbcidcl_id, dbp, dbcpp));
  444. }
  446. int
  447. __dbcl_dbc_close_ret(dbcp, replyp)
  448. DBC *dbcp;
  449. __dbc_close_reply *replyp;
  450. {
  451. DB *dbp;
  453. dbp = dbcp->dbp;
  454. __dbcl_c_refresh(dbcp);
  455. return (replyp->status);
  456. }
  458. int
  459. __dbcl_dbc_count_ret(dbc, countp, flags, replyp)
  460. DBC *dbc;
  461. db_recno_t *countp;
  462. u_int32_t flags;
  463. __dbc_count_reply *replyp;
  464. {
  465. COMPQUIET(dbc, NULL);
  466. COMPQUIET(flags, 0);
  468. if (replyp->status != 0)
  469. return (replyp->status);
  470. *countp = replyp->dupcount;
  472. return (replyp->status);
  473. }
  475. int
  476. __dbcl_dbc_dup_ret(dbcp, dbcpp, flags, replyp)
  477. DBC *dbcp, **dbcpp;
  478. u_int32_t flags;
  479. __dbc_dup_reply *replyp;
  480. {
  481. COMPQUIET(flags, 0);
  483. if (replyp->status != 0)
  484. return (replyp->status);
  486. return (__dbcl_c_setup(replyp->dbcidcl_id, dbcp->dbp, dbcpp));
  487. }
  489. int
  490. __dbcl_dbc_get_ret(dbcp, key, data, flags, replyp)
  491. DBC *dbcp;
  492. DBT *key, *data;
  493. u_int32_t flags;
  494. __dbc_get_reply *replyp;
  495. {
  496. DB_ENV *dbenv;
  497. int ret;
  498. void *oldkey;
  500. COMPQUIET(flags, 0);
  502. ret = 0;
  503. if (replyp->status != 0)
  504. return (replyp->status);
  506. dbenv = dbcp->dbp->dbenv;
  507. oldkey = key->data;
  508. ret = __dbcl_retcopy(dbenv, key, replyp->keydata.keydata_val,
  509.     replyp->keydata.keydata_len);
  510. if (ret)
  511. return (ret);
  512. ret = __dbcl_retcopy(dbenv, data, replyp->datadata.datadata_val,
  513.     replyp->datadata.datadata_len);
  515. /*
  516.  * If an error on copying 'data' and we allocated for 'key'
  517.  * free it before returning the error.
  518.  */
  519. if (ret && oldkey != NULL)
  520. __os_free(key->data, key->size);
  521. return (ret);
  522. }
  524. int
  525. __dbcl_dbc_put_ret(dbcp, key, data, flags, replyp)
  526. DBC *dbcp;
  527. DBT *key, *data;
  528. u_int32_t flags;
  529. __dbc_put_reply *replyp;
  530. {
  531. COMPQUIET(data, NULL);
  533. if (replyp->status != 0)
  534. return (replyp->status);
  536. if (replyp->status == 0 && dbcp->dbp->type == DB_RECNO &&
  537.     (flags == DB_AFTER || flags == DB_BEFORE))
  538. *(db_recno_t *)key->data =
  539.     *(db_recno_t *)replyp->keydata.keydata_val;
  540. return (replyp->status);
  541. }
  542. #endif /* HAVE_RPC */