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

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

MySQL数据库

开发平台：

Visual C++

gen_client.c：源码内容
  1. /* Do not edit: automatically built by gen_rpc.awk. */
  2. #include "db_config.h"
  4. #ifdef HAVE_RPC
  5. #ifndef NO_SYSTEM_INCLUDES
  6. #include <sys/types.h>
  7. #include <rpc/rpc.h>
  8. #include <rpc/xdr.h>
  10. #include <errno.h>
  11. #include <string.h>
  12. #endif
  13. #include "db_server.h"
  15. #include "db_int.h"
  16. #include "db_page.h"
  17. #include "db_ext.h"
  18. #include "mp.h"
  19. #include "rpc_client_ext.h"
  20. #include "txn.h"
  22. #include "gen_client_ext.h"
  24. int
  25. __dbcl_env_cachesize(dbenv, gbytes, bytes, ncache)
  26. DB_ENV * dbenv;
  27. u_int32_t gbytes;
  28. u_int32_t bytes;
  29. int ncache;
  30. {
  31. CLIENT *cl;
  32. __env_cachesize_msg req;
  33. static __env_cachesize_reply *replyp = NULL;
  34. int ret;
  36. ret = 0;
  37. if (dbenv == NULL || dbenv->cl_handle == NULL) {
  38. __db_err(dbenv, "No server environment.");
  39. return (DB_NOSERVER);
  40. }
  42. if (replyp != NULL) {
  43. xdr_free((xdrproc_t)xdr___env_cachesize_reply, (void *)replyp);
  44. replyp = NULL;
  45. }
  46. cl = (CLIENT *)dbenv->cl_handle;
  48. if (dbenv == NULL)
  49. req.dbenvcl_id = 0;
  50. else
  51. req.dbenvcl_id = dbenv->cl_id;
  52. req.gbytes = gbytes;
  53. req.bytes = bytes;
  54. req.ncache = ncache;
  56. replyp = __db_env_cachesize_1(&req, cl);
  57. if (replyp == NULL) {
  58. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  59. ret = DB_NOSERVER;
  60. goto out;
  61. }
  62. ret = replyp->status;
  63. out:
  64. return (ret);
  65. }
  67. int
  68. __dbcl_env_close(dbenv, flags)
  69. DB_ENV * dbenv;
  70. u_int32_t flags;
  71. {
  72. CLIENT *cl;
  73. __env_close_msg req;
  74. static __env_close_reply *replyp = NULL;
  75. int ret;
  77. ret = 0;
  78. if (dbenv == NULL || dbenv->cl_handle == NULL) {
  79. __db_err(dbenv, "No server environment.");
  80. return (DB_NOSERVER);
  81. }
  83. if (replyp != NULL) {
  84. xdr_free((xdrproc_t)xdr___env_close_reply, (void *)replyp);
  85. replyp = NULL;
  86. }
  87. cl = (CLIENT *)dbenv->cl_handle;
  89. if (dbenv == NULL)
  90. req.dbenvcl_id = 0;
  91. else
  92. req.dbenvcl_id = dbenv->cl_id;
  93. req.flags = flags;
  95. replyp = __db_env_close_1(&req, cl);
  96. if (replyp == NULL) {
  97. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  98. ret = DB_NOSERVER;
  99. goto out;
  100. }
  101. return (__dbcl_env_close_ret(dbenv, flags, replyp));
  102. out:
  103. return (ret);
  104. }
  106. int
  107. __dbcl_rpc_illegal(dbenv, name)
  108. DB_ENV *dbenv;
  109. char *name;
  110. {
  111. __db_err(dbenv,
  112.     "%s method meaningless in RPC environment", name);
  113. return (__db_eopnotsup(dbenv));
  114. }
  116. int
  117. __dbcl_set_data_dir(dbenv, dir)
  118. DB_ENV * dbenv;
  119. const char * dir;
  120. {
  121. COMPQUIET(dir, NULL);
  122. return (__dbcl_rpc_illegal(dbenv, "set_data_dir"));
  123. }
  125. int
  126. __dbcl_env_set_feedback(dbenv, func0)
  127. DB_ENV * dbenv;
  128. void (*func0) __P((DB_ENV *, int, int));
  129. {
  130. COMPQUIET(func0, 0);
  131. return (__dbcl_rpc_illegal(dbenv, "env_set_feedback"));
  132. }
  134. int
  135. __dbcl_env_flags(dbenv, flags, onoff)
  136. DB_ENV * dbenv;
  137. u_int32_t flags;
  138. int onoff;
  139. {
  140. CLIENT *cl;
  141. __env_flags_msg req;
  142. static __env_flags_reply *replyp = NULL;
  143. int ret;
  145. ret = 0;
  146. if (dbenv == NULL || dbenv->cl_handle == NULL) {
  147. __db_err(dbenv, "No server environment.");
  148. return (DB_NOSERVER);
  149. }
  151. if (replyp != NULL) {
  152. xdr_free((xdrproc_t)xdr___env_flags_reply, (void *)replyp);
  153. replyp = NULL;
  154. }
  155. cl = (CLIENT *)dbenv->cl_handle;
  157. if (dbenv == NULL)
  158. req.dbenvcl_id = 0;
  159. else
  160. req.dbenvcl_id = dbenv->cl_id;
  161. req.flags = flags;
  162. req.onoff = onoff;
  164. replyp = __db_env_flags_1(&req, cl);
  165. if (replyp == NULL) {
  166. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  167. ret = DB_NOSERVER;
  168. goto out;
  169. }
  170. ret = replyp->status;
  171. out:
  172. return (ret);
  173. }
  175. int
  176. __dbcl_set_lg_bsize(dbenv, bsize)
  177. DB_ENV * dbenv;
  178. u_int32_t bsize;
  179. {
  180. COMPQUIET(bsize, 0);
  181. return (__dbcl_rpc_illegal(dbenv, "set_lg_bsize"));
  182. }
  184. int
  185. __dbcl_set_lg_dir(dbenv, dir)
  186. DB_ENV * dbenv;
  187. const char * dir;
  188. {
  189. COMPQUIET(dir, NULL);
  190. return (__dbcl_rpc_illegal(dbenv, "set_lg_dir"));
  191. }
  193. int
  194. __dbcl_set_lg_max(dbenv, max)
  195. DB_ENV * dbenv;
  196. u_int32_t max;
  197. {
  198. COMPQUIET(max, 0);
  199. return (__dbcl_rpc_illegal(dbenv, "set_lg_max"));
  200. }
  202. int
  203. __dbcl_set_lk_conflict(dbenv, conflicts, modes)
  204. DB_ENV * dbenv;
  205. u_int8_t * conflicts;
  206. int modes;
  207. {
  208. COMPQUIET(conflicts, 0);
  209. COMPQUIET(modes, 0);
  210. return (__dbcl_rpc_illegal(dbenv, "set_lk_conflict"));
  211. }
  213. int
  214. __dbcl_set_lk_detect(dbenv, detect)
  215. DB_ENV * dbenv;
  216. u_int32_t detect;
  217. {
  218. COMPQUIET(detect, 0);
  219. return (__dbcl_rpc_illegal(dbenv, "set_lk_detect"));
  220. }
  222. int
  223. __dbcl_set_lk_max(dbenv, max)
  224. DB_ENV * dbenv;
  225. u_int32_t max;
  226. {
  227. COMPQUIET(max, 0);
  228. return (__dbcl_rpc_illegal(dbenv, "set_lk_max"));
  229. }
  231. int
  232. __dbcl_set_lk_max_locks(dbenv, max)
  233. DB_ENV * dbenv;
  234. u_int32_t max;
  235. {
  236. COMPQUIET(max, 0);
  237. return (__dbcl_rpc_illegal(dbenv, "set_lk_max_locks"));
  238. }
  240. int
  241. __dbcl_set_lk_max_lockers(dbenv, max)
  242. DB_ENV * dbenv;
  243. u_int32_t max;
  244. {
  245. COMPQUIET(max, 0);
  246. return (__dbcl_rpc_illegal(dbenv, "set_lk_max_lockers"));
  247. }
  249. int
  250. __dbcl_set_lk_max_objects(dbenv, max)
  251. DB_ENV * dbenv;
  252. u_int32_t max;
  253. {
  254. COMPQUIET(max, 0);
  255. return (__dbcl_rpc_illegal(dbenv, "set_lk_max_objects"));
  256. }
  258. int
  259. __dbcl_set_mp_mmapsize(dbenv, mmapsize)
  260. DB_ENV * dbenv;
  261. size_t mmapsize;
  262. {
  263. COMPQUIET(mmapsize, 0);
  264. return (__dbcl_rpc_illegal(dbenv, "set_mp_mmapsize"));
  265. }
  267. int
  268. __dbcl_set_mutex_locks(dbenv, do_lock)
  269. DB_ENV * dbenv;
  270. int do_lock;
  271. {
  272. COMPQUIET(do_lock, 0);
  273. return (__dbcl_rpc_illegal(dbenv, "set_mutex_locks"));
  274. }
  276. int
  277. __dbcl_env_open(dbenv, home, flags, mode)
  278. DB_ENV * dbenv;
  279. const char * home;
  280. u_int32_t flags;
  281. int mode;
  282. {
  283. CLIENT *cl;
  284. __env_open_msg req;
  285. static __env_open_reply *replyp = NULL;
  286. int ret;
  288. ret = 0;
  289. if (dbenv == NULL || dbenv->cl_handle == NULL) {
  290. __db_err(dbenv, "No server environment.");
  291. return (DB_NOSERVER);
  292. }
  294. if (replyp != NULL) {
  295. xdr_free((xdrproc_t)xdr___env_open_reply, (void *)replyp);
  296. replyp = NULL;
  297. }
  298. cl = (CLIENT *)dbenv->cl_handle;
  300. if (dbenv == NULL)
  301. req.dbenvcl_id = 0;
  302. else
  303. req.dbenvcl_id = dbenv->cl_id;
  304. if (home == NULL)
  305. req.home = "";
  306. else
  307. req.home = (char *)home;
  308. req.flags = flags;
  309. req.mode = mode;
  311. replyp = __db_env_open_1(&req, cl);
  312. if (replyp == NULL) {
  313. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  314. ret = DB_NOSERVER;
  315. goto out;
  316. }
  317. return (__dbcl_env_open_ret(dbenv, home, flags, mode, replyp));
  318. out:
  319. return (ret);
  320. }
  322. int
  323. __dbcl_env_paniccall(dbenv, func0)
  324. DB_ENV * dbenv;
  325. void (*func0) __P((DB_ENV *, int));
  326. {
  327. COMPQUIET(func0, 0);
  328. return (__dbcl_rpc_illegal(dbenv, "env_paniccall"));
  329. }
  331. int
  332. __dbcl_set_recovery_init(dbenv, func0)
  333. DB_ENV * dbenv;
  334. int (*func0) __P((DB_ENV *));
  335. {
  336. COMPQUIET(func0, 0);
  337. return (__dbcl_rpc_illegal(dbenv, "set_recovery_init"));
  338. }
  340. int
  341. __dbcl_env_remove(dbenv, home, flags)
  342. DB_ENV * dbenv;
  343. const char * home;
  344. u_int32_t flags;
  345. {
  346. CLIENT *cl;
  347. __env_remove_msg req;
  348. static __env_remove_reply *replyp = NULL;
  349. int ret;
  351. ret = 0;
  352. if (dbenv == NULL || dbenv->cl_handle == NULL) {
  353. __db_err(dbenv, "No server environment.");
  354. return (DB_NOSERVER);
  355. }
  357. if (replyp != NULL) {
  358. xdr_free((xdrproc_t)xdr___env_remove_reply, (void *)replyp);
  359. replyp = NULL;
  360. }
  361. cl = (CLIENT *)dbenv->cl_handle;
  363. if (dbenv == NULL)
  364. req.dbenvcl_id = 0;
  365. else
  366. req.dbenvcl_id = dbenv->cl_id;
  367. if (home == NULL)
  368. req.home = "";
  369. else
  370. req.home = (char *)home;
  371. req.flags = flags;
  373. replyp = __db_env_remove_1(&req, cl);
  374. if (replyp == NULL) {
  375. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  376. ret = DB_NOSERVER;
  377. goto out;
  378. }
  379. return (__dbcl_env_remove_ret(dbenv, home, flags, replyp));
  380. out:
  381. return (ret);
  382. }
  384. int
  385. __dbcl_set_shm_key(dbenv, shm_key)
  386. DB_ENV * dbenv;
  387. long shm_key;
  388. {
  389. COMPQUIET(shm_key, 0);
  390. return (__dbcl_rpc_illegal(dbenv, "set_shm_key"));
  391. }
  393. int
  394. __dbcl_set_tmp_dir(dbenv, dir)
  395. DB_ENV * dbenv;
  396. const char * dir;
  397. {
  398. COMPQUIET(dir, NULL);
  399. return (__dbcl_rpc_illegal(dbenv, "set_tmp_dir"));
  400. }
  402. int
  403. __dbcl_set_tx_recover(dbenv, func0)
  404. DB_ENV * dbenv;
  405. int (*func0) __P((DB_ENV *, DBT *, DB_LSN *, db_recops));
  406. {
  407. COMPQUIET(func0, 0);
  408. return (__dbcl_rpc_illegal(dbenv, "set_tx_recover"));
  409. }
  411. int
  412. __dbcl_set_tx_max(dbenv, max)
  413. DB_ENV * dbenv;
  414. u_int32_t max;
  415. {
  416. COMPQUIET(max, 0);
  417. return (__dbcl_rpc_illegal(dbenv, "set_tx_max"));
  418. }
  420. int
  421. __dbcl_set_tx_timestamp(dbenv, max)
  422. DB_ENV * dbenv;
  423. time_t * max;
  424. {
  425. COMPQUIET(max, 0);
  426. return (__dbcl_rpc_illegal(dbenv, "set_tx_timestamp"));
  427. }
  429. int
  430. __dbcl_set_verbose(dbenv, which, onoff)
  431. DB_ENV * dbenv;
  432. u_int32_t which;
  433. int onoff;
  434. {
  435. COMPQUIET(which, 0);
  436. COMPQUIET(onoff, 0);
  437. return (__dbcl_rpc_illegal(dbenv, "set_verbose"));
  438. }
  440. int
  441. __dbcl_txn_abort(txnp)
  442. DB_TXN * txnp;
  443. {
  444. CLIENT *cl;
  445. __txn_abort_msg req;
  446. static __txn_abort_reply *replyp = NULL;
  447. int ret;
  448. DB_ENV *dbenv;
  450. ret = 0;
  451. dbenv = NULL;
  452. dbenv = txnp->mgrp->dbenv;
  453. if (dbenv == NULL || dbenv->cl_handle == NULL) {
  454. __db_err(dbenv, "No server environment.");
  455. return (DB_NOSERVER);
  456. }
  458. if (replyp != NULL) {
  459. xdr_free((xdrproc_t)xdr___txn_abort_reply, (void *)replyp);
  460. replyp = NULL;
  461. }
  462. cl = (CLIENT *)dbenv->cl_handle;
  464. if (txnp == NULL)
  465. req.txnpcl_id = 0;
  466. else
  467. req.txnpcl_id = txnp->txnid;
  469. replyp = __db_txn_abort_1(&req, cl);
  470. if (replyp == NULL) {
  471. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  472. ret = DB_NOSERVER;
  473. goto out;
  474. }
  475. return (__dbcl_txn_abort_ret(txnp, replyp));
  476. out:
  477. return (ret);
  478. }
  480. int
  481. __dbcl_txn_begin(envp, parent, txnpp, flags)
  482. DB_ENV * envp;
  483. DB_TXN * parent;
  484. DB_TXN ** txnpp;
  485. u_int32_t flags;
  486. {
  487. CLIENT *cl;
  488. __txn_begin_msg req;
  489. static __txn_begin_reply *replyp = NULL;
  490. int ret;
  492. ret = 0;
  493. if (envp == NULL || envp->cl_handle == NULL) {
  494. __db_err(envp, "No server environment.");
  495. return (DB_NOSERVER);
  496. }
  498. if (replyp != NULL) {
  499. xdr_free((xdrproc_t)xdr___txn_begin_reply, (void *)replyp);
  500. replyp = NULL;
  501. }
  502. cl = (CLIENT *)envp->cl_handle;
  504. if (envp == NULL)
  505. req.envpcl_id = 0;
  506. else
  507. req.envpcl_id = envp->cl_id;
  508. if (parent == NULL)
  509. req.parentcl_id = 0;
  510. else
  511. req.parentcl_id = parent->txnid;
  512. req.flags = flags;
  514. replyp = __db_txn_begin_1(&req, cl);
  515. if (replyp == NULL) {
  516. __db_err(envp, clnt_sperror(cl, "Berkeley DB"));
  517. ret = DB_NOSERVER;
  518. goto out;
  519. }
  520. return (__dbcl_txn_begin_ret(envp, parent, txnpp, flags, replyp));
  521. out:
  522. return (ret);
  523. }
  525. int
  526. __dbcl_txn_checkpoint(dbenv, kbyte, min)
  527. DB_ENV * dbenv;
  528. u_int32_t kbyte;
  529. u_int32_t min;
  530. {
  531. COMPQUIET(kbyte, 0);
  532. COMPQUIET(min, 0);
  533. return (__dbcl_rpc_illegal(dbenv, "txn_checkpoint"));
  534. }
  536. int
  537. __dbcl_txn_commit(txnp, flags)
  538. DB_TXN * txnp;
  539. u_int32_t flags;
  540. {
  541. CLIENT *cl;
  542. __txn_commit_msg req;
  543. static __txn_commit_reply *replyp = NULL;
  544. int ret;
  545. DB_ENV *dbenv;
  547. ret = 0;
  548. dbenv = NULL;
  549. dbenv = txnp->mgrp->dbenv;
  550. if (dbenv == NULL || dbenv->cl_handle == NULL) {
  551. __db_err(dbenv, "No server environment.");
  552. return (DB_NOSERVER);
  553. }
  555. if (replyp != NULL) {
  556. xdr_free((xdrproc_t)xdr___txn_commit_reply, (void *)replyp);
  557. replyp = NULL;
  558. }
  559. cl = (CLIENT *)dbenv->cl_handle;
  561. if (txnp == NULL)
  562. req.txnpcl_id = 0;
  563. else
  564. req.txnpcl_id = txnp->txnid;
  565. req.flags = flags;
  567. replyp = __db_txn_commit_1(&req, cl);
  568. if (replyp == NULL) {
  569. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  570. ret = DB_NOSERVER;
  571. goto out;
  572. }
  573. return (__dbcl_txn_commit_ret(txnp, flags, replyp));
  574. out:
  575. return (ret);
  576. }
  578. int
  579. __dbcl_txn_prepare(txnp)
  580. DB_TXN * txnp;
  581. {
  582. DB_ENV *dbenv;
  584. dbenv = txnp->mgrp->dbenv;
  585. return (__dbcl_rpc_illegal(dbenv, "txn_prepare"));
  586. }
  588. int
  589. __dbcl_txn_stat(dbenv, statp, func0)
  590. DB_ENV * dbenv;
  591. DB_TXN_STAT ** statp;
  592. void *(*func0) __P((size_t));
  593. {
  594. COMPQUIET(statp, 0);
  595. COMPQUIET(func0, 0);
  596. return (__dbcl_rpc_illegal(dbenv, "txn_stat"));
  597. }
  599. int
  600. __dbcl_db_bt_compare(dbp, func0)
  601. DB * dbp;
  602. int (*func0) __P((DB *, const DBT *, const DBT *));
  603. {
  604. DB_ENV *dbenv;
  606. dbenv = dbp->dbenv;
  607. COMPQUIET(func0, 0);
  608. return (__dbcl_rpc_illegal(dbenv, "db_bt_compare"));
  609. }
  611. int
  612. __dbcl_db_bt_maxkey(dbp, maxkey)
  613. DB * dbp;
  614. u_int32_t maxkey;
  615. {
  616. CLIENT *cl;
  617. __db_bt_maxkey_msg req;
  618. static __db_bt_maxkey_reply *replyp = NULL;
  619. int ret;
  620. DB_ENV *dbenv;
  622. ret = 0;
  623. dbenv = NULL;
  624. dbenv = dbp->dbenv;
  625. if (dbenv == NULL || dbenv->cl_handle == NULL) {
  626. __db_err(dbenv, "No server environment.");
  627. return (DB_NOSERVER);
  628. }
  630. if (replyp != NULL) {
  631. xdr_free((xdrproc_t)xdr___db_bt_maxkey_reply, (void *)replyp);
  632. replyp = NULL;
  633. }
  634. cl = (CLIENT *)dbenv->cl_handle;
  636. if (dbp == NULL)
  637. req.dbpcl_id = 0;
  638. else
  639. req.dbpcl_id = dbp->cl_id;
  640. req.maxkey = maxkey;
  642. replyp = __db_db_bt_maxkey_1(&req, cl);
  643. if (replyp == NULL) {
  644. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  645. ret = DB_NOSERVER;
  646. goto out;
  647. }
  648. ret = replyp->status;
  649. out:
  650. return (ret);
  651. }
  653. int
  654. __dbcl_db_bt_minkey(dbp, minkey)
  655. DB * dbp;
  656. u_int32_t minkey;
  657. {
  658. CLIENT *cl;
  659. __db_bt_minkey_msg req;
  660. static __db_bt_minkey_reply *replyp = NULL;
  661. int ret;
  662. DB_ENV *dbenv;
  664. ret = 0;
  665. dbenv = NULL;
  666. dbenv = dbp->dbenv;
  667. if (dbenv == NULL || dbenv->cl_handle == NULL) {
  668. __db_err(dbenv, "No server environment.");
  669. return (DB_NOSERVER);
  670. }
  672. if (replyp != NULL) {
  673. xdr_free((xdrproc_t)xdr___db_bt_minkey_reply, (void *)replyp);
  674. replyp = NULL;
  675. }
  676. cl = (CLIENT *)dbenv->cl_handle;
  678. if (dbp == NULL)
  679. req.dbpcl_id = 0;
  680. else
  681. req.dbpcl_id = dbp->cl_id;
  682. req.minkey = minkey;
  684. replyp = __db_db_bt_minkey_1(&req, cl);
  685. if (replyp == NULL) {
  686. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  687. ret = DB_NOSERVER;
  688. goto out;
  689. }
  690. ret = replyp->status;
  691. out:
  692. return (ret);
  693. }
  695. int
  696. __dbcl_db_bt_prefix(dbp, func0)
  697. DB * dbp;
  698. size_t (*func0) __P((DB *, const DBT *, const DBT *));
  699. {
  700. DB_ENV *dbenv;
  702. dbenv = dbp->dbenv;
  703. COMPQUIET(func0, 0);
  704. return (__dbcl_rpc_illegal(dbenv, "db_bt_prefix"));
  705. }
  707. int
  708. __dbcl_db_set_append_recno(dbp, func0)
  709. DB * dbp;
  710. int (*func0) __P((DB *, DBT *, db_recno_t));
  711. {
  712. DB_ENV *dbenv;
  714. dbenv = dbp->dbenv;
  715. COMPQUIET(func0, 0);
  716. return (__dbcl_rpc_illegal(dbenv, "db_set_append_recno"));
  717. }
  719. int
  720. __dbcl_db_cachesize(dbp, gbytes, bytes, ncache)
  721. DB * dbp;
  722. u_int32_t gbytes;
  723. u_int32_t bytes;
  724. int ncache;
  725. {
  726. DB_ENV *dbenv;
  728. dbenv = dbp->dbenv;
  729. COMPQUIET(gbytes, 0);
  730. COMPQUIET(bytes, 0);
  731. COMPQUIET(ncache, 0);
  732. return (__dbcl_rpc_illegal(dbenv, "db_cachesize"));
  733. }
  735. int
  736. __dbcl_db_close(dbp, flags)
  737. DB * dbp;
  738. u_int32_t flags;
  739. {
  740. CLIENT *cl;
  741. __db_close_msg req;
  742. static __db_close_reply *replyp = NULL;
  743. int ret;
  744. DB_ENV *dbenv;
  746. ret = 0;
  747. dbenv = NULL;
  748. dbenv = dbp->dbenv;
  749. if (dbenv == NULL || dbenv->cl_handle == NULL) {
  750. __db_err(dbenv, "No server environment.");
  751. return (DB_NOSERVER);
  752. }
  754. if (replyp != NULL) {
  755. xdr_free((xdrproc_t)xdr___db_close_reply, (void *)replyp);
  756. replyp = NULL;
  757. }
  758. cl = (CLIENT *)dbenv->cl_handle;
  760. if (dbp == NULL)
  761. req.dbpcl_id = 0;
  762. else
  763. req.dbpcl_id = dbp->cl_id;
  764. req.flags = flags;
  766. replyp = __db_db_close_1(&req, cl);
  767. if (replyp == NULL) {
  768. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  769. ret = DB_NOSERVER;
  770. goto out;
  771. }
  772. return (__dbcl_db_close_ret(dbp, flags, replyp));
  773. out:
  774. return (ret);
  775. }
  777. int
  778. __dbcl_db_del(dbp, txnp, key, flags)
  779. DB * dbp;
  780. DB_TXN * txnp;
  781. DBT * key;
  782. u_int32_t flags;
  783. {
  784. CLIENT *cl;
  785. __db_del_msg req;
  786. static __db_del_reply *replyp = NULL;
  787. int ret;
  788. DB_ENV *dbenv;
  790. ret = 0;
  791. dbenv = NULL;
  792. dbenv = dbp->dbenv;
  793. if (dbenv == NULL || dbenv->cl_handle == NULL) {
  794. __db_err(dbenv, "No server environment.");
  795. return (DB_NOSERVER);
  796. }
  798. if (replyp != NULL) {
  799. xdr_free((xdrproc_t)xdr___db_del_reply, (void *)replyp);
  800. replyp = NULL;
  801. }
  802. cl = (CLIENT *)dbenv->cl_handle;
  804. if (dbp == NULL)
  805. req.dbpcl_id = 0;
  806. else
  807. req.dbpcl_id = dbp->cl_id;
  808. if (txnp == NULL)
  809. req.txnpcl_id = 0;
  810. else
  811. req.txnpcl_id = txnp->txnid;
  812. req.keydlen = key->dlen;
  813. req.keydoff = key->doff;
  814. req.keyflags = key->flags;
  815. req.keydata.keydata_val = key->data;
  816. req.keydata.keydata_len = key->size;
  817. req.flags = flags;
  819. replyp = __db_db_del_1(&req, cl);
  820. if (replyp == NULL) {
  821. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  822. ret = DB_NOSERVER;
  823. goto out;
  824. }
  825. ret = replyp->status;
  826. out:
  827. return (ret);
  828. }
  830. int
  831. __dbcl_db_extentsize(dbp, extentsize)
  832. DB * dbp;
  833. u_int32_t extentsize;
  834. {
  835. CLIENT *cl;
  836. __db_extentsize_msg req;
  837. static __db_extentsize_reply *replyp = NULL;
  838. int ret;
  839. DB_ENV *dbenv;
  841. ret = 0;
  842. dbenv = NULL;
  843. dbenv = dbp->dbenv;
  844. if (dbenv == NULL || dbenv->cl_handle == NULL) {
  845. __db_err(dbenv, "No server environment.");
  846. return (DB_NOSERVER);
  847. }
  849. if (replyp != NULL) {
  850. xdr_free((xdrproc_t)xdr___db_extentsize_reply, (void *)replyp);
  851. replyp = NULL;
  852. }
  853. cl = (CLIENT *)dbenv->cl_handle;
  855. if (dbp == NULL)
  856. req.dbpcl_id = 0;
  857. else
  858. req.dbpcl_id = dbp->cl_id;
  859. req.extentsize = extentsize;
  861. replyp = __db_db_extentsize_1(&req, cl);
  862. if (replyp == NULL) {
  863. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  864. ret = DB_NOSERVER;
  865. goto out;
  866. }
  867. ret = replyp->status;
  868. out:
  869. return (ret);
  870. }
  872. int
  873. __dbcl_db_fd(dbp, fdp)
  874. DB * dbp;
  875. int * fdp;
  876. {
  877. DB_ENV *dbenv;
  879. dbenv = dbp->dbenv;
  880. COMPQUIET(fdp, 0);
  881. return (__dbcl_rpc_illegal(dbenv, "db_fd"));
  882. }
  884. int
  885. __dbcl_db_feedback(dbp, func0)
  886. DB * dbp;
  887. void (*func0) __P((DB *, int, int));
  888. {
  889. DB_ENV *dbenv;
  891. dbenv = dbp->dbenv;
  892. COMPQUIET(func0, 0);
  893. return (__dbcl_rpc_illegal(dbenv, "db_feedback"));
  894. }
  896. int
  897. __dbcl_db_flags(dbp, flags)
  898. DB * dbp;
  899. u_int32_t flags;
  900. {
  901. CLIENT *cl;
  902. __db_flags_msg req;
  903. static __db_flags_reply *replyp = NULL;
  904. int ret;
  905. DB_ENV *dbenv;
  907. ret = 0;
  908. dbenv = NULL;
  909. dbenv = dbp->dbenv;
  910. if (dbenv == NULL || dbenv->cl_handle == NULL) {
  911. __db_err(dbenv, "No server environment.");
  912. return (DB_NOSERVER);
  913. }
  915. if (replyp != NULL) {
  916. xdr_free((xdrproc_t)xdr___db_flags_reply, (void *)replyp);
  917. replyp = NULL;
  918. }
  919. cl = (CLIENT *)dbenv->cl_handle;
  921. if (dbp == NULL)
  922. req.dbpcl_id = 0;
  923. else
  924. req.dbpcl_id = dbp->cl_id;
  925. req.flags = flags;
  927. replyp = __db_db_flags_1(&req, cl);
  928. if (replyp == NULL) {
  929. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  930. ret = DB_NOSERVER;
  931. goto out;
  932. }
  933. ret = replyp->status;
  934. out:
  935. return (ret);
  936. }
  938. int
  939. __dbcl_db_get(dbp, txnp, key, data, flags)
  940. DB * dbp;
  941. DB_TXN * txnp;
  942. DBT * key;
  943. DBT * data;
  944. u_int32_t flags;
  945. {
  946. CLIENT *cl;
  947. __db_get_msg req;
  948. static __db_get_reply *replyp = NULL;
  949. int ret;
  950. DB_ENV *dbenv;
  952. ret = 0;
  953. dbenv = NULL;
  954. dbenv = dbp->dbenv;
  955. if (dbenv == NULL || dbenv->cl_handle == NULL) {
  956. __db_err(dbenv, "No server environment.");
  957. return (DB_NOSERVER);
  958. }
  960. if (replyp != NULL) {
  961. xdr_free((xdrproc_t)xdr___db_get_reply, (void *)replyp);
  962. replyp = NULL;
  963. }
  964. cl = (CLIENT *)dbenv->cl_handle;
  966. if (dbp == NULL)
  967. req.dbpcl_id = 0;
  968. else
  969. req.dbpcl_id = dbp->cl_id;
  970. if (txnp == NULL)
  971. req.txnpcl_id = 0;
  972. else
  973. req.txnpcl_id = txnp->txnid;
  974. req.keydlen = key->dlen;
  975. req.keydoff = key->doff;
  976. req.keyflags = key->flags;
  977. req.keydata.keydata_val = key->data;
  978. req.keydata.keydata_len = key->size;
  979. req.datadlen = data->dlen;
  980. req.datadoff = data->doff;
  981. req.dataflags = data->flags;
  982. req.datadata.datadata_val = data->data;
  983. req.datadata.datadata_len = data->size;
  984. req.flags = flags;
  986. replyp = __db_db_get_1(&req, cl);
  987. if (replyp == NULL) {
  988. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  989. ret = DB_NOSERVER;
  990. goto out;
  991. }
  992. return (__dbcl_db_get_ret(dbp, txnp, key, data, flags, replyp));
  993. out:
  994. return (ret);
  995. }
  997. int
  998. __dbcl_db_h_ffactor(dbp, ffactor)
  999. DB * dbp;
  1000. u_int32_t ffactor;
  1001. {
  1002. CLIENT *cl;
  1003. __db_h_ffactor_msg req;
  1004. static __db_h_ffactor_reply *replyp = NULL;
  1005. int ret;
  1006. DB_ENV *dbenv;
  1008. ret = 0;
  1009. dbenv = NULL;
  1010. dbenv = dbp->dbenv;
  1011. if (dbenv == NULL || dbenv->cl_handle == NULL) {
  1012. __db_err(dbenv, "No server environment.");
  1013. return (DB_NOSERVER);
  1014. }
  1016. if (replyp != NULL) {
  1017. xdr_free((xdrproc_t)xdr___db_h_ffactor_reply, (void *)replyp);
  1018. replyp = NULL;
  1019. }
  1020. cl = (CLIENT *)dbenv->cl_handle;
  1022. if (dbp == NULL)
  1023. req.dbpcl_id = 0;
  1024. else
  1025. req.dbpcl_id = dbp->cl_id;
  1026. req.ffactor = ffactor;
  1028. replyp = __db_db_h_ffactor_1(&req, cl);
  1029. if (replyp == NULL) {
  1030. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  1031. ret = DB_NOSERVER;
  1032. goto out;
  1033. }
  1034. ret = replyp->status;
  1035. out:
  1036. return (ret);
  1037. }
  1039. int
  1040. __dbcl_db_h_hash(dbp, func0)
  1041. DB * dbp;
  1042. u_int32_t (*func0) __P((DB *, const void *, u_int32_t));
  1043. {
  1044. DB_ENV *dbenv;
  1046. dbenv = dbp->dbenv;
  1047. COMPQUIET(func0, 0);
  1048. return (__dbcl_rpc_illegal(dbenv, "db_h_hash"));
  1049. }
  1051. int
  1052. __dbcl_db_h_nelem(dbp, nelem)
  1053. DB * dbp;
  1054. u_int32_t nelem;
  1055. {
  1056. CLIENT *cl;
  1057. __db_h_nelem_msg req;
  1058. static __db_h_nelem_reply *replyp = NULL;
  1059. int ret;
  1060. DB_ENV *dbenv;
  1062. ret = 0;
  1063. dbenv = NULL;
  1064. dbenv = dbp->dbenv;
  1065. if (dbenv == NULL || dbenv->cl_handle == NULL) {
  1066. __db_err(dbenv, "No server environment.");
  1067. return (DB_NOSERVER);
  1068. }
  1070. if (replyp != NULL) {
  1071. xdr_free((xdrproc_t)xdr___db_h_nelem_reply, (void *)replyp);
  1072. replyp = NULL;
  1073. }
  1074. cl = (CLIENT *)dbenv->cl_handle;
  1076. if (dbp == NULL)
  1077. req.dbpcl_id = 0;
  1078. else
  1079. req.dbpcl_id = dbp->cl_id;
  1080. req.nelem = nelem;
  1082. replyp = __db_db_h_nelem_1(&req, cl);
  1083. if (replyp == NULL) {
  1084. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  1085. ret = DB_NOSERVER;
  1086. goto out;
  1087. }
  1088. ret = replyp->status;
  1089. out:
  1090. return (ret);
  1091. }
  1093. int
  1094. __dbcl_db_key_range(dbp, txnp, key, range, flags)
  1095. DB * dbp;
  1096. DB_TXN * txnp;
  1097. DBT * key;
  1098. DB_KEY_RANGE * range;
  1099. u_int32_t flags;
  1100. {
  1101. CLIENT *cl;
  1102. __db_key_range_msg req;
  1103. static __db_key_range_reply *replyp = NULL;
  1104. int ret;
  1105. DB_ENV *dbenv;
  1107. ret = 0;
  1108. dbenv = NULL;
  1109. dbenv = dbp->dbenv;
  1110. if (dbenv == NULL || dbenv->cl_handle == NULL) {
  1111. __db_err(dbenv, "No server environment.");
  1112. return (DB_NOSERVER);
  1113. }
  1115. if (replyp != NULL) {
  1116. xdr_free((xdrproc_t)xdr___db_key_range_reply, (void *)replyp);
  1117. replyp = NULL;
  1118. }
  1119. cl = (CLIENT *)dbenv->cl_handle;
  1121. if (dbp == NULL)
  1122. req.dbpcl_id = 0;
  1123. else
  1124. req.dbpcl_id = dbp->cl_id;
  1125. if (txnp == NULL)
  1126. req.txnpcl_id = 0;
  1127. else
  1128. req.txnpcl_id = txnp->txnid;
  1129. req.keydlen = key->dlen;
  1130. req.keydoff = key->doff;
  1131. req.keyflags = key->flags;
  1132. req.keydata.keydata_val = key->data;
  1133. req.keydata.keydata_len = key->size;
  1134. req.flags = flags;
  1136. replyp = __db_db_key_range_1(&req, cl);
  1137. if (replyp == NULL) {
  1138. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  1139. ret = DB_NOSERVER;
  1140. goto out;
  1141. }
  1142. return (__dbcl_db_key_range_ret(dbp, txnp, key, range, flags, replyp));
  1143. out:
  1144. return (ret);
  1145. }
  1147. int
  1148. __dbcl_db_lorder(dbp, lorder)
  1149. DB * dbp;
  1150. int lorder;
  1151. {
  1152. CLIENT *cl;
  1153. __db_lorder_msg req;
  1154. static __db_lorder_reply *replyp = NULL;
  1155. int ret;
  1156. DB_ENV *dbenv;
  1158. ret = 0;
  1159. dbenv = NULL;
  1160. dbenv = dbp->dbenv;
  1161. if (dbenv == NULL || dbenv->cl_handle == NULL) {
  1162. __db_err(dbenv, "No server environment.");
  1163. return (DB_NOSERVER);
  1164. }
  1166. if (replyp != NULL) {
  1167. xdr_free((xdrproc_t)xdr___db_lorder_reply, (void *)replyp);
  1168. replyp = NULL;
  1169. }
  1170. cl = (CLIENT *)dbenv->cl_handle;
  1172. if (dbp == NULL)
  1173. req.dbpcl_id = 0;
  1174. else
  1175. req.dbpcl_id = dbp->cl_id;
  1176. req.lorder = lorder;
  1178. replyp = __db_db_lorder_1(&req, cl);
  1179. if (replyp == NULL) {
  1180. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  1181. ret = DB_NOSERVER;
  1182. goto out;
  1183. }
  1184. ret = replyp->status;
  1185. out:
  1186. return (ret);
  1187. }
  1189. int
  1190. __dbcl_db_malloc(dbp, func0)
  1191. DB * dbp;
  1192. void *(*func0) __P((size_t));
  1193. {
  1194. DB_ENV *dbenv;
  1196. dbenv = dbp->dbenv;
  1197. COMPQUIET(func0, 0);
  1198. return (__dbcl_rpc_illegal(dbenv, "db_malloc"));
  1199. }
  1201. int
  1202. __dbcl_db_open(dbp, name, subdb, type, flags, mode)
  1203. DB * dbp;
  1204. const char * name;
  1205. const char * subdb;
  1206. DBTYPE type;
  1207. u_int32_t flags;
  1208. int mode;
  1209. {
  1210. CLIENT *cl;
  1211. __db_open_msg req;
  1212. static __db_open_reply *replyp = NULL;
  1213. int ret;
  1214. DB_ENV *dbenv;
  1216. ret = 0;
  1217. dbenv = NULL;
  1218. dbenv = dbp->dbenv;
  1219. if (dbenv == NULL || dbenv->cl_handle == NULL) {
  1220. __db_err(dbenv, "No server environment.");
  1221. return (DB_NOSERVER);
  1222. }
  1224. if (replyp != NULL) {
  1225. xdr_free((xdrproc_t)xdr___db_open_reply, (void *)replyp);
  1226. replyp = NULL;
  1227. }
  1228. cl = (CLIENT *)dbenv->cl_handle;
  1230. if (dbp == NULL)
  1231. req.dbpcl_id = 0;
  1232. else
  1233. req.dbpcl_id = dbp->cl_id;
  1234. if (name == NULL)
  1235. req.name = "";
  1236. else
  1237. req.name = (char *)name;
  1238. if (subdb == NULL)
  1239. req.subdb = "";
  1240. else
  1241. req.subdb = (char *)subdb;
  1242. req.type = type;
  1243. req.flags = flags;
  1244. req.mode = mode;
  1246. replyp = __db_db_open_1(&req, cl);
  1247. if (replyp == NULL) {
  1248. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  1249. ret = DB_NOSERVER;
  1250. goto out;
  1251. }
  1252. return (__dbcl_db_open_ret(dbp, name, subdb, type, flags, mode, replyp));
  1253. out:
  1254. return (ret);
  1255. }
  1257. int
  1258. __dbcl_db_pagesize(dbp, pagesize)
  1259. DB * dbp;
  1260. u_int32_t pagesize;
  1261. {
  1262. CLIENT *cl;
  1263. __db_pagesize_msg req;
  1264. static __db_pagesize_reply *replyp = NULL;
  1265. int ret;
  1266. DB_ENV *dbenv;
  1268. ret = 0;
  1269. dbenv = NULL;
  1270. dbenv = dbp->dbenv;
  1271. if (dbenv == NULL || dbenv->cl_handle == NULL) {
  1272. __db_err(dbenv, "No server environment.");
  1273. return (DB_NOSERVER);
  1274. }
  1276. if (replyp != NULL) {
  1277. xdr_free((xdrproc_t)xdr___db_pagesize_reply, (void *)replyp);
  1278. replyp = NULL;
  1279. }
  1280. cl = (CLIENT *)dbenv->cl_handle;
  1282. if (dbp == NULL)
  1283. req.dbpcl_id = 0;
  1284. else
  1285. req.dbpcl_id = dbp->cl_id;
  1286. req.pagesize = pagesize;
  1288. replyp = __db_db_pagesize_1(&req, cl);
  1289. if (replyp == NULL) {
  1290. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  1291. ret = DB_NOSERVER;
  1292. goto out;
  1293. }
  1294. ret = replyp->status;
  1295. out:
  1296. return (ret);
  1297. }
  1299. int
  1300. __dbcl_db_panic(dbp, func0)
  1301. DB * dbp;
  1302. void (*func0) __P((DB_ENV *, int));
  1303. {
  1304. DB_ENV *dbenv;
  1306. dbenv = dbp->dbenv;
  1307. COMPQUIET(func0, 0);
  1308. return (__dbcl_rpc_illegal(dbenv, "db_panic"));
  1309. }
  1311. int
  1312. __dbcl_db_put(dbp, txnp, key, data, flags)
  1313. DB * dbp;
  1314. DB_TXN * txnp;
  1315. DBT * key;
  1316. DBT * data;
  1317. u_int32_t flags;
  1318. {
  1319. CLIENT *cl;
  1320. __db_put_msg req;
  1321. static __db_put_reply *replyp = NULL;
  1322. int ret;
  1323. DB_ENV *dbenv;
  1325. ret = 0;
  1326. dbenv = NULL;
  1327. dbenv = dbp->dbenv;
  1328. if (dbenv == NULL || dbenv->cl_handle == NULL) {
  1329. __db_err(dbenv, "No server environment.");
  1330. return (DB_NOSERVER);
  1331. }
  1333. if (replyp != NULL) {
  1334. xdr_free((xdrproc_t)xdr___db_put_reply, (void *)replyp);
  1335. replyp = NULL;
  1336. }
  1337. cl = (CLIENT *)dbenv->cl_handle;
  1339. if (dbp == NULL)
  1340. req.dbpcl_id = 0;
  1341. else
  1342. req.dbpcl_id = dbp->cl_id;
  1343. if (txnp == NULL)
  1344. req.txnpcl_id = 0;
  1345. else
  1346. req.txnpcl_id = txnp->txnid;
  1347. req.keydlen = key->dlen;
  1348. req.keydoff = key->doff;
  1349. req.keyflags = key->flags;
  1350. req.keydata.keydata_val = key->data;
  1351. req.keydata.keydata_len = key->size;
  1352. req.datadlen = data->dlen;
  1353. req.datadoff = data->doff;
  1354. req.dataflags = data->flags;
  1355. req.datadata.datadata_val = data->data;
  1356. req.datadata.datadata_len = data->size;
  1357. req.flags = flags;
  1359. replyp = __db_db_put_1(&req, cl);
  1360. if (replyp == NULL) {
  1361. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  1362. ret = DB_NOSERVER;
  1363. goto out;
  1364. }
  1365. return (__dbcl_db_put_ret(dbp, txnp, key, data, flags, replyp));
  1366. out:
  1367. return (ret);
  1368. }
  1370. int
  1371. __dbcl_db_realloc(dbp, func0)
  1372. DB * dbp;
  1373. void *(*func0) __P((void *, size_t));
  1374. {
  1375. DB_ENV *dbenv;
  1377. dbenv = dbp->dbenv;
  1378. COMPQUIET(func0, 0);
  1379. return (__dbcl_rpc_illegal(dbenv, "db_realloc"));
  1380. }
  1382. int
  1383. __dbcl_db_re_delim(dbp, delim)
  1384. DB * dbp;
  1385. int delim;
  1386. {
  1387. CLIENT *cl;
  1388. __db_re_delim_msg req;
  1389. static __db_re_delim_reply *replyp = NULL;
  1390. int ret;
  1391. DB_ENV *dbenv;
  1393. ret = 0;
  1394. dbenv = NULL;
  1395. dbenv = dbp->dbenv;
  1396. if (dbenv == NULL || dbenv->cl_handle == NULL) {
  1397. __db_err(dbenv, "No server environment.");
  1398. return (DB_NOSERVER);
  1399. }
  1401. if (replyp != NULL) {
  1402. xdr_free((xdrproc_t)xdr___db_re_delim_reply, (void *)replyp);
  1403. replyp = NULL;
  1404. }
  1405. cl = (CLIENT *)dbenv->cl_handle;
  1407. if (dbp == NULL)
  1408. req.dbpcl_id = 0;
  1409. else
  1410. req.dbpcl_id = dbp->cl_id;
  1411. req.delim = delim;
  1413. replyp = __db_db_re_delim_1(&req, cl);
  1414. if (replyp == NULL) {
  1415. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  1416. ret = DB_NOSERVER;
  1417. goto out;
  1418. }
  1419. ret = replyp->status;
  1420. out:
  1421. return (ret);
  1422. }
  1424. int
  1425. __dbcl_db_re_len(dbp, len)
  1426. DB * dbp;
  1427. u_int32_t len;
  1428. {
  1429. CLIENT *cl;
  1430. __db_re_len_msg req;
  1431. static __db_re_len_reply *replyp = NULL;
  1432. int ret;
  1433. DB_ENV *dbenv;
  1435. ret = 0;
  1436. dbenv = NULL;
  1437. dbenv = dbp->dbenv;
  1438. if (dbenv == NULL || dbenv->cl_handle == NULL) {
  1439. __db_err(dbenv, "No server environment.");
  1440. return (DB_NOSERVER);
  1441. }
  1443. if (replyp != NULL) {
  1444. xdr_free((xdrproc_t)xdr___db_re_len_reply, (void *)replyp);
  1445. replyp = NULL;
  1446. }
  1447. cl = (CLIENT *)dbenv->cl_handle;
  1449. if (dbp == NULL)
  1450. req.dbpcl_id = 0;
  1451. else
  1452. req.dbpcl_id = dbp->cl_id;
  1453. req.len = len;
  1455. replyp = __db_db_re_len_1(&req, cl);
  1456. if (replyp == NULL) {
  1457. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  1458. ret = DB_NOSERVER;
  1459. goto out;
  1460. }
  1461. ret = replyp->status;
  1462. out:
  1463. return (ret);
  1464. }
  1466. int
  1467. __dbcl_db_re_pad(dbp, pad)
  1468. DB * dbp;
  1469. int pad;
  1470. {
  1471. CLIENT *cl;
  1472. __db_re_pad_msg req;
  1473. static __db_re_pad_reply *replyp = NULL;
  1474. int ret;
  1475. DB_ENV *dbenv;
  1477. ret = 0;
  1478. dbenv = NULL;
  1479. dbenv = dbp->dbenv;
  1480. if (dbenv == NULL || dbenv->cl_handle == NULL) {
  1481. __db_err(dbenv, "No server environment.");
  1482. return (DB_NOSERVER);
  1483. }
  1485. if (replyp != NULL) {
  1486. xdr_free((xdrproc_t)xdr___db_re_pad_reply, (void *)replyp);
  1487. replyp = NULL;
  1488. }
  1489. cl = (CLIENT *)dbenv->cl_handle;
  1491. if (dbp == NULL)
  1492. req.dbpcl_id = 0;
  1493. else
  1494. req.dbpcl_id = dbp->cl_id;
  1495. req.pad = pad;
  1497. replyp = __db_db_re_pad_1(&req, cl);
  1498. if (replyp == NULL) {
  1499. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  1500. ret = DB_NOSERVER;
  1501. goto out;
  1502. }
  1503. ret = replyp->status;
  1504. out:
  1505. return (ret);
  1506. }
  1508. int
  1509. __dbcl_db_re_source(dbp, re_source)
  1510. DB * dbp;
  1511. const char * re_source;
  1512. {
  1513. DB_ENV *dbenv;
  1515. dbenv = dbp->dbenv;
  1516. COMPQUIET(re_source, NULL);
  1517. return (__dbcl_rpc_illegal(dbenv, "db_re_source"));
  1518. }
  1520. int
  1521. __dbcl_db_remove(dbp, name, subdb, flags)
  1522. DB * dbp;
  1523. const char * name;
  1524. const char * subdb;
  1525. u_int32_t flags;
  1526. {
  1527. CLIENT *cl;
  1528. __db_remove_msg req;
  1529. static __db_remove_reply *replyp = NULL;
  1530. int ret;
  1531. DB_ENV *dbenv;
  1533. ret = 0;
  1534. dbenv = NULL;
  1535. dbenv = dbp->dbenv;
  1536. if (dbenv == NULL || dbenv->cl_handle == NULL) {
  1537. __db_err(dbenv, "No server environment.");
  1538. return (DB_NOSERVER);
  1539. }
  1541. if (replyp != NULL) {
  1542. xdr_free((xdrproc_t)xdr___db_remove_reply, (void *)replyp);
  1543. replyp = NULL;
  1544. }
  1545. cl = (CLIENT *)dbenv->cl_handle;
  1547. if (dbp == NULL)
  1548. req.dbpcl_id = 0;
  1549. else
  1550. req.dbpcl_id = dbp->cl_id;
  1551. if (name == NULL)
  1552. req.name = "";
  1553. else
  1554. req.name = (char *)name;
  1555. if (subdb == NULL)
  1556. req.subdb = "";
  1557. else
  1558. req.subdb = (char *)subdb;
  1559. req.flags = flags;
  1561. replyp = __db_db_remove_1(&req, cl);
  1562. if (replyp == NULL) {
  1563. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  1564. ret = DB_NOSERVER;
  1565. goto out;
  1566. }
  1567. return (__dbcl_db_remove_ret(dbp, name, subdb, flags, replyp));
  1568. out:
  1569. return (ret);
  1570. }
  1572. int
  1573. __dbcl_db_rename(dbp, name, subdb, newname, flags)
  1574. DB * dbp;
  1575. const char * name;
  1576. const char * subdb;
  1577. const char * newname;
  1578. u_int32_t flags;
  1579. {
  1580. CLIENT *cl;
  1581. __db_rename_msg req;
  1582. static __db_rename_reply *replyp = NULL;
  1583. int ret;
  1584. DB_ENV *dbenv;
  1586. ret = 0;
  1587. dbenv = NULL;
  1588. dbenv = dbp->dbenv;
  1589. if (dbenv == NULL || dbenv->cl_handle == NULL) {
  1590. __db_err(dbenv, "No server environment.");
  1591. return (DB_NOSERVER);
  1592. }
  1594. if (replyp != NULL) {
  1595. xdr_free((xdrproc_t)xdr___db_rename_reply, (void *)replyp);
  1596. replyp = NULL;
  1597. }
  1598. cl = (CLIENT *)dbenv->cl_handle;
  1600. if (dbp == NULL)
  1601. req.dbpcl_id = 0;
  1602. else
  1603. req.dbpcl_id = dbp->cl_id;
  1604. if (name == NULL)
  1605. req.name = "";
  1606. else
  1607. req.name = (char *)name;
  1608. if (subdb == NULL)
  1609. req.subdb = "";
  1610. else
  1611. req.subdb = (char *)subdb;
  1612. if (newname == NULL)
  1613. req.newname = "";
  1614. else
  1615. req.newname = (char *)newname;
  1616. req.flags = flags;
  1618. replyp = __db_db_rename_1(&req, cl);
  1619. if (replyp == NULL) {
  1620. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  1621. ret = DB_NOSERVER;
  1622. goto out;
  1623. }
  1624. return (__dbcl_db_rename_ret(dbp, name, subdb, newname, flags, replyp));
  1625. out:
  1626. return (ret);
  1627. }
  1629. int
  1630. __dbcl_db_stat(dbp, sp, func0, flags)
  1631. DB * dbp;
  1632. void * sp;
  1633. void *(*func0) __P((size_t));
  1634. u_int32_t flags;
  1635. {
  1636. CLIENT *cl;
  1637. __db_stat_msg req;
  1638. static __db_stat_reply *replyp = NULL;
  1639. int ret;
  1640. DB_ENV *dbenv;
  1642. ret = 0;
  1643. dbenv = NULL;
  1644. dbenv = dbp->dbenv;
  1645. if (dbenv == NULL || dbenv->cl_handle == NULL) {
  1646. __db_err(dbenv, "No server environment.");
  1647. return (DB_NOSERVER);
  1648. }
  1650. if (replyp != NULL) {
  1651. xdr_free((xdrproc_t)xdr___db_stat_reply, (void *)replyp);
  1652. replyp = NULL;
  1653. }
  1654. cl = (CLIENT *)dbenv->cl_handle;
  1656. if (func0 != NULL) {
  1657. __db_err(sp, "User functions not supported in RPC.");
  1658. return (EINVAL);
  1659. }
  1660. if (dbp == NULL)
  1661. req.dbpcl_id = 0;
  1662. else
  1663. req.dbpcl_id = dbp->cl_id;
  1664. req.flags = flags;
  1666. replyp = __db_db_stat_1(&req, cl);
  1667. if (replyp == NULL) {
  1668. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  1669. ret = DB_NOSERVER;
  1670. goto out;
  1671. }
  1672. return (__dbcl_db_stat_ret(dbp, sp, func0, flags, replyp));
  1673. out:
  1674. return (ret);
  1675. }
  1677. int
  1678. __dbcl_db_swapped(dbp)
  1679. DB * dbp;
  1680. {
  1681. CLIENT *cl;
  1682. __db_swapped_msg req;
  1683. static __db_swapped_reply *replyp = NULL;
  1684. int ret;
  1685. DB_ENV *dbenv;
  1687. ret = 0;
  1688. dbenv = NULL;
  1689. dbenv = dbp->dbenv;
  1690. if (dbenv == NULL || dbenv->cl_handle == NULL) {
  1691. __db_err(dbenv, "No server environment.");
  1692. return (DB_NOSERVER);
  1693. }
  1695. if (replyp != NULL) {
  1696. xdr_free((xdrproc_t)xdr___db_swapped_reply, (void *)replyp);
  1697. replyp = NULL;
  1698. }
  1699. cl = (CLIENT *)dbenv->cl_handle;
  1701. if (dbp == NULL)
  1702. req.dbpcl_id = 0;
  1703. else
  1704. req.dbpcl_id = dbp->cl_id;
  1706. replyp = __db_db_swapped_1(&req, cl);
  1707. if (replyp == NULL) {
  1708. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  1709. ret = DB_NOSERVER;
  1710. goto out;
  1711. }
  1712. ret = replyp->status;
  1713. out:
  1714. return (ret);
  1715. }
  1717. int
  1718. __dbcl_db_sync(dbp, flags)
  1719. DB * dbp;
  1720. u_int32_t flags;
  1721. {
  1722. CLIENT *cl;
  1723. __db_sync_msg req;
  1724. static __db_sync_reply *replyp = NULL;
  1725. int ret;
  1726. DB_ENV *dbenv;
  1728. ret = 0;
  1729. dbenv = NULL;
  1730. dbenv = dbp->dbenv;
  1731. if (dbenv == NULL || dbenv->cl_handle == NULL) {
  1732. __db_err(dbenv, "No server environment.");
  1733. return (DB_NOSERVER);
  1734. }
  1736. if (replyp != NULL) {
  1737. xdr_free((xdrproc_t)xdr___db_sync_reply, (void *)replyp);
  1738. replyp = NULL;
  1739. }
  1740. cl = (CLIENT *)dbenv->cl_handle;
  1742. if (dbp == NULL)
  1743. req.dbpcl_id = 0;
  1744. else
  1745. req.dbpcl_id = dbp->cl_id;
  1746. req.flags = flags;
  1748. replyp = __db_db_sync_1(&req, cl);
  1749. if (replyp == NULL) {
  1750. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  1751. ret = DB_NOSERVER;
  1752. goto out;
  1753. }
  1754. ret = replyp->status;
  1755. out:
  1756. return (ret);
  1757. }
  1759. int
  1760. __dbcl_db_upgrade(dbp, fname, flags)
  1761. DB * dbp;
  1762. const char * fname;
  1763. u_int32_t flags;
  1764. {
  1765. DB_ENV *dbenv;
  1767. dbenv = dbp->dbenv;
  1768. COMPQUIET(fname, NULL);
  1769. COMPQUIET(flags, 0);
  1770. return (__dbcl_rpc_illegal(dbenv, "db_upgrade"));
  1771. }
  1773. int
  1774. __dbcl_db_cursor(dbp, txnp, dbcpp, flags)
  1775. DB * dbp;
  1776. DB_TXN * txnp;
  1777. DBC ** dbcpp;
  1778. u_int32_t flags;
  1779. {
  1780. CLIENT *cl;
  1781. __db_cursor_msg req;
  1782. static __db_cursor_reply *replyp = NULL;
  1783. int ret;
  1784. DB_ENV *dbenv;
  1786. ret = 0;
  1787. dbenv = NULL;
  1788. dbenv = dbp->dbenv;
  1789. if (dbenv == NULL || dbenv->cl_handle == NULL) {
  1790. __db_err(dbenv, "No server environment.");
  1791. return (DB_NOSERVER);
  1792. }
  1794. if (replyp != NULL) {
  1795. xdr_free((xdrproc_t)xdr___db_cursor_reply, (void *)replyp);
  1796. replyp = NULL;
  1797. }
  1798. cl = (CLIENT *)dbenv->cl_handle;
  1800. if (dbp == NULL)
  1801. req.dbpcl_id = 0;
  1802. else
  1803. req.dbpcl_id = dbp->cl_id;
  1804. if (txnp == NULL)
  1805. req.txnpcl_id = 0;
  1806. else
  1807. req.txnpcl_id = txnp->txnid;
  1808. req.flags = flags;
  1810. replyp = __db_db_cursor_1(&req, cl);
  1811. if (replyp == NULL) {
  1812. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  1813. ret = DB_NOSERVER;
  1814. goto out;
  1815. }
  1816. return (__dbcl_db_cursor_ret(dbp, txnp, dbcpp, flags, replyp));
  1817. out:
  1818. return (ret);
  1819. }
  1821. static int __dbcl_db_join_curslist __P((__db_join_curslist **, DBC **));
  1822. static void __dbcl_db_join_cursfree __P((__db_join_curslist **));
  1823. int
  1824. __dbcl_db_join(dbp, curs, dbcp, flags)
  1825. DB * dbp;
  1826. DBC ** curs;
  1827. DBC ** dbcp;
  1828. u_int32_t flags;
  1829. {
  1830. CLIENT *cl;
  1831. __db_join_msg req;
  1832. static __db_join_reply *replyp = NULL;
  1833. int ret;
  1834. DB_ENV *dbenv;
  1836. ret = 0;
  1837. dbenv = NULL;
  1838. dbenv = dbp->dbenv;
  1839. if (dbenv == NULL || dbenv->cl_handle == NULL) {
  1840. __db_err(dbenv, "No server environment.");
  1841. return (DB_NOSERVER);
  1842. }
  1844. if (replyp != NULL) {
  1845. xdr_free((xdrproc_t)xdr___db_join_reply, (void *)replyp);
  1846. replyp = NULL;
  1847. }
  1848. cl = (CLIENT *)dbenv->cl_handle;
  1850. if (dbp == NULL)
  1851. req.dbpcl_id = 0;
  1852. else
  1853. req.dbpcl_id = dbp->cl_id;
  1854. if ((ret = __dbcl_db_join_curslist(&req.curslist, curs)) != 0)
  1855. goto out;
  1856. req.flags = flags;
  1858. replyp = __db_db_join_1(&req, cl);
  1859. if (replyp == NULL) {
  1860. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  1861. ret = DB_NOSERVER;
  1862. goto out;
  1863. }
  1864. __dbcl_db_join_cursfree(&req.curslist);
  1865. return (__dbcl_db_join_ret(dbp, curs, dbcp, flags, replyp));
  1866. out:
  1867. __dbcl_db_join_cursfree(&req.curslist);
  1868. return (ret);
  1869. }
  1871. int
  1872. __dbcl_db_join_curslist(locp, pp)
  1873. __db_join_curslist **locp;
  1874. DBC ** pp;
  1875. {
  1876. DBC ** p;
  1877. u_int32_t *q;
  1878. int ret;
  1879. __db_join_curslist *nl, **nlp;
  1881. *locp = NULL;
  1882. if (pp == NULL)
  1883. return (0);
  1884. nlp = locp;
  1885. for (p = pp; *p != 0; p++) {
  1886. if ((ret = __os_malloc(NULL, sizeof(*nl), NULL, nlp)) != 0)
  1887. goto out;
  1888. nl = *nlp;
  1889. nl->next = NULL;
  1890. nl->ent.ent_val = NULL;
  1891. nl->ent.ent_len = 0;
  1892. if ((ret = __os_malloc(NULL, sizeof(u_int32_t), NULL, &nl->ent.ent_val)) != 0)
  1893. goto out;
  1894. q = (u_int32_t *)nl->ent.ent_val;
  1895. *q = (*p)->cl_id;
  1896. nl->ent.ent_len = sizeof(u_int32_t);
  1897. nlp = &nl->next;
  1898. }
  1899. return (0);
  1900. out:
  1901. __dbcl_db_join_cursfree(locp);
  1902. return (ret);
  1903. }
  1905. void
  1906. __dbcl_db_join_cursfree(locp)
  1907. __db_join_curslist **locp;
  1908. {
  1909. __db_join_curslist *nl, *nl1;
  1911. if (locp == NULL)
  1912. return;
  1913. for (nl = *locp; nl != NULL; nl = nl1) {
  1914. nl1 = nl->next;
  1915. if (nl->ent.ent_val)
  1916. __os_free(nl->ent.ent_val, nl->ent.ent_len);
  1917. __os_free(nl, sizeof(*nl));
  1918. }
  1919. }
  1921. int
  1922. __dbcl_dbc_close(dbc)
  1923. DBC * dbc;
  1924. {
  1925. CLIENT *cl;
  1926. __dbc_close_msg req;
  1927. static __dbc_close_reply *replyp = NULL;
  1928. int ret;
  1929. DB_ENV *dbenv;
  1931. ret = 0;
  1932. dbenv = NULL;
  1933. dbenv = dbc->dbp->dbenv;
  1934. if (dbenv == NULL || dbenv->cl_handle == NULL) {
  1935. __db_err(dbenv, "No server environment.");
  1936. return (DB_NOSERVER);
  1937. }
  1939. if (replyp != NULL) {
  1940. xdr_free((xdrproc_t)xdr___dbc_close_reply, (void *)replyp);
  1941. replyp = NULL;
  1942. }
  1943. cl = (CLIENT *)dbenv->cl_handle;
  1945. if (dbc == NULL)
  1946. req.dbccl_id = 0;
  1947. else
  1948. req.dbccl_id = dbc->cl_id;
  1950. replyp = __db_dbc_close_1(&req, cl);
  1951. if (replyp == NULL) {
  1952. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  1953. ret = DB_NOSERVER;
  1954. goto out;
  1955. }
  1956. return (__dbcl_dbc_close_ret(dbc, replyp));
  1957. out:
  1958. return (ret);
  1959. }
  1961. int
  1962. __dbcl_dbc_count(dbc, countp, flags)
  1963. DBC * dbc;
  1964. db_recno_t * countp;
  1965. u_int32_t flags;
  1966. {
  1967. CLIENT *cl;
  1968. __dbc_count_msg req;
  1969. static __dbc_count_reply *replyp = NULL;
  1970. int ret;
  1971. DB_ENV *dbenv;
  1973. ret = 0;
  1974. dbenv = NULL;
  1975. dbenv = dbc->dbp->dbenv;
  1976. if (dbenv == NULL || dbenv->cl_handle == NULL) {
  1977. __db_err(dbenv, "No server environment.");
  1978. return (DB_NOSERVER);
  1979. }
  1981. if (replyp != NULL) {
  1982. xdr_free((xdrproc_t)xdr___dbc_count_reply, (void *)replyp);
  1983. replyp = NULL;
  1984. }
  1985. cl = (CLIENT *)dbenv->cl_handle;
  1987. if (dbc == NULL)
  1988. req.dbccl_id = 0;
  1989. else
  1990. req.dbccl_id = dbc->cl_id;
  1991. req.flags = flags;
  1993. replyp = __db_dbc_count_1(&req, cl);
  1994. if (replyp == NULL) {
  1995. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  1996. ret = DB_NOSERVER;
  1997. goto out;
  1998. }
  1999. return (__dbcl_dbc_count_ret(dbc, countp, flags, replyp));
  2000. out:
  2001. return (ret);
  2002. }
  2004. int
  2005. __dbcl_dbc_del(dbc, flags)
  2006. DBC * dbc;
  2007. u_int32_t flags;
  2008. {
  2009. CLIENT *cl;
  2010. __dbc_del_msg req;
  2011. static __dbc_del_reply *replyp = NULL;
  2012. int ret;
  2013. DB_ENV *dbenv;
  2015. ret = 0;
  2016. dbenv = NULL;
  2017. dbenv = dbc->dbp->dbenv;
  2018. if (dbenv == NULL || dbenv->cl_handle == NULL) {
  2019. __db_err(dbenv, "No server environment.");
  2020. return (DB_NOSERVER);
  2021. }
  2023. if (replyp != NULL) {
  2024. xdr_free((xdrproc_t)xdr___dbc_del_reply, (void *)replyp);
  2025. replyp = NULL;
  2026. }
  2027. cl = (CLIENT *)dbenv->cl_handle;
  2029. if (dbc == NULL)
  2030. req.dbccl_id = 0;
  2031. else
  2032. req.dbccl_id = dbc->cl_id;
  2033. req.flags = flags;
  2035. replyp = __db_dbc_del_1(&req, cl);
  2036. if (replyp == NULL) {
  2037. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  2038. ret = DB_NOSERVER;
  2039. goto out;
  2040. }
  2041. ret = replyp->status;
  2042. out:
  2043. return (ret);
  2044. }
  2046. int
  2047. __dbcl_dbc_dup(dbc, dbcp, flags)
  2048. DBC * dbc;
  2049. DBC ** dbcp;
  2050. u_int32_t flags;
  2051. {
  2052. CLIENT *cl;
  2053. __dbc_dup_msg req;
  2054. static __dbc_dup_reply *replyp = NULL;
  2055. int ret;
  2056. DB_ENV *dbenv;
  2058. ret = 0;
  2059. dbenv = NULL;
  2060. dbenv = dbc->dbp->dbenv;
  2061. if (dbenv == NULL || dbenv->cl_handle == NULL) {
  2062. __db_err(dbenv, "No server environment.");
  2063. return (DB_NOSERVER);
  2064. }
  2066. if (replyp != NULL) {
  2067. xdr_free((xdrproc_t)xdr___dbc_dup_reply, (void *)replyp);
  2068. replyp = NULL;
  2069. }
  2070. cl = (CLIENT *)dbenv->cl_handle;
  2072. if (dbc == NULL)
  2073. req.dbccl_id = 0;
  2074. else
  2075. req.dbccl_id = dbc->cl_id;
  2076. req.flags = flags;
  2078. replyp = __db_dbc_dup_1(&req, cl);
  2079. if (replyp == NULL) {
  2080. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  2081. ret = DB_NOSERVER;
  2082. goto out;
  2083. }
  2084. return (__dbcl_dbc_dup_ret(dbc, dbcp, flags, replyp));
  2085. out:
  2086. return (ret);
  2087. }
  2089. int
  2090. __dbcl_dbc_get(dbc, key, data, flags)
  2091. DBC * dbc;
  2092. DBT * key;
  2093. DBT * data;
  2094. u_int32_t flags;
  2095. {
  2096. CLIENT *cl;
  2097. __dbc_get_msg req;
  2098. static __dbc_get_reply *replyp = NULL;
  2099. int ret;
  2100. DB_ENV *dbenv;
  2102. ret = 0;
  2103. dbenv = NULL;
  2104. dbenv = dbc->dbp->dbenv;
  2105. if (dbenv == NULL || dbenv->cl_handle == NULL) {
  2106. __db_err(dbenv, "No server environment.");
  2107. return (DB_NOSERVER);
  2108. }
  2110. if (replyp != NULL) {
  2111. xdr_free((xdrproc_t)xdr___dbc_get_reply, (void *)replyp);
  2112. replyp = NULL;
  2113. }
  2114. cl = (CLIENT *)dbenv->cl_handle;
  2116. if (dbc == NULL)
  2117. req.dbccl_id = 0;
  2118. else
  2119. req.dbccl_id = dbc->cl_id;
  2120. req.keydlen = key->dlen;
  2121. req.keydoff = key->doff;
  2122. req.keyflags = key->flags;
  2123. req.keydata.keydata_val = key->data;
  2124. req.keydata.keydata_len = key->size;
  2125. req.datadlen = data->dlen;
  2126. req.datadoff = data->doff;
  2127. req.dataflags = data->flags;
  2128. req.datadata.datadata_val = data->data;
  2129. req.datadata.datadata_len = data->size;
  2130. req.flags = flags;
  2132. replyp = __db_dbc_get_1(&req, cl);
  2133. if (replyp == NULL) {
  2134. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  2135. ret = DB_NOSERVER;
  2136. goto out;
  2137. }
  2138. return (__dbcl_dbc_get_ret(dbc, key, data, flags, replyp));
  2139. out:
  2140. return (ret);
  2141. }
  2143. int
  2144. __dbcl_dbc_put(dbc, key, data, flags)
  2145. DBC * dbc;
  2146. DBT * key;
  2147. DBT * data;
  2148. u_int32_t flags;
  2149. {
  2150. CLIENT *cl;
  2151. __dbc_put_msg req;
  2152. static __dbc_put_reply *replyp = NULL;
  2153. int ret;
  2154. DB_ENV *dbenv;
  2156. ret = 0;
  2157. dbenv = NULL;
  2158. dbenv = dbc->dbp->dbenv;
  2159. if (dbenv == NULL || dbenv->cl_handle == NULL) {
  2160. __db_err(dbenv, "No server environment.");
  2161. return (DB_NOSERVER);
  2162. }
  2164. if (replyp != NULL) {
  2165. xdr_free((xdrproc_t)xdr___dbc_put_reply, (void *)replyp);
  2166. replyp = NULL;
  2167. }
  2168. cl = (CLIENT *)dbenv->cl_handle;
  2170. if (dbc == NULL)
  2171. req.dbccl_id = 0;
  2172. else
  2173. req.dbccl_id = dbc->cl_id;
  2174. req.keydlen = key->dlen;
  2175. req.keydoff = key->doff;
  2176. req.keyflags = key->flags;
  2177. req.keydata.keydata_val = key->data;
  2178. req.keydata.keydata_len = key->size;
  2179. req.datadlen = data->dlen;
  2180. req.datadoff = data->doff;
  2181. req.dataflags = data->flags;
  2182. req.datadata.datadata_val = data->data;
  2183. req.datadata.datadata_len = data->size;
  2184. req.flags = flags;
  2186. replyp = __db_dbc_put_1(&req, cl);
  2187. if (replyp == NULL) {
  2188. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  2189. ret = DB_NOSERVER;
  2190. goto out;
  2191. }
  2192. return (__dbcl_dbc_put_ret(dbc, key, data, flags, replyp));
  2193. out:
  2194. return (ret);
  2195. }
  2197. int
  2198. __dbcl_lock_detect(dbenv, flags, atype, aborted)
  2199. DB_ENV * dbenv;
  2200. u_int32_t flags;
  2201. u_int32_t atype;
  2202. int * aborted;
  2203. {
  2204. COMPQUIET(flags, 0);
  2205. COMPQUIET(atype, 0);
  2206. COMPQUIET(aborted, 0);
  2207. return (__dbcl_rpc_illegal(dbenv, "lock_detect"));
  2208. }
  2210. int
  2211. __dbcl_lock_get(dbenv, locker, flags, obj, mode, lock)
  2212. DB_ENV * dbenv;
  2213. u_int32_t locker;
  2214. u_int32_t flags;
  2215. const DBT * obj;
  2216. db_lockmode_t mode;
  2217. DB_LOCK * lock;
  2218. {
  2219. COMPQUIET(locker, 0);
  2220. COMPQUIET(flags, 0);
  2221. COMPQUIET(obj, NULL);
  2222. COMPQUIET(mode, 0);
  2223. COMPQUIET(lock, 0);
  2224. return (__dbcl_rpc_illegal(dbenv, "lock_get"));
  2225. }
  2227. int
  2228. __dbcl_lock_id(dbenv, idp)
  2229. DB_ENV * dbenv;
  2230. u_int32_t * idp;
  2231. {
  2232. COMPQUIET(idp, 0);
  2233. return (__dbcl_rpc_illegal(dbenv, "lock_id"));
  2234. }
  2236. int
  2237. __dbcl_lock_put(dbenv, lock)
  2238. DB_ENV * dbenv;
  2239. DB_LOCK * lock;
  2240. {
  2241. COMPQUIET(lock, 0);
  2242. return (__dbcl_rpc_illegal(dbenv, "lock_put"));
  2243. }
  2245. int
  2246. __dbcl_lock_stat(dbenv, statp, func0)
  2247. DB_ENV * dbenv;
  2248. DB_LOCK_STAT ** statp;
  2249. void *(*func0) __P((size_t));
  2250. {
  2251. COMPQUIET(statp, 0);
  2252. COMPQUIET(func0, 0);
  2253. return (__dbcl_rpc_illegal(dbenv, "lock_stat"));
  2254. }
  2256. int
  2257. __dbcl_lock_vec(dbenv, locker, flags, list, nlist, elistp)
  2258. DB_ENV * dbenv;
  2259. u_int32_t locker;
  2260. u_int32_t flags;
  2261. DB_LOCKREQ * list;
  2262. int nlist;
  2263. DB_LOCKREQ ** elistp;
  2264. {
  2265. COMPQUIET(locker, 0);
  2266. COMPQUIET(flags, 0);
  2267. COMPQUIET(list, 0);
  2268. COMPQUIET(nlist, 0);
  2269. COMPQUIET(elistp, 0);
  2270. return (__dbcl_rpc_illegal(dbenv, "lock_vec"));
  2271. }
  2273. int
  2274. __dbcl_log_archive(dbenv, listp, flags, func0)
  2275. DB_ENV * dbenv;
  2276. char *** listp;
  2277. u_int32_t flags;
  2278. void *(*func0) __P((size_t));
  2279. {
  2280. COMPQUIET(listp, 0);
  2281. COMPQUIET(flags, 0);
  2282. COMPQUIET(func0, 0);
  2283. return (__dbcl_rpc_illegal(dbenv, "log_archive"));
  2284. }
  2286. int
  2287. __dbcl_log_file(dbenv, lsn, namep, len)
  2288. DB_ENV * dbenv;
  2289. const DB_LSN * lsn;
  2290. char * namep;
  2291. size_t len;
  2292. {
  2293. COMPQUIET(lsn, NULL);
  2294. COMPQUIET(namep, NULL);
  2295. COMPQUIET(len, 0);
  2296. return (__dbcl_rpc_illegal(dbenv, "log_file"));
  2297. }
  2299. int
  2300. __dbcl_log_flush(dbenv, lsn)
  2301. DB_ENV * dbenv;
  2302. const DB_LSN * lsn;
  2303. {
  2304. COMPQUIET(lsn, NULL);
  2305. return (__dbcl_rpc_illegal(dbenv, "log_flush"));
  2306. }
  2308. int
  2309. __dbcl_log_get(dbenv, lsn, data, flags)
  2310. DB_ENV * dbenv;
  2311. DB_LSN * lsn;
  2312. DBT * data;
  2313. u_int32_t flags;
  2314. {
  2315. COMPQUIET(lsn, 0);
  2316. COMPQUIET(data, NULL);
  2317. COMPQUIET(flags, 0);
  2318. return (__dbcl_rpc_illegal(dbenv, "log_get"));
  2319. }
  2321. int
  2322. __dbcl_log_put(dbenv, lsn, data, flags)
  2323. DB_ENV * dbenv;
  2324. DB_LSN * lsn;
  2325. const DBT * data;
  2326. u_int32_t flags;
  2327. {
  2328. COMPQUIET(lsn, 0);
  2329. COMPQUIET(data, NULL);
  2330. COMPQUIET(flags, 0);
  2331. return (__dbcl_rpc_illegal(dbenv, "log_put"));
  2332. }
  2334. int
  2335. __dbcl_log_register(dbenv, dbp, namep)
  2336. DB_ENV * dbenv;
  2337. DB * dbp;
  2338. const char * namep;
  2339. {
  2340. COMPQUIET(dbp, 0);
  2341. COMPQUIET(namep, NULL);
  2342. return (__dbcl_rpc_illegal(dbenv, "log_register"));
  2343. }
  2345. int
  2346. __dbcl_log_stat(dbenv, statp, func0)
  2347. DB_ENV * dbenv;
  2348. DB_LOG_STAT ** statp;
  2349. void *(*func0) __P((size_t));
  2350. {
  2351. COMPQUIET(statp, 0);
  2352. COMPQUIET(func0, 0);
  2353. return (__dbcl_rpc_illegal(dbenv, "log_stat"));
  2354. }
  2356. int
  2357. __dbcl_log_unregister(dbenv, dbp)
  2358. DB_ENV * dbenv;
  2359. DB * dbp;
  2360. {
  2361. COMPQUIET(dbp, 0);
  2362. return (__dbcl_rpc_illegal(dbenv, "log_unregister"));
  2363. }
  2365. int
  2366. __dbcl_memp_fclose(mpf)
  2367. DB_MPOOLFILE * mpf;
  2368. {
  2369. DB_ENV *dbenv;
  2371. dbenv = mpf->dbmp->dbenv;
  2372. return (__dbcl_rpc_illegal(dbenv, "memp_fclose"));
  2373. }
  2375. int
  2376. __dbcl_memp_fget(mpf, pgno, flags, pagep)
  2377. DB_MPOOLFILE * mpf;
  2378. db_pgno_t * pgno;
  2379. u_int32_t flags;
  2380. void ** pagep;
  2381. {
  2382. DB_ENV *dbenv;
  2384. dbenv = mpf->dbmp->dbenv;
  2385. COMPQUIET(pgno, 0);
  2386. COMPQUIET(flags, 0);
  2387. COMPQUIET(pagep, 0);
  2388. return (__dbcl_rpc_illegal(dbenv, "memp_fget"));
  2389. }
  2391. int
  2392. __dbcl_memp_fopen(dbenv, file, flags, mode, pagesize, finfop, mpf)
  2393. DB_ENV * dbenv;
  2394. const char * file;
  2395. u_int32_t flags;
  2396. int mode;
  2397. size_t pagesize;
  2398. DB_MPOOL_FINFO * finfop;
  2399. DB_MPOOLFILE ** mpf;
  2400. {
  2401. COMPQUIET(file, NULL);
  2402. COMPQUIET(flags, 0);
  2403. COMPQUIET(mode, 0);
  2404. COMPQUIET(pagesize, 0);
  2405. COMPQUIET(finfop, 0);
  2406. COMPQUIET(mpf, 0);
  2407. return (__dbcl_rpc_illegal(dbenv, "memp_fopen"));
  2408. }
  2410. int
  2411. __dbcl_memp_fput(mpf, pgaddr, flags)
  2412. DB_MPOOLFILE * mpf;
  2413. void * pgaddr;
  2414. u_int32_t flags;
  2415. {
  2416. DB_ENV *dbenv;
  2418. dbenv = mpf->dbmp->dbenv;
  2419. COMPQUIET(pgaddr, 0);
  2420. COMPQUIET(flags, 0);
  2421. return (__dbcl_rpc_illegal(dbenv, "memp_fput"));
  2422. }
  2424. int
  2425. __dbcl_memp_fset(mpf, pgaddr, flags)
  2426. DB_MPOOLFILE * mpf;
  2427. void * pgaddr;
  2428. u_int32_t flags;
  2429. {
  2430. DB_ENV *dbenv;
  2432. dbenv = mpf->dbmp->dbenv;
  2433. COMPQUIET(pgaddr, 0);
  2434. COMPQUIET(flags, 0);
  2435. return (__dbcl_rpc_illegal(dbenv, "memp_fset"));
  2436. }
  2438. int
  2439. __dbcl_memp_fsync(mpf)
  2440. DB_MPOOLFILE * mpf;
  2441. {
  2442. DB_ENV *dbenv;
  2444. dbenv = mpf->dbmp->dbenv;
  2445. return (__dbcl_rpc_illegal(dbenv, "memp_fsync"));
  2446. }
  2448. int
  2449. __dbcl_memp_register(dbenv, ftype, func0, func1)
  2450. DB_ENV * dbenv;
  2451. int ftype;
  2452. int (*func0) __P((DB_ENV *, db_pgno_t, void *, DBT *));
  2453. int (*func1) __P((DB_ENV *, db_pgno_t, void *, DBT *));
  2454. {
  2455. COMPQUIET(ftype, 0);
  2456. COMPQUIET(func0, 0);
  2457. COMPQUIET(func1, 0);
  2458. return (__dbcl_rpc_illegal(dbenv, "memp_register"));
  2459. }
  2461. int
  2462. __dbcl_memp_stat(dbenv, gstatp, fstatp, func0)
  2463. DB_ENV * dbenv;
  2464. DB_MPOOL_STAT ** gstatp;
  2465. DB_MPOOL_FSTAT *** fstatp;
  2466. void *(*func0) __P((size_t));
  2467. {
  2468. COMPQUIET(gstatp, 0);
  2469. COMPQUIET(fstatp, 0);
  2470. COMPQUIET(func0, 0);
  2471. return (__dbcl_rpc_illegal(dbenv, "memp_stat"));
  2472. }
  2474. int
  2475. __dbcl_memp_sync(dbenv, lsn)
  2476. DB_ENV * dbenv;
  2477. DB_LSN * lsn;
  2478. {
  2479. COMPQUIET(lsn, 0);
  2480. return (__dbcl_rpc_illegal(dbenv, "memp_sync"));
  2481. }
  2483. int
  2484. __dbcl_memp_trickle(dbenv, pct, nwrotep)
  2485. DB_ENV * dbenv;
  2486. int pct;
  2487. int * nwrotep;
  2488. {
  2489. COMPQUIET(pct, 0);
  2490. COMPQUIET(nwrotep, 0);
  2491. return (__dbcl_rpc_illegal(dbenv, "memp_trickle"));
  2492. }
  2494. #endif /* HAVE_RPC */