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

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

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>
  8. #include <rpc/rpc.h>
  9. #include <rpc/xdr.h>
  11. #include <string.h>
  12. #endif
  14. #include "db_int.h"
  15. #include "dbinc/txn.h"
  17. #include "dbinc_auto/db_server.h"
  18. #include "dbinc_auto/rpc_client_ext.h"
  20. static int __dbcl_noserver __P((DB_ENV *));
  22. static int
  23. __dbcl_noserver(dbenv)
  24. DB_ENV *dbenv;
  25. {
  26. __db_err(dbenv, "No server environment");
  27. return (DB_NOSERVER);
  28. }
  30. static int __dbcl_rpc_illegal __P((DB_ENV *, char *));
  32. static int
  33. __dbcl_rpc_illegal(dbenv, name)
  34. DB_ENV *dbenv;
  35. char *name;
  36. {
  37. __db_err(dbenv, "%s method meaningless in an RPC environment", name);
  38. return (__db_eopnotsup(dbenv));
  39. }
  41. /*
  42.  * PUBLIC: int __dbcl_env_alloc __P((DB_ENV *, void *(*)(size_t),
  43.  * PUBLIC:      void *(*)(void *, size_t), void (*)(void *)));
  44.  */
  45. int
  46. __dbcl_env_alloc(dbenv, func0, func1, func2)
  47. DB_ENV * dbenv;
  48. void *(*func0) __P((size_t));
  49. void *(*func1) __P((void *, size_t));
  50. void (*func2) __P((void *));
  51. {
  52. COMPQUIET(func0, 0);
  53. COMPQUIET(func1, 0);
  54. COMPQUIET(func2, 0);
  55. return (__dbcl_rpc_illegal(dbenv, "env_alloc"));
  56. }
  58. /*
  59.  * PUBLIC: int __dbcl_set_app_dispatch __P((DB_ENV *, int (*)(DB_ENV *, DBT *,
  60.  * PUBLIC:      DB_LSN *, db_recops)));
  61.  */
  62. int
  63. __dbcl_set_app_dispatch(dbenv, func0)
  64. DB_ENV * dbenv;
  65. int (*func0) __P((DB_ENV *, DBT *, DB_LSN *, db_recops));
  66. {
  67. COMPQUIET(func0, 0);
  68. return (__dbcl_rpc_illegal(dbenv, "set_app_dispatch"));
  69. }
  71. /*
  72.  * PUBLIC: int __dbcl_env_cachesize __P((DB_ENV *, u_int32_t, u_int32_t, int));
  73.  */
  74. int
  75. __dbcl_env_cachesize(dbenv, gbytes, bytes, ncache)
  76. DB_ENV * dbenv;
  77. u_int32_t gbytes;
  78. u_int32_t bytes;
  79. int ncache;
  80. {
  81. CLIENT *cl;
  82. __env_cachesize_msg msg;
  83. __env_cachesize_reply *replyp = NULL;
  84. int ret;
  86. ret = 0;
  87. if (dbenv == NULL || !RPC_ON(dbenv))
  88. return (__dbcl_noserver(dbenv));
  90. cl = (CLIENT *)dbenv->cl_handle;
  92. if (dbenv == NULL)
  93. msg.dbenvcl_id = 0;
  94. else
  95. msg.dbenvcl_id = dbenv->cl_id;
  96. msg.gbytes = gbytes;
  97. msg.bytes = bytes;
  98. msg.ncache = ncache;
  100. replyp = __db_env_cachesize_4001(&msg, cl);
  101. if (replyp == NULL) {
  102. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  103. ret = DB_NOSERVER;
  104. goto out;
  105. }
  106. ret = replyp->status;
  107. out:
  108. if (replyp != NULL)
  109. xdr_free((xdrproc_t)xdr___env_cachesize_reply, (void *)replyp);
  110. return (ret);
  111. }
  113. /*
  114.  * PUBLIC: int __dbcl_env_close __P((DB_ENV *, u_int32_t));
  115.  */
  116. int
  117. __dbcl_env_close(dbenv, flags)
  118. DB_ENV * dbenv;
  119. u_int32_t flags;
  120. {
  121. CLIENT *cl;
  122. __env_close_msg msg;
  123. __env_close_reply *replyp = NULL;
  124. int ret;
  126. ret = 0;
  127. if (dbenv == NULL || !RPC_ON(dbenv))
  128. return (__dbcl_noserver(dbenv));
  130. cl = (CLIENT *)dbenv->cl_handle;
  132. if (dbenv == NULL)
  133. msg.dbenvcl_id = 0;
  134. else
  135. msg.dbenvcl_id = dbenv->cl_id;
  136. msg.flags = flags;
  138. replyp = __db_env_close_4001(&msg, cl);
  139. if (replyp == NULL) {
  140. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  141. ret = DB_NOSERVER;
  142. goto out;
  143. }
  144. ret = __dbcl_env_close_ret(dbenv, flags, replyp);
  145. out:
  146. if (replyp != NULL)
  147. xdr_free((xdrproc_t)xdr___env_close_reply, (void *)replyp);
  148. return (ret);
  149. }
  151. /*
  152.  * PUBLIC: int __dbcl_env_create __P((DB_ENV *, long));
  153.  */
  154. int
  155. __dbcl_env_create(dbenv, timeout)
  156. DB_ENV * dbenv;
  157. long timeout;
  158. {
  159. CLIENT *cl;
  160. __env_create_msg msg;
  161. __env_create_reply *replyp = NULL;
  162. int ret;
  164. ret = 0;
  165. if (dbenv == NULL || !RPC_ON(dbenv))
  166. return (__dbcl_noserver(dbenv));
  168. cl = (CLIENT *)dbenv->cl_handle;
  170. msg.timeout = timeout;
  172. replyp = __db_env_create_4001(&msg, cl);
  173. if (replyp == NULL) {
  174. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  175. ret = DB_NOSERVER;
  176. goto out;
  177. }
  178. ret = __dbcl_env_create_ret(dbenv, timeout, replyp);
  179. out:
  180. if (replyp != NULL)
  181. xdr_free((xdrproc_t)xdr___env_create_reply, (void *)replyp);
  182. return (ret);
  183. }
  185. /*
  186.  * PUBLIC: int __dbcl_set_data_dir __P((DB_ENV *, const char *));
  187.  */
  188. int
  189. __dbcl_set_data_dir(dbenv, dir)
  190. DB_ENV * dbenv;
  191. const char * dir;
  192. {
  193. COMPQUIET(dir, NULL);
  194. return (__dbcl_rpc_illegal(dbenv, "set_data_dir"));
  195. }
  197. /*
  198.  * PUBLIC: int __dbcl_env_dbremove __P((DB_ENV *, DB_TXN *, const char *,
  199.  * PUBLIC:      const char *, u_int32_t));
  200.  */
  201. int
  202. __dbcl_env_dbremove(dbenv, txnp, name, subdb, flags)
  203. DB_ENV * dbenv;
  204. DB_TXN * txnp;
  205. const char * name;
  206. const char * subdb;
  207. u_int32_t flags;
  208. {
  209. CLIENT *cl;
  210. __env_dbremove_msg msg;
  211. __env_dbremove_reply *replyp = NULL;
  212. int ret;
  214. ret = 0;
  215. if (dbenv == NULL || !RPC_ON(dbenv))
  216. return (__dbcl_noserver(dbenv));
  218. cl = (CLIENT *)dbenv->cl_handle;
  220. if (dbenv == NULL)
  221. msg.dbenvcl_id = 0;
  222. else
  223. msg.dbenvcl_id = dbenv->cl_id;
  224. if (txnp == NULL)
  225. msg.txnpcl_id = 0;
  226. else
  227. msg.txnpcl_id = txnp->txnid;
  228. if (name == NULL)
  229. msg.name = "";
  230. else
  231. msg.name = (char *)name;
  232. if (subdb == NULL)
  233. msg.subdb = "";
  234. else
  235. msg.subdb = (char *)subdb;
  236. msg.flags = flags;
  238. replyp = __db_env_dbremove_4001(&msg, cl);
  239. if (replyp == NULL) {
  240. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  241. ret = DB_NOSERVER;
  242. goto out;
  243. }
  244. ret = replyp->status;
  245. out:
  246. if (replyp != NULL)
  247. xdr_free((xdrproc_t)xdr___env_dbremove_reply, (void *)replyp);
  248. return (ret);
  249. }
  251. /*
  252.  * PUBLIC: int __dbcl_env_dbrename __P((DB_ENV *, DB_TXN *, const char *,
  253.  * PUBLIC:      const char *, const char *, u_int32_t));
  254.  */
  255. int
  256. __dbcl_env_dbrename(dbenv, txnp, name, subdb, newname, flags)
  257. DB_ENV * dbenv;
  258. DB_TXN * txnp;
  259. const char * name;
  260. const char * subdb;
  261. const char * newname;
  262. u_int32_t flags;
  263. {
  264. CLIENT *cl;
  265. __env_dbrename_msg msg;
  266. __env_dbrename_reply *replyp = NULL;
  267. int ret;
  269. ret = 0;
  270. if (dbenv == NULL || !RPC_ON(dbenv))
  271. return (__dbcl_noserver(dbenv));
  273. cl = (CLIENT *)dbenv->cl_handle;
  275. if (dbenv == NULL)
  276. msg.dbenvcl_id = 0;
  277. else
  278. msg.dbenvcl_id = dbenv->cl_id;
  279. if (txnp == NULL)
  280. msg.txnpcl_id = 0;
  281. else
  282. msg.txnpcl_id = txnp->txnid;
  283. if (name == NULL)
  284. msg.name = "";
  285. else
  286. msg.name = (char *)name;
  287. if (subdb == NULL)
  288. msg.subdb = "";
  289. else
  290. msg.subdb = (char *)subdb;
  291. if (newname == NULL)
  292. msg.newname = "";
  293. else
  294. msg.newname = (char *)newname;
  295. msg.flags = flags;
  297. replyp = __db_env_dbrename_4001(&msg, cl);
  298. if (replyp == NULL) {
  299. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  300. ret = DB_NOSERVER;
  301. goto out;
  302. }
  303. ret = replyp->status;
  304. out:
  305. if (replyp != NULL)
  306. xdr_free((xdrproc_t)xdr___env_dbrename_reply, (void *)replyp);
  307. return (ret);
  308. }
  310. /*
  311.  * PUBLIC: int __dbcl_env_encrypt __P((DB_ENV *, const char *, u_int32_t));
  312.  */
  313. int
  314. __dbcl_env_encrypt(dbenv, passwd, flags)
  315. DB_ENV * dbenv;
  316. const char * passwd;
  317. u_int32_t flags;
  318. {
  319. CLIENT *cl;
  320. __env_encrypt_msg msg;
  321. __env_encrypt_reply *replyp = NULL;
  322. int ret;
  324. ret = 0;
  325. if (dbenv == NULL || !RPC_ON(dbenv))
  326. return (__dbcl_noserver(dbenv));
  328. cl = (CLIENT *)dbenv->cl_handle;
  330. if (dbenv == NULL)
  331. msg.dbenvcl_id = 0;
  332. else
  333. msg.dbenvcl_id = dbenv->cl_id;
  334. if (passwd == NULL)
  335. msg.passwd = "";
  336. else
  337. msg.passwd = (char *)passwd;
  338. msg.flags = flags;
  340. replyp = __db_env_encrypt_4001(&msg, cl);
  341. if (replyp == NULL) {
  342. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  343. ret = DB_NOSERVER;
  344. goto out;
  345. }
  346. ret = replyp->status;
  347. out:
  348. if (replyp != NULL)
  349. xdr_free((xdrproc_t)xdr___env_encrypt_reply, (void *)replyp);
  350. return (ret);
  351. }
  353. /*
  354.  * PUBLIC: int __dbcl_env_set_feedback __P((DB_ENV *, void (*)(DB_ENV *, int,
  355.  * PUBLIC:      int)));
  356.  */
  357. int
  358. __dbcl_env_set_feedback(dbenv, func0)
  359. DB_ENV * dbenv;
  360. void (*func0) __P((DB_ENV *, int, int));
  361. {
  362. COMPQUIET(func0, 0);
  363. return (__dbcl_rpc_illegal(dbenv, "env_set_feedback"));
  364. }
  366. /*
  367.  * PUBLIC: int __dbcl_env_flags __P((DB_ENV *, u_int32_t, int));
  368.  */
  369. int
  370. __dbcl_env_flags(dbenv, flags, onoff)
  371. DB_ENV * dbenv;
  372. u_int32_t flags;
  373. int onoff;
  374. {
  375. CLIENT *cl;
  376. __env_flags_msg msg;
  377. __env_flags_reply *replyp = NULL;
  378. int ret;
  380. ret = 0;
  381. if (dbenv == NULL || !RPC_ON(dbenv))
  382. return (__dbcl_noserver(dbenv));
  384. cl = (CLIENT *)dbenv->cl_handle;
  386. if (dbenv == NULL)
  387. msg.dbenvcl_id = 0;
  388. else
  389. msg.dbenvcl_id = dbenv->cl_id;
  390. msg.flags = flags;
  391. msg.onoff = onoff;
  393. replyp = __db_env_flags_4001(&msg, cl);
  394. if (replyp == NULL) {
  395. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  396. ret = DB_NOSERVER;
  397. goto out;
  398. }
  399. ret = replyp->status;
  400. out:
  401. if (replyp != NULL)
  402. xdr_free((xdrproc_t)xdr___env_flags_reply, (void *)replyp);
  403. return (ret);
  404. }
  406. /*
  407.  * PUBLIC: int __dbcl_set_lg_bsize __P((DB_ENV *, u_int32_t));
  408.  */
  409. int
  410. __dbcl_set_lg_bsize(dbenv, bsize)
  411. DB_ENV * dbenv;
  412. u_int32_t bsize;
  413. {
  414. COMPQUIET(bsize, 0);
  415. return (__dbcl_rpc_illegal(dbenv, "set_lg_bsize"));
  416. }
  418. /*
  419.  * PUBLIC: int __dbcl_set_lg_dir __P((DB_ENV *, const char *));
  420.  */
  421. int
  422. __dbcl_set_lg_dir(dbenv, dir)
  423. DB_ENV * dbenv;
  424. const char * dir;
  425. {
  426. COMPQUIET(dir, NULL);
  427. return (__dbcl_rpc_illegal(dbenv, "set_lg_dir"));
  428. }
  430. /*
  431.  * PUBLIC: int __dbcl_set_lg_max __P((DB_ENV *, u_int32_t));
  432.  */
  433. int
  434. __dbcl_set_lg_max(dbenv, max)
  435. DB_ENV * dbenv;
  436. u_int32_t max;
  437. {
  438. COMPQUIET(max, 0);
  439. return (__dbcl_rpc_illegal(dbenv, "set_lg_max"));
  440. }
  442. /*
  443.  * PUBLIC: int __dbcl_set_lg_regionmax __P((DB_ENV *, u_int32_t));
  444.  */
  445. int
  446. __dbcl_set_lg_regionmax(dbenv, max)
  447. DB_ENV * dbenv;
  448. u_int32_t max;
  449. {
  450. COMPQUIET(max, 0);
  451. return (__dbcl_rpc_illegal(dbenv, "set_lg_regionmax"));
  452. }
  454. /*
  455.  * PUBLIC: int __dbcl_set_lk_conflict __P((DB_ENV *, u_int8_t *, int));
  456.  */
  457. int
  458. __dbcl_set_lk_conflict(dbenv, conflicts, modes)
  459. DB_ENV * dbenv;
  460. u_int8_t * conflicts;
  461. int modes;
  462. {
  463. COMPQUIET(conflicts, 0);
  464. COMPQUIET(modes, 0);
  465. return (__dbcl_rpc_illegal(dbenv, "set_lk_conflict"));
  466. }
  468. /*
  469.  * PUBLIC: int __dbcl_set_lk_detect __P((DB_ENV *, u_int32_t));
  470.  */
  471. int
  472. __dbcl_set_lk_detect(dbenv, detect)
  473. DB_ENV * dbenv;
  474. u_int32_t detect;
  475. {
  476. COMPQUIET(detect, 0);
  477. return (__dbcl_rpc_illegal(dbenv, "set_lk_detect"));
  478. }
  480. /*
  481.  * PUBLIC: int __dbcl_set_lk_max __P((DB_ENV *, u_int32_t));
  482.  */
  483. int
  484. __dbcl_set_lk_max(dbenv, max)
  485. DB_ENV * dbenv;
  486. u_int32_t max;
  487. {
  488. COMPQUIET(max, 0);
  489. return (__dbcl_rpc_illegal(dbenv, "set_lk_max"));
  490. }
  492. /*
  493.  * PUBLIC: int __dbcl_set_lk_max_locks __P((DB_ENV *, u_int32_t));
  494.  */
  495. int
  496. __dbcl_set_lk_max_locks(dbenv, max)
  497. DB_ENV * dbenv;
  498. u_int32_t max;
  499. {
  500. COMPQUIET(max, 0);
  501. return (__dbcl_rpc_illegal(dbenv, "set_lk_max_locks"));
  502. }
  504. /*
  505.  * PUBLIC: int __dbcl_set_lk_max_lockers __P((DB_ENV *, u_int32_t));
  506.  */
  507. int
  508. __dbcl_set_lk_max_lockers(dbenv, max)
  509. DB_ENV * dbenv;
  510. u_int32_t max;
  511. {
  512. COMPQUIET(max, 0);
  513. return (__dbcl_rpc_illegal(dbenv, "set_lk_max_lockers"));
  514. }
  516. /*
  517.  * PUBLIC: int __dbcl_set_lk_max_objects __P((DB_ENV *, u_int32_t));
  518.  */
  519. int
  520. __dbcl_set_lk_max_objects(dbenv, max)
  521. DB_ENV * dbenv;
  522. u_int32_t max;
  523. {
  524. COMPQUIET(max, 0);
  525. return (__dbcl_rpc_illegal(dbenv, "set_lk_max_objects"));
  526. }
  528. /*
  529.  * PUBLIC: int __dbcl_set_mp_mmapsize __P((DB_ENV *, size_t));
  530.  */
  531. int
  532. __dbcl_set_mp_mmapsize(dbenv, mmapsize)
  533. DB_ENV * dbenv;
  534. size_t mmapsize;
  535. {
  536. COMPQUIET(mmapsize, 0);
  537. return (__dbcl_rpc_illegal(dbenv, "set_mp_mmapsize"));
  538. }
  540. /*
  541.  * PUBLIC: int __dbcl_env_open __P((DB_ENV *, const char *, u_int32_t, int));
  542.  */
  543. int
  544. __dbcl_env_open(dbenv, home, flags, mode)
  545. DB_ENV * dbenv;
  546. const char * home;
  547. u_int32_t flags;
  548. int mode;
  549. {
  550. CLIENT *cl;
  551. __env_open_msg msg;
  552. __env_open_reply *replyp = NULL;
  553. int ret;
  555. ret = 0;
  556. if (dbenv == NULL || !RPC_ON(dbenv))
  557. return (__dbcl_noserver(dbenv));
  559. cl = (CLIENT *)dbenv->cl_handle;
  561. if (dbenv == NULL)
  562. msg.dbenvcl_id = 0;
  563. else
  564. msg.dbenvcl_id = dbenv->cl_id;
  565. if (home == NULL)
  566. msg.home = "";
  567. else
  568. msg.home = (char *)home;
  569. msg.flags = flags;
  570. msg.mode = mode;
  572. replyp = __db_env_open_4001(&msg, cl);
  573. if (replyp == NULL) {
  574. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  575. ret = DB_NOSERVER;
  576. goto out;
  577. }
  578. ret = __dbcl_env_open_ret(dbenv, home, flags, mode, replyp);
  579. out:
  580. if (replyp != NULL)
  581. xdr_free((xdrproc_t)xdr___env_open_reply, (void *)replyp);
  582. return (ret);
  583. }
  585. /*
  586.  * PUBLIC: int __dbcl_env_paniccall __P((DB_ENV *, void (*)(DB_ENV *, int)));
  587.  */
  588. int
  589. __dbcl_env_paniccall(dbenv, func0)
  590. DB_ENV * dbenv;
  591. void (*func0) __P((DB_ENV *, int));
  592. {
  593. COMPQUIET(func0, 0);
  594. return (__dbcl_rpc_illegal(dbenv, "env_paniccall"));
  595. }
  597. /*
  598.  * PUBLIC: int __dbcl_env_remove __P((DB_ENV *, const char *, u_int32_t));
  599.  */
  600. int
  601. __dbcl_env_remove(dbenv, home, flags)
  602. DB_ENV * dbenv;
  603. const char * home;
  604. u_int32_t flags;
  605. {
  606. CLIENT *cl;
  607. __env_remove_msg msg;
  608. __env_remove_reply *replyp = NULL;
  609. int ret;
  611. ret = 0;
  612. if (dbenv == NULL || !RPC_ON(dbenv))
  613. return (__dbcl_noserver(dbenv));
  615. cl = (CLIENT *)dbenv->cl_handle;
  617. if (dbenv == NULL)
  618. msg.dbenvcl_id = 0;
  619. else
  620. msg.dbenvcl_id = dbenv->cl_id;
  621. if (home == NULL)
  622. msg.home = "";
  623. else
  624. msg.home = (char *)home;
  625. msg.flags = flags;
  627. replyp = __db_env_remove_4001(&msg, cl);
  628. if (replyp == NULL) {
  629. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  630. ret = DB_NOSERVER;
  631. goto out;
  632. }
  633. ret = __dbcl_env_remove_ret(dbenv, home, flags, replyp);
  634. out:
  635. if (replyp != NULL)
  636. xdr_free((xdrproc_t)xdr___env_remove_reply, (void *)replyp);
  637. return (ret);
  638. }
  640. /*
  641.  * PUBLIC: int __dbcl_set_shm_key __P((DB_ENV *, long));
  642.  */
  643. int
  644. __dbcl_set_shm_key(dbenv, shm_key)
  645. DB_ENV * dbenv;
  646. long shm_key;
  647. {
  648. COMPQUIET(shm_key, 0);
  649. return (__dbcl_rpc_illegal(dbenv, "set_shm_key"));
  650. }
  652. /*
  653.  * PUBLIC: int __dbcl_set_tas_spins __P((DB_ENV *, u_int32_t));
  654.  */
  655. int
  656. __dbcl_set_tas_spins(dbenv, tas_spins)
  657. DB_ENV * dbenv;
  658. u_int32_t tas_spins;
  659. {
  660. COMPQUIET(tas_spins, 0);
  661. return (__dbcl_rpc_illegal(dbenv, "set_tas_spins"));
  662. }
  664. /*
  665.  * PUBLIC: int __dbcl_set_timeout __P((DB_ENV *, u_int32_t, u_int32_t));
  666.  */
  667. int
  668. __dbcl_set_timeout(dbenv, timeout, flags)
  669. DB_ENV * dbenv;
  670. u_int32_t timeout;
  671. u_int32_t flags;
  672. {
  673. COMPQUIET(timeout, 0);
  674. COMPQUIET(flags, 0);
  675. return (__dbcl_rpc_illegal(dbenv, "set_timeout"));
  676. }
  678. /*
  679.  * PUBLIC: int __dbcl_set_tmp_dir __P((DB_ENV *, const char *));
  680.  */
  681. int
  682. __dbcl_set_tmp_dir(dbenv, dir)
  683. DB_ENV * dbenv;
  684. const char * dir;
  685. {
  686. COMPQUIET(dir, NULL);
  687. return (__dbcl_rpc_illegal(dbenv, "set_tmp_dir"));
  688. }
  690. /*
  691.  * PUBLIC: int __dbcl_set_tx_max __P((DB_ENV *, u_int32_t));
  692.  */
  693. int
  694. __dbcl_set_tx_max(dbenv, max)
  695. DB_ENV * dbenv;
  696. u_int32_t max;
  697. {
  698. COMPQUIET(max, 0);
  699. return (__dbcl_rpc_illegal(dbenv, "set_tx_max"));
  700. }
  702. /*
  703.  * PUBLIC: int __dbcl_set_tx_timestamp __P((DB_ENV *, time_t *));
  704.  */
  705. int
  706. __dbcl_set_tx_timestamp(dbenv, max)
  707. DB_ENV * dbenv;
  708. time_t * max;
  709. {
  710. COMPQUIET(max, 0);
  711. return (__dbcl_rpc_illegal(dbenv, "set_tx_timestamp"));
  712. }
  714. /*
  715.  * PUBLIC: int __dbcl_set_verbose __P((DB_ENV *, u_int32_t, int));
  716.  */
  717. int
  718. __dbcl_set_verbose(dbenv, which, onoff)
  719. DB_ENV * dbenv;
  720. u_int32_t which;
  721. int onoff;
  722. {
  723. COMPQUIET(which, 0);
  724. COMPQUIET(onoff, 0);
  725. return (__dbcl_rpc_illegal(dbenv, "set_verbose"));
  726. }
  728. /*
  729.  * PUBLIC: int __dbcl_txn_abort __P((DB_TXN *));
  730.  */
  731. int
  732. __dbcl_txn_abort(txnp)
  733. DB_TXN * txnp;
  734. {
  735. CLIENT *cl;
  736. __txn_abort_msg msg;
  737. __txn_abort_reply *replyp = NULL;
  738. int ret;
  739. DB_ENV *dbenv;
  741. ret = 0;
  742. dbenv = txnp->mgrp->dbenv;
  743. if (dbenv == NULL || !RPC_ON(dbenv))
  744. return (__dbcl_noserver(NULL));
  746. cl = (CLIENT *)dbenv->cl_handle;
  748. if (txnp == NULL)
  749. msg.txnpcl_id = 0;
  750. else
  751. msg.txnpcl_id = txnp->txnid;
  753. replyp = __db_txn_abort_4001(&msg, cl);
  754. if (replyp == NULL) {
  755. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  756. ret = DB_NOSERVER;
  757. goto out;
  758. }
  759. ret = __dbcl_txn_abort_ret(txnp, replyp);
  760. out:
  761. if (replyp != NULL)
  762. xdr_free((xdrproc_t)xdr___txn_abort_reply, (void *)replyp);
  763. return (ret);
  764. }
  766. /*
  767.  * PUBLIC: int __dbcl_txn_begin __P((DB_ENV *, DB_TXN *, DB_TXN **,
  768.  * PUBLIC:      u_int32_t));
  769.  */
  770. int
  771. __dbcl_txn_begin(dbenv, parent, txnpp, flags)
  772. DB_ENV * dbenv;
  773. DB_TXN * parent;
  774. DB_TXN ** txnpp;
  775. u_int32_t flags;
  776. {
  777. CLIENT *cl;
  778. __txn_begin_msg msg;
  779. __txn_begin_reply *replyp = NULL;
  780. int ret;
  782. ret = 0;
  783. if (dbenv == NULL || !RPC_ON(dbenv))
  784. return (__dbcl_noserver(dbenv));
  786. cl = (CLIENT *)dbenv->cl_handle;
  788. if (dbenv == NULL)
  789. msg.dbenvcl_id = 0;
  790. else
  791. msg.dbenvcl_id = dbenv->cl_id;
  792. if (parent == NULL)
  793. msg.parentcl_id = 0;
  794. else
  795. msg.parentcl_id = parent->txnid;
  796. msg.flags = flags;
  798. replyp = __db_txn_begin_4001(&msg, cl);
  799. if (replyp == NULL) {
  800. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  801. ret = DB_NOSERVER;
  802. goto out;
  803. }
  804. ret = __dbcl_txn_begin_ret(dbenv, parent, txnpp, flags, replyp);
  805. out:
  806. if (replyp != NULL)
  807. xdr_free((xdrproc_t)xdr___txn_begin_reply, (void *)replyp);
  808. return (ret);
  809. }
  811. /*
  812.  * PUBLIC: int __dbcl_txn_checkpoint __P((DB_ENV *, u_int32_t, u_int32_t,
  813.  * PUBLIC:      u_int32_t));
  814.  */
  815. int
  816. __dbcl_txn_checkpoint(dbenv, kbyte, min, flags)
  817. DB_ENV * dbenv;
  818. u_int32_t kbyte;
  819. u_int32_t min;
  820. u_int32_t flags;
  821. {
  822. COMPQUIET(kbyte, 0);
  823. COMPQUIET(min, 0);
  824. COMPQUIET(flags, 0);
  825. return (__dbcl_rpc_illegal(dbenv, "txn_checkpoint"));
  826. }
  828. /*
  829.  * PUBLIC: int __dbcl_txn_commit __P((DB_TXN *, u_int32_t));
  830.  */
  831. int
  832. __dbcl_txn_commit(txnp, flags)
  833. DB_TXN * txnp;
  834. u_int32_t flags;
  835. {
  836. CLIENT *cl;
  837. __txn_commit_msg msg;
  838. __txn_commit_reply *replyp = NULL;
  839. int ret;
  840. DB_ENV *dbenv;
  842. ret = 0;
  843. dbenv = txnp->mgrp->dbenv;
  844. if (dbenv == NULL || !RPC_ON(dbenv))
  845. return (__dbcl_noserver(NULL));
  847. cl = (CLIENT *)dbenv->cl_handle;
  849. if (txnp == NULL)
  850. msg.txnpcl_id = 0;
  851. else
  852. msg.txnpcl_id = txnp->txnid;
  853. msg.flags = flags;
  855. replyp = __db_txn_commit_4001(&msg, cl);
  856. if (replyp == NULL) {
  857. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  858. ret = DB_NOSERVER;
  859. goto out;
  860. }
  861. ret = __dbcl_txn_commit_ret(txnp, flags, replyp);
  862. out:
  863. if (replyp != NULL)
  864. xdr_free((xdrproc_t)xdr___txn_commit_reply, (void *)replyp);
  865. return (ret);
  866. }
  868. /*
  869.  * PUBLIC: int __dbcl_txn_discard __P((DB_TXN *, u_int32_t));
  870.  */
  871. int
  872. __dbcl_txn_discard(txnp, flags)
  873. DB_TXN * txnp;
  874. u_int32_t flags;
  875. {
  876. CLIENT *cl;
  877. __txn_discard_msg msg;
  878. __txn_discard_reply *replyp = NULL;
  879. int ret;
  880. DB_ENV *dbenv;
  882. ret = 0;
  883. dbenv = txnp->mgrp->dbenv;
  884. if (dbenv == NULL || !RPC_ON(dbenv))
  885. return (__dbcl_noserver(NULL));
  887. cl = (CLIENT *)dbenv->cl_handle;
  889. if (txnp == NULL)
  890. msg.txnpcl_id = 0;
  891. else
  892. msg.txnpcl_id = txnp->txnid;
  893. msg.flags = flags;
  895. replyp = __db_txn_discard_4001(&msg, cl);
  896. if (replyp == NULL) {
  897. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  898. ret = DB_NOSERVER;
  899. goto out;
  900. }
  901. ret = __dbcl_txn_discard_ret(txnp, flags, replyp);
  902. out:
  903. if (replyp != NULL)
  904. xdr_free((xdrproc_t)xdr___txn_discard_reply, (void *)replyp);
  905. return (ret);
  906. }
  908. /*
  909.  * PUBLIC: int __dbcl_txn_prepare __P((DB_TXN *, u_int8_t *));
  910.  */
  911. int
  912. __dbcl_txn_prepare(txnp, gid)
  913. DB_TXN * txnp;
  914. u_int8_t * gid;
  915. {
  916. CLIENT *cl;
  917. __txn_prepare_msg msg;
  918. __txn_prepare_reply *replyp = NULL;
  919. int ret;
  920. DB_ENV *dbenv;
  922. ret = 0;
  923. dbenv = txnp->mgrp->dbenv;
  924. if (dbenv == NULL || !RPC_ON(dbenv))
  925. return (__dbcl_noserver(NULL));
  927. cl = (CLIENT *)dbenv->cl_handle;
  929. if (txnp == NULL)
  930. msg.txnpcl_id = 0;
  931. else
  932. msg.txnpcl_id = txnp->txnid;
  933. memcpy(msg.gid, gid, 128);
  935. replyp = __db_txn_prepare_4001(&msg, cl);
  936. if (replyp == NULL) {
  937. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  938. ret = DB_NOSERVER;
  939. goto out;
  940. }
  941. ret = replyp->status;
  942. out:
  943. if (replyp != NULL)
  944. xdr_free((xdrproc_t)xdr___txn_prepare_reply, (void *)replyp);
  945. return (ret);
  946. }
  948. /*
  949.  * PUBLIC: int __dbcl_txn_recover __P((DB_ENV *, DB_PREPLIST *, long, long *,
  950.  * PUBLIC:      u_int32_t));
  951.  */
  952. int
  953. __dbcl_txn_recover(dbenv, preplist, count, retp, flags)
  954. DB_ENV * dbenv;
  955. DB_PREPLIST * preplist;
  956. long count;
  957. long * retp;
  958. u_int32_t flags;
  959. {
  960. CLIENT *cl;
  961. __txn_recover_msg msg;
  962. __txn_recover_reply *replyp = NULL;
  963. int ret;
  965. ret = 0;
  966. if (dbenv == NULL || !RPC_ON(dbenv))
  967. return (__dbcl_noserver(dbenv));
  969. cl = (CLIENT *)dbenv->cl_handle;
  971. if (dbenv == NULL)
  972. msg.dbenvcl_id = 0;
  973. else
  974. msg.dbenvcl_id = dbenv->cl_id;
  975. msg.count = count;
  976. msg.flags = flags;
  978. replyp = __db_txn_recover_4001(&msg, cl);
  979. if (replyp == NULL) {
  980. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  981. ret = DB_NOSERVER;
  982. goto out;
  983. }
  984. ret = __dbcl_txn_recover_ret(dbenv, preplist, count, retp, flags, replyp);
  985. out:
  986. if (replyp != NULL)
  987. xdr_free((xdrproc_t)xdr___txn_recover_reply, (void *)replyp);
  988. return (ret);
  989. }
  991. /*
  992.  * PUBLIC: int __dbcl_txn_stat __P((DB_ENV *, DB_TXN_STAT **, u_int32_t));
  993.  */
  994. int
  995. __dbcl_txn_stat(dbenv, statp, flags)
  996. DB_ENV * dbenv;
  997. DB_TXN_STAT ** statp;
  998. u_int32_t flags;
  999. {
  1000. COMPQUIET(statp, 0);
  1001. COMPQUIET(flags, 0);
  1002. return (__dbcl_rpc_illegal(dbenv, "txn_stat"));
  1003. }
  1005. /*
  1006.  * PUBLIC: int __dbcl_txn_timeout __P((DB_TXN *, u_int32_t, u_int32_t));
  1007.  */
  1008. int
  1009. __dbcl_txn_timeout(txnp, timeout, flags)
  1010. DB_TXN * txnp;
  1011. u_int32_t timeout;
  1012. u_int32_t flags;
  1013. {
  1014. DB_ENV *dbenv;
  1016. dbenv = txnp->mgrp->dbenv;
  1017. COMPQUIET(timeout, 0);
  1018. COMPQUIET(flags, 0);
  1019. return (__dbcl_rpc_illegal(dbenv, "txn_timeout"));
  1020. }
  1022. /*
  1023.  * PUBLIC: int __dbcl_rep_elect __P((DB_ENV *, int, int, u_int32_t, int *));
  1024.  */
  1025. int
  1026. __dbcl_rep_elect(dbenv, nsites, pri, timeout, idp)
  1027. DB_ENV * dbenv;
  1028. int nsites;
  1029. int pri;
  1030. u_int32_t timeout;
  1031. int * idp;
  1032. {
  1033. COMPQUIET(nsites, 0);
  1034. COMPQUIET(pri, 0);
  1035. COMPQUIET(timeout, 0);
  1036. COMPQUIET(idp, 0);
  1037. return (__dbcl_rpc_illegal(dbenv, "rep_elect"));
  1038. }
  1040. /*
  1041.  * PUBLIC: int __dbcl_rep_flush __P((DB_ENV *));
  1042.  */
  1043. int
  1044. __dbcl_rep_flush(dbenv)
  1045. DB_ENV * dbenv;
  1046. {
  1047. return (__dbcl_rpc_illegal(dbenv, "rep_flush"));
  1048. }
  1050. /*
  1051.  * PUBLIC: int __dbcl_rep_process_message __P((DB_ENV *, DBT *, DBT *, int *));
  1052.  */
  1053. int
  1054. __dbcl_rep_process_message(dbenv, rec, control, idp)
  1055. DB_ENV * dbenv;
  1056. DBT * rec;
  1057. DBT * control;
  1058. int * idp;
  1059. {
  1060. COMPQUIET(rec, NULL);
  1061. COMPQUIET(control, NULL);
  1062. COMPQUIET(idp, 0);
  1063. return (__dbcl_rpc_illegal(dbenv, "rep_process_message"));
  1064. }
  1066. /*
  1067.  * PUBLIC: int __dbcl_rep_set_limit __P((DB_ENV *, u_int32_t, u_int32_t));
  1068.  */
  1069. int
  1070. __dbcl_rep_set_limit(dbenv, mbytes, bytes)
  1071. DB_ENV * dbenv;
  1072. u_int32_t mbytes;
  1073. u_int32_t bytes;
  1074. {
  1075. COMPQUIET(mbytes, 0);
  1076. COMPQUIET(bytes, 0);
  1077. return (__dbcl_rpc_illegal(dbenv, "rep_set_limit"));
  1078. }
  1080. /*
  1081.  * PUBLIC: int __dbcl_rep_set_request __P((DB_ENV *, u_int32_t, u_int32_t));
  1082.  */
  1083. int
  1084. __dbcl_rep_set_request(dbenv, min, max)
  1085. DB_ENV * dbenv;
  1086. u_int32_t min;
  1087. u_int32_t max;
  1088. {
  1089. COMPQUIET(min, 0);
  1090. COMPQUIET(max, 0);
  1091. return (__dbcl_rpc_illegal(dbenv, "rep_set_request"));
  1092. }
  1094. /*
  1095.  * PUBLIC: int __dbcl_rep_set_rep_transport __P((DB_ENV *, int,
  1096.  * PUBLIC:      int (*)(DB_ENV *, const DBT *, const DBT *, int, u_int32_t)));
  1097.  */
  1098. int
  1099. __dbcl_rep_set_rep_transport(dbenv, id, func0)
  1100. DB_ENV * dbenv;
  1101. int id;
  1102. int (*func0) __P((DB_ENV *, const DBT *, const DBT *, int, u_int32_t));
  1103. {
  1104. COMPQUIET(id, 0);
  1105. COMPQUIET(func0, 0);
  1106. return (__dbcl_rpc_illegal(dbenv, "rep_set_rep_transport"));
  1107. }
  1109. /*
  1110.  * PUBLIC: int __dbcl_rep_start __P((DB_ENV *, DBT *, u_int32_t));
  1111.  */
  1112. int
  1113. __dbcl_rep_start(dbenv, cdata, flags)
  1114. DB_ENV * dbenv;
  1115. DBT * cdata;
  1116. u_int32_t flags;
  1117. {
  1118. COMPQUIET(cdata, NULL);
  1119. COMPQUIET(flags, 0);
  1120. return (__dbcl_rpc_illegal(dbenv, "rep_start"));
  1121. }
  1123. /*
  1124.  * PUBLIC: int __dbcl_rep_stat __P((DB_ENV *, DB_REP_STAT **, u_int32_t));
  1125.  */
  1126. int
  1127. __dbcl_rep_stat(dbenv, statp, flags)
  1128. DB_ENV * dbenv;
  1129. DB_REP_STAT ** statp;
  1130. u_int32_t flags;
  1131. {
  1132. COMPQUIET(statp, 0);
  1133. COMPQUIET(flags, 0);
  1134. return (__dbcl_rpc_illegal(dbenv, "rep_stat"));
  1135. }
  1137. /*
  1138.  * PUBLIC: int __dbcl_db_alloc __P((DB *, void *(*)(size_t), void *(*)(void *,
  1139.  * PUBLIC:      size_t), void (*)(void *)));
  1140.  */
  1141. int
  1142. __dbcl_db_alloc(dbp, func0, func1, func2)
  1143. DB * dbp;
  1144. void *(*func0) __P((size_t));
  1145. void *(*func1) __P((void *, size_t));
  1146. void (*func2) __P((void *));
  1147. {
  1148. DB_ENV *dbenv;
  1150. dbenv = dbp->dbenv;
  1151. COMPQUIET(func0, 0);
  1152. COMPQUIET(func1, 0);
  1153. COMPQUIET(func2, 0);
  1154. return (__dbcl_rpc_illegal(dbenv, "db_alloc"));
  1155. }
  1157. /*
  1158.  * PUBLIC: int __dbcl_db_associate __P((DB *, DB_TXN *, DB *, int (*)(DB *,
  1159.  * PUBLIC:      const DBT *, const DBT *, DBT *), u_int32_t));
  1160.  */
  1161. int
  1162. __dbcl_db_associate(dbp, txnp, sdbp, func0, flags)
  1163. DB * dbp;
  1164. DB_TXN * txnp;
  1165. DB * sdbp;
  1166. int (*func0) __P((DB *, const DBT *, const DBT *, DBT *));
  1167. u_int32_t flags;
  1168. {
  1169. CLIENT *cl;
  1170. __db_associate_msg msg;
  1171. __db_associate_reply *replyp = NULL;
  1172. int ret;
  1173. DB_ENV *dbenv;
  1175. ret = 0;
  1176. dbenv = dbp->dbenv;
  1177. if (dbenv == NULL || !RPC_ON(dbenv))
  1178. return (__dbcl_noserver(NULL));
  1180. cl = (CLIENT *)dbenv->cl_handle;
  1182. if (func0 != NULL) {
  1183. __db_err(dbenv, "User functions not supported in RPC");
  1184. return (EINVAL);
  1185. }
  1186. if (dbp == NULL)
  1187. msg.dbpcl_id = 0;
  1188. else
  1189. msg.dbpcl_id = dbp->cl_id;
  1190. if (txnp == NULL)
  1191. msg.txnpcl_id = 0;
  1192. else
  1193. msg.txnpcl_id = txnp->txnid;
  1194. if (sdbp == NULL)
  1195. msg.sdbpcl_id = 0;
  1196. else
  1197. msg.sdbpcl_id = sdbp->cl_id;
  1198. msg.flags = flags;
  1200. replyp = __db_db_associate_4001(&msg, cl);
  1201. if (replyp == NULL) {
  1202. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  1203. ret = DB_NOSERVER;
  1204. goto out;
  1205. }
  1206. ret = replyp->status;
  1207. out:
  1208. if (replyp != NULL)
  1209. xdr_free((xdrproc_t)xdr___db_associate_reply, (void *)replyp);
  1210. return (ret);
  1211. }
  1213. /*
  1214.  * PUBLIC: int __dbcl_db_bt_compare __P((DB *, int (*)(DB *, const DBT *,
  1215.  * PUBLIC:      const DBT *)));
  1216.  */
  1217. int
  1218. __dbcl_db_bt_compare(dbp, func0)
  1219. DB * dbp;
  1220. int (*func0) __P((DB *, const DBT *, const DBT *));
  1221. {
  1222. DB_ENV *dbenv;
  1224. dbenv = dbp->dbenv;
  1225. COMPQUIET(func0, 0);
  1226. return (__dbcl_rpc_illegal(dbenv, "db_bt_compare"));
  1227. }
  1229. /*
  1230.  * PUBLIC: int __dbcl_db_bt_maxkey __P((DB *, u_int32_t));
  1231.  */
  1232. int
  1233. __dbcl_db_bt_maxkey(dbp, maxkey)
  1234. DB * dbp;
  1235. u_int32_t maxkey;
  1236. {
  1237. CLIENT *cl;
  1238. __db_bt_maxkey_msg msg;
  1239. __db_bt_maxkey_reply *replyp = NULL;
  1240. int ret;
  1241. DB_ENV *dbenv;
  1243. ret = 0;
  1244. dbenv = dbp->dbenv;
  1245. if (dbenv == NULL || !RPC_ON(dbenv))
  1246. return (__dbcl_noserver(NULL));
  1248. cl = (CLIENT *)dbenv->cl_handle;
  1250. if (dbp == NULL)
  1251. msg.dbpcl_id = 0;
  1252. else
  1253. msg.dbpcl_id = dbp->cl_id;
  1254. msg.maxkey = maxkey;
  1256. replyp = __db_db_bt_maxkey_4001(&msg, cl);
  1257. if (replyp == NULL) {
  1258. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  1259. ret = DB_NOSERVER;
  1260. goto out;
  1261. }
  1262. ret = replyp->status;
  1263. out:
  1264. if (replyp != NULL)
  1265. xdr_free((xdrproc_t)xdr___db_bt_maxkey_reply, (void *)replyp);
  1266. return (ret);
  1267. }
  1269. /*
  1270.  * PUBLIC: int __dbcl_db_bt_minkey __P((DB *, u_int32_t));
  1271.  */
  1272. int
  1273. __dbcl_db_bt_minkey(dbp, minkey)
  1274. DB * dbp;
  1275. u_int32_t minkey;
  1276. {
  1277. CLIENT *cl;
  1278. __db_bt_minkey_msg msg;
  1279. __db_bt_minkey_reply *replyp = NULL;
  1280. int ret;
  1281. DB_ENV *dbenv;
  1283. ret = 0;
  1284. dbenv = dbp->dbenv;
  1285. if (dbenv == NULL || !RPC_ON(dbenv))
  1286. return (__dbcl_noserver(NULL));
  1288. cl = (CLIENT *)dbenv->cl_handle;
  1290. if (dbp == NULL)
  1291. msg.dbpcl_id = 0;
  1292. else
  1293. msg.dbpcl_id = dbp->cl_id;
  1294. msg.minkey = minkey;
  1296. replyp = __db_db_bt_minkey_4001(&msg, cl);
  1297. if (replyp == NULL) {
  1298. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  1299. ret = DB_NOSERVER;
  1300. goto out;
  1301. }
  1302. ret = replyp->status;
  1303. out:
  1304. if (replyp != NULL)
  1305. xdr_free((xdrproc_t)xdr___db_bt_minkey_reply, (void *)replyp);
  1306. return (ret);
  1307. }
  1309. /*
  1310.  * PUBLIC: int __dbcl_db_bt_prefix __P((DB *, size_t(*)(DB *, const DBT *,
  1311.  * PUBLIC:      const DBT *)));
  1312.  */
  1313. int
  1314. __dbcl_db_bt_prefix(dbp, func0)
  1315. DB * dbp;
  1316. size_t (*func0) __P((DB *, const DBT *, const DBT *));
  1317. {
  1318. DB_ENV *dbenv;
  1320. dbenv = dbp->dbenv;
  1321. COMPQUIET(func0, 0);
  1322. return (__dbcl_rpc_illegal(dbenv, "db_bt_prefix"));
  1323. }
  1325. /*
  1326.  * PUBLIC: int __dbcl_db_set_append_recno __P((DB *, int (*)(DB *, DBT *,
  1327.  * PUBLIC:      db_recno_t)));
  1328.  */
  1329. int
  1330. __dbcl_db_set_append_recno(dbp, func0)
  1331. DB * dbp;
  1332. int (*func0) __P((DB *, DBT *, db_recno_t));
  1333. {
  1334. DB_ENV *dbenv;
  1336. dbenv = dbp->dbenv;
  1337. COMPQUIET(func0, 0);
  1338. return (__dbcl_rpc_illegal(dbenv, "db_set_append_recno"));
  1339. }
  1341. /*
  1342.  * PUBLIC: int __dbcl_db_cache_priority __P((DB *, DB_CACHE_PRIORITY));
  1343.  */
  1344. int
  1345. __dbcl_db_cache_priority(dbp, priority)
  1346. DB * dbp;
  1347. DB_CACHE_PRIORITY priority;
  1348. {
  1349. DB_ENV *dbenv;
  1351. dbenv = dbp->dbenv;
  1352. COMPQUIET(priority, 0);
  1353. return (__dbcl_rpc_illegal(dbenv, "db_cache_priority"));
  1354. }
  1356. /*
  1357.  * PUBLIC: int __dbcl_db_cachesize __P((DB *, u_int32_t, u_int32_t, int));
  1358.  */
  1359. int
  1360. __dbcl_db_cachesize(dbp, gbytes, bytes, ncache)
  1361. DB * dbp;
  1362. u_int32_t gbytes;
  1363. u_int32_t bytes;
  1364. int ncache;
  1365. {
  1366. DB_ENV *dbenv;
  1368. dbenv = dbp->dbenv;
  1369. COMPQUIET(gbytes, 0);
  1370. COMPQUIET(bytes, 0);
  1371. COMPQUIET(ncache, 0);
  1372. return (__dbcl_rpc_illegal(dbenv, "db_cachesize"));
  1373. }
  1375. /*
  1376.  * PUBLIC: int __dbcl_db_close __P((DB *, u_int32_t));
  1377.  */
  1378. int
  1379. __dbcl_db_close(dbp, flags)
  1380. DB * dbp;
  1381. u_int32_t flags;
  1382. {
  1383. CLIENT *cl;
  1384. __db_close_msg msg;
  1385. __db_close_reply *replyp = NULL;
  1386. int ret;
  1387. DB_ENV *dbenv;
  1389. ret = 0;
  1390. dbenv = dbp->dbenv;
  1391. if (dbenv == NULL || !RPC_ON(dbenv))
  1392. return (__dbcl_noserver(NULL));
  1394. cl = (CLIENT *)dbenv->cl_handle;
  1396. if (dbp == NULL)
  1397. msg.dbpcl_id = 0;
  1398. else
  1399. msg.dbpcl_id = dbp->cl_id;
  1400. msg.flags = flags;
  1402. replyp = __db_db_close_4001(&msg, cl);
  1403. if (replyp == NULL) {
  1404. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  1405. ret = DB_NOSERVER;
  1406. goto out;
  1407. }
  1408. ret = __dbcl_db_close_ret(dbp, flags, replyp);
  1409. out:
  1410. if (replyp != NULL)
  1411. xdr_free((xdrproc_t)xdr___db_close_reply, (void *)replyp);
  1412. return (ret);
  1413. }
  1415. /*
  1416.  * PUBLIC: int __dbcl_db_create __P((DB *, DB_ENV *, u_int32_t));
  1417.  */
  1418. int
  1419. __dbcl_db_create(dbp, dbenv, flags)
  1420. DB * dbp;
  1421. DB_ENV * dbenv;
  1422. u_int32_t flags;
  1423. {
  1424. CLIENT *cl;
  1425. __db_create_msg msg;
  1426. __db_create_reply *replyp = NULL;
  1427. int ret;
  1429. ret = 0;
  1430. if (dbenv == NULL || !RPC_ON(dbenv))
  1431. return (__dbcl_noserver(dbenv));
  1433. cl = (CLIENT *)dbenv->cl_handle;
  1435. if (dbenv == NULL)
  1436. msg.dbenvcl_id = 0;
  1437. else
  1438. msg.dbenvcl_id = dbenv->cl_id;
  1439. msg.flags = flags;
  1441. replyp = __db_db_create_4001(&msg, cl);
  1442. if (replyp == NULL) {
  1443. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  1444. ret = DB_NOSERVER;
  1445. goto out;
  1446. }
  1447. ret = __dbcl_db_create_ret(dbp, dbenv, flags, replyp);
  1448. out:
  1449. if (replyp != NULL)
  1450. xdr_free((xdrproc_t)xdr___db_create_reply, (void *)replyp);
  1451. return (ret);
  1452. }
  1454. /*
  1455.  * PUBLIC: int __dbcl_db_del __P((DB *, DB_TXN *, DBT *, u_int32_t));
  1456.  */
  1457. int
  1458. __dbcl_db_del(dbp, txnp, key, flags)
  1459. DB * dbp;
  1460. DB_TXN * txnp;
  1461. DBT * key;
  1462. u_int32_t flags;
  1463. {
  1464. CLIENT *cl;
  1465. __db_del_msg msg;
  1466. __db_del_reply *replyp = NULL;
  1467. int ret;
  1468. DB_ENV *dbenv;
  1470. ret = 0;
  1471. dbenv = dbp->dbenv;
  1472. if (dbenv == NULL || !RPC_ON(dbenv))
  1473. return (__dbcl_noserver(NULL));
  1475. cl = (CLIENT *)dbenv->cl_handle;
  1477. if (dbp == NULL)
  1478. msg.dbpcl_id = 0;
  1479. else
  1480. msg.dbpcl_id = dbp->cl_id;
  1481. if (txnp == NULL)
  1482. msg.txnpcl_id = 0;
  1483. else
  1484. msg.txnpcl_id = txnp->txnid;
  1485. msg.keydlen = key->dlen;
  1486. msg.keydoff = key->doff;
  1487. msg.keyulen = key->ulen;
  1488. msg.keyflags = key->flags;
  1489. msg.keydata.keydata_val = key->data;
  1490. msg.keydata.keydata_len = key->size;
  1491. msg.flags = flags;
  1493. replyp = __db_db_del_4001(&msg, cl);
  1494. if (replyp == NULL) {
  1495. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  1496. ret = DB_NOSERVER;
  1497. goto out;
  1498. }
  1499. ret = replyp->status;
  1500. out:
  1501. if (replyp != NULL)
  1502. xdr_free((xdrproc_t)xdr___db_del_reply, (void *)replyp);
  1503. return (ret);
  1504. }
  1506. /*
  1507.  * PUBLIC: int __dbcl_db_dup_compare __P((DB *, int (*)(DB *, const DBT *,
  1508.  * PUBLIC:      const DBT *)));
  1509.  */
  1510. int
  1511. __dbcl_db_dup_compare(dbp, func0)
  1512. DB * dbp;
  1513. int (*func0) __P((DB *, const DBT *, const DBT *));
  1514. {
  1515. DB_ENV *dbenv;
  1517. dbenv = dbp->dbenv;
  1518. COMPQUIET(func0, 0);
  1519. return (__dbcl_rpc_illegal(dbenv, "db_dup_compare"));
  1520. }
  1522. /*
  1523.  * PUBLIC: int __dbcl_db_encrypt __P((DB *, const char *, u_int32_t));
  1524.  */
  1525. int
  1526. __dbcl_db_encrypt(dbp, passwd, flags)
  1527. DB * dbp;
  1528. const char * passwd;
  1529. u_int32_t flags;
  1530. {
  1531. CLIENT *cl;
  1532. __db_encrypt_msg msg;
  1533. __db_encrypt_reply *replyp = NULL;
  1534. int ret;
  1535. DB_ENV *dbenv;
  1537. ret = 0;
  1538. dbenv = dbp->dbenv;
  1539. if (dbenv == NULL || !RPC_ON(dbenv))
  1540. return (__dbcl_noserver(NULL));
  1542. cl = (CLIENT *)dbenv->cl_handle;
  1544. if (dbp == NULL)
  1545. msg.dbpcl_id = 0;
  1546. else
  1547. msg.dbpcl_id = dbp->cl_id;
  1548. if (passwd == NULL)
  1549. msg.passwd = "";
  1550. else
  1551. msg.passwd = (char *)passwd;
  1552. msg.flags = flags;
  1554. replyp = __db_db_encrypt_4001(&msg, cl);
  1555. if (replyp == NULL) {
  1556. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  1557. ret = DB_NOSERVER;
  1558. goto out;
  1559. }
  1560. ret = replyp->status;
  1561. out:
  1562. if (replyp != NULL)
  1563. xdr_free((xdrproc_t)xdr___db_encrypt_reply, (void *)replyp);
  1564. return (ret);
  1565. }
  1567. /*
  1568.  * PUBLIC: int __dbcl_db_extentsize __P((DB *, u_int32_t));
  1569.  */
  1570. int
  1571. __dbcl_db_extentsize(dbp, extentsize)
  1572. DB * dbp;
  1573. u_int32_t extentsize;
  1574. {
  1575. CLIENT *cl;
  1576. __db_extentsize_msg msg;
  1577. __db_extentsize_reply *replyp = NULL;
  1578. int ret;
  1579. DB_ENV *dbenv;
  1581. ret = 0;
  1582. dbenv = dbp->dbenv;
  1583. if (dbenv == NULL || !RPC_ON(dbenv))
  1584. return (__dbcl_noserver(NULL));
  1586. cl = (CLIENT *)dbenv->cl_handle;
  1588. if (dbp == NULL)
  1589. msg.dbpcl_id = 0;
  1590. else
  1591. msg.dbpcl_id = dbp->cl_id;
  1592. msg.extentsize = extentsize;
  1594. replyp = __db_db_extentsize_4001(&msg, cl);
  1595. if (replyp == NULL) {
  1596. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  1597. ret = DB_NOSERVER;
  1598. goto out;
  1599. }
  1600. ret = replyp->status;
  1601. out:
  1602. if (replyp != NULL)
  1603. xdr_free((xdrproc_t)xdr___db_extentsize_reply, (void *)replyp);
  1604. return (ret);
  1605. }
  1607. /*
  1608.  * PUBLIC: int __dbcl_db_fd __P((DB *, int *));
  1609.  */
  1610. int
  1611. __dbcl_db_fd(dbp, fdp)
  1612. DB * dbp;
  1613. int * fdp;
  1614. {
  1615. DB_ENV *dbenv;
  1617. dbenv = dbp->dbenv;
  1618. COMPQUIET(fdp, 0);
  1619. return (__dbcl_rpc_illegal(dbenv, "db_fd"));
  1620. }
  1622. /*
  1623.  * PUBLIC: int __dbcl_db_feedback __P((DB *, void (*)(DB *, int, int)));
  1624.  */
  1625. int
  1626. __dbcl_db_feedback(dbp, func0)
  1627. DB * dbp;
  1628. void (*func0) __P((DB *, int, int));
  1629. {
  1630. DB_ENV *dbenv;
  1632. dbenv = dbp->dbenv;
  1633. COMPQUIET(func0, 0);
  1634. return (__dbcl_rpc_illegal(dbenv, "db_feedback"));
  1635. }
  1637. /*
  1638.  * PUBLIC: int __dbcl_db_flags __P((DB *, u_int32_t));
  1639.  */
  1640. int
  1641. __dbcl_db_flags(dbp, flags)
  1642. DB * dbp;
  1643. u_int32_t flags;
  1644. {
  1645. CLIENT *cl;
  1646. __db_flags_msg msg;
  1647. __db_flags_reply *replyp = NULL;
  1648. int ret;
  1649. DB_ENV *dbenv;
  1651. ret = 0;
  1652. dbenv = dbp->dbenv;
  1653. if (dbenv == NULL || !RPC_ON(dbenv))
  1654. return (__dbcl_noserver(NULL));
  1656. cl = (CLIENT *)dbenv->cl_handle;
  1658. if (dbp == NULL)
  1659. msg.dbpcl_id = 0;
  1660. else
  1661. msg.dbpcl_id = dbp->cl_id;
  1662. msg.flags = flags;
  1664. replyp = __db_db_flags_4001(&msg, cl);
  1665. if (replyp == NULL) {
  1666. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  1667. ret = DB_NOSERVER;
  1668. goto out;
  1669. }
  1670. ret = replyp->status;
  1671. out:
  1672. if (replyp != NULL)
  1673. xdr_free((xdrproc_t)xdr___db_flags_reply, (void *)replyp);
  1674. return (ret);
  1675. }
  1677. /*
  1678.  * PUBLIC: int __dbcl_db_get __P((DB *, DB_TXN *, DBT *, DBT *, u_int32_t));
  1679.  */
  1680. int
  1681. __dbcl_db_get(dbp, txnp, key, data, flags)
  1682. DB * dbp;
  1683. DB_TXN * txnp;
  1684. DBT * key;
  1685. DBT * data;
  1686. u_int32_t flags;
  1687. {
  1688. CLIENT *cl;
  1689. __db_get_msg msg;
  1690. __db_get_reply *replyp = NULL;
  1691. int ret;
  1692. DB_ENV *dbenv;
  1694. ret = 0;
  1695. dbenv = dbp->dbenv;
  1696. if (dbenv == NULL || !RPC_ON(dbenv))
  1697. return (__dbcl_noserver(NULL));
  1699. cl = (CLIENT *)dbenv->cl_handle;
  1701. if (dbp == NULL)
  1702. msg.dbpcl_id = 0;
  1703. else
  1704. msg.dbpcl_id = dbp->cl_id;
  1705. if (txnp == NULL)
  1706. msg.txnpcl_id = 0;
  1707. else
  1708. msg.txnpcl_id = txnp->txnid;
  1709. msg.keydlen = key->dlen;
  1710. msg.keydoff = key->doff;
  1711. msg.keyulen = key->ulen;
  1712. msg.keyflags = key->flags;
  1713. msg.keydata.keydata_val = key->data;
  1714. msg.keydata.keydata_len = key->size;
  1715. msg.datadlen = data->dlen;
  1716. msg.datadoff = data->doff;
  1717. msg.dataulen = data->ulen;
  1718. msg.dataflags = data->flags;
  1719. msg.datadata.datadata_val = data->data;
  1720. msg.datadata.datadata_len = data->size;
  1721. msg.flags = flags;
  1723. replyp = __db_db_get_4001(&msg, cl);
  1724. if (replyp == NULL) {
  1725. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  1726. ret = DB_NOSERVER;
  1727. goto out;
  1728. }
  1729. ret = __dbcl_db_get_ret(dbp, txnp, key, data, flags, replyp);
  1730. out:
  1731. if (replyp != NULL)
  1732. xdr_free((xdrproc_t)xdr___db_get_reply, (void *)replyp);
  1733. return (ret);
  1734. }
  1736. /*
  1737.  * PUBLIC: int __dbcl_db_h_ffactor __P((DB *, u_int32_t));
  1738.  */
  1739. int
  1740. __dbcl_db_h_ffactor(dbp, ffactor)
  1741. DB * dbp;
  1742. u_int32_t ffactor;
  1743. {
  1744. CLIENT *cl;
  1745. __db_h_ffactor_msg msg;
  1746. __db_h_ffactor_reply *replyp = NULL;
  1747. int ret;
  1748. DB_ENV *dbenv;
  1750. ret = 0;
  1751. dbenv = dbp->dbenv;
  1752. if (dbenv == NULL || !RPC_ON(dbenv))
  1753. return (__dbcl_noserver(NULL));
  1755. cl = (CLIENT *)dbenv->cl_handle;
  1757. if (dbp == NULL)
  1758. msg.dbpcl_id = 0;
  1759. else
  1760. msg.dbpcl_id = dbp->cl_id;
  1761. msg.ffactor = ffactor;
  1763. replyp = __db_db_h_ffactor_4001(&msg, cl);
  1764. if (replyp == NULL) {
  1765. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  1766. ret = DB_NOSERVER;
  1767. goto out;
  1768. }
  1769. ret = replyp->status;
  1770. out:
  1771. if (replyp != NULL)
  1772. xdr_free((xdrproc_t)xdr___db_h_ffactor_reply, (void *)replyp);
  1773. return (ret);
  1774. }
  1776. /*
  1777.  * PUBLIC: int __dbcl_db_h_hash __P((DB *, u_int32_t(*)(DB *, const void *,
  1778.  * PUBLIC:      u_int32_t)));
  1779.  */
  1780. int
  1781. __dbcl_db_h_hash(dbp, func0)
  1782. DB * dbp;
  1783. u_int32_t (*func0) __P((DB *, const void *, u_int32_t));
  1784. {
  1785. DB_ENV *dbenv;
  1787. dbenv = dbp->dbenv;
  1788. COMPQUIET(func0, 0);
  1789. return (__dbcl_rpc_illegal(dbenv, "db_h_hash"));
  1790. }
  1792. /*
  1793.  * PUBLIC: int __dbcl_db_h_nelem __P((DB *, u_int32_t));
  1794.  */
  1795. int
  1796. __dbcl_db_h_nelem(dbp, nelem)
  1797. DB * dbp;
  1798. u_int32_t nelem;
  1799. {
  1800. CLIENT *cl;
  1801. __db_h_nelem_msg msg;
  1802. __db_h_nelem_reply *replyp = NULL;
  1803. int ret;
  1804. DB_ENV *dbenv;
  1806. ret = 0;
  1807. dbenv = dbp->dbenv;
  1808. if (dbenv == NULL || !RPC_ON(dbenv))
  1809. return (__dbcl_noserver(NULL));
  1811. cl = (CLIENT *)dbenv->cl_handle;
  1813. if (dbp == NULL)
  1814. msg.dbpcl_id = 0;
  1815. else
  1816. msg.dbpcl_id = dbp->cl_id;
  1817. msg.nelem = nelem;
  1819. replyp = __db_db_h_nelem_4001(&msg, cl);
  1820. if (replyp == NULL) {
  1821. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  1822. ret = DB_NOSERVER;
  1823. goto out;
  1824. }
  1825. ret = replyp->status;
  1826. out:
  1827. if (replyp != NULL)
  1828. xdr_free((xdrproc_t)xdr___db_h_nelem_reply, (void *)replyp);
  1829. return (ret);
  1830. }
  1832. /*
  1833.  * PUBLIC: int __dbcl_db_key_range __P((DB *, DB_TXN *, DBT *, DB_KEY_RANGE *,
  1834.  * PUBLIC:      u_int32_t));
  1835.  */
  1836. int
  1837. __dbcl_db_key_range(dbp, txnp, key, range, flags)
  1838. DB * dbp;
  1839. DB_TXN * txnp;
  1840. DBT * key;
  1841. DB_KEY_RANGE * range;
  1842. u_int32_t flags;
  1843. {
  1844. CLIENT *cl;
  1845. __db_key_range_msg msg;
  1846. __db_key_range_reply *replyp = NULL;
  1847. int ret;
  1848. DB_ENV *dbenv;
  1850. ret = 0;
  1851. dbenv = dbp->dbenv;
  1852. if (dbenv == NULL || !RPC_ON(dbenv))
  1853. return (__dbcl_noserver(NULL));
  1855. cl = (CLIENT *)dbenv->cl_handle;
  1857. if (dbp == NULL)
  1858. msg.dbpcl_id = 0;
  1859. else
  1860. msg.dbpcl_id = dbp->cl_id;
  1861. if (txnp == NULL)
  1862. msg.txnpcl_id = 0;
  1863. else
  1864. msg.txnpcl_id = txnp->txnid;
  1865. msg.keydlen = key->dlen;
  1866. msg.keydoff = key->doff;
  1867. msg.keyulen = key->ulen;
  1868. msg.keyflags = key->flags;
  1869. msg.keydata.keydata_val = key->data;
  1870. msg.keydata.keydata_len = key->size;
  1871. msg.flags = flags;
  1873. replyp = __db_db_key_range_4001(&msg, cl);
  1874. if (replyp == NULL) {
  1875. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  1876. ret = DB_NOSERVER;
  1877. goto out;
  1878. }
  1879. ret = __dbcl_db_key_range_ret(dbp, txnp, key, range, flags, replyp);
  1880. out:
  1881. if (replyp != NULL)
  1882. xdr_free((xdrproc_t)xdr___db_key_range_reply, (void *)replyp);
  1883. return (ret);
  1884. }
  1886. /*
  1887.  * PUBLIC: int __dbcl_db_lorder __P((DB *, int));
  1888.  */
  1889. int
  1890. __dbcl_db_lorder(dbp, lorder)
  1891. DB * dbp;
  1892. int lorder;
  1893. {
  1894. CLIENT *cl;
  1895. __db_lorder_msg msg;
  1896. __db_lorder_reply *replyp = NULL;
  1897. int ret;
  1898. DB_ENV *dbenv;
  1900. ret = 0;
  1901. dbenv = dbp->dbenv;
  1902. if (dbenv == NULL || !RPC_ON(dbenv))
  1903. return (__dbcl_noserver(NULL));
  1905. cl = (CLIENT *)dbenv->cl_handle;
  1907. if (dbp == NULL)
  1908. msg.dbpcl_id = 0;
  1909. else
  1910. msg.dbpcl_id = dbp->cl_id;
  1911. msg.lorder = lorder;
  1913. replyp = __db_db_lorder_4001(&msg, cl);
  1914. if (replyp == NULL) {
  1915. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  1916. ret = DB_NOSERVER;
  1917. goto out;
  1918. }
  1919. ret = replyp->status;
  1920. out:
  1921. if (replyp != NULL)
  1922. xdr_free((xdrproc_t)xdr___db_lorder_reply, (void *)replyp);
  1923. return (ret);
  1924. }
  1926. /*
  1927.  * PUBLIC: int __dbcl_db_open __P((DB *, DB_TXN *, const char *, const char *,
  1928.  * PUBLIC:      DBTYPE, u_int32_t, int));
  1929.  */
  1930. int
  1931. __dbcl_db_open(dbp, txnp, name, subdb, type, flags, mode)
  1932. DB * dbp;
  1933. DB_TXN * txnp;
  1934. const char * name;
  1935. const char * subdb;
  1936. DBTYPE type;
  1937. u_int32_t flags;
  1938. int mode;
  1939. {
  1940. CLIENT *cl;
  1941. __db_open_msg msg;
  1942. __db_open_reply *replyp = NULL;
  1943. int ret;
  1944. DB_ENV *dbenv;
  1946. ret = 0;
  1947. dbenv = dbp->dbenv;
  1948. if (dbenv == NULL || !RPC_ON(dbenv))
  1949. return (__dbcl_noserver(NULL));
  1951. cl = (CLIENT *)dbenv->cl_handle;
  1953. if (dbp == NULL)
  1954. msg.dbpcl_id = 0;
  1955. else
  1956. msg.dbpcl_id = dbp->cl_id;
  1957. if (txnp == NULL)
  1958. msg.txnpcl_id = 0;
  1959. else
  1960. msg.txnpcl_id = txnp->txnid;
  1961. if (name == NULL)
  1962. msg.name = "";
  1963. else
  1964. msg.name = (char *)name;
  1965. if (subdb == NULL)
  1966. msg.subdb = "";
  1967. else
  1968. msg.subdb = (char *)subdb;
  1969. msg.type = type;
  1970. msg.flags = flags;
  1971. msg.mode = mode;
  1973. replyp = __db_db_open_4001(&msg, cl);
  1974. if (replyp == NULL) {
  1975. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  1976. ret = DB_NOSERVER;
  1977. goto out;
  1978. }
  1979. ret = __dbcl_db_open_ret(dbp, txnp, name, subdb, type, flags, mode, replyp);
  1980. out:
  1981. if (replyp != NULL)
  1982. xdr_free((xdrproc_t)xdr___db_open_reply, (void *)replyp);
  1983. return (ret);
  1984. }
  1986. /*
  1987.  * PUBLIC: int __dbcl_db_pagesize __P((DB *, u_int32_t));
  1988.  */
  1989. int
  1990. __dbcl_db_pagesize(dbp, pagesize)
  1991. DB * dbp;
  1992. u_int32_t pagesize;
  1993. {
  1994. CLIENT *cl;
  1995. __db_pagesize_msg msg;
  1996. __db_pagesize_reply *replyp = NULL;
  1997. int ret;
  1998. DB_ENV *dbenv;
  2000. ret = 0;
  2001. dbenv = dbp->dbenv;
  2002. if (dbenv == NULL || !RPC_ON(dbenv))
  2003. return (__dbcl_noserver(NULL));
  2005. cl = (CLIENT *)dbenv->cl_handle;
  2007. if (dbp == NULL)
  2008. msg.dbpcl_id = 0;
  2009. else
  2010. msg.dbpcl_id = dbp->cl_id;
  2011. msg.pagesize = pagesize;
  2013. replyp = __db_db_pagesize_4001(&msg, cl);
  2014. if (replyp == NULL) {
  2015. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  2016. ret = DB_NOSERVER;
  2017. goto out;
  2018. }
  2019. ret = replyp->status;
  2020. out:
  2021. if (replyp != NULL)
  2022. xdr_free((xdrproc_t)xdr___db_pagesize_reply, (void *)replyp);
  2023. return (ret);
  2024. }
  2026. /*
  2027.  * PUBLIC: int __dbcl_db_panic __P((DB *, void (*)(DB_ENV *, int)));
  2028.  */
  2029. int
  2030. __dbcl_db_panic(dbp, func0)
  2031. DB * dbp;
  2032. void (*func0) __P((DB_ENV *, int));
  2033. {
  2034. DB_ENV *dbenv;
  2036. dbenv = dbp->dbenv;
  2037. COMPQUIET(func0, 0);
  2038. return (__dbcl_rpc_illegal(dbenv, "db_panic"));
  2039. }
  2041. /*
  2042.  * PUBLIC: int __dbcl_db_pget __P((DB *, DB_TXN *, DBT *, DBT *, DBT *,
  2043.  * PUBLIC:      u_int32_t));
  2044.  */
  2045. int
  2046. __dbcl_db_pget(dbp, txnp, skey, pkey, data, flags)
  2047. DB * dbp;
  2048. DB_TXN * txnp;
  2049. DBT * skey;
  2050. DBT * pkey;
  2051. DBT * data;
  2052. u_int32_t flags;
  2053. {
  2054. CLIENT *cl;
  2055. __db_pget_msg msg;
  2056. __db_pget_reply *replyp = NULL;
  2057. int ret;
  2058. DB_ENV *dbenv;
  2060. ret = 0;
  2061. dbenv = dbp->dbenv;
  2062. if (dbenv == NULL || !RPC_ON(dbenv))
  2063. return (__dbcl_noserver(NULL));
  2065. cl = (CLIENT *)dbenv->cl_handle;
  2067. if (dbp == NULL)
  2068. msg.dbpcl_id = 0;
  2069. else
  2070. msg.dbpcl_id = dbp->cl_id;
  2071. if (txnp == NULL)
  2072. msg.txnpcl_id = 0;
  2073. else
  2074. msg.txnpcl_id = txnp->txnid;
  2075. msg.skeydlen = skey->dlen;
  2076. msg.skeydoff = skey->doff;
  2077. msg.skeyulen = skey->ulen;
  2078. msg.skeyflags = skey->flags;
  2079. msg.skeydata.skeydata_val = skey->data;
  2080. msg.skeydata.skeydata_len = skey->size;
  2081. msg.pkeydlen = pkey->dlen;
  2082. msg.pkeydoff = pkey->doff;
  2083. msg.pkeyulen = pkey->ulen;
  2084. msg.pkeyflags = pkey->flags;
  2085. msg.pkeydata.pkeydata_val = pkey->data;
  2086. msg.pkeydata.pkeydata_len = pkey->size;
  2087. msg.datadlen = data->dlen;
  2088. msg.datadoff = data->doff;
  2089. msg.dataulen = data->ulen;
  2090. msg.dataflags = data->flags;
  2091. msg.datadata.datadata_val = data->data;
  2092. msg.datadata.datadata_len = data->size;
  2093. msg.flags = flags;
  2095. replyp = __db_db_pget_4001(&msg, cl);
  2096. if (replyp == NULL) {
  2097. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  2098. ret = DB_NOSERVER;
  2099. goto out;
  2100. }
  2101. ret = __dbcl_db_pget_ret(dbp, txnp, skey, pkey, data, flags, replyp);
  2102. out:
  2103. if (replyp != NULL)
  2104. xdr_free((xdrproc_t)xdr___db_pget_reply, (void *)replyp);
  2105. return (ret);
  2106. }
  2108. /*
  2109.  * PUBLIC: int __dbcl_db_put __P((DB *, DB_TXN *, DBT *, DBT *, u_int32_t));
  2110.  */
  2111. int
  2112. __dbcl_db_put(dbp, txnp, key, data, flags)
  2113. DB * dbp;
  2114. DB_TXN * txnp;
  2115. DBT * key;
  2116. DBT * data;
  2117. u_int32_t flags;
  2118. {
  2119. CLIENT *cl;
  2120. __db_put_msg msg;
  2121. __db_put_reply *replyp = NULL;
  2122. int ret;
  2123. DB_ENV *dbenv;
  2125. ret = 0;
  2126. dbenv = dbp->dbenv;
  2127. if (dbenv == NULL || !RPC_ON(dbenv))
  2128. return (__dbcl_noserver(NULL));
  2130. cl = (CLIENT *)dbenv->cl_handle;
  2132. if (dbp == NULL)
  2133. msg.dbpcl_id = 0;
  2134. else
  2135. msg.dbpcl_id = dbp->cl_id;
  2136. if (txnp == NULL)
  2137. msg.txnpcl_id = 0;
  2138. else
  2139. msg.txnpcl_id = txnp->txnid;
  2140. msg.keydlen = key->dlen;
  2141. msg.keydoff = key->doff;
  2142. msg.keyulen = key->ulen;
  2143. msg.keyflags = key->flags;
  2144. msg.keydata.keydata_val = key->data;
  2145. msg.keydata.keydata_len = key->size;
  2146. msg.datadlen = data->dlen;
  2147. msg.datadoff = data->doff;
  2148. msg.dataulen = data->ulen;
  2149. msg.dataflags = data->flags;
  2150. msg.datadata.datadata_val = data->data;
  2151. msg.datadata.datadata_len = data->size;
  2152. msg.flags = flags;
  2154. replyp = __db_db_put_4001(&msg, cl);
  2155. if (replyp == NULL) {
  2156. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  2157. ret = DB_NOSERVER;
  2158. goto out;
  2159. }
  2160. ret = __dbcl_db_put_ret(dbp, txnp, key, data, flags, replyp);
  2161. out:
  2162. if (replyp != NULL)
  2163. xdr_free((xdrproc_t)xdr___db_put_reply, (void *)replyp);
  2164. return (ret);
  2165. }
  2167. /*
  2168.  * PUBLIC: int __dbcl_db_re_delim __P((DB *, int));
  2169.  */
  2170. int
  2171. __dbcl_db_re_delim(dbp, delim)
  2172. DB * dbp;
  2173. int delim;
  2174. {
  2175. CLIENT *cl;
  2176. __db_re_delim_msg msg;
  2177. __db_re_delim_reply *replyp = NULL;
  2178. int ret;
  2179. DB_ENV *dbenv;
  2181. ret = 0;
  2182. dbenv = dbp->dbenv;
  2183. if (dbenv == NULL || !RPC_ON(dbenv))
  2184. return (__dbcl_noserver(NULL));
  2186. cl = (CLIENT *)dbenv->cl_handle;
  2188. if (dbp == NULL)
  2189. msg.dbpcl_id = 0;
  2190. else
  2191. msg.dbpcl_id = dbp->cl_id;
  2192. msg.delim = delim;
  2194. replyp = __db_db_re_delim_4001(&msg, cl);
  2195. if (replyp == NULL) {
  2196. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  2197. ret = DB_NOSERVER;
  2198. goto out;
  2199. }
  2200. ret = replyp->status;
  2201. out:
  2202. if (replyp != NULL)
  2203. xdr_free((xdrproc_t)xdr___db_re_delim_reply, (void *)replyp);
  2204. return (ret);
  2205. }
  2207. /*
  2208.  * PUBLIC: int __dbcl_db_re_len __P((DB *, u_int32_t));
  2209.  */
  2210. int
  2211. __dbcl_db_re_len(dbp, len)
  2212. DB * dbp;
  2213. u_int32_t len;
  2214. {
  2215. CLIENT *cl;
  2216. __db_re_len_msg msg;
  2217. __db_re_len_reply *replyp = NULL;
  2218. int ret;
  2219. DB_ENV *dbenv;
  2221. ret = 0;
  2222. dbenv = dbp->dbenv;
  2223. if (dbenv == NULL || !RPC_ON(dbenv))
  2224. return (__dbcl_noserver(NULL));
  2226. cl = (CLIENT *)dbenv->cl_handle;
  2228. if (dbp == NULL)
  2229. msg.dbpcl_id = 0;
  2230. else
  2231. msg.dbpcl_id = dbp->cl_id;
  2232. msg.len = len;
  2234. replyp = __db_db_re_len_4001(&msg, cl);
  2235. if (replyp == NULL) {
  2236. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  2237. ret = DB_NOSERVER;
  2238. goto out;
  2239. }
  2240. ret = replyp->status;
  2241. out:
  2242. if (replyp != NULL)
  2243. xdr_free((xdrproc_t)xdr___db_re_len_reply, (void *)replyp);
  2244. return (ret);
  2245. }
  2247. /*
  2248.  * PUBLIC: int __dbcl_db_re_pad __P((DB *, int));
  2249.  */
  2250. int
  2251. __dbcl_db_re_pad(dbp, pad)
  2252. DB * dbp;
  2253. int pad;
  2254. {
  2255. CLIENT *cl;
  2256. __db_re_pad_msg msg;
  2257. __db_re_pad_reply *replyp = NULL;
  2258. int ret;
  2259. DB_ENV *dbenv;
  2261. ret = 0;
  2262. dbenv = dbp->dbenv;
  2263. if (dbenv == NULL || !RPC_ON(dbenv))
  2264. return (__dbcl_noserver(NULL));
  2266. cl = (CLIENT *)dbenv->cl_handle;
  2268. if (dbp == NULL)
  2269. msg.dbpcl_id = 0;
  2270. else
  2271. msg.dbpcl_id = dbp->cl_id;
  2272. msg.pad = pad;
  2274. replyp = __db_db_re_pad_4001(&msg, cl);
  2275. if (replyp == NULL) {
  2276. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  2277. ret = DB_NOSERVER;
  2278. goto out;
  2279. }
  2280. ret = replyp->status;
  2281. out:
  2282. if (replyp != NULL)
  2283. xdr_free((xdrproc_t)xdr___db_re_pad_reply, (void *)replyp);
  2284. return (ret);
  2285. }
  2287. /*
  2288.  * PUBLIC: int __dbcl_db_re_source __P((DB *, const char *));
  2289.  */
  2290. int
  2291. __dbcl_db_re_source(dbp, re_source)
  2292. DB * dbp;
  2293. const char * re_source;
  2294. {
  2295. DB_ENV *dbenv;
  2297. dbenv = dbp->dbenv;
  2298. COMPQUIET(re_source, NULL);
  2299. return (__dbcl_rpc_illegal(dbenv, "db_re_source"));
  2300. }
  2302. /*
  2303.  * PUBLIC: int __dbcl_db_remove __P((DB *, const char *, const char *,
  2304.  * PUBLIC:      u_int32_t));
  2305.  */
  2306. int
  2307. __dbcl_db_remove(dbp, name, subdb, flags)
  2308. DB * dbp;
  2309. const char * name;
  2310. const char * subdb;
  2311. u_int32_t flags;
  2312. {
  2313. CLIENT *cl;
  2314. __db_remove_msg msg;
  2315. __db_remove_reply *replyp = NULL;
  2316. int ret;
  2317. DB_ENV *dbenv;
  2319. ret = 0;
  2320. dbenv = dbp->dbenv;
  2321. if (dbenv == NULL || !RPC_ON(dbenv))
  2322. return (__dbcl_noserver(NULL));
  2324. cl = (CLIENT *)dbenv->cl_handle;
  2326. if (dbp == NULL)
  2327. msg.dbpcl_id = 0;
  2328. else
  2329. msg.dbpcl_id = dbp->cl_id;
  2330. if (name == NULL)
  2331. msg.name = "";
  2332. else
  2333. msg.name = (char *)name;
  2334. if (subdb == NULL)
  2335. msg.subdb = "";
  2336. else
  2337. msg.subdb = (char *)subdb;
  2338. msg.flags = flags;
  2340. replyp = __db_db_remove_4001(&msg, cl);
  2341. if (replyp == NULL) {
  2342. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  2343. ret = DB_NOSERVER;
  2344. goto out;
  2345. }
  2346. ret = __dbcl_db_remove_ret(dbp, name, subdb, flags, replyp);
  2347. out:
  2348. if (replyp != NULL)
  2349. xdr_free((xdrproc_t)xdr___db_remove_reply, (void *)replyp);
  2350. return (ret);
  2351. }
  2353. /*
  2354.  * PUBLIC: int __dbcl_db_rename __P((DB *, const char *, const char *,
  2355.  * PUBLIC:      const char *, u_int32_t));
  2356.  */
  2357. int
  2358. __dbcl_db_rename(dbp, name, subdb, newname, flags)
  2359. DB * dbp;
  2360. const char * name;
  2361. const char * subdb;
  2362. const char * newname;
  2363. u_int32_t flags;
  2364. {
  2365. CLIENT *cl;
  2366. __db_rename_msg msg;
  2367. __db_rename_reply *replyp = NULL;
  2368. int ret;
  2369. DB_ENV *dbenv;
  2371. ret = 0;
  2372. dbenv = dbp->dbenv;
  2373. if (dbenv == NULL || !RPC_ON(dbenv))
  2374. return (__dbcl_noserver(NULL));
  2376. cl = (CLIENT *)dbenv->cl_handle;
  2378. if (dbp == NULL)
  2379. msg.dbpcl_id = 0;
  2380. else
  2381. msg.dbpcl_id = dbp->cl_id;
  2382. if (name == NULL)
  2383. msg.name = "";
  2384. else
  2385. msg.name = (char *)name;
  2386. if (subdb == NULL)
  2387. msg.subdb = "";
  2388. else
  2389. msg.subdb = (char *)subdb;
  2390. if (newname == NULL)
  2391. msg.newname = "";
  2392. else
  2393. msg.newname = (char *)newname;
  2394. msg.flags = flags;
  2396. replyp = __db_db_rename_4001(&msg, cl);
  2397. if (replyp == NULL) {
  2398. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  2399. ret = DB_NOSERVER;
  2400. goto out;
  2401. }
  2402. ret = __dbcl_db_rename_ret(dbp, name, subdb, newname, flags, replyp);
  2403. out:
  2404. if (replyp != NULL)
  2405. xdr_free((xdrproc_t)xdr___db_rename_reply, (void *)replyp);
  2406. return (ret);
  2407. }
  2409. /*
  2410.  * PUBLIC: int __dbcl_db_stat __P((DB *, void *, u_int32_t));
  2411.  */
  2412. int
  2413. __dbcl_db_stat(dbp, sp, flags)
  2414. DB * dbp;
  2415. void * sp;
  2416. u_int32_t flags;
  2417. {
  2418. CLIENT *cl;
  2419. __db_stat_msg msg;
  2420. __db_stat_reply *replyp = NULL;
  2421. int ret;
  2422. DB_ENV *dbenv;
  2424. ret = 0;
  2425. dbenv = dbp->dbenv;
  2426. if (dbenv == NULL || !RPC_ON(dbenv))
  2427. return (__dbcl_noserver(NULL));
  2429. cl = (CLIENT *)dbenv->cl_handle;
  2431. if (dbp == NULL)
  2432. msg.dbpcl_id = 0;
  2433. else
  2434. msg.dbpcl_id = dbp->cl_id;
  2435. msg.flags = flags;
  2437. replyp = __db_db_stat_4001(&msg, cl);
  2438. if (replyp == NULL) {
  2439. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  2440. ret = DB_NOSERVER;
  2441. goto out;
  2442. }
  2443. ret = __dbcl_db_stat_ret(dbp, sp, flags, replyp);
  2444. out:
  2445. if (replyp != NULL)
  2446. xdr_free((xdrproc_t)xdr___db_stat_reply, (void *)replyp);
  2447. return (ret);
  2448. }
  2450. /*
  2451.  * PUBLIC: int __dbcl_db_sync __P((DB *, u_int32_t));
  2452.  */
  2453. int
  2454. __dbcl_db_sync(dbp, flags)
  2455. DB * dbp;
  2456. u_int32_t flags;
  2457. {
  2458. CLIENT *cl;
  2459. __db_sync_msg msg;
  2460. __db_sync_reply *replyp = NULL;
  2461. int ret;
  2462. DB_ENV *dbenv;
  2464. ret = 0;
  2465. dbenv = dbp->dbenv;
  2466. if (dbenv == NULL || !RPC_ON(dbenv))
  2467. return (__dbcl_noserver(NULL));
  2469. cl = (CLIENT *)dbenv->cl_handle;
  2471. if (dbp == NULL)
  2472. msg.dbpcl_id = 0;
  2473. else
  2474. msg.dbpcl_id = dbp->cl_id;
  2475. msg.flags = flags;
  2477. replyp = __db_db_sync_4001(&msg, cl);
  2478. if (replyp == NULL) {
  2479. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  2480. ret = DB_NOSERVER;
  2481. goto out;
  2482. }
  2483. ret = replyp->status;
  2484. out:
  2485. if (replyp != NULL)
  2486. xdr_free((xdrproc_t)xdr___db_sync_reply, (void *)replyp);
  2487. return (ret);
  2488. }
  2490. /*
  2491.  * PUBLIC: int __dbcl_db_truncate __P((DB *, DB_TXN *, u_int32_t  *,
  2492.  * PUBLIC:      u_int32_t));
  2493.  */
  2494. int
  2495. __dbcl_db_truncate(dbp, txnp, countp, flags)
  2496. DB * dbp;
  2497. DB_TXN * txnp;
  2498. u_int32_t  * countp;
  2499. u_int32_t flags;
  2500. {
  2501. CLIENT *cl;
  2502. __db_truncate_msg msg;
  2503. __db_truncate_reply *replyp = NULL;
  2504. int ret;
  2505. DB_ENV *dbenv;
  2507. ret = 0;
  2508. dbenv = dbp->dbenv;
  2509. if (dbenv == NULL || !RPC_ON(dbenv))
  2510. return (__dbcl_noserver(NULL));
  2512. cl = (CLIENT *)dbenv->cl_handle;
  2514. if (dbp == NULL)
  2515. msg.dbpcl_id = 0;
  2516. else
  2517. msg.dbpcl_id = dbp->cl_id;
  2518. if (txnp == NULL)
  2519. msg.txnpcl_id = 0;
  2520. else
  2521. msg.txnpcl_id = txnp->txnid;
  2522. msg.flags = flags;
  2524. replyp = __db_db_truncate_4001(&msg, cl);
  2525. if (replyp == NULL) {
  2526. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  2527. ret = DB_NOSERVER;
  2528. goto out;
  2529. }
  2530. ret = __dbcl_db_truncate_ret(dbp, txnp, countp, flags, replyp);
  2531. out:
  2532. if (replyp != NULL)
  2533. xdr_free((xdrproc_t)xdr___db_truncate_reply, (void *)replyp);
  2534. return (ret);
  2535. }
  2537. /*
  2538.  * PUBLIC: int __dbcl_db_upgrade __P((DB *, const char *, u_int32_t));
  2539.  */
  2540. int
  2541. __dbcl_db_upgrade(dbp, fname, flags)
  2542. DB * dbp;
  2543. const char * fname;
  2544. u_int32_t flags;
  2545. {
  2546. DB_ENV *dbenv;
  2548. dbenv = dbp->dbenv;
  2549. COMPQUIET(fname, NULL);
  2550. COMPQUIET(flags, 0);
  2551. return (__dbcl_rpc_illegal(dbenv, "db_upgrade"));
  2552. }
  2554. /*
  2555.  * PUBLIC: int __dbcl_db_verify __P((DB *, const char *, const char *, FILE *,
  2556.  * PUBLIC:      u_int32_t));
  2557.  */
  2558. int
  2559. __dbcl_db_verify(dbp, fname, subdb, outfile, flags)
  2560. DB * dbp;
  2561. const char * fname;
  2562. const char * subdb;
  2563. FILE * outfile;
  2564. u_int32_t flags;
  2565. {
  2566. DB_ENV *dbenv;
  2568. dbenv = dbp->dbenv;
  2569. COMPQUIET(fname, NULL);
  2570. COMPQUIET(subdb, NULL);
  2571. COMPQUIET(outfile, 0);
  2572. COMPQUIET(flags, 0);
  2573. return (__dbcl_rpc_illegal(dbenv, "db_verify"));
  2574. }
  2576. /*
  2577.  * PUBLIC: int __dbcl_db_cursor __P((DB *, DB_TXN *, DBC **, u_int32_t));
  2578.  */
  2579. int
  2580. __dbcl_db_cursor(dbp, txnp, dbcpp, flags)
  2581. DB * dbp;
  2582. DB_TXN * txnp;
  2583. DBC ** dbcpp;
  2584. u_int32_t flags;
  2585. {
  2586. CLIENT *cl;
  2587. __db_cursor_msg msg;
  2588. __db_cursor_reply *replyp = NULL;
  2589. int ret;
  2590. DB_ENV *dbenv;
  2592. ret = 0;
  2593. dbenv = dbp->dbenv;
  2594. if (dbenv == NULL || !RPC_ON(dbenv))
  2595. return (__dbcl_noserver(NULL));
  2597. cl = (CLIENT *)dbenv->cl_handle;
  2599. if (dbp == NULL)
  2600. msg.dbpcl_id = 0;
  2601. else
  2602. msg.dbpcl_id = dbp->cl_id;
  2603. if (txnp == NULL)
  2604. msg.txnpcl_id = 0;
  2605. else
  2606. msg.txnpcl_id = txnp->txnid;
  2607. msg.flags = flags;
  2609. replyp = __db_db_cursor_4001(&msg, cl);
  2610. if (replyp == NULL) {
  2611. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  2612. ret = DB_NOSERVER;
  2613. goto out;
  2614. }
  2615. ret = __dbcl_db_cursor_ret(dbp, txnp, dbcpp, flags, replyp);
  2616. out:
  2617. if (replyp != NULL)
  2618. xdr_free((xdrproc_t)xdr___db_cursor_reply, (void *)replyp);
  2619. return (ret);
  2620. }
  2622. /*
  2623.  * PUBLIC: int __dbcl_db_join __P((DB *, DBC **, DBC **, u_int32_t));
  2624.  */
  2625. int
  2626. __dbcl_db_join(dbp, curs, dbcp, flags)
  2627. DB * dbp;
  2628. DBC ** curs;
  2629. DBC ** dbcp;
  2630. u_int32_t flags;
  2631. {
  2632. CLIENT *cl;
  2633. __db_join_msg msg;
  2634. __db_join_reply *replyp = NULL;
  2635. int ret;
  2636. DB_ENV *dbenv;
  2637. DBC ** cursp;
  2638. int cursi;
  2639. u_int32_t * cursq;
  2641. ret = 0;
  2642. dbenv = dbp->dbenv;
  2643. if (dbenv == NULL || !RPC_ON(dbenv))
  2644. return (__dbcl_noserver(NULL));
  2646. cl = (CLIENT *)dbenv->cl_handle;
  2648. if (dbp == NULL)
  2649. msg.dbpcl_id = 0;
  2650. else
  2651. msg.dbpcl_id = dbp->cl_id;
  2652. for (cursi = 0, cursp = curs; *cursp != 0;  cursi++, cursp++)
  2653. ;
  2654. msg.curs.curs_len = cursi;
  2655. if ((ret = __os_calloc(dbenv,
  2656.     msg.curs.curs_len, sizeof(u_int32_t), &msg.curs.curs_val)) != 0)
  2657. return (ret);
  2658. for (cursq = msg.curs.curs_val, cursp = curs; cursi--; cursq++, cursp++)
  2659. *cursq = (*cursp)->cl_id;
  2660. msg.flags = flags;
  2662. replyp = __db_db_join_4001(&msg, cl);
  2663. __os_free(dbenv, msg.curs.curs_val);
  2664. if (replyp == NULL) {
  2665. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  2666. ret = DB_NOSERVER;
  2667. goto out;
  2668. }
  2669. ret = __dbcl_db_join_ret(dbp, curs, dbcp, flags, replyp);
  2670. out:
  2671. if (replyp != NULL)
  2672. xdr_free((xdrproc_t)xdr___db_join_reply, (void *)replyp);
  2673. return (ret);
  2674. }
  2676. /*
  2677.  * PUBLIC: int __dbcl_dbc_close __P((DBC *));
  2678.  */
  2679. int
  2680. __dbcl_dbc_close(dbc)
  2681. DBC * dbc;
  2682. {
  2683. CLIENT *cl;
  2684. __dbc_close_msg msg;
  2685. __dbc_close_reply *replyp = NULL;
  2686. int ret;
  2687. DB_ENV *dbenv;
  2689. ret = 0;
  2690. dbenv = dbc->dbp->dbenv;
  2691. if (dbenv == NULL || !RPC_ON(dbenv))
  2692. return (__dbcl_noserver(NULL));
  2694. cl = (CLIENT *)dbenv->cl_handle;
  2696. if (dbc == NULL)
  2697. msg.dbccl_id = 0;
  2698. else
  2699. msg.dbccl_id = dbc->cl_id;
  2701. replyp = __db_dbc_close_4001(&msg, cl);
  2702. if (replyp == NULL) {
  2703. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  2704. ret = DB_NOSERVER;
  2705. goto out;
  2706. }
  2707. ret = __dbcl_dbc_close_ret(dbc, replyp);
  2708. out:
  2709. if (replyp != NULL)
  2710. xdr_free((xdrproc_t)xdr___dbc_close_reply, (void *)replyp);
  2711. return (ret);
  2712. }
  2714. /*
  2715.  * PUBLIC: int __dbcl_dbc_count __P((DBC *, db_recno_t *, u_int32_t));
  2716.  */
  2717. int
  2718. __dbcl_dbc_count(dbc, countp, flags)
  2719. DBC * dbc;
  2720. db_recno_t * countp;
  2721. u_int32_t flags;
  2722. {
  2723. CLIENT *cl;
  2724. __dbc_count_msg msg;
  2725. __dbc_count_reply *replyp = NULL;
  2726. int ret;
  2727. DB_ENV *dbenv;
  2729. ret = 0;
  2730. dbenv = dbc->dbp->dbenv;
  2731. if (dbenv == NULL || !RPC_ON(dbenv))
  2732. return (__dbcl_noserver(NULL));
  2734. cl = (CLIENT *)dbenv->cl_handle;
  2736. if (dbc == NULL)
  2737. msg.dbccl_id = 0;
  2738. else
  2739. msg.dbccl_id = dbc->cl_id;
  2740. msg.flags = flags;
  2742. replyp = __db_dbc_count_4001(&msg, cl);
  2743. if (replyp == NULL) {
  2744. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  2745. ret = DB_NOSERVER;
  2746. goto out;
  2747. }
  2748. ret = __dbcl_dbc_count_ret(dbc, countp, flags, replyp);
  2749. out:
  2750. if (replyp != NULL)
  2751. xdr_free((xdrproc_t)xdr___dbc_count_reply, (void *)replyp);
  2752. return (ret);
  2753. }
  2755. /*
  2756.  * PUBLIC: int __dbcl_dbc_del __P((DBC *, u_int32_t));
  2757.  */
  2758. int
  2759. __dbcl_dbc_del(dbc, flags)
  2760. DBC * dbc;
  2761. u_int32_t flags;
  2762. {
  2763. CLIENT *cl;
  2764. __dbc_del_msg msg;
  2765. __dbc_del_reply *replyp = NULL;
  2766. int ret;
  2767. DB_ENV *dbenv;
  2769. ret = 0;
  2770. dbenv = dbc->dbp->dbenv;
  2771. if (dbenv == NULL || !RPC_ON(dbenv))
  2772. return (__dbcl_noserver(NULL));
  2774. cl = (CLIENT *)dbenv->cl_handle;
  2776. if (dbc == NULL)
  2777. msg.dbccl_id = 0;
  2778. else
  2779. msg.dbccl_id = dbc->cl_id;
  2780. msg.flags = flags;
  2782. replyp = __db_dbc_del_4001(&msg, cl);
  2783. if (replyp == NULL) {
  2784. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  2785. ret = DB_NOSERVER;
  2786. goto out;
  2787. }
  2788. ret = replyp->status;
  2789. out:
  2790. if (replyp != NULL)
  2791. xdr_free((xdrproc_t)xdr___dbc_del_reply, (void *)replyp);
  2792. return (ret);
  2793. }
  2795. /*
  2796.  * PUBLIC: int __dbcl_dbc_dup __P((DBC *, DBC **, u_int32_t));
  2797.  */
  2798. int
  2799. __dbcl_dbc_dup(dbc, dbcp, flags)
  2800. DBC * dbc;
  2801. DBC ** dbcp;
  2802. u_int32_t flags;
  2803. {
  2804. CLIENT *cl;
  2805. __dbc_dup_msg msg;
  2806. __dbc_dup_reply *replyp = NULL;
  2807. int ret;
  2808. DB_ENV *dbenv;
  2810. ret = 0;
  2811. dbenv = dbc->dbp->dbenv;
  2812. if (dbenv == NULL || !RPC_ON(dbenv))
  2813. return (__dbcl_noserver(NULL));
  2815. cl = (CLIENT *)dbenv->cl_handle;
  2817. if (dbc == NULL)
  2818. msg.dbccl_id = 0;
  2819. else
  2820. msg.dbccl_id = dbc->cl_id;
  2821. msg.flags = flags;
  2823. replyp = __db_dbc_dup_4001(&msg, cl);
  2824. if (replyp == NULL) {
  2825. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  2826. ret = DB_NOSERVER;
  2827. goto out;
  2828. }
  2829. ret = __dbcl_dbc_dup_ret(dbc, dbcp, flags, replyp);
  2830. out:
  2831. if (replyp != NULL)
  2832. xdr_free((xdrproc_t)xdr___dbc_dup_reply, (void *)replyp);
  2833. return (ret);
  2834. }
  2836. /*
  2837.  * PUBLIC: int __dbcl_dbc_get __P((DBC *, DBT *, DBT *, u_int32_t));
  2838.  */
  2839. int
  2840. __dbcl_dbc_get(dbc, key, data, flags)
  2841. DBC * dbc;
  2842. DBT * key;
  2843. DBT * data;
  2844. u_int32_t flags;
  2845. {
  2846. CLIENT *cl;
  2847. __dbc_get_msg msg;
  2848. __dbc_get_reply *replyp = NULL;
  2849. int ret;
  2850. DB_ENV *dbenv;
  2852. ret = 0;
  2853. dbenv = dbc->dbp->dbenv;
  2854. if (dbenv == NULL || !RPC_ON(dbenv))
  2855. return (__dbcl_noserver(NULL));
  2857. cl = (CLIENT *)dbenv->cl_handle;
  2859. if (dbc == NULL)
  2860. msg.dbccl_id = 0;
  2861. else
  2862. msg.dbccl_id = dbc->cl_id;
  2863. msg.keydlen = key->dlen;
  2864. msg.keydoff = key->doff;
  2865. msg.keyulen = key->ulen;
  2866. msg.keyflags = key->flags;
  2867. msg.keydata.keydata_val = key->data;
  2868. msg.keydata.keydata_len = key->size;
  2869. msg.datadlen = data->dlen;
  2870. msg.datadoff = data->doff;
  2871. msg.dataulen = data->ulen;
  2872. msg.dataflags = data->flags;
  2873. msg.datadata.datadata_val = data->data;
  2874. msg.datadata.datadata_len = data->size;
  2875. msg.flags = flags;
  2877. replyp = __db_dbc_get_4001(&msg, cl);
  2878. if (replyp == NULL) {
  2879. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  2880. ret = DB_NOSERVER;
  2881. goto out;
  2882. }
  2883. ret = __dbcl_dbc_get_ret(dbc, key, data, flags, replyp);
  2884. out:
  2885. if (replyp != NULL)
  2886. xdr_free((xdrproc_t)xdr___dbc_get_reply, (void *)replyp);
  2887. return (ret);
  2888. }
  2890. /*
  2891.  * PUBLIC: int __dbcl_dbc_pget __P((DBC *, DBT *, DBT *, DBT *, u_int32_t));
  2892.  */
  2893. int
  2894. __dbcl_dbc_pget(dbc, skey, pkey, data, flags)
  2895. DBC * dbc;
  2896. DBT * skey;
  2897. DBT * pkey;
  2898. DBT * data;
  2899. u_int32_t flags;
  2900. {
  2901. CLIENT *cl;
  2902. __dbc_pget_msg msg;
  2903. __dbc_pget_reply *replyp = NULL;
  2904. int ret;
  2905. DB_ENV *dbenv;
  2907. ret = 0;
  2908. dbenv = dbc->dbp->dbenv;
  2909. if (dbenv == NULL || !RPC_ON(dbenv))
  2910. return (__dbcl_noserver(NULL));
  2912. cl = (CLIENT *)dbenv->cl_handle;
  2914. if (dbc == NULL)
  2915. msg.dbccl_id = 0;
  2916. else
  2917. msg.dbccl_id = dbc->cl_id;
  2918. msg.skeydlen = skey->dlen;
  2919. msg.skeydoff = skey->doff;
  2920. msg.skeyulen = skey->ulen;
  2921. msg.skeyflags = skey->flags;
  2922. msg.skeydata.skeydata_val = skey->data;
  2923. msg.skeydata.skeydata_len = skey->size;
  2924. msg.pkeydlen = pkey->dlen;
  2925. msg.pkeydoff = pkey->doff;
  2926. msg.pkeyulen = pkey->ulen;
  2927. msg.pkeyflags = pkey->flags;
  2928. msg.pkeydata.pkeydata_val = pkey->data;
  2929. msg.pkeydata.pkeydata_len = pkey->size;
  2930. msg.datadlen = data->dlen;
  2931. msg.datadoff = data->doff;
  2932. msg.dataulen = data->ulen;
  2933. msg.dataflags = data->flags;
  2934. msg.datadata.datadata_val = data->data;
  2935. msg.datadata.datadata_len = data->size;
  2936. msg.flags = flags;
  2938. replyp = __db_dbc_pget_4001(&msg, cl);
  2939. if (replyp == NULL) {
  2940. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  2941. ret = DB_NOSERVER;
  2942. goto out;
  2943. }
  2944. ret = __dbcl_dbc_pget_ret(dbc, skey, pkey, data, flags, replyp);
  2945. out:
  2946. if (replyp != NULL)
  2947. xdr_free((xdrproc_t)xdr___dbc_pget_reply, (void *)replyp);
  2948. return (ret);
  2949. }
  2951. /*
  2952.  * PUBLIC: int __dbcl_dbc_put __P((DBC *, DBT *, DBT *, u_int32_t));
  2953.  */
  2954. int
  2955. __dbcl_dbc_put(dbc, key, data, flags)
  2956. DBC * dbc;
  2957. DBT * key;
  2958. DBT * data;
  2959. u_int32_t flags;
  2960. {
  2961. CLIENT *cl;
  2962. __dbc_put_msg msg;
  2963. __dbc_put_reply *replyp = NULL;
  2964. int ret;
  2965. DB_ENV *dbenv;
  2967. ret = 0;
  2968. dbenv = dbc->dbp->dbenv;
  2969. if (dbenv == NULL || !RPC_ON(dbenv))
  2970. return (__dbcl_noserver(NULL));
  2972. cl = (CLIENT *)dbenv->cl_handle;
  2974. if (dbc == NULL)
  2975. msg.dbccl_id = 0;
  2976. else
  2977. msg.dbccl_id = dbc->cl_id;
  2978. msg.keydlen = key->dlen;
  2979. msg.keydoff = key->doff;
  2980. msg.keyulen = key->ulen;
  2981. msg.keyflags = key->flags;
  2982. msg.keydata.keydata_val = key->data;
  2983. msg.keydata.keydata_len = key->size;
  2984. msg.datadlen = data->dlen;
  2985. msg.datadoff = data->doff;
  2986. msg.dataulen = data->ulen;
  2987. msg.dataflags = data->flags;
  2988. msg.datadata.datadata_val = data->data;
  2989. msg.datadata.datadata_len = data->size;
  2990. msg.flags = flags;
  2992. replyp = __db_dbc_put_4001(&msg, cl);
  2993. if (replyp == NULL) {
  2994. __db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
  2995. ret = DB_NOSERVER;
  2996. goto out;
  2997. }
  2998. ret = __dbcl_dbc_put_ret(dbc, key, data, flags, replyp);
  2999. out:
  3000. if (replyp != NULL)
  3001. xdr_free((xdrproc_t)xdr___dbc_put_reply, (void *)replyp);
  3002. return (ret);
  3003. }
  3005. /*
  3006.  * PUBLIC: int __dbcl_lock_detect __P((DB_ENV *, u_int32_t, u_int32_t, int *));
  3007.  */
  3008. int
  3009. __dbcl_lock_detect(dbenv, flags, atype, aborted)
  3010. DB_ENV * dbenv;
  3011. u_int32_t flags;
  3012. u_int32_t atype;
  3013. int * aborted;
  3014. {
  3015. COMPQUIET(flags, 0);
  3016. COMPQUIET(atype, 0);
  3017. COMPQUIET(aborted, 0);
  3018. return (__dbcl_rpc_illegal(dbenv, "lock_detect"));
  3019. }
  3021. /*
  3022.  * PUBLIC: int __dbcl_lock_get __P((DB_ENV *, u_int32_t, u_int32_t,
  3023.  * PUBLIC:      const DBT *, db_lockmode_t, DB_LOCK *));
  3024.  */
  3025. int
  3026. __dbcl_lock_get(dbenv, locker, flags, obj, mode, lock)
  3027. DB_ENV * dbenv;
  3028. u_int32_t locker;
  3029. u_int32_t flags;
  3030. const DBT * obj;
  3031. db_lockmode_t mode;
  3032. DB_LOCK * lock;
  3033. {
  3034. COMPQUIET(locker, 0);
  3035. COMPQUIET(flags, 0);
  3036. COMPQUIET(obj, NULL);
  3037. COMPQUIET(mode, 0);
  3038. COMPQUIET(lock, 0);
  3039. return (__dbcl_rpc_illegal(dbenv, "lock_get"));
  3040. }
  3042. /*
  3043.  * PUBLIC: int __dbcl_lock_id __P((DB_ENV *, u_int32_t *));
  3044.  */
  3045. int
  3046. __dbcl_lock_id(dbenv, idp)
  3047. DB_ENV * dbenv;
  3048. u_int32_t * idp;
  3049. {
  3050. COMPQUIET(idp, 0);
  3051. return (__dbcl_rpc_illegal(dbenv, "lock_id"));
  3052. }
  3054. /*
  3055.  * PUBLIC: int __dbcl_lock_id_free __P((DB_ENV *, u_int32_t));
  3056.  */
  3057. int
  3058. __dbcl_lock_id_free(dbenv, id)
  3059. DB_ENV * dbenv;
  3060. u_int32_t id;
  3061. {
  3062. COMPQUIET(id, 0);
  3063. return (__dbcl_rpc_illegal(dbenv, "lock_id_free"));
  3064. }
  3066. /*
  3067.  * PUBLIC: int __dbcl_lock_put __P((DB_ENV *, DB_LOCK *));
  3068.  */
  3069. int
  3070. __dbcl_lock_put(dbenv, lock)
  3071. DB_ENV * dbenv;
  3072. DB_LOCK * lock;
  3073. {
  3074. COMPQUIET(lock, 0);
  3075. return (__dbcl_rpc_illegal(dbenv, "lock_put"));
  3076. }
  3078. /*
  3079.  * PUBLIC: int __dbcl_lock_stat __P((DB_ENV *, DB_LOCK_STAT **, u_int32_t));
  3080.  */
  3081. int
  3082. __dbcl_lock_stat(dbenv, statp, flags)
  3083. DB_ENV * dbenv;
  3084. DB_LOCK_STAT ** statp;
  3085. u_int32_t flags;
  3086. {
  3087. COMPQUIET(statp, 0);
  3088. COMPQUIET(flags, 0);
  3089. return (__dbcl_rpc_illegal(dbenv, "lock_stat"));
  3090. }
  3092. /*
  3093.  * PUBLIC: int __dbcl_lock_vec __P((DB_ENV *, u_int32_t, u_int32_t,
  3094.  * PUBLIC:      DB_LOCKREQ *, int, DB_LOCKREQ **));
  3095.  */
  3096. int
  3097. __dbcl_lock_vec(dbenv, locker, flags, list, nlist, elistp)
  3098. DB_ENV * dbenv;
  3099. u_int32_t locker;
  3100. u_int32_t flags;
  3101. DB_LOCKREQ * list;
  3102. int nlist;
  3103. DB_LOCKREQ ** elistp;
  3104. {
  3105. COMPQUIET(locker, 0);
  3106. COMPQUIET(flags, 0);
  3107. COMPQUIET(list, 0);
  3108. COMPQUIET(nlist, 0);
  3109. COMPQUIET(elistp, 0);
  3110. return (__dbcl_rpc_illegal(dbenv, "lock_vec"));
  3111. }
  3113. /*
  3114.  * PUBLIC: int __dbcl_log_archive __P((DB_ENV *, char ***, u_int32_t));
  3115.  */
  3116. int
  3117. __dbcl_log_archive(dbenv, listp, flags)
  3118. DB_ENV * dbenv;
  3119. char *** listp;
  3120. u_int32_t flags;
  3121. {
  3122. COMPQUIET(listp, 0);
  3123. COMPQUIET(flags, 0);
  3124. return (__dbcl_rpc_illegal(dbenv, "log_archive"));
  3125. }
  3127. /*
  3128.  * PUBLIC: int __dbcl_log_cursor __P((DB_ENV *, DB_LOGC **, u_int32_t));
  3129.  */
  3130. int
  3131. __dbcl_log_cursor(dbenv, logcp, flags)
  3132. DB_ENV * dbenv;
  3133. DB_LOGC ** logcp;
  3134. u_int32_t flags;
  3135. {
  3136. COMPQUIET(logcp, 0);
  3137. COMPQUIET(flags, 0);
  3138. return (__dbcl_rpc_illegal(dbenv, "log_cursor"));
  3139. }
  3141. /*
  3142.  * PUBLIC: int __dbcl_log_file __P((DB_ENV *, const DB_LSN *, char *, size_t));
  3143.  */
  3144. int
  3145. __dbcl_log_file(dbenv, lsn, namep, len)
  3146. DB_ENV * dbenv;
  3147. const DB_LSN * lsn;
  3148. char * namep;
  3149. size_t len;
  3150. {
  3151. COMPQUIET(lsn, NULL);
  3152. COMPQUIET(namep, NULL);
  3153. COMPQUIET(len, 0);
  3154. return (__dbcl_rpc_illegal(dbenv, "log_file"));
  3155. }
  3157. /*
  3158.  * PUBLIC: int __dbcl_log_flush __P((DB_ENV *, const DB_LSN *));
  3159.  */
  3160. int
  3161. __dbcl_log_flush(dbenv, lsn)
  3162. DB_ENV * dbenv;
  3163. const DB_LSN * lsn;
  3164. {
  3165. COMPQUIET(lsn, NULL);
  3166. return (__dbcl_rpc_illegal(dbenv, "log_flush"));
  3167. }
  3169. /*
  3170.  * PUBLIC: int __dbcl_log_put __P((DB_ENV *, DB_LSN *, const DBT *,
  3171.  * PUBLIC:      u_int32_t));
  3172.  */
  3173. int
  3174. __dbcl_log_put(dbenv, lsn, data, flags)
  3175. DB_ENV * dbenv;
  3176. DB_LSN * lsn;
  3177. const DBT * data;
  3178. u_int32_t flags;
  3179. {
  3180. COMPQUIET(lsn, 0);
  3181. COMPQUIET(data, NULL);
  3182. COMPQUIET(flags, 0);
  3183. return (__dbcl_rpc_illegal(dbenv, "log_put"));
  3184. }
  3186. /*
  3187.  * PUBLIC: int __dbcl_log_stat __P((DB_ENV *, DB_LOG_STAT **, u_int32_t));
  3188.  */
  3189. int
  3190. __dbcl_log_stat(dbenv, statp, flags)
  3191. DB_ENV * dbenv;
  3192. DB_LOG_STAT ** statp;
  3193. u_int32_t flags;
  3194. {
  3195. COMPQUIET(statp, 0);
  3196. COMPQUIET(flags, 0);
  3197. return (__dbcl_rpc_illegal(dbenv, "log_stat"));
  3198. }
  3200. /*
  3201.  * PUBLIC: int __dbcl_memp_fcreate __P((DB_ENV *, DB_MPOOLFILE **, u_int32_t));
  3202.  */
  3203. int
  3204. __dbcl_memp_fcreate(dbenv, mpf, flags)
  3205. DB_ENV * dbenv;
  3206. DB_MPOOLFILE ** mpf;
  3207. u_int32_t flags;
  3208. {
  3209. COMPQUIET(mpf, 0);
  3210. COMPQUIET(flags, 0);
  3211. return (__dbcl_rpc_illegal(dbenv, "memp_fcreate"));
  3212. }
  3214. /*
  3215.  * PUBLIC: int __dbcl_memp_register __P((DB_ENV *, int, int (*)(DB_ENV *,
  3216.  * PUBLIC:      db_pgno_t, void *, DBT *), int (*)(DB_ENV *, db_pgno_t, void *, DBT *)));
  3217.  */
  3218. int
  3219. __dbcl_memp_register(dbenv, ftype, func0, func1)
  3220. DB_ENV * dbenv;
  3221. int ftype;
  3222. int (*func0) __P((DB_ENV *, db_pgno_t, void *, DBT *));
  3223. int (*func1) __P((DB_ENV *, db_pgno_t, void *, DBT *));
  3224. {
  3225. COMPQUIET(ftype, 0);
  3226. COMPQUIET(func0, 0);
  3227. COMPQUIET(func1, 0);
  3228. return (__dbcl_rpc_illegal(dbenv, "memp_register"));
  3229. }
  3231. /*
  3232.  * PUBLIC: int __dbcl_memp_stat __P((DB_ENV *, DB_MPOOL_STAT **,
  3233.  * PUBLIC:      DB_MPOOL_FSTAT ***, u_int32_t));
  3234.  */
  3235. int
  3236. __dbcl_memp_stat(dbenv, gstatp, fstatp, flags)
  3237. DB_ENV * dbenv;
  3238. DB_MPOOL_STAT ** gstatp;
  3239. DB_MPOOL_FSTAT *** fstatp;
  3240. u_int32_t flags;
  3241. {
  3242. COMPQUIET(gstatp, 0);
  3243. COMPQUIET(fstatp, 0);
  3244. COMPQUIET(flags, 0);
  3245. return (__dbcl_rpc_illegal(dbenv, "memp_stat"));
  3246. }
  3248. /*
  3249.  * PUBLIC: int __dbcl_memp_sync __P((DB_ENV *, DB_LSN *));
  3250.  */
  3251. int
  3252. __dbcl_memp_sync(dbenv, lsn)
  3253. DB_ENV * dbenv;
  3254. DB_LSN * lsn;
  3255. {
  3256. COMPQUIET(lsn, 0);
  3257. return (__dbcl_rpc_illegal(dbenv, "memp_sync"));
  3258. }
  3260. /*
  3261.  * PUBLIC: int __dbcl_memp_trickle __P((DB_ENV *, int, int *));
  3262.  */
  3263. int
  3264. __dbcl_memp_trickle(dbenv, pct, nwrotep)
  3265. DB_ENV * dbenv;
  3266. int pct;
  3267. int * nwrotep;
  3268. {
  3269. COMPQUIET(pct, 0);
  3270. COMPQUIET(nwrotep, 0);
  3271. return (__dbcl_rpc_illegal(dbenv, "memp_trickle"));
  3272. }
  3274. #endif /* HAVE_RPC */