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

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

MySQL数据库

开发平台：

Visual C++

gen_db_server.c：源码内容
  1. /* Do not edit: automatically built by gen_rpc.awk. */
  2. #include "db_config.h"
  4. #ifndef NO_SYSTEM_INCLUDES
  5. #include <sys/types.h>
  7. #include <rpc/rpc.h>
  8. #include <rpc/xdr.h>
  10. #include <string.h>
  11. #endif
  13. #include "db_int.h"
  14. #include "dbinc_auto/db_server.h"
  15. #include "dbinc/db_server_int.h"
  16. #include "dbinc_auto/rpc_server_ext.h"
  18. /*
  19.  * PUBLIC: __env_cachesize_reply *__db_env_cachesize_4001 
  20.  * PUBLIC:     __P((__env_cachesize_msg *, struct svc_req *));
  21.  */
  22. __env_cachesize_reply *
  23. __db_env_cachesize_4001(msg, req)
  24. __env_cachesize_msg *msg;
  25. struct svc_req *req;
  26. {
  27. static __env_cachesize_reply reply; /* must be static */
  28. COMPQUIET(req, NULL);
  30. __env_cachesize_proc(msg->dbenvcl_id,
  31.     msg->gbytes,
  32.     msg->bytes,
  33.     msg->ncache,
  34.     &reply);
  36. return (&reply);
  37. }
  39. /*
  40.  * PUBLIC: __env_close_reply *__db_env_close_4001 __P((__env_close_msg *,
  41.  * PUBLIC:      struct svc_req *));
  42.  */
  43. __env_close_reply *
  44. __db_env_close_4001(msg, req)
  45. __env_close_msg *msg;
  46. struct svc_req *req;
  47. {
  48. static __env_close_reply reply; /* must be static */
  49. COMPQUIET(req, NULL);
  51. __env_close_proc(msg->dbenvcl_id,
  52.     msg->flags,
  53.     &reply);
  55. return (&reply);
  56. }
  58. /*
  59.  * PUBLIC: __env_create_reply *__db_env_create_4001 __P((__env_create_msg *,
  60.  * PUBLIC:      struct svc_req *));
  61.  */
  62. __env_create_reply *
  63. __db_env_create_4001(msg, req)
  64. __env_create_msg *msg;
  65. struct svc_req *req;
  66. {
  67. static __env_create_reply reply; /* must be static */
  68. COMPQUIET(req, NULL);
  70. __env_create_proc(msg->timeout,
  71.     &reply);
  73. return (&reply);
  74. }
  76. /*
  77.  * PUBLIC: __env_dbremove_reply *__db_env_dbremove_4001 
  78.  * PUBLIC:     __P((__env_dbremove_msg *, struct svc_req *));
  79.  */
  80. __env_dbremove_reply *
  81. __db_env_dbremove_4001(msg, req)
  82. __env_dbremove_msg *msg;
  83. struct svc_req *req;
  84. {
  85. static __env_dbremove_reply reply; /* must be static */
  86. COMPQUIET(req, NULL);
  88. __env_dbremove_proc(msg->dbenvcl_id,
  89.     msg->txnpcl_id,
  90.     (*msg->name == '') ? NULL : msg->name,
  91.     (*msg->subdb == '') ? NULL : msg->subdb,
  92.     msg->flags,
  93.     &reply);
  95. return (&reply);
  96. }
  98. /*
  99.  * PUBLIC: __env_dbrename_reply *__db_env_dbrename_4001 
  100.  * PUBLIC:     __P((__env_dbrename_msg *, struct svc_req *));
  101.  */
  102. __env_dbrename_reply *
  103. __db_env_dbrename_4001(msg, req)
  104. __env_dbrename_msg *msg;
  105. struct svc_req *req;
  106. {
  107. static __env_dbrename_reply reply; /* must be static */
  108. COMPQUIET(req, NULL);
  110. __env_dbrename_proc(msg->dbenvcl_id,
  111.     msg->txnpcl_id,
  112.     (*msg->name == '') ? NULL : msg->name,
  113.     (*msg->subdb == '') ? NULL : msg->subdb,
  114.     (*msg->newname == '') ? NULL : msg->newname,
  115.     msg->flags,
  116.     &reply);
  118. return (&reply);
  119. }
  121. /*
  122.  * PUBLIC: __env_encrypt_reply *__db_env_encrypt_4001 
  123.  * PUBLIC:     __P((__env_encrypt_msg *, struct svc_req *));
  124.  */
  125. __env_encrypt_reply *
  126. __db_env_encrypt_4001(msg, req)
  127. __env_encrypt_msg *msg;
  128. struct svc_req *req;
  129. {
  130. static __env_encrypt_reply reply; /* must be static */
  131. COMPQUIET(req, NULL);
  133. __env_encrypt_proc(msg->dbenvcl_id,
  134.     (*msg->passwd == '') ? NULL : msg->passwd,
  135.     msg->flags,
  136.     &reply);
  138. return (&reply);
  139. }
  141. /*
  142.  * PUBLIC: __env_flags_reply *__db_env_flags_4001 __P((__env_flags_msg *,
  143.  * PUBLIC:      struct svc_req *));
  144.  */
  145. __env_flags_reply *
  146. __db_env_flags_4001(msg, req)
  147. __env_flags_msg *msg;
  148. struct svc_req *req;
  149. {
  150. static __env_flags_reply reply; /* must be static */
  151. COMPQUIET(req, NULL);
  153. __env_flags_proc(msg->dbenvcl_id,
  154.     msg->flags,
  155.     msg->onoff,
  156.     &reply);
  158. return (&reply);
  159. }
  161. /*
  162.  * PUBLIC: __env_open_reply *__db_env_open_4001 __P((__env_open_msg *,
  163.  * PUBLIC:      struct svc_req *));
  164.  */
  165. __env_open_reply *
  166. __db_env_open_4001(msg, req)
  167. __env_open_msg *msg;
  168. struct svc_req *req;
  169. {
  170. static __env_open_reply reply; /* must be static */
  171. COMPQUIET(req, NULL);
  173. __env_open_proc(msg->dbenvcl_id,
  174.     (*msg->home == '') ? NULL : msg->home,
  175.     msg->flags,
  176.     msg->mode,
  177.     &reply);
  179. return (&reply);
  180. }
  182. /*
  183.  * PUBLIC: __env_remove_reply *__db_env_remove_4001 __P((__env_remove_msg *,
  184.  * PUBLIC:      struct svc_req *));
  185.  */
  186. __env_remove_reply *
  187. __db_env_remove_4001(msg, req)
  188. __env_remove_msg *msg;
  189. struct svc_req *req;
  190. {
  191. static __env_remove_reply reply; /* must be static */
  192. COMPQUIET(req, NULL);
  194. __env_remove_proc(msg->dbenvcl_id,
  195.     (*msg->home == '') ? NULL : msg->home,
  196.     msg->flags,
  197.     &reply);
  199. return (&reply);
  200. }
  202. /*
  203.  * PUBLIC: __txn_abort_reply *__db_txn_abort_4001 __P((__txn_abort_msg *,
  204.  * PUBLIC:      struct svc_req *));
  205.  */
  206. __txn_abort_reply *
  207. __db_txn_abort_4001(msg, req)
  208. __txn_abort_msg *msg;
  209. struct svc_req *req;
  210. {
  211. static __txn_abort_reply reply; /* must be static */
  212. COMPQUIET(req, NULL);
  214. __txn_abort_proc(msg->txnpcl_id,
  215.     &reply);
  217. return (&reply);
  218. }
  220. /*
  221.  * PUBLIC: __txn_begin_reply *__db_txn_begin_4001 __P((__txn_begin_msg *,
  222.  * PUBLIC:      struct svc_req *));
  223.  */
  224. __txn_begin_reply *
  225. __db_txn_begin_4001(msg, req)
  226. __txn_begin_msg *msg;
  227. struct svc_req *req;
  228. {
  229. static __txn_begin_reply reply; /* must be static */
  230. COMPQUIET(req, NULL);
  232. __txn_begin_proc(msg->dbenvcl_id,
  233.     msg->parentcl_id,
  234.     msg->flags,
  235.     &reply);
  237. return (&reply);
  238. }
  240. /*
  241.  * PUBLIC: __txn_commit_reply *__db_txn_commit_4001 __P((__txn_commit_msg *,
  242.  * PUBLIC:      struct svc_req *));
  243.  */
  244. __txn_commit_reply *
  245. __db_txn_commit_4001(msg, req)
  246. __txn_commit_msg *msg;
  247. struct svc_req *req;
  248. {
  249. static __txn_commit_reply reply; /* must be static */
  250. COMPQUIET(req, NULL);
  252. __txn_commit_proc(msg->txnpcl_id,
  253.     msg->flags,
  254.     &reply);
  256. return (&reply);
  257. }
  259. /*
  260.  * PUBLIC: __txn_discard_reply *__db_txn_discard_4001 
  261.  * PUBLIC:     __P((__txn_discard_msg *, struct svc_req *));
  262.  */
  263. __txn_discard_reply *
  264. __db_txn_discard_4001(msg, req)
  265. __txn_discard_msg *msg;
  266. struct svc_req *req;
  267. {
  268. static __txn_discard_reply reply; /* must be static */
  269. COMPQUIET(req, NULL);
  271. __txn_discard_proc(msg->txnpcl_id,
  272.     msg->flags,
  273.     &reply);
  275. return (&reply);
  276. }
  278. /*
  279.  * PUBLIC: __txn_prepare_reply *__db_txn_prepare_4001 
  280.  * PUBLIC:     __P((__txn_prepare_msg *, struct svc_req *));
  281.  */
  282. __txn_prepare_reply *
  283. __db_txn_prepare_4001(msg, req)
  284. __txn_prepare_msg *msg;
  285. struct svc_req *req;
  286. {
  287. static __txn_prepare_reply reply; /* must be static */
  288. COMPQUIET(req, NULL);
  290. __txn_prepare_proc(msg->txnpcl_id,
  291.     msg->gid,
  292.     &reply);
  294. return (&reply);
  295. }
  297. /*
  298.  * PUBLIC: __txn_recover_reply *__db_txn_recover_4001 
  299.  * PUBLIC:     __P((__txn_recover_msg *, struct svc_req *));
  300.  */
  301. __txn_recover_reply *
  302. __db_txn_recover_4001(msg, req)
  303. __txn_recover_msg *msg;
  304. struct svc_req *req;
  305. {
  306. static __txn_recover_reply reply; /* must be static */
  307. static int __txn_recover_free = 0; /* must be static */
  309. COMPQUIET(req, NULL);
  310. if (__txn_recover_free)
  311. xdr_free((xdrproc_t)xdr___txn_recover_reply, (void *)&reply);
  312. __txn_recover_free = 0;
  314. /* Reinitialize allocated fields */
  315. reply.txn.txn_val = NULL;
  316. reply.gid.gid_val = NULL;
  318. __txn_recover_proc(msg->dbenvcl_id,
  319.     msg->count,
  320.     msg->flags,
  321.     &reply,
  322.     &__txn_recover_free);
  323. return (&reply);
  324. }
  326. /*
  327.  * PUBLIC: __db_associate_reply *__db_db_associate_4001 
  328.  * PUBLIC:     __P((__db_associate_msg *, struct svc_req *));
  329.  */
  330. __db_associate_reply *
  331. __db_db_associate_4001(msg, req)
  332. __db_associate_msg *msg;
  333. struct svc_req *req;
  334. {
  335. static __db_associate_reply reply; /* must be static */
  336. COMPQUIET(req, NULL);
  338. __db_associate_proc(msg->dbpcl_id,
  339.     msg->txnpcl_id,
  340.     msg->sdbpcl_id,
  341.     msg->flags,
  342.     &reply);
  344. return (&reply);
  345. }
  347. /*
  348.  * PUBLIC: __db_bt_maxkey_reply *__db_db_bt_maxkey_4001 
  349.  * PUBLIC:     __P((__db_bt_maxkey_msg *, struct svc_req *));
  350.  */
  351. __db_bt_maxkey_reply *
  352. __db_db_bt_maxkey_4001(msg, req)
  353. __db_bt_maxkey_msg *msg;
  354. struct svc_req *req;
  355. {
  356. static __db_bt_maxkey_reply reply; /* must be static */
  357. COMPQUIET(req, NULL);
  359. __db_bt_maxkey_proc(msg->dbpcl_id,
  360.     msg->maxkey,
  361.     &reply);
  363. return (&reply);
  364. }
  366. /*
  367.  * PUBLIC: __db_bt_minkey_reply *__db_db_bt_minkey_4001 
  368.  * PUBLIC:     __P((__db_bt_minkey_msg *, struct svc_req *));
  369.  */
  370. __db_bt_minkey_reply *
  371. __db_db_bt_minkey_4001(msg, req)
  372. __db_bt_minkey_msg *msg;
  373. struct svc_req *req;
  374. {
  375. static __db_bt_minkey_reply reply; /* must be static */
  376. COMPQUIET(req, NULL);
  378. __db_bt_minkey_proc(msg->dbpcl_id,
  379.     msg->minkey,
  380.     &reply);
  382. return (&reply);
  383. }
  385. /*
  386.  * PUBLIC: __db_close_reply *__db_db_close_4001 __P((__db_close_msg *,
  387.  * PUBLIC:      struct svc_req *));
  388.  */
  389. __db_close_reply *
  390. __db_db_close_4001(msg, req)
  391. __db_close_msg *msg;
  392. struct svc_req *req;
  393. {
  394. static __db_close_reply reply; /* must be static */
  395. COMPQUIET(req, NULL);
  397. __db_close_proc(msg->dbpcl_id,
  398.     msg->flags,
  399.     &reply);
  401. return (&reply);
  402. }
  404. /*
  405.  * PUBLIC: __db_create_reply *__db_db_create_4001 __P((__db_create_msg *,
  406.  * PUBLIC:      struct svc_req *));
  407.  */
  408. __db_create_reply *
  409. __db_db_create_4001(msg, req)
  410. __db_create_msg *msg;
  411. struct svc_req *req;
  412. {
  413. static __db_create_reply reply; /* must be static */
  414. COMPQUIET(req, NULL);
  416. __db_create_proc(msg->dbenvcl_id,
  417.     msg->flags,
  418.     &reply);
  420. return (&reply);
  421. }
  423. /*
  424.  * PUBLIC: __db_del_reply *__db_db_del_4001 __P((__db_del_msg *,
  425.  * PUBLIC:      struct svc_req *));
  426.  */
  427. __db_del_reply *
  428. __db_db_del_4001(msg, req)
  429. __db_del_msg *msg;
  430. struct svc_req *req;
  431. {
  432. static __db_del_reply reply; /* must be static */
  433. COMPQUIET(req, NULL);
  435. __db_del_proc(msg->dbpcl_id,
  436.     msg->txnpcl_id,
  437.     msg->keydlen,
  438.     msg->keydoff,
  439.     msg->keyulen,
  440.     msg->keyflags,
  441.     msg->keydata.keydata_val,
  442.     msg->keydata.keydata_len,
  443.     msg->flags,
  444.     &reply);
  446. return (&reply);
  447. }
  449. /*
  450.  * PUBLIC: __db_encrypt_reply *__db_db_encrypt_4001 __P((__db_encrypt_msg *,
  451.  * PUBLIC:      struct svc_req *));
  452.  */
  453. __db_encrypt_reply *
  454. __db_db_encrypt_4001(msg, req)
  455. __db_encrypt_msg *msg;
  456. struct svc_req *req;
  457. {
  458. static __db_encrypt_reply reply; /* must be static */
  459. COMPQUIET(req, NULL);
  461. __db_encrypt_proc(msg->dbpcl_id,
  462.     (*msg->passwd == '') ? NULL : msg->passwd,
  463.     msg->flags,
  464.     &reply);
  466. return (&reply);
  467. }
  469. /*
  470.  * PUBLIC: __db_extentsize_reply *__db_db_extentsize_4001 
  471.  * PUBLIC:     __P((__db_extentsize_msg *, struct svc_req *));
  472.  */
  473. __db_extentsize_reply *
  474. __db_db_extentsize_4001(msg, req)
  475. __db_extentsize_msg *msg;
  476. struct svc_req *req;
  477. {
  478. static __db_extentsize_reply reply; /* must be static */
  479. COMPQUIET(req, NULL);
  481. __db_extentsize_proc(msg->dbpcl_id,
  482.     msg->extentsize,
  483.     &reply);
  485. return (&reply);
  486. }
  488. /*
  489.  * PUBLIC: __db_flags_reply *__db_db_flags_4001 __P((__db_flags_msg *,
  490.  * PUBLIC:      struct svc_req *));
  491.  */
  492. __db_flags_reply *
  493. __db_db_flags_4001(msg, req)
  494. __db_flags_msg *msg;
  495. struct svc_req *req;
  496. {
  497. static __db_flags_reply reply; /* must be static */
  498. COMPQUIET(req, NULL);
  500. __db_flags_proc(msg->dbpcl_id,
  501.     msg->flags,
  502.     &reply);
  504. return (&reply);
  505. }
  507. /*
  508.  * PUBLIC: __db_get_reply *__db_db_get_4001 __P((__db_get_msg *,
  509.  * PUBLIC:      struct svc_req *));
  510.  */
  511. __db_get_reply *
  512. __db_db_get_4001(msg, req)
  513. __db_get_msg *msg;
  514. struct svc_req *req;
  515. {
  516. static __db_get_reply reply; /* must be static */
  517. static int __db_get_free = 0; /* must be static */
  519. COMPQUIET(req, NULL);
  520. if (__db_get_free)
  521. xdr_free((xdrproc_t)xdr___db_get_reply, (void *)&reply);
  522. __db_get_free = 0;
  524. /* Reinitialize allocated fields */
  525. reply.keydata.keydata_val = NULL;
  526. reply.datadata.datadata_val = NULL;
  528. __db_get_proc(msg->dbpcl_id,
  529.     msg->txnpcl_id,
  530.     msg->keydlen,
  531.     msg->keydoff,
  532.     msg->keyulen,
  533.     msg->keyflags,
  534.     msg->keydata.keydata_val,
  535.     msg->keydata.keydata_len,
  536.     msg->datadlen,
  537.     msg->datadoff,
  538.     msg->dataulen,
  539.     msg->dataflags,
  540.     msg->datadata.datadata_val,
  541.     msg->datadata.datadata_len,
  542.     msg->flags,
  543.     &reply,
  544.     &__db_get_free);
  545. return (&reply);
  546. }
  548. /*
  549.  * PUBLIC: __db_h_ffactor_reply *__db_db_h_ffactor_4001 
  550.  * PUBLIC:     __P((__db_h_ffactor_msg *, struct svc_req *));
  551.  */
  552. __db_h_ffactor_reply *
  553. __db_db_h_ffactor_4001(msg, req)
  554. __db_h_ffactor_msg *msg;
  555. struct svc_req *req;
  556. {
  557. static __db_h_ffactor_reply reply; /* must be static */
  558. COMPQUIET(req, NULL);
  560. __db_h_ffactor_proc(msg->dbpcl_id,
  561.     msg->ffactor,
  562.     &reply);
  564. return (&reply);
  565. }
  567. /*
  568.  * PUBLIC: __db_h_nelem_reply *__db_db_h_nelem_4001 __P((__db_h_nelem_msg *,
  569.  * PUBLIC:      struct svc_req *));
  570.  */
  571. __db_h_nelem_reply *
  572. __db_db_h_nelem_4001(msg, req)
  573. __db_h_nelem_msg *msg;
  574. struct svc_req *req;
  575. {
  576. static __db_h_nelem_reply reply; /* must be static */
  577. COMPQUIET(req, NULL);
  579. __db_h_nelem_proc(msg->dbpcl_id,
  580.     msg->nelem,
  581.     &reply);
  583. return (&reply);
  584. }
  586. /*
  587.  * PUBLIC: __db_key_range_reply *__db_db_key_range_4001 
  588.  * PUBLIC:     __P((__db_key_range_msg *, struct svc_req *));
  589.  */
  590. __db_key_range_reply *
  591. __db_db_key_range_4001(msg, req)
  592. __db_key_range_msg *msg;
  593. struct svc_req *req;
  594. {
  595. static __db_key_range_reply reply; /* must be static */
  596. COMPQUIET(req, NULL);
  598. __db_key_range_proc(msg->dbpcl_id,
  599.     msg->txnpcl_id,
  600.     msg->keydlen,
  601.     msg->keydoff,
  602.     msg->keyulen,
  603.     msg->keyflags,
  604.     msg->keydata.keydata_val,
  605.     msg->keydata.keydata_len,
  606.     msg->flags,
  607.     &reply);
  609. return (&reply);
  610. }
  612. /*
  613.  * PUBLIC: __db_lorder_reply *__db_db_lorder_4001 __P((__db_lorder_msg *,
  614.  * PUBLIC:      struct svc_req *));
  615.  */
  616. __db_lorder_reply *
  617. __db_db_lorder_4001(msg, req)
  618. __db_lorder_msg *msg;
  619. struct svc_req *req;
  620. {
  621. static __db_lorder_reply reply; /* must be static */
  622. COMPQUIET(req, NULL);
  624. __db_lorder_proc(msg->dbpcl_id,
  625.     msg->lorder,
  626.     &reply);
  628. return (&reply);
  629. }
  631. /*
  632.  * PUBLIC: __db_open_reply *__db_db_open_4001 __P((__db_open_msg *,
  633.  * PUBLIC:      struct svc_req *));
  634.  */
  635. __db_open_reply *
  636. __db_db_open_4001(msg, req)
  637. __db_open_msg *msg;
  638. struct svc_req *req;
  639. {
  640. static __db_open_reply reply; /* must be static */
  641. COMPQUIET(req, NULL);
  643. __db_open_proc(msg->dbpcl_id,
  644.     msg->txnpcl_id,
  645.     (*msg->name == '') ? NULL : msg->name,
  646.     (*msg->subdb == '') ? NULL : msg->subdb,
  647.     msg->type,
  648.     msg->flags,
  649.     msg->mode,
  650.     &reply);
  652. return (&reply);
  653. }
  655. /*
  656.  * PUBLIC: __db_pagesize_reply *__db_db_pagesize_4001 
  657.  * PUBLIC:     __P((__db_pagesize_msg *, struct svc_req *));
  658.  */
  659. __db_pagesize_reply *
  660. __db_db_pagesize_4001(msg, req)
  661. __db_pagesize_msg *msg;
  662. struct svc_req *req;
  663. {
  664. static __db_pagesize_reply reply; /* must be static */
  665. COMPQUIET(req, NULL);
  667. __db_pagesize_proc(msg->dbpcl_id,
  668.     msg->pagesize,
  669.     &reply);
  671. return (&reply);
  672. }
  674. /*
  675.  * PUBLIC: __db_pget_reply *__db_db_pget_4001 __P((__db_pget_msg *,
  676.  * PUBLIC:      struct svc_req *));
  677.  */
  678. __db_pget_reply *
  679. __db_db_pget_4001(msg, req)
  680. __db_pget_msg *msg;
  681. struct svc_req *req;
  682. {
  683. static __db_pget_reply reply; /* must be static */
  684. static int __db_pget_free = 0; /* must be static */
  686. COMPQUIET(req, NULL);
  687. if (__db_pget_free)
  688. xdr_free((xdrproc_t)xdr___db_pget_reply, (void *)&reply);
  689. __db_pget_free = 0;
  691. /* Reinitialize allocated fields */
  692. reply.skeydata.skeydata_val = NULL;
  693. reply.pkeydata.pkeydata_val = NULL;
  694. reply.datadata.datadata_val = NULL;
  696. __db_pget_proc(msg->dbpcl_id,
  697.     msg->txnpcl_id,
  698.     msg->skeydlen,
  699.     msg->skeydoff,
  700.     msg->skeyulen,
  701.     msg->skeyflags,
  702.     msg->skeydata.skeydata_val,
  703.     msg->skeydata.skeydata_len,
  704.     msg->pkeydlen,
  705.     msg->pkeydoff,
  706.     msg->pkeyulen,
  707.     msg->pkeyflags,
  708.     msg->pkeydata.pkeydata_val,
  709.     msg->pkeydata.pkeydata_len,
  710.     msg->datadlen,
  711.     msg->datadoff,
  712.     msg->dataulen,
  713.     msg->dataflags,
  714.     msg->datadata.datadata_val,
  715.     msg->datadata.datadata_len,
  716.     msg->flags,
  717.     &reply,
  718.     &__db_pget_free);
  719. return (&reply);
  720. }
  722. /*
  723.  * PUBLIC: __db_put_reply *__db_db_put_4001 __P((__db_put_msg *,
  724.  * PUBLIC:      struct svc_req *));
  725.  */
  726. __db_put_reply *
  727. __db_db_put_4001(msg, req)
  728. __db_put_msg *msg;
  729. struct svc_req *req;
  730. {
  731. static __db_put_reply reply; /* must be static */
  732. static int __db_put_free = 0; /* must be static */
  734. COMPQUIET(req, NULL);
  735. if (__db_put_free)
  736. xdr_free((xdrproc_t)xdr___db_put_reply, (void *)&reply);
  737. __db_put_free = 0;
  739. /* Reinitialize allocated fields */
  740. reply.keydata.keydata_val = NULL;
  742. __db_put_proc(msg->dbpcl_id,
  743.     msg->txnpcl_id,
  744.     msg->keydlen,
  745.     msg->keydoff,
  746.     msg->keyulen,
  747.     msg->keyflags,
  748.     msg->keydata.keydata_val,
  749.     msg->keydata.keydata_len,
  750.     msg->datadlen,
  751.     msg->datadoff,
  752.     msg->dataulen,
  753.     msg->dataflags,
  754.     msg->datadata.datadata_val,
  755.     msg->datadata.datadata_len,
  756.     msg->flags,
  757.     &reply,
  758.     &__db_put_free);
  759. return (&reply);
  760. }
  762. /*
  763.  * PUBLIC: __db_re_delim_reply *__db_db_re_delim_4001 
  764.  * PUBLIC:     __P((__db_re_delim_msg *, struct svc_req *));
  765.  */
  766. __db_re_delim_reply *
  767. __db_db_re_delim_4001(msg, req)
  768. __db_re_delim_msg *msg;
  769. struct svc_req *req;
  770. {
  771. static __db_re_delim_reply reply; /* must be static */
  772. COMPQUIET(req, NULL);
  774. __db_re_delim_proc(msg->dbpcl_id,
  775.     msg->delim,
  776.     &reply);
  778. return (&reply);
  779. }
  781. /*
  782.  * PUBLIC: __db_re_len_reply *__db_db_re_len_4001 __P((__db_re_len_msg *,
  783.  * PUBLIC:      struct svc_req *));
  784.  */
  785. __db_re_len_reply *
  786. __db_db_re_len_4001(msg, req)
  787. __db_re_len_msg *msg;
  788. struct svc_req *req;
  789. {
  790. static __db_re_len_reply reply; /* must be static */
  791. COMPQUIET(req, NULL);
  793. __db_re_len_proc(msg->dbpcl_id,
  794.     msg->len,
  795.     &reply);
  797. return (&reply);
  798. }
  800. /*
  801.  * PUBLIC: __db_re_pad_reply *__db_db_re_pad_4001 __P((__db_re_pad_msg *,
  802.  * PUBLIC:      struct svc_req *));
  803.  */
  804. __db_re_pad_reply *
  805. __db_db_re_pad_4001(msg, req)
  806. __db_re_pad_msg *msg;
  807. struct svc_req *req;
  808. {
  809. static __db_re_pad_reply reply; /* must be static */
  810. COMPQUIET(req, NULL);
  812. __db_re_pad_proc(msg->dbpcl_id,
  813.     msg->pad,
  814.     &reply);
  816. return (&reply);
  817. }
  819. /*
  820.  * PUBLIC: __db_remove_reply *__db_db_remove_4001 __P((__db_remove_msg *,
  821.  * PUBLIC:      struct svc_req *));
  822.  */
  823. __db_remove_reply *
  824. __db_db_remove_4001(msg, req)
  825. __db_remove_msg *msg;
  826. struct svc_req *req;
  827. {
  828. static __db_remove_reply reply; /* must be static */
  829. COMPQUIET(req, NULL);
  831. __db_remove_proc(msg->dbpcl_id,
  832.     (*msg->name == '') ? NULL : msg->name,
  833.     (*msg->subdb == '') ? NULL : msg->subdb,
  834.     msg->flags,
  835.     &reply);
  837. return (&reply);
  838. }
  840. /*
  841.  * PUBLIC: __db_rename_reply *__db_db_rename_4001 __P((__db_rename_msg *,
  842.  * PUBLIC:      struct svc_req *));
  843.  */
  844. __db_rename_reply *
  845. __db_db_rename_4001(msg, req)
  846. __db_rename_msg *msg;
  847. struct svc_req *req;
  848. {
  849. static __db_rename_reply reply; /* must be static */
  850. COMPQUIET(req, NULL);
  852. __db_rename_proc(msg->dbpcl_id,
  853.     (*msg->name == '') ? NULL : msg->name,
  854.     (*msg->subdb == '') ? NULL : msg->subdb,
  855.     (*msg->newname == '') ? NULL : msg->newname,
  856.     msg->flags,
  857.     &reply);
  859. return (&reply);
  860. }
  862. /*
  863.  * PUBLIC: __db_stat_reply *__db_db_stat_4001 __P((__db_stat_msg *,
  864.  * PUBLIC:      struct svc_req *));
  865.  */
  866. __db_stat_reply *
  867. __db_db_stat_4001(msg, req)
  868. __db_stat_msg *msg;
  869. struct svc_req *req;
  870. {
  871. static __db_stat_reply reply; /* must be static */
  872. static int __db_stat_free = 0; /* must be static */
  874. COMPQUIET(req, NULL);
  875. if (__db_stat_free)
  876. xdr_free((xdrproc_t)xdr___db_stat_reply, (void *)&reply);
  877. __db_stat_free = 0;
  879. /* Reinitialize allocated fields */
  880. reply.stats.stats_val = NULL;
  882. __db_stat_proc(msg->dbpcl_id,
  883.     msg->flags,
  884.     &reply,
  885.     &__db_stat_free);
  886. return (&reply);
  887. }
  889. /*
  890.  * PUBLIC: __db_sync_reply *__db_db_sync_4001 __P((__db_sync_msg *,
  891.  * PUBLIC:      struct svc_req *));
  892.  */
  893. __db_sync_reply *
  894. __db_db_sync_4001(msg, req)
  895. __db_sync_msg *msg;
  896. struct svc_req *req;
  897. {
  898. static __db_sync_reply reply; /* must be static */
  899. COMPQUIET(req, NULL);
  901. __db_sync_proc(msg->dbpcl_id,
  902.     msg->flags,
  903.     &reply);
  905. return (&reply);
  906. }
  908. /*
  909.  * PUBLIC: __db_truncate_reply *__db_db_truncate_4001 
  910.  * PUBLIC:     __P((__db_truncate_msg *, struct svc_req *));
  911.  */
  912. __db_truncate_reply *
  913. __db_db_truncate_4001(msg, req)
  914. __db_truncate_msg *msg;
  915. struct svc_req *req;
  916. {
  917. static __db_truncate_reply reply; /* must be static */
  918. COMPQUIET(req, NULL);
  920. __db_truncate_proc(msg->dbpcl_id,
  921.     msg->txnpcl_id,
  922.     msg->flags,
  923.     &reply);
  925. return (&reply);
  926. }
  928. /*
  929.  * PUBLIC: __db_cursor_reply *__db_db_cursor_4001 __P((__db_cursor_msg *,
  930.  * PUBLIC:      struct svc_req *));
  931.  */
  932. __db_cursor_reply *
  933. __db_db_cursor_4001(msg, req)
  934. __db_cursor_msg *msg;
  935. struct svc_req *req;
  936. {
  937. static __db_cursor_reply reply; /* must be static */
  938. COMPQUIET(req, NULL);
  940. __db_cursor_proc(msg->dbpcl_id,
  941.     msg->txnpcl_id,
  942.     msg->flags,
  943.     &reply);
  945. return (&reply);
  946. }
  948. /*
  949.  * PUBLIC: __db_join_reply *__db_db_join_4001 __P((__db_join_msg *,
  950.  * PUBLIC:      struct svc_req *));
  951.  */
  952. __db_join_reply *
  953. __db_db_join_4001(msg, req)
  954. __db_join_msg *msg;
  955. struct svc_req *req;
  956. {
  957. static __db_join_reply reply; /* must be static */
  958. COMPQUIET(req, NULL);
  960. __db_join_proc(msg->dbpcl_id,
  961.     msg->curs.curs_val,
  962.     msg->curs.curs_len,
  963.     msg->flags,
  964.     &reply);
  966. return (&reply);
  967. }
  969. /*
  970.  * PUBLIC: __dbc_close_reply *__db_dbc_close_4001 __P((__dbc_close_msg *,
  971.  * PUBLIC:      struct svc_req *));
  972.  */
  973. __dbc_close_reply *
  974. __db_dbc_close_4001(msg, req)
  975. __dbc_close_msg *msg;
  976. struct svc_req *req;
  977. {
  978. static __dbc_close_reply reply; /* must be static */
  979. COMPQUIET(req, NULL);
  981. __dbc_close_proc(msg->dbccl_id,
  982.     &reply);
  984. return (&reply);
  985. }
  987. /*
  988.  * PUBLIC: __dbc_count_reply *__db_dbc_count_4001 __P((__dbc_count_msg *,
  989.  * PUBLIC:      struct svc_req *));
  990.  */
  991. __dbc_count_reply *
  992. __db_dbc_count_4001(msg, req)
  993. __dbc_count_msg *msg;
  994. struct svc_req *req;
  995. {
  996. static __dbc_count_reply reply; /* must be static */
  997. COMPQUIET(req, NULL);
  999. __dbc_count_proc(msg->dbccl_id,
  1000.     msg->flags,
  1001.     &reply);
  1003. return (&reply);
  1004. }
  1006. /*
  1007.  * PUBLIC: __dbc_del_reply *__db_dbc_del_4001 __P((__dbc_del_msg *,
  1008.  * PUBLIC:      struct svc_req *));
  1009.  */
  1010. __dbc_del_reply *
  1011. __db_dbc_del_4001(msg, req)
  1012. __dbc_del_msg *msg;
  1013. struct svc_req *req;
  1014. {
  1015. static __dbc_del_reply reply; /* must be static */
  1016. COMPQUIET(req, NULL);
  1018. __dbc_del_proc(msg->dbccl_id,
  1019.     msg->flags,
  1020.     &reply);
  1022. return (&reply);
  1023. }
  1025. /*
  1026.  * PUBLIC: __dbc_dup_reply *__db_dbc_dup_4001 __P((__dbc_dup_msg *,
  1027.  * PUBLIC:      struct svc_req *));
  1028.  */
  1029. __dbc_dup_reply *
  1030. __db_dbc_dup_4001(msg, req)
  1031. __dbc_dup_msg *msg;
  1032. struct svc_req *req;
  1033. {
  1034. static __dbc_dup_reply reply; /* must be static */
  1035. COMPQUIET(req, NULL);
  1037. __dbc_dup_proc(msg->dbccl_id,
  1038.     msg->flags,
  1039.     &reply);
  1041. return (&reply);
  1042. }
  1044. /*
  1045.  * PUBLIC: __dbc_get_reply *__db_dbc_get_4001 __P((__dbc_get_msg *,
  1046.  * PUBLIC:      struct svc_req *));
  1047.  */
  1048. __dbc_get_reply *
  1049. __db_dbc_get_4001(msg, req)
  1050. __dbc_get_msg *msg;
  1051. struct svc_req *req;
  1052. {
  1053. static __dbc_get_reply reply; /* must be static */
  1054. static int __dbc_get_free = 0; /* must be static */
  1056. COMPQUIET(req, NULL);
  1057. if (__dbc_get_free)
  1058. xdr_free((xdrproc_t)xdr___dbc_get_reply, (void *)&reply);
  1059. __dbc_get_free = 0;
  1061. /* Reinitialize allocated fields */
  1062. reply.keydata.keydata_val = NULL;
  1063. reply.datadata.datadata_val = NULL;
  1065. __dbc_get_proc(msg->dbccl_id,
  1066.     msg->keydlen,
  1067.     msg->keydoff,
  1068.     msg->keyulen,
  1069.     msg->keyflags,
  1070.     msg->keydata.keydata_val,
  1071.     msg->keydata.keydata_len,
  1072.     msg->datadlen,
  1073.     msg->datadoff,
  1074.     msg->dataulen,
  1075.     msg->dataflags,
  1076.     msg->datadata.datadata_val,
  1077.     msg->datadata.datadata_len,
  1078.     msg->flags,
  1079.     &reply,
  1080.     &__dbc_get_free);
  1081. return (&reply);
  1082. }
  1084. /*
  1085.  * PUBLIC: __dbc_pget_reply *__db_dbc_pget_4001 __P((__dbc_pget_msg *,
  1086.  * PUBLIC:      struct svc_req *));
  1087.  */
  1088. __dbc_pget_reply *
  1089. __db_dbc_pget_4001(msg, req)
  1090. __dbc_pget_msg *msg;
  1091. struct svc_req *req;
  1092. {
  1093. static __dbc_pget_reply reply; /* must be static */
  1094. static int __dbc_pget_free = 0; /* must be static */
  1096. COMPQUIET(req, NULL);
  1097. if (__dbc_pget_free)
  1098. xdr_free((xdrproc_t)xdr___dbc_pget_reply, (void *)&reply);
  1099. __dbc_pget_free = 0;
  1101. /* Reinitialize allocated fields */
  1102. reply.skeydata.skeydata_val = NULL;
  1103. reply.pkeydata.pkeydata_val = NULL;
  1104. reply.datadata.datadata_val = NULL;
  1106. __dbc_pget_proc(msg->dbccl_id,
  1107.     msg->skeydlen,
  1108.     msg->skeydoff,
  1109.     msg->skeyulen,
  1110.     msg->skeyflags,
  1111.     msg->skeydata.skeydata_val,
  1112.     msg->skeydata.skeydata_len,
  1113.     msg->pkeydlen,
  1114.     msg->pkeydoff,
  1115.     msg->pkeyulen,
  1116.     msg->pkeyflags,
  1117.     msg->pkeydata.pkeydata_val,
  1118.     msg->pkeydata.pkeydata_len,
  1119.     msg->datadlen,
  1120.     msg->datadoff,
  1121.     msg->dataulen,
  1122.     msg->dataflags,
  1123.     msg->datadata.datadata_val,
  1124.     msg->datadata.datadata_len,
  1125.     msg->flags,
  1126.     &reply,
  1127.     &__dbc_pget_free);
  1128. return (&reply);
  1129. }
  1131. /*
  1132.  * PUBLIC: __dbc_put_reply *__db_dbc_put_4001 __P((__dbc_put_msg *,
  1133.  * PUBLIC:      struct svc_req *));
  1134.  */
  1135. __dbc_put_reply *
  1136. __db_dbc_put_4001(msg, req)
  1137. __dbc_put_msg *msg;
  1138. struct svc_req *req;
  1139. {
  1140. static __dbc_put_reply reply; /* must be static */
  1141. static int __dbc_put_free = 0; /* must be static */
  1143. COMPQUIET(req, NULL);
  1144. if (__dbc_put_free)
  1145. xdr_free((xdrproc_t)xdr___dbc_put_reply, (void *)&reply);
  1146. __dbc_put_free = 0;
  1148. /* Reinitialize allocated fields */
  1149. reply.keydata.keydata_val = NULL;
  1151. __dbc_put_proc(msg->dbccl_id,
  1152.     msg->keydlen,
  1153.     msg->keydoff,
  1154.     msg->keyulen,
  1155.     msg->keyflags,
  1156.     msg->keydata.keydata_val,
  1157.     msg->keydata.keydata_len,
  1158.     msg->datadlen,
  1159.     msg->datadoff,
  1160.     msg->dataulen,
  1161.     msg->dataflags,
  1162.     msg->datadata.datadata_val,
  1163.     msg->datadata.datadata_len,
  1164.     msg->flags,
  1165.     &reply,
  1166.     &__dbc_put_free);
  1167. return (&reply);
  1168. }