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

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

MySQL数据库

开发平台：

Visual C++

db_server_clnt.c：源码内容
  1. #include "db_config.h"
  2. #ifdef HAVE_RPC
  3. /*
  4.  * Please do not edit this file.
  5.  * It was generated using rpcgen.
  6.  */
  8. #include <memory.h> /* for memset */
  9. #include "../rpc_server/db_server.h"
  11. /* Default timeout can be changed using clnt_control() */
  12. static struct timeval TIMEOUT = { 25, 0 };
  14. __env_cachesize_reply *
  15. __db_env_cachesize_1(__env_cachesize_msg *argp, CLIENT *clnt)
  16. {
  17. static __env_cachesize_reply clnt_res;
  19. memset((char *)&clnt_res, 0, sizeof(clnt_res));
  20. if (clnt_call (clnt, __DB_env_cachesize,
  21. (xdrproc_t) xdr___env_cachesize_msg, (caddr_t) argp,
  22. (xdrproc_t) xdr___env_cachesize_reply, (caddr_t) &clnt_res,
  23. TIMEOUT) != RPC_SUCCESS) {
  24. return (NULL);
  25. }
  26. return (&clnt_res);
  27. }
  29. __env_close_reply *
  30. __db_env_close_1(__env_close_msg *argp, CLIENT *clnt)
  31. {
  32. static __env_close_reply clnt_res;
  34. memset((char *)&clnt_res, 0, sizeof(clnt_res));
  35. if (clnt_call (clnt, __DB_env_close,
  36. (xdrproc_t) xdr___env_close_msg, (caddr_t) argp,
  37. (xdrproc_t) xdr___env_close_reply, (caddr_t) &clnt_res,
  38. TIMEOUT) != RPC_SUCCESS) {
  39. return (NULL);
  40. }
  41. return (&clnt_res);
  42. }
  44. __env_create_reply *
  45. __db_env_create_1(__env_create_msg *argp, CLIENT *clnt)
  46. {
  47. static __env_create_reply clnt_res;
  49. memset((char *)&clnt_res, 0, sizeof(clnt_res));
  50. if (clnt_call (clnt, __DB_env_create,
  51. (xdrproc_t) xdr___env_create_msg, (caddr_t) argp,
  52. (xdrproc_t) xdr___env_create_reply, (caddr_t) &clnt_res,
  53. TIMEOUT) != RPC_SUCCESS) {
  54. return (NULL);
  55. }
  56. return (&clnt_res);
  57. }
  59. __env_flags_reply *
  60. __db_env_flags_1(__env_flags_msg *argp, CLIENT *clnt)
  61. {
  62. static __env_flags_reply clnt_res;
  64. memset((char *)&clnt_res, 0, sizeof(clnt_res));
  65. if (clnt_call (clnt, __DB_env_flags,
  66. (xdrproc_t) xdr___env_flags_msg, (caddr_t) argp,
  67. (xdrproc_t) xdr___env_flags_reply, (caddr_t) &clnt_res,
  68. TIMEOUT) != RPC_SUCCESS) {
  69. return (NULL);
  70. }
  71. return (&clnt_res);
  72. }
  74. __env_open_reply *
  75. __db_env_open_1(__env_open_msg *argp, CLIENT *clnt)
  76. {
  77. static __env_open_reply clnt_res;
  79. memset((char *)&clnt_res, 0, sizeof(clnt_res));
  80. if (clnt_call (clnt, __DB_env_open,
  81. (xdrproc_t) xdr___env_open_msg, (caddr_t) argp,
  82. (xdrproc_t) xdr___env_open_reply, (caddr_t) &clnt_res,
  83. TIMEOUT) != RPC_SUCCESS) {
  84. return (NULL);
  85. }
  86. return (&clnt_res);
  87. }
  89. __env_remove_reply *
  90. __db_env_remove_1(__env_remove_msg *argp, CLIENT *clnt)
  91. {
  92. static __env_remove_reply clnt_res;
  94. memset((char *)&clnt_res, 0, sizeof(clnt_res));
  95. if (clnt_call (clnt, __DB_env_remove,
  96. (xdrproc_t) xdr___env_remove_msg, (caddr_t) argp,
  97. (xdrproc_t) xdr___env_remove_reply, (caddr_t) &clnt_res,
  98. TIMEOUT) != RPC_SUCCESS) {
  99. return (NULL);
  100. }
  101. return (&clnt_res);
  102. }
  104. __txn_abort_reply *
  105. __db_txn_abort_1(__txn_abort_msg *argp, CLIENT *clnt)
  106. {
  107. static __txn_abort_reply clnt_res;
  109. memset((char *)&clnt_res, 0, sizeof(clnt_res));
  110. if (clnt_call (clnt, __DB_txn_abort,
  111. (xdrproc_t) xdr___txn_abort_msg, (caddr_t) argp,
  112. (xdrproc_t) xdr___txn_abort_reply, (caddr_t) &clnt_res,
  113. TIMEOUT) != RPC_SUCCESS) {
  114. return (NULL);
  115. }
  116. return (&clnt_res);
  117. }
  119. __txn_begin_reply *
  120. __db_txn_begin_1(__txn_begin_msg *argp, CLIENT *clnt)
  121. {
  122. static __txn_begin_reply clnt_res;
  124. memset((char *)&clnt_res, 0, sizeof(clnt_res));
  125. if (clnt_call (clnt, __DB_txn_begin,
  126. (xdrproc_t) xdr___txn_begin_msg, (caddr_t) argp,
  127. (xdrproc_t) xdr___txn_begin_reply, (caddr_t) &clnt_res,
  128. TIMEOUT) != RPC_SUCCESS) {
  129. return (NULL);
  130. }
  131. return (&clnt_res);
  132. }
  134. __txn_commit_reply *
  135. __db_txn_commit_1(__txn_commit_msg *argp, CLIENT *clnt)
  136. {
  137. static __txn_commit_reply clnt_res;
  139. memset((char *)&clnt_res, 0, sizeof(clnt_res));
  140. if (clnt_call (clnt, __DB_txn_commit,
  141. (xdrproc_t) xdr___txn_commit_msg, (caddr_t) argp,
  142. (xdrproc_t) xdr___txn_commit_reply, (caddr_t) &clnt_res,
  143. TIMEOUT) != RPC_SUCCESS) {
  144. return (NULL);
  145. }
  146. return (&clnt_res);
  147. }
  149. __db_bt_maxkey_reply *
  150. __db_db_bt_maxkey_1(__db_bt_maxkey_msg *argp, CLIENT *clnt)
  151. {
  152. static __db_bt_maxkey_reply clnt_res;
  154. memset((char *)&clnt_res, 0, sizeof(clnt_res));
  155. if (clnt_call (clnt, __DB_db_bt_maxkey,
  156. (xdrproc_t) xdr___db_bt_maxkey_msg, (caddr_t) argp,
  157. (xdrproc_t) xdr___db_bt_maxkey_reply, (caddr_t) &clnt_res,
  158. TIMEOUT) != RPC_SUCCESS) {
  159. return (NULL);
  160. }
  161. return (&clnt_res);
  162. }
  164. __db_bt_minkey_reply *
  165. __db_db_bt_minkey_1(__db_bt_minkey_msg *argp, CLIENT *clnt)
  166. {
  167. static __db_bt_minkey_reply clnt_res;
  169. memset((char *)&clnt_res, 0, sizeof(clnt_res));
  170. if (clnt_call (clnt, __DB_db_bt_minkey,
  171. (xdrproc_t) xdr___db_bt_minkey_msg, (caddr_t) argp,
  172. (xdrproc_t) xdr___db_bt_minkey_reply, (caddr_t) &clnt_res,
  173. TIMEOUT) != RPC_SUCCESS) {
  174. return (NULL);
  175. }
  176. return (&clnt_res);
  177. }
  179. __db_close_reply *
  180. __db_db_close_1(__db_close_msg *argp, CLIENT *clnt)
  181. {
  182. static __db_close_reply clnt_res;
  184. memset((char *)&clnt_res, 0, sizeof(clnt_res));
  185. if (clnt_call (clnt, __DB_db_close,
  186. (xdrproc_t) xdr___db_close_msg, (caddr_t) argp,
  187. (xdrproc_t) xdr___db_close_reply, (caddr_t) &clnt_res,
  188. TIMEOUT) != RPC_SUCCESS) {
  189. return (NULL);
  190. }
  191. return (&clnt_res);
  192. }
  194. __db_create_reply *
  195. __db_db_create_1(__db_create_msg *argp, CLIENT *clnt)
  196. {
  197. static __db_create_reply clnt_res;
  199. memset((char *)&clnt_res, 0, sizeof(clnt_res));
  200. if (clnt_call (clnt, __DB_db_create,
  201. (xdrproc_t) xdr___db_create_msg, (caddr_t) argp,
  202. (xdrproc_t) xdr___db_create_reply, (caddr_t) &clnt_res,
  203. TIMEOUT) != RPC_SUCCESS) {
  204. return (NULL);
  205. }
  206. return (&clnt_res);
  207. }
  209. __db_del_reply *
  210. __db_db_del_1(__db_del_msg *argp, CLIENT *clnt)
  211. {
  212. static __db_del_reply clnt_res;
  214. memset((char *)&clnt_res, 0, sizeof(clnt_res));
  215. if (clnt_call (clnt, __DB_db_del,
  216. (xdrproc_t) xdr___db_del_msg, (caddr_t) argp,
  217. (xdrproc_t) xdr___db_del_reply, (caddr_t) &clnt_res,
  218. TIMEOUT) != RPC_SUCCESS) {
  219. return (NULL);
  220. }
  221. return (&clnt_res);
  222. }
  224. __db_extentsize_reply *
  225. __db_db_extentsize_1(__db_extentsize_msg *argp, CLIENT *clnt)
  226. {
  227. static __db_extentsize_reply clnt_res;
  229. memset((char *)&clnt_res, 0, sizeof(clnt_res));
  230. if (clnt_call (clnt, __DB_db_extentsize,
  231. (xdrproc_t) xdr___db_extentsize_msg, (caddr_t) argp,
  232. (xdrproc_t) xdr___db_extentsize_reply, (caddr_t) &clnt_res,
  233. TIMEOUT) != RPC_SUCCESS) {
  234. return (NULL);
  235. }
  236. return (&clnt_res);
  237. }
  239. __db_flags_reply *
  240. __db_db_flags_1(__db_flags_msg *argp, CLIENT *clnt)
  241. {
  242. static __db_flags_reply clnt_res;
  244. memset((char *)&clnt_res, 0, sizeof(clnt_res));
  245. if (clnt_call (clnt, __DB_db_flags,
  246. (xdrproc_t) xdr___db_flags_msg, (caddr_t) argp,
  247. (xdrproc_t) xdr___db_flags_reply, (caddr_t) &clnt_res,
  248. TIMEOUT) != RPC_SUCCESS) {
  249. return (NULL);
  250. }
  251. return (&clnt_res);
  252. }
  254. __db_get_reply *
  255. __db_db_get_1(__db_get_msg *argp, CLIENT *clnt)
  256. {
  257. static __db_get_reply clnt_res;
  259. memset((char *)&clnt_res, 0, sizeof(clnt_res));
  260. if (clnt_call (clnt, __DB_db_get,
  261. (xdrproc_t) xdr___db_get_msg, (caddr_t) argp,
  262. (xdrproc_t) xdr___db_get_reply, (caddr_t) &clnt_res,
  263. TIMEOUT) != RPC_SUCCESS) {
  264. return (NULL);
  265. }
  266. return (&clnt_res);
  267. }
  269. __db_h_ffactor_reply *
  270. __db_db_h_ffactor_1(__db_h_ffactor_msg *argp, CLIENT *clnt)
  271. {
  272. static __db_h_ffactor_reply clnt_res;
  274. memset((char *)&clnt_res, 0, sizeof(clnt_res));
  275. if (clnt_call (clnt, __DB_db_h_ffactor,
  276. (xdrproc_t) xdr___db_h_ffactor_msg, (caddr_t) argp,
  277. (xdrproc_t) xdr___db_h_ffactor_reply, (caddr_t) &clnt_res,
  278. TIMEOUT) != RPC_SUCCESS) {
  279. return (NULL);
  280. }
  281. return (&clnt_res);
  282. }
  284. __db_h_nelem_reply *
  285. __db_db_h_nelem_1(__db_h_nelem_msg *argp, CLIENT *clnt)
  286. {
  287. static __db_h_nelem_reply clnt_res;
  289. memset((char *)&clnt_res, 0, sizeof(clnt_res));
  290. if (clnt_call (clnt, __DB_db_h_nelem,
  291. (xdrproc_t) xdr___db_h_nelem_msg, (caddr_t) argp,
  292. (xdrproc_t) xdr___db_h_nelem_reply, (caddr_t) &clnt_res,
  293. TIMEOUT) != RPC_SUCCESS) {
  294. return (NULL);
  295. }
  296. return (&clnt_res);
  297. }
  299. __db_key_range_reply *
  300. __db_db_key_range_1(__db_key_range_msg *argp, CLIENT *clnt)
  301. {
  302. static __db_key_range_reply clnt_res;
  304. memset((char *)&clnt_res, 0, sizeof(clnt_res));
  305. if (clnt_call (clnt, __DB_db_key_range,
  306. (xdrproc_t) xdr___db_key_range_msg, (caddr_t) argp,
  307. (xdrproc_t) xdr___db_key_range_reply, (caddr_t) &clnt_res,
  308. TIMEOUT) != RPC_SUCCESS) {
  309. return (NULL);
  310. }
  311. return (&clnt_res);
  312. }
  314. __db_lorder_reply *
  315. __db_db_lorder_1(__db_lorder_msg *argp, CLIENT *clnt)
  316. {
  317. static __db_lorder_reply clnt_res;
  319. memset((char *)&clnt_res, 0, sizeof(clnt_res));
  320. if (clnt_call (clnt, __DB_db_lorder,
  321. (xdrproc_t) xdr___db_lorder_msg, (caddr_t) argp,
  322. (xdrproc_t) xdr___db_lorder_reply, (caddr_t) &clnt_res,
  323. TIMEOUT) != RPC_SUCCESS) {
  324. return (NULL);
  325. }
  326. return (&clnt_res);
  327. }
  329. __db_open_reply *
  330. __db_db_open_1(__db_open_msg *argp, CLIENT *clnt)
  331. {
  332. static __db_open_reply clnt_res;
  334. memset((char *)&clnt_res, 0, sizeof(clnt_res));
  335. if (clnt_call (clnt, __DB_db_open,
  336. (xdrproc_t) xdr___db_open_msg, (caddr_t) argp,
  337. (xdrproc_t) xdr___db_open_reply, (caddr_t) &clnt_res,
  338. TIMEOUT) != RPC_SUCCESS) {
  339. return (NULL);
  340. }
  341. return (&clnt_res);
  342. }
  344. __db_pagesize_reply *
  345. __db_db_pagesize_1(__db_pagesize_msg *argp, CLIENT *clnt)
  346. {
  347. static __db_pagesize_reply clnt_res;
  349. memset((char *)&clnt_res, 0, sizeof(clnt_res));
  350. if (clnt_call (clnt, __DB_db_pagesize,
  351. (xdrproc_t) xdr___db_pagesize_msg, (caddr_t) argp,
  352. (xdrproc_t) xdr___db_pagesize_reply, (caddr_t) &clnt_res,
  353. TIMEOUT) != RPC_SUCCESS) {
  354. return (NULL);
  355. }
  356. return (&clnt_res);
  357. }
  359. __db_put_reply *
  360. __db_db_put_1(__db_put_msg *argp, CLIENT *clnt)
  361. {
  362. static __db_put_reply clnt_res;
  364. memset((char *)&clnt_res, 0, sizeof(clnt_res));
  365. if (clnt_call (clnt, __DB_db_put,
  366. (xdrproc_t) xdr___db_put_msg, (caddr_t) argp,
  367. (xdrproc_t) xdr___db_put_reply, (caddr_t) &clnt_res,
  368. TIMEOUT) != RPC_SUCCESS) {
  369. return (NULL);
  370. }
  371. return (&clnt_res);
  372. }
  374. __db_re_delim_reply *
  375. __db_db_re_delim_1(__db_re_delim_msg *argp, CLIENT *clnt)
  376. {
  377. static __db_re_delim_reply clnt_res;
  379. memset((char *)&clnt_res, 0, sizeof(clnt_res));
  380. if (clnt_call (clnt, __DB_db_re_delim,
  381. (xdrproc_t) xdr___db_re_delim_msg, (caddr_t) argp,
  382. (xdrproc_t) xdr___db_re_delim_reply, (caddr_t) &clnt_res,
  383. TIMEOUT) != RPC_SUCCESS) {
  384. return (NULL);
  385. }
  386. return (&clnt_res);
  387. }
  389. __db_re_len_reply *
  390. __db_db_re_len_1(__db_re_len_msg *argp, CLIENT *clnt)
  391. {
  392. static __db_re_len_reply clnt_res;
  394. memset((char *)&clnt_res, 0, sizeof(clnt_res));
  395. if (clnt_call (clnt, __DB_db_re_len,
  396. (xdrproc_t) xdr___db_re_len_msg, (caddr_t) argp,
  397. (xdrproc_t) xdr___db_re_len_reply, (caddr_t) &clnt_res,
  398. TIMEOUT) != RPC_SUCCESS) {
  399. return (NULL);
  400. }
  401. return (&clnt_res);
  402. }
  404. __db_re_pad_reply *
  405. __db_db_re_pad_1(__db_re_pad_msg *argp, CLIENT *clnt)
  406. {
  407. static __db_re_pad_reply clnt_res;
  409. memset((char *)&clnt_res, 0, sizeof(clnt_res));
  410. if (clnt_call (clnt, __DB_db_re_pad,
  411. (xdrproc_t) xdr___db_re_pad_msg, (caddr_t) argp,
  412. (xdrproc_t) xdr___db_re_pad_reply, (caddr_t) &clnt_res,
  413. TIMEOUT) != RPC_SUCCESS) {
  414. return (NULL);
  415. }
  416. return (&clnt_res);
  417. }
  419. __db_remove_reply *
  420. __db_db_remove_1(__db_remove_msg *argp, CLIENT *clnt)
  421. {
  422. static __db_remove_reply clnt_res;
  424. memset((char *)&clnt_res, 0, sizeof(clnt_res));
  425. if (clnt_call (clnt, __DB_db_remove,
  426. (xdrproc_t) xdr___db_remove_msg, (caddr_t) argp,
  427. (xdrproc_t) xdr___db_remove_reply, (caddr_t) &clnt_res,
  428. TIMEOUT) != RPC_SUCCESS) {
  429. return (NULL);
  430. }
  431. return (&clnt_res);
  432. }
  434. __db_rename_reply *
  435. __db_db_rename_1(__db_rename_msg *argp, CLIENT *clnt)
  436. {
  437. static __db_rename_reply clnt_res;
  439. memset((char *)&clnt_res, 0, sizeof(clnt_res));
  440. if (clnt_call (clnt, __DB_db_rename,
  441. (xdrproc_t) xdr___db_rename_msg, (caddr_t) argp,
  442. (xdrproc_t) xdr___db_rename_reply, (caddr_t) &clnt_res,
  443. TIMEOUT) != RPC_SUCCESS) {
  444. return (NULL);
  445. }
  446. return (&clnt_res);
  447. }
  449. __db_stat_reply *
  450. __db_db_stat_1(__db_stat_msg *argp, CLIENT *clnt)
  451. {
  452. static __db_stat_reply clnt_res;
  454. memset((char *)&clnt_res, 0, sizeof(clnt_res));
  455. if (clnt_call (clnt, __DB_db_stat,
  456. (xdrproc_t) xdr___db_stat_msg, (caddr_t) argp,
  457. (xdrproc_t) xdr___db_stat_reply, (caddr_t) &clnt_res,
  458. TIMEOUT) != RPC_SUCCESS) {
  459. return (NULL);
  460. }
  461. return (&clnt_res);
  462. }
  464. __db_swapped_reply *
  465. __db_db_swapped_1(__db_swapped_msg *argp, CLIENT *clnt)
  466. {
  467. static __db_swapped_reply clnt_res;
  469. memset((char *)&clnt_res, 0, sizeof(clnt_res));
  470. if (clnt_call (clnt, __DB_db_swapped,
  471. (xdrproc_t) xdr___db_swapped_msg, (caddr_t) argp,
  472. (xdrproc_t) xdr___db_swapped_reply, (caddr_t) &clnt_res,
  473. TIMEOUT) != RPC_SUCCESS) {
  474. return (NULL);
  475. }
  476. return (&clnt_res);
  477. }
  479. __db_sync_reply *
  480. __db_db_sync_1(__db_sync_msg *argp, CLIENT *clnt)
  481. {
  482. static __db_sync_reply clnt_res;
  484. memset((char *)&clnt_res, 0, sizeof(clnt_res));
  485. if (clnt_call (clnt, __DB_db_sync,
  486. (xdrproc_t) xdr___db_sync_msg, (caddr_t) argp,
  487. (xdrproc_t) xdr___db_sync_reply, (caddr_t) &clnt_res,
  488. TIMEOUT) != RPC_SUCCESS) {
  489. return (NULL);
  490. }
  491. return (&clnt_res);
  492. }
  494. __db_cursor_reply *
  495. __db_db_cursor_1(__db_cursor_msg *argp, CLIENT *clnt)
  496. {
  497. static __db_cursor_reply clnt_res;
  499. memset((char *)&clnt_res, 0, sizeof(clnt_res));
  500. if (clnt_call (clnt, __DB_db_cursor,
  501. (xdrproc_t) xdr___db_cursor_msg, (caddr_t) argp,
  502. (xdrproc_t) xdr___db_cursor_reply, (caddr_t) &clnt_res,
  503. TIMEOUT) != RPC_SUCCESS) {
  504. return (NULL);
  505. }
  506. return (&clnt_res);
  507. }
  509. __db_join_reply *
  510. __db_db_join_1(__db_join_msg *argp, CLIENT *clnt)
  511. {
  512. static __db_join_reply clnt_res;
  514. memset((char *)&clnt_res, 0, sizeof(clnt_res));
  515. if (clnt_call (clnt, __DB_db_join,
  516. (xdrproc_t) xdr___db_join_msg, (caddr_t) argp,
  517. (xdrproc_t) xdr___db_join_reply, (caddr_t) &clnt_res,
  518. TIMEOUT) != RPC_SUCCESS) {
  519. return (NULL);
  520. }
  521. return (&clnt_res);
  522. }
  524. __dbc_close_reply *
  525. __db_dbc_close_1(__dbc_close_msg *argp, CLIENT *clnt)
  526. {
  527. static __dbc_close_reply clnt_res;
  529. memset((char *)&clnt_res, 0, sizeof(clnt_res));
  530. if (clnt_call (clnt, __DB_dbc_close,
  531. (xdrproc_t) xdr___dbc_close_msg, (caddr_t) argp,
  532. (xdrproc_t) xdr___dbc_close_reply, (caddr_t) &clnt_res,
  533. TIMEOUT) != RPC_SUCCESS) {
  534. return (NULL);
  535. }
  536. return (&clnt_res);
  537. }
  539. __dbc_count_reply *
  540. __db_dbc_count_1(__dbc_count_msg *argp, CLIENT *clnt)
  541. {
  542. static __dbc_count_reply clnt_res;
  544. memset((char *)&clnt_res, 0, sizeof(clnt_res));
  545. if (clnt_call (clnt, __DB_dbc_count,
  546. (xdrproc_t) xdr___dbc_count_msg, (caddr_t) argp,
  547. (xdrproc_t) xdr___dbc_count_reply, (caddr_t) &clnt_res,
  548. TIMEOUT) != RPC_SUCCESS) {
  549. return (NULL);
  550. }
  551. return (&clnt_res);
  552. }
  554. __dbc_del_reply *
  555. __db_dbc_del_1(__dbc_del_msg *argp, CLIENT *clnt)
  556. {
  557. static __dbc_del_reply clnt_res;
  559. memset((char *)&clnt_res, 0, sizeof(clnt_res));
  560. if (clnt_call (clnt, __DB_dbc_del,
  561. (xdrproc_t) xdr___dbc_del_msg, (caddr_t) argp,
  562. (xdrproc_t) xdr___dbc_del_reply, (caddr_t) &clnt_res,
  563. TIMEOUT) != RPC_SUCCESS) {
  564. return (NULL);
  565. }
  566. return (&clnt_res);
  567. }
  569. __dbc_dup_reply *
  570. __db_dbc_dup_1(__dbc_dup_msg *argp, CLIENT *clnt)
  571. {
  572. static __dbc_dup_reply clnt_res;
  574. memset((char *)&clnt_res, 0, sizeof(clnt_res));
  575. if (clnt_call (clnt, __DB_dbc_dup,
  576. (xdrproc_t) xdr___dbc_dup_msg, (caddr_t) argp,
  577. (xdrproc_t) xdr___dbc_dup_reply, (caddr_t) &clnt_res,
  578. TIMEOUT) != RPC_SUCCESS) {
  579. return (NULL);
  580. }
  581. return (&clnt_res);
  582. }
  584. __dbc_get_reply *
  585. __db_dbc_get_1(__dbc_get_msg *argp, CLIENT *clnt)
  586. {
  587. static __dbc_get_reply clnt_res;
  589. memset((char *)&clnt_res, 0, sizeof(clnt_res));
  590. if (clnt_call (clnt, __DB_dbc_get,
  591. (xdrproc_t) xdr___dbc_get_msg, (caddr_t) argp,
  592. (xdrproc_t) xdr___dbc_get_reply, (caddr_t) &clnt_res,
  593. TIMEOUT) != RPC_SUCCESS) {
  594. return (NULL);
  595. }
  596. return (&clnt_res);
  597. }
  599. __dbc_put_reply *
  600. __db_dbc_put_1(__dbc_put_msg *argp, CLIENT *clnt)
  601. {
  602. static __dbc_put_reply clnt_res;
  604. memset((char *)&clnt_res, 0, sizeof(clnt_res));
  605. if (clnt_call (clnt, __DB_dbc_put,
  606. (xdrproc_t) xdr___dbc_put_msg, (caddr_t) argp,
  607. (xdrproc_t) xdr___dbc_put_reply, (caddr_t) &clnt_res,
  608. TIMEOUT) != RPC_SUCCESS) {
  609. return (NULL);
  610. }
  611. return (&clnt_res);
  612. }
  613. #endif /* HAVE_RPC */