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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
gen_client_ret.c
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：17k
源码类别：

MySQL数据库

开发平台：

Visual C++

gen_client_ret.c：源码内容
  1. /*-
  2.  * See the file LICENSE for redistribution information.
  3.  *
  4.  * Copyright (c) 2000-2002
  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.57 2002/08/06 06:18:37 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
  23. #include "db_int.h"
  24. #include "dbinc/db_page.h"
  25. #include "dbinc/db_am.h"
  26. #include "dbinc/txn.h"
  28. #include "dbinc_auto/db_server.h"
  29. #include "dbinc_auto/rpc_client_ext.h"
  31. /*
  32.  * PUBLIC: int __dbcl_env_close_ret
  33.  * PUBLIC:     __P((DB_ENV *, u_int32_t, __env_close_reply *));
  34.  */
  35. int
  36. __dbcl_env_close_ret(dbenv, flags, replyp)
  37. DB_ENV *dbenv;
  38. u_int32_t flags;
  39. __env_close_reply *replyp;
  40. {
  41. int ret;
  43. COMPQUIET(flags, 0);
  45. ret = __dbcl_refresh(dbenv);
  46. __os_free(NULL, dbenv);
  47. if (replyp->status == 0 && ret != 0)
  48. return (ret);
  49. else
  50. return (replyp->status);
  51. }
  53. /*
  54.  * PUBLIC: int __dbcl_env_create_ret
  55.  * PUBLIC:     __P((DB_ENV *, long, __env_create_reply *));
  56.  */
  57. int
  58. __dbcl_env_create_ret(dbenv, timeout, replyp)
  59. DB_ENV * dbenv;
  60. long timeout;
  61. __env_create_reply *replyp;
  62. {
  64. COMPQUIET(timeout, 0);
  66. if (replyp->status != 0)
  67. return (replyp->status);
  68. dbenv->cl_id = replyp->envcl_id;
  69. return (replyp->status);
  70. }
  72. /*
  73.  * PUBLIC: int __dbcl_env_open_ret __P((DB_ENV *,
  74.  * PUBLIC:     const char *, u_int32_t, int, __env_open_reply *));
  75.  */
  76. int
  77. __dbcl_env_open_ret(dbenv, home, flags, mode, replyp)
  78. DB_ENV *dbenv;
  79. const char *home;
  80. u_int32_t flags;
  81. int mode;
  82. __env_open_reply *replyp;
  83. {
  84. DB_TXNMGR *tmgrp;
  85. int ret;
  87. COMPQUIET(home, NULL);
  88. COMPQUIET(mode, 0);
  90. /*
  91.  * If error, return it.
  92.  */
  93. if (replyp->status != 0)
  94. return (replyp->status);
  96. dbenv->cl_id = replyp->envcl_id;
  97. /*
  98.  * If the user requested transactions, then we have some
  99.  * local client-side setup to do also.
  100.  */
  101. if (LF_ISSET(DB_INIT_TXN)) {
  102. if ((ret = __os_calloc(dbenv,
  103.     1, sizeof(DB_TXNMGR), &tmgrp)) != 0)
  104. return (ret);
  105. TAILQ_INIT(&tmgrp->txn_chain);
  106. tmgrp->dbenv = dbenv;
  107. dbenv->tx_handle = tmgrp;
  108. }
  110. return (replyp->status);
  111. }
  113. /*
  114.  * PUBLIC: int __dbcl_env_remove_ret
  115.  * PUBLIC:     __P((DB_ENV *, const char *, u_int32_t, __env_remove_reply *));
  116.  */
  117. int
  118. __dbcl_env_remove_ret(dbenv, home, flags, replyp)
  119. DB_ENV *dbenv;
  120. const char *home;
  121. u_int32_t flags;
  122. __env_remove_reply *replyp;
  123. {
  124. int ret;
  126. COMPQUIET(home, NULL);
  127. COMPQUIET(flags, 0);
  129. ret = __dbcl_refresh(dbenv);
  130. __os_free(NULL, dbenv);
  131. if (replyp->status == 0 && ret != 0)
  132. return (ret);
  133. else
  134. return (replyp->status);
  135. }
  137. /*
  138.  * PUBLIC: int __dbcl_txn_abort_ret __P((DB_TXN *, __txn_abort_reply *));
  139.  */
  140. int
  141. __dbcl_txn_abort_ret(txnp, replyp)
  142. DB_TXN *txnp;
  143. __txn_abort_reply *replyp;
  144. {
  145. __dbcl_txn_end(txnp);
  146. return (replyp->status);
  147. }
  149. /*
  150.  * PUBLIC: int __dbcl_txn_begin_ret __P((DB_ENV *,
  151.  * PUBLIC:     DB_TXN *, DB_TXN **, u_int32_t, __txn_begin_reply *));
  152.  */
  153. int
  154. __dbcl_txn_begin_ret(envp, parent, txnpp, flags, replyp)
  155. DB_ENV *envp;
  156. DB_TXN *parent, **txnpp;
  157. u_int32_t flags;
  158. __txn_begin_reply *replyp;
  159. {
  160. DB_TXN *txn;
  161. int ret;
  163. COMPQUIET(flags, 0);
  165. if (replyp->status != 0)
  166. return (replyp->status);
  168. if ((ret = __os_calloc(envp, 1, sizeof(DB_TXN), &txn)) != 0)
  169. return (ret);
  170. __dbcl_txn_setup(envp, txn, parent, replyp->txnidcl_id);
  171. *txnpp = txn;
  172. return (replyp->status);
  173. }
  175. /*
  176.  * PUBLIC: int __dbcl_txn_commit_ret
  177.  * PUBLIC:     __P((DB_TXN *, u_int32_t, __txn_commit_reply *));
  178.  */
  179. int
  180. __dbcl_txn_commit_ret(txnp, flags, replyp)
  181. DB_TXN *txnp;
  182. u_int32_t flags;
  183. __txn_commit_reply *replyp;
  184. {
  185. COMPQUIET(flags, 0);
  187. __dbcl_txn_end(txnp);
  188. return (replyp->status);
  189. }
  191. /*
  192.  * PUBLIC: int __dbcl_txn_discard_ret __P((DB_TXN *, u_int32_t,
  193.  * PUBLIC:      __txn_discard_reply *));
  194.  */
  195. int
  196. __dbcl_txn_discard_ret(txnp, flags, replyp)
  197. DB_TXN * txnp;
  198. u_int32_t flags;
  199. __txn_discard_reply *replyp;
  200. {
  201. COMPQUIET(flags, 0);
  203. __dbcl_txn_end(txnp);
  204. return (replyp->status);
  205. }
  207. /*
  208.  * PUBLIC: int __dbcl_txn_recover_ret __P((DB_ENV *, DB_PREPLIST *, long,
  209.  * PUBLIC:      long *, u_int32_t, __txn_recover_reply *));
  210.  */
  211. int
  212. __dbcl_txn_recover_ret(dbenv, preplist, count, retp, flags, replyp)
  213. DB_ENV * dbenv;
  214. DB_PREPLIST * preplist;
  215. long count;
  216. long * retp;
  217. u_int32_t flags;
  218. __txn_recover_reply *replyp;
  219. {
  220. DB_PREPLIST *prep;
  221. DB_TXN *txnarray, *txn;
  222. u_int32_t i, *txnid;
  223. int ret;
  224. u_int8_t *gid;
  226. COMPQUIET(flags, 0);
  227. COMPQUIET(count, 0);
  229. if (replyp->status != 0)
  230. return (replyp->status);
  232. *retp = (long) replyp->retcount;
  234. if (replyp->retcount == 0)
  235. return (replyp->status);
  237. if ((ret = __os_calloc(dbenv, replyp->retcount, sizeof(DB_TXN),
  238.     &txnarray)) != 0)
  239. return (ret);
  240. /*
  241.  * We have a bunch of arrays that need to iterate in
  242.  * lockstep with each other.
  243.  */
  244. i = 0;
  245. txn = txnarray;
  246. txnid = (u_int32_t *)replyp->txn.txn_val;
  247. gid = (u_int8_t *)replyp->gid.gid_val;
  248. prep = preplist;
  249. while (i++ < replyp->retcount) {
  250. __dbcl_txn_setup(dbenv, txn, NULL, *txnid);
  251. prep->txn = txn;
  252. memcpy(&prep->gid, gid, DB_XIDDATASIZE);
  253. /*
  254.  * Now increment all our array pointers.
  255.  */
  256. txn++;
  257. gid += DB_XIDDATASIZE;
  258. txnid++;
  259. prep++;
  260. }
  262. return (0);
  263. }
  265. /*
  266.  * PUBLIC: int __dbcl_db_close_ret __P((DB *, u_int32_t, __db_close_reply *));
  267.  */
  268. int
  269. __dbcl_db_close_ret(dbp, flags, replyp)
  270. DB *dbp;
  271. u_int32_t flags;
  272. __db_close_reply *replyp;
  273. {
  274. int ret;
  276. COMPQUIET(flags, 0);
  278. ret = __dbcl_dbclose_common(dbp);
  280. if (replyp->status != 0)
  281. return (replyp->status);
  282. else
  283. return (ret);
  284. }
  286. /*
  287.  * PUBLIC: int __dbcl_db_create_ret
  288.  * PUBLIC:     __P((DB *, DB_ENV *, u_int32_t, __db_create_reply *));
  289.  */
  290. int
  291. __dbcl_db_create_ret(dbp, dbenv, flags, replyp)
  292. DB * dbp;
  293. DB_ENV * dbenv;
  294. u_int32_t flags;
  295. __db_create_reply *replyp;
  296. {
  297. COMPQUIET(dbenv, NULL);
  298. COMPQUIET(flags, 0);
  300. if (replyp->status != 0)
  301. return (replyp->status);
  302. dbp->cl_id = replyp->dbcl_id;
  303. return (replyp->status);
  304. }
  306. /*
  307.  * PUBLIC: int __dbcl_db_get_ret
  308.  * PUBLIC:     __P((DB *, DB_TXN *, DBT *, DBT *, u_int32_t, __db_get_reply *));
  309.  */
  310. int
  311. __dbcl_db_get_ret(dbp, txnp, key, data, flags, replyp)
  312. DB *dbp;
  313. DB_TXN *txnp;
  314. DBT *key, *data;
  315. u_int32_t flags;
  316. __db_get_reply *replyp;
  317. {
  318. DB_ENV *dbenv;
  319. int ret;
  320. void *oldkey;
  322. COMPQUIET(txnp, NULL);
  323. COMPQUIET(flags, 0);
  325. ret = 0;
  326. if (replyp->status != 0)
  327. return (replyp->status);
  329. dbenv = dbp->dbenv;
  331. oldkey = key->data;
  332. ret = __dbcl_retcopy(dbenv, key, replyp->keydata.keydata_val,
  333.     replyp->keydata.keydata_len, &dbp->my_rkey.data,
  334.     &dbp->my_rkey.ulen);
  335. if (ret)
  336. return (ret);
  337. ret = __dbcl_retcopy(dbenv, data, replyp->datadata.datadata_val,
  338.     replyp->datadata.datadata_len, &dbp->my_rdata.data,
  339.     &dbp->my_rdata.ulen);
  340. /*
  341.  * If an error on copying 'data' and we allocated for 'key'
  342.  * free it before returning the error.
  343.  */
  344. if (ret && oldkey != NULL)
  345. __os_free(dbenv, key->data);
  346. return (ret);
  347. }
  349. /*
  350.  * PUBLIC: int __dbcl_db_key_range_ret __P((DB *, DB_TXN *,
  351.  * PUBLIC:     DBT *, DB_KEY_RANGE *, u_int32_t, __db_key_range_reply *));
  352.  */
  353. int
  354. __dbcl_db_key_range_ret(dbp, txnp, key, range, flags, replyp)
  355. DB *dbp;
  356. DB_TXN *txnp;
  357. DBT *key;
  358. DB_KEY_RANGE *range;
  359. u_int32_t flags;
  360. __db_key_range_reply *replyp;
  361. {
  362. COMPQUIET(dbp, NULL);
  363. COMPQUIET(txnp, NULL);
  364. COMPQUIET(key, NULL);
  365. COMPQUIET(flags, 0);
  367. if (replyp->status != 0)
  368. return (replyp->status);
  369. range->less = replyp->less;
  370. range->equal = replyp->equal;
  371. range->greater = replyp->greater;
  372. return (replyp->status);
  373. }
  375. /*
  376.  * PUBLIC: int __dbcl_db_open_ret __P((DB *, DB_TXN *, const char *,
  377.  * PUBLIC:     const char *, DBTYPE, u_int32_t, int, __db_open_reply *));
  378.  */
  379. int
  380. __dbcl_db_open_ret(dbp, txn, name, subdb, type, flags, mode, replyp)
  381. DB *dbp;
  382. DB_TXN *txn;
  383. const char *name, *subdb;
  384. DBTYPE type;
  385. u_int32_t flags;
  386. int mode;
  387. __db_open_reply *replyp;
  388. {
  389. COMPQUIET(txn, NULL);
  390. COMPQUIET(name, NULL);
  391. COMPQUIET(subdb, NULL);
  392. COMPQUIET(type, 0);
  393. COMPQUIET(flags, 0);
  394. COMPQUIET(mode, 0);
  396. if (replyp->status == 0) {
  397. dbp->cl_id = replyp->dbcl_id;
  398. dbp->type = replyp->type;
  399. /*
  400.  * We get back the database's byteorder on the server.
  401.  * Determine if our byteorder is the same or not by
  402.  * calling __db_set_lorder.
  403.  *
  404.  * XXX
  405.  * This MUST come before we set the flags because
  406.  * __db_set_lorder checks that it is called before
  407.  * the open flag is set.
  408.  */
  409. (void)__db_set_lorder(dbp, replyp->lorder);
  411. /*
  412.  * XXX
  413.  * This is only for Tcl which peeks at the dbp flags.
  414.  * When dbp->get_flags exists, this should go away.
  415.  */
  416. dbp->flags = replyp->dbflags;
  417. }
  418. return (replyp->status);
  419. }
  421. /*
  422.  * PUBLIC: int __dbcl_db_pget_ret __P((DB *, DB_TXN *, DBT *, DBT *, DBT *,
  423.  * PUBLIC:      u_int32_t, __db_pget_reply *));
  424.  */
  425. int
  426. __dbcl_db_pget_ret(dbp, txnp, skey, pkey, data, flags, replyp)
  427. DB * dbp;
  428. DB_TXN * txnp;
  429. DBT * skey;
  430. DBT * pkey;
  431. DBT * data;
  432. u_int32_t flags;
  433. __db_pget_reply *replyp;
  434. {
  435. DB_ENV *dbenv;
  436. int ret;
  437. void *oldskey, *oldpkey;
  439. COMPQUIET(txnp, NULL);
  440. COMPQUIET(flags, 0);
  442. ret = 0;
  443. if (replyp->status != 0)
  444. return (replyp->status);
  446. dbenv = dbp->dbenv;
  448. oldskey = skey->data;
  449. ret = __dbcl_retcopy(dbenv, skey, replyp->skeydata.skeydata_val,
  450.     replyp->skeydata.skeydata_len, &dbp->my_rskey.data,
  451.     &dbp->my_rskey.ulen);
  452. if (ret)
  453. return (ret);
  455. oldpkey = pkey->data;
  456. ret = __dbcl_retcopy(dbenv, pkey, replyp->pkeydata.pkeydata_val,
  457.     replyp->pkeydata.pkeydata_len, &dbp->my_rkey.data,
  458.     &dbp->my_rkey.ulen);
  459. if (ret && oldskey != NULL) {
  460. __os_free(dbenv, skey->data);
  461. return (ret);
  462. }
  463. ret = __dbcl_retcopy(dbenv, data, replyp->datadata.datadata_val,
  464.     replyp->datadata.datadata_len, &dbp->my_rdata.data,
  465.     &dbp->my_rdata.ulen);
  466. /*
  467.  * If an error on copying 'data' and we allocated for '*key'
  468.  * free it before returning the error.
  469.  */
  470. if (ret) {
  471. if (oldskey != NULL)
  472. __os_free(dbenv, skey->data);
  473. if (oldpkey != NULL)
  474. __os_free(dbenv, pkey->data);
  475. }
  476. return (ret);
  477. }
  479. /*
  480.  * PUBLIC: int __dbcl_db_put_ret
  481.  * PUBLIC:     __P((DB *, DB_TXN *, DBT *, DBT *, u_int32_t, __db_put_reply *));
  482.  */
  483. int
  484. __dbcl_db_put_ret(dbp, txnp, key, data, flags, replyp)
  485. DB *dbp;
  486. DB_TXN *txnp;
  487. DBT *key, *data;
  488. u_int32_t flags;
  489. __db_put_reply *replyp;
  490. {
  491. int ret;
  493. COMPQUIET(dbp, NULL);
  494. COMPQUIET(txnp, NULL);
  495. COMPQUIET(data, NULL);
  497. ret = replyp->status;
  498. if (replyp->status == 0 && (flags == DB_APPEND))
  499. *(db_recno_t *)key->data =
  500.     *(db_recno_t *)replyp->keydata.keydata_val;
  501. return (ret);
  502. }
  504. /*
  505.  * PUBLIC: int __dbcl_db_remove_ret __P((DB *,
  506.  * PUBLIC:     const char *, const char *, u_int32_t, __db_remove_reply *));
  507.  */
  508. int
  509. __dbcl_db_remove_ret(dbp, name, subdb, flags, replyp)
  510. DB *dbp;
  511. const char *name, *subdb;
  512. u_int32_t flags;
  513. __db_remove_reply *replyp;
  514. {
  515. int ret;
  517. COMPQUIET(name, 0);
  518. COMPQUIET(subdb, 0);
  519. COMPQUIET(flags, 0);
  521. ret = __dbcl_dbclose_common(dbp);
  523. if (replyp->status != 0)
  524. return (replyp->status);
  525. else
  526. return (ret);
  527. }
  529. /*
  530.  * PUBLIC: int __dbcl_db_rename_ret __P((DB *, const char *,
  531.  * PUBLIC:     const char *, const char *, u_int32_t, __db_rename_reply *));
  532.  */
  533. int
  534. __dbcl_db_rename_ret(dbp, name, subdb, newname, flags, replyp)
  535. DB *dbp;
  536. const char *name, *subdb, *newname;
  537. u_int32_t flags;
  538. __db_rename_reply *replyp;
  539. {
  540. int ret;
  542. COMPQUIET(name, 0);
  543. COMPQUIET(subdb, 0);
  544. COMPQUIET(newname, 0);
  545. COMPQUIET(flags, 0);
  547. ret = __dbcl_dbclose_common(dbp);
  549. if (replyp->status != 0)
  550. return (replyp->status);
  551. else
  552. return (ret);
  553. }
  555. /*
  556.  * PUBLIC: int __dbcl_db_stat_ret
  557.  * PUBLIC:     __P((DB *, void *, u_int32_t, __db_stat_reply *));
  558.  */
  559. int
  560. __dbcl_db_stat_ret(dbp, sp, flags, replyp)
  561. DB *dbp;
  562. void *sp;
  563. u_int32_t flags;
  564. __db_stat_reply *replyp;
  565. {
  566. int len, ret;
  567. u_int32_t i, *q, *p, *retsp;
  569. COMPQUIET(flags, 0);
  571. if (replyp->status != 0 || sp == NULL)
  572. return (replyp->status);
  574. len = replyp->stats.stats_len * sizeof(u_int32_t);
  575. if ((ret = __os_umalloc(dbp->dbenv, len, &retsp)) != 0)
  576. return (ret);
  577. for (i = 0, q = retsp, p = (u_int32_t *)replyp->stats.stats_val;
  578.     i < replyp->stats.stats_len; i++, q++, p++)
  579. *q = *p;
  580. *(u_int32_t **)sp = retsp;
  581. return (0);
  582. }
  584. /*
  585.  * PUBLIC: int __dbcl_db_truncate_ret __P((DB *, DB_TXN *, u_int32_t  *,
  586.  * PUBLIC:      u_int32_t, __db_truncate_reply *));
  587.  */
  588. int
  589. __dbcl_db_truncate_ret(dbp, txnp, countp, flags, replyp)
  590. DB *dbp;
  591. DB_TXN *txnp;
  592. u_int32_t *countp, flags;
  593. __db_truncate_reply *replyp;
  594. {
  595. COMPQUIET(dbp, NULL);
  596. COMPQUIET(txnp, NULL);
  597. COMPQUIET(flags, 0);
  599. if (replyp->status != 0)
  600. return (replyp->status);
  601. *countp = replyp->count;
  603. return (replyp->status);
  604. }
  606. /*
  607.  * PUBLIC: int __dbcl_db_cursor_ret
  608.  * PUBLIC:     __P((DB *, DB_TXN *, DBC **, u_int32_t, __db_cursor_reply *));
  609.  */
  610. int
  611. __dbcl_db_cursor_ret(dbp, txnp, dbcp, flags, replyp)
  612. DB *dbp;
  613. DB_TXN *txnp;
  614. DBC **dbcp;
  615. u_int32_t flags;
  616. __db_cursor_reply *replyp;
  617. {
  618. COMPQUIET(txnp, NULL);
  619. COMPQUIET(flags, 0);
  621. if (replyp->status != 0)
  622. return (replyp->status);
  624. return (__dbcl_c_setup(replyp->dbcidcl_id, dbp, dbcp));
  625. }
  627. /*
  628.  * PUBLIC: int __dbcl_db_join_ret
  629.  * PUBLIC:     __P((DB *, DBC **, DBC **, u_int32_t, __db_join_reply *));
  630.  */
  631. int
  632. __dbcl_db_join_ret(dbp, curs, dbcp, flags, replyp)
  633. DB *dbp;
  634. DBC **curs, **dbcp;
  635. u_int32_t flags;
  636. __db_join_reply *replyp;
  637. {
  638. COMPQUIET(curs, NULL);
  639. COMPQUIET(flags, 0);
  641. if (replyp->status != 0)
  642. return (replyp->status);
  644. /*
  645.  * We set this up as a normal cursor.  We do not need
  646.  * to treat a join cursor any differently than a normal
  647.  * cursor, even though DB itself must.  We only need the
  648.  * client-side cursor/db relationship to know what cursors
  649.  * are open in the db, and to store their ID.  Nothing else.
  650.  */
  651. return (__dbcl_c_setup(replyp->dbcidcl_id, dbp, dbcp));
  652. }
  654. /*
  655.  * PUBLIC: int __dbcl_dbc_close_ret __P((DBC *, __dbc_close_reply *));
  656.  */
  657. int
  658. __dbcl_dbc_close_ret(dbc, replyp)
  659. DBC *dbc;
  660. __dbc_close_reply *replyp;
  661. {
  662. __dbcl_c_refresh(dbc);
  663. return (replyp->status);
  664. }
  666. /*
  667.  * PUBLIC: int __dbcl_dbc_count_ret
  668.  * PUBLIC:     __P((DBC *, db_recno_t *, u_int32_t, __dbc_count_reply *));
  669.  */
  670. int
  671. __dbcl_dbc_count_ret(dbc, countp, flags, replyp)
  672. DBC *dbc;
  673. db_recno_t *countp;
  674. u_int32_t flags;
  675. __dbc_count_reply *replyp;
  676. {
  677. COMPQUIET(dbc, NULL);
  678. COMPQUIET(flags, 0);
  680. if (replyp->status != 0)
  681. return (replyp->status);
  682. *countp = replyp->dupcount;
  684. return (replyp->status);
  685. }
  687. /*
  688.  * PUBLIC: int __dbcl_dbc_dup_ret
  689.  * PUBLIC:     __P((DBC *, DBC **, u_int32_t, __dbc_dup_reply *));
  690.  */
  691. int
  692. __dbcl_dbc_dup_ret(dbc, dbcp, flags, replyp)
  693. DBC *dbc, **dbcp;
  694. u_int32_t flags;
  695. __dbc_dup_reply *replyp;
  696. {
  697. COMPQUIET(flags, 0);
  699. if (replyp->status != 0)
  700. return (replyp->status);
  702. return (__dbcl_c_setup(replyp->dbcidcl_id, dbc->dbp, dbcp));
  703. }
  705. /*
  706.  * PUBLIC: int __dbcl_dbc_get_ret
  707.  * PUBLIC:     __P((DBC *, DBT *, DBT *, u_int32_t, __dbc_get_reply *));
  708.  */
  709. int
  710. __dbcl_dbc_get_ret(dbc, key, data, flags, replyp)
  711. DBC *dbc;
  712. DBT *key, *data;
  713. u_int32_t flags;
  714. __dbc_get_reply *replyp;
  715. {
  716. DB_ENV *dbenv;
  717. int ret;
  718. void *oldkey;
  720. COMPQUIET(flags, 0);
  722. ret = 0;
  723. if (replyp->status != 0)
  724. return (replyp->status);
  726. dbenv = dbc->dbp->dbenv;
  727. oldkey = key->data;
  728. ret = __dbcl_retcopy(dbenv, key, replyp->keydata.keydata_val,
  729.     replyp->keydata.keydata_len, &dbc->my_rkey.data,
  730.     &dbc->my_rkey.ulen);
  731. if (ret)
  732. return (ret);
  733. ret = __dbcl_retcopy(dbenv, data, replyp->datadata.datadata_val,
  734.     replyp->datadata.datadata_len, &dbc->my_rdata.data,
  735.     &dbc->my_rdata.ulen);
  737. /*
  738.  * If an error on copying 'data' and we allocated for 'key'
  739.  * free it before returning the error.
  740.  */
  741. if (ret && oldkey != NULL)
  742. __os_free(dbenv, key->data);
  743. return (ret);
  744. }
  746. /*
  747.  * PUBLIC: int __dbcl_dbc_pget_ret __P((DBC *, DBT *, DBT *, DBT *, u_int32_t,
  748.  * PUBLIC:      __dbc_pget_reply *));
  749.  */
  750. int
  751. __dbcl_dbc_pget_ret(dbc, skey, pkey, data, flags, replyp)
  752. DBC * dbc;
  753. DBT * skey;
  754. DBT * pkey;
  755. DBT * data;
  756. u_int32_t flags;
  757. __dbc_pget_reply *replyp;
  758. {
  759. DB_ENV *dbenv;
  760. int ret;
  761. void *oldskey, *oldpkey;
  763. COMPQUIET(flags, 0);
  765. ret = 0;
  766. if (replyp->status != 0)
  767. return (replyp->status);
  769. dbenv = dbc->dbp->dbenv;
  771. oldskey = skey->data;
  772. ret = __dbcl_retcopy(dbenv, skey, replyp->skeydata.skeydata_val,
  773.     replyp->skeydata.skeydata_len, &dbc->my_rskey.data,
  774.     &dbc->my_rskey.ulen);
  775. if (ret)
  776. return (ret);
  778. oldpkey = pkey->data;
  779. ret = __dbcl_retcopy(dbenv, pkey, replyp->pkeydata.pkeydata_val,
  780.     replyp->pkeydata.pkeydata_len, &dbc->my_rkey.data,
  781.     &dbc->my_rkey.ulen);
  782. if (ret && oldskey != NULL) {
  783. __os_free(dbenv, skey->data);
  784. return (ret);
  785. }
  786. ret = __dbcl_retcopy(dbenv, data, replyp->datadata.datadata_val,
  787.     replyp->datadata.datadata_len, &dbc->my_rdata.data,
  788.     &dbc->my_rdata.ulen);
  789. /*
  790.  * If an error on copying 'data' and we allocated for '*key'
  791.  * free it before returning the error.
  792.  */
  793. if (ret) {
  794. if (oldskey != NULL)
  795. __os_free(dbenv, skey->data);
  796. if (oldpkey != NULL)
  797. __os_free(dbenv, pkey->data);
  798. }
  799. return (ret);
  800. }
  802. /*
  803.  * PUBLIC: int __dbcl_dbc_put_ret
  804.  * PUBLIC:     __P((DBC *, DBT *, DBT *, u_int32_t, __dbc_put_reply *));
  805.  */
  806. int
  807. __dbcl_dbc_put_ret(dbc, key, data, flags, replyp)
  808. DBC *dbc;
  809. DBT *key, *data;
  810. u_int32_t flags;
  811. __dbc_put_reply *replyp;
  812. {
  813. COMPQUIET(data, NULL);
  815. if (replyp->status != 0)
  816. return (replyp->status);
  818. if (replyp->status == 0 && dbc->dbp->type == DB_RECNO &&
  819.     (flags == DB_AFTER || flags == DB_BEFORE))
  820. *(db_recno_t *)key->data =
  821.     *(db_recno_t *)replyp->keydata.keydata_val;
  822. return (replyp->status);
  823. }
  824. #endif /* HAVE_RPC */