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

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

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 <errno.h>
  11. #include <string.h>
  12. #endif
  13. #include "db_server.h"
  15. #include "db_int.h"
  16. #include "db_server_int.h"
  17. #include "rpc_server_ext.h"
  19. #include "gen_server_ext.h"
  21. __env_cachesize_reply *
  22. __db_env_cachesize_1(req)
  23. __env_cachesize_msg *req;
  24. {
  25. static __env_cachesize_reply reply; /* must be static */
  27. __env_cachesize_1_proc(req->dbenvcl_id,
  28.     req->gbytes,
  29.     req->bytes,
  30.     req->ncache,
  31.     &reply);
  33. return (&reply);
  34. }
  36. __env_close_reply *
  37. __db_env_close_1(req)
  38. __env_close_msg *req;
  39. {
  40. static __env_close_reply reply; /* must be static */
  42. __env_close_1_proc(req->dbenvcl_id,
  43.     req->flags,
  44.     &reply);
  46. return (&reply);
  47. }
  49. __env_create_reply *
  50. __db_env_create_1(req)
  51. __env_create_msg *req;
  52. {
  53. static __env_create_reply reply; /* must be static */
  55. __env_create_1_proc(req->timeout,
  56.     &reply);
  58. return (&reply);
  59. }
  61. __env_flags_reply *
  62. __db_env_flags_1(req)
  63. __env_flags_msg *req;
  64. {
  65. static __env_flags_reply reply; /* must be static */
  67. __env_flags_1_proc(req->dbenvcl_id,
  68.     req->flags,
  69.     req->onoff,
  70.     &reply);
  72. return (&reply);
  73. }
  75. __env_open_reply *
  76. __db_env_open_1(req)
  77. __env_open_msg *req;
  78. {
  79. static __env_open_reply reply; /* must be static */
  81. __env_open_1_proc(req->dbenvcl_id,
  82.     (*req->home == '') ? NULL : req->home,
  83.     req->flags,
  84.     req->mode,
  85.     &reply);
  87. return (&reply);
  88. }
  90. __env_remove_reply *
  91. __db_env_remove_1(req)
  92. __env_remove_msg *req;
  93. {
  94. static __env_remove_reply reply; /* must be static */
  96. __env_remove_1_proc(req->dbenvcl_id,
  97.     (*req->home == '') ? NULL : req->home,
  98.     req->flags,
  99.     &reply);
  101. return (&reply);
  102. }
  104. __txn_abort_reply *
  105. __db_txn_abort_1(req)
  106. __txn_abort_msg *req;
  107. {
  108. static __txn_abort_reply reply; /* must be static */
  110. __txn_abort_1_proc(req->txnpcl_id,
  111.     &reply);
  113. return (&reply);
  114. }
  116. __txn_begin_reply *
  117. __db_txn_begin_1(req)
  118. __txn_begin_msg *req;
  119. {
  120. static __txn_begin_reply reply; /* must be static */
  122. __txn_begin_1_proc(req->envpcl_id,
  123.     req->parentcl_id,
  124.     req->flags,
  125.     &reply);
  127. return (&reply);
  128. }
  130. __txn_commit_reply *
  131. __db_txn_commit_1(req)
  132. __txn_commit_msg *req;
  133. {
  134. static __txn_commit_reply reply; /* must be static */
  136. __txn_commit_1_proc(req->txnpcl_id,
  137.     req->flags,
  138.     &reply);
  140. return (&reply);
  141. }
  143. __db_bt_maxkey_reply *
  144. __db_db_bt_maxkey_1(req)
  145. __db_bt_maxkey_msg *req;
  146. {
  147. static __db_bt_maxkey_reply reply; /* must be static */
  149. __db_bt_maxkey_1_proc(req->dbpcl_id,
  150.     req->maxkey,
  151.     &reply);
  153. return (&reply);
  154. }
  156. __db_bt_minkey_reply *
  157. __db_db_bt_minkey_1(req)
  158. __db_bt_minkey_msg *req;
  159. {
  160. static __db_bt_minkey_reply reply; /* must be static */
  162. __db_bt_minkey_1_proc(req->dbpcl_id,
  163.     req->minkey,
  164.     &reply);
  166. return (&reply);
  167. }
  169. __db_close_reply *
  170. __db_db_close_1(req)
  171. __db_close_msg *req;
  172. {
  173. static __db_close_reply reply; /* must be static */
  175. __db_close_1_proc(req->dbpcl_id,
  176.     req->flags,
  177.     &reply);
  179. return (&reply);
  180. }
  182. __db_create_reply *
  183. __db_db_create_1(req)
  184. __db_create_msg *req;
  185. {
  186. static __db_create_reply reply; /* must be static */
  188. __db_create_1_proc(req->flags,
  189.     req->envpcl_id,
  190.     &reply);
  192. return (&reply);
  193. }
  195. __db_del_reply *
  196. __db_db_del_1(req)
  197. __db_del_msg *req;
  198. {
  199. static __db_del_reply reply; /* must be static */
  201. __db_del_1_proc(req->dbpcl_id,
  202.     req->txnpcl_id,
  203.     req->keydlen,
  204.     req->keydoff,
  205.     req->keyflags,
  206.     req->keydata.keydata_val,
  207.     req->keydata.keydata_len,
  208.     req->flags,
  209.     &reply);
  211. return (&reply);
  212. }
  214. __db_extentsize_reply *
  215. __db_db_extentsize_1(req)
  216. __db_extentsize_msg *req;
  217. {
  218. static __db_extentsize_reply reply; /* must be static */
  220. __db_extentsize_1_proc(req->dbpcl_id,
  221.     req->extentsize,
  222.     &reply);
  224. return (&reply);
  225. }
  227. __db_flags_reply *
  228. __db_db_flags_1(req)
  229. __db_flags_msg *req;
  230. {
  231. static __db_flags_reply reply; /* must be static */
  233. __db_flags_1_proc(req->dbpcl_id,
  234.     req->flags,
  235.     &reply);
  237. return (&reply);
  238. }
  240. __db_get_reply *
  241. __db_db_get_1(req)
  242. __db_get_msg *req;
  243. {
  244. static __db_get_reply reply; /* must be static */
  245. static int __db_get_free = 0; /* must be static */
  247. if (__db_get_free)
  248. xdr_free((xdrproc_t)xdr___db_get_reply, (void *)&reply);
  249. __db_get_free = 0;
  251. /* Reinitialize allocated fields */
  252. reply.keydata.keydata_val = NULL;
  253. reply.datadata.datadata_val = NULL;
  255. __db_get_1_proc(req->dbpcl_id,
  256.     req->txnpcl_id,
  257.     req->keydlen,
  258.     req->keydoff,
  259.     req->keyflags,
  260.     req->keydata.keydata_val,
  261.     req->keydata.keydata_len,
  262.     req->datadlen,
  263.     req->datadoff,
  264.     req->dataflags,
  265.     req->datadata.datadata_val,
  266.     req->datadata.datadata_len,
  267.     req->flags,
  268.     &reply,
  269.     &__db_get_free);
  270. return (&reply);
  271. }
  273. __db_h_ffactor_reply *
  274. __db_db_h_ffactor_1(req)
  275. __db_h_ffactor_msg *req;
  276. {
  277. static __db_h_ffactor_reply reply; /* must be static */
  279. __db_h_ffactor_1_proc(req->dbpcl_id,
  280.     req->ffactor,
  281.     &reply);
  283. return (&reply);
  284. }
  286. __db_h_nelem_reply *
  287. __db_db_h_nelem_1(req)
  288. __db_h_nelem_msg *req;
  289. {
  290. static __db_h_nelem_reply reply; /* must be static */
  292. __db_h_nelem_1_proc(req->dbpcl_id,
  293.     req->nelem,
  294.     &reply);
  296. return (&reply);
  297. }
  299. __db_key_range_reply *
  300. __db_db_key_range_1(req)
  301. __db_key_range_msg *req;
  302. {
  303. static __db_key_range_reply reply; /* must be static */
  305. __db_key_range_1_proc(req->dbpcl_id,
  306.     req->txnpcl_id,
  307.     req->keydlen,
  308.     req->keydoff,
  309.     req->keyflags,
  310.     req->keydata.keydata_val,
  311.     req->keydata.keydata_len,
  312.     req->flags,
  313.     &reply);
  315. return (&reply);
  316. }
  318. __db_lorder_reply *
  319. __db_db_lorder_1(req)
  320. __db_lorder_msg *req;
  321. {
  322. static __db_lorder_reply reply; /* must be static */
  324. __db_lorder_1_proc(req->dbpcl_id,
  325.     req->lorder,
  326.     &reply);
  328. return (&reply);
  329. }
  331. __db_open_reply *
  332. __db_db_open_1(req)
  333. __db_open_msg *req;
  334. {
  335. static __db_open_reply reply; /* must be static */
  337. __db_open_1_proc(req->dbpcl_id,
  338.     (*req->name == '') ? NULL : req->name,
  339.     (*req->subdb == '') ? NULL : req->subdb,
  340.     req->type,
  341.     req->flags,
  342.     req->mode,
  343.     &reply);
  345. return (&reply);
  346. }
  348. __db_pagesize_reply *
  349. __db_db_pagesize_1(req)
  350. __db_pagesize_msg *req;
  351. {
  352. static __db_pagesize_reply reply; /* must be static */
  354. __db_pagesize_1_proc(req->dbpcl_id,
  355.     req->pagesize,
  356.     &reply);
  358. return (&reply);
  359. }
  361. __db_put_reply *
  362. __db_db_put_1(req)
  363. __db_put_msg *req;
  364. {
  365. static __db_put_reply reply; /* must be static */
  366. static int __db_put_free = 0; /* must be static */
  368. if (__db_put_free)
  369. xdr_free((xdrproc_t)xdr___db_put_reply, (void *)&reply);
  370. __db_put_free = 0;
  372. /* Reinitialize allocated fields */
  373. reply.keydata.keydata_val = NULL;
  375. __db_put_1_proc(req->dbpcl_id,
  376.     req->txnpcl_id,
  377.     req->keydlen,
  378.     req->keydoff,
  379.     req->keyflags,
  380.     req->keydata.keydata_val,
  381.     req->keydata.keydata_len,
  382.     req->datadlen,
  383.     req->datadoff,
  384.     req->dataflags,
  385.     req->datadata.datadata_val,
  386.     req->datadata.datadata_len,
  387.     req->flags,
  388.     &reply,
  389.     &__db_put_free);
  390. return (&reply);
  391. }
  393. __db_re_delim_reply *
  394. __db_db_re_delim_1(req)
  395. __db_re_delim_msg *req;
  396. {
  397. static __db_re_delim_reply reply; /* must be static */
  399. __db_re_delim_1_proc(req->dbpcl_id,
  400.     req->delim,
  401.     &reply);
  403. return (&reply);
  404. }
  406. __db_re_len_reply *
  407. __db_db_re_len_1(req)
  408. __db_re_len_msg *req;
  409. {
  410. static __db_re_len_reply reply; /* must be static */
  412. __db_re_len_1_proc(req->dbpcl_id,
  413.     req->len,
  414.     &reply);
  416. return (&reply);
  417. }
  419. __db_re_pad_reply *
  420. __db_db_re_pad_1(req)
  421. __db_re_pad_msg *req;
  422. {
  423. static __db_re_pad_reply reply; /* must be static */
  425. __db_re_pad_1_proc(req->dbpcl_id,
  426.     req->pad,
  427.     &reply);
  429. return (&reply);
  430. }
  432. __db_remove_reply *
  433. __db_db_remove_1(req)
  434. __db_remove_msg *req;
  435. {
  436. static __db_remove_reply reply; /* must be static */
  438. __db_remove_1_proc(req->dbpcl_id,
  439.     (*req->name == '') ? NULL : req->name,
  440.     (*req->subdb == '') ? NULL : req->subdb,
  441.     req->flags,
  442.     &reply);
  444. return (&reply);
  445. }
  447. __db_rename_reply *
  448. __db_db_rename_1(req)
  449. __db_rename_msg *req;
  450. {
  451. static __db_rename_reply reply; /* must be static */
  453. __db_rename_1_proc(req->dbpcl_id,
  454.     (*req->name == '') ? NULL : req->name,
  455.     (*req->subdb == '') ? NULL : req->subdb,
  456.     (*req->newname == '') ? NULL : req->newname,
  457.     req->flags,
  458.     &reply);
  460. return (&reply);
  461. }
  463. __db_stat_reply *
  464. __db_db_stat_1(req)
  465. __db_stat_msg *req;
  466. {
  467. static __db_stat_reply reply; /* must be static */
  468. static int __db_stat_free = 0; /* must be static */
  470. if (__db_stat_free)
  471. xdr_free((xdrproc_t)xdr___db_stat_reply, (void *)&reply);
  472. __db_stat_free = 0;
  474. /* Reinitialize allocated fields */
  475. reply.statslist = NULL;
  477. __db_stat_1_proc(req->dbpcl_id,
  478.     req->flags,
  479.     &reply,
  480.     &__db_stat_free);
  481. return (&reply);
  482. }
  484. __db_swapped_reply *
  485. __db_db_swapped_1(req)
  486. __db_swapped_msg *req;
  487. {
  488. static __db_swapped_reply reply; /* must be static */
  490. __db_swapped_1_proc(req->dbpcl_id,
  491.     &reply);
  493. return (&reply);
  494. }
  496. __db_sync_reply *
  497. __db_db_sync_1(req)
  498. __db_sync_msg *req;
  499. {
  500. static __db_sync_reply reply; /* must be static */
  502. __db_sync_1_proc(req->dbpcl_id,
  503.     req->flags,
  504.     &reply);
  506. return (&reply);
  507. }
  509. __db_cursor_reply *
  510. __db_db_cursor_1(req)
  511. __db_cursor_msg *req;
  512. {
  513. static __db_cursor_reply reply; /* must be static */
  515. __db_cursor_1_proc(req->dbpcl_id,
  516.     req->txnpcl_id,
  517.     req->flags,
  518.     &reply);
  520. return (&reply);
  521. }
  523. int __db_db_join_curslist __P((__db_join_curslist *, u_int32_t **));
  524. void __db_db_join_cursfree __P((u_int32_t *));
  526. __db_join_reply *
  527. __db_db_join_1(req)
  528. __db_join_msg *req;
  529. {
  530. u_int32_t *__db_curslist;
  531. int ret;
  532. static __db_join_reply reply; /* must be static */
  534. if ((ret = __db_db_join_curslist(req->curslist, &__db_curslist)) != 0)
  535. goto out;
  537. __db_join_1_proc(req->dbpcl_id,
  538.     __db_curslist,
  539.     req->flags,
  540.     &reply);
  542. __db_db_join_cursfree(__db_curslist);
  544. out:
  545. return (&reply);
  546. }
  548. int
  549. __db_db_join_curslist(locp, ppp)
  550. __db_join_curslist *locp;
  551. u_int32_t **ppp;
  552. {
  553. u_int32_t *pp;
  554. int cnt, ret, size;
  555. __db_join_curslist *nl;
  557. for (cnt = 0, nl = locp; nl != NULL; cnt++, nl = nl->next)
  558. ;
  560. if (cnt == 0) {
  561. *ppp = NULL;
  562. return (0);
  563. }
  564. size = sizeof(*pp) * (cnt + 1);
  565. if ((ret = __os_malloc(NULL, size, NULL, ppp)) != 0)
  566. return (ret);
  567. memset(*ppp, 0, size);
  568. for (pp = *ppp, nl = locp; nl != NULL; nl = nl->next, pp++) {
  569. *pp = *(u_int32_t *)nl->ent.ent_val;
  570. }
  571. return (0);
  572. }
  574. void
  575. __db_db_join_cursfree(pp)
  576. u_int32_t *pp;
  577. {
  578. size_t size;
  579. u_int32_t *p;
  581. if (pp == NULL)
  582. return;
  583. size = sizeof(*p);
  584. for (p = pp; *p != 0; p++) {
  585. size += sizeof(*p);
  586. }
  587. __os_free(pp, size);
  588. }
  590. __dbc_close_reply *
  591. __db_dbc_close_1(req)
  592. __dbc_close_msg *req;
  593. {
  594. static __dbc_close_reply reply; /* must be static */
  596. __dbc_close_1_proc(req->dbccl_id,
  597.     &reply);
  599. return (&reply);
  600. }
  602. __dbc_count_reply *
  603. __db_dbc_count_1(req)
  604. __dbc_count_msg *req;
  605. {
  606. static __dbc_count_reply reply; /* must be static */
  608. __dbc_count_1_proc(req->dbccl_id,
  609.     req->flags,
  610.     &reply);
  612. return (&reply);
  613. }
  615. __dbc_del_reply *
  616. __db_dbc_del_1(req)
  617. __dbc_del_msg *req;
  618. {
  619. static __dbc_del_reply reply; /* must be static */
  621. __dbc_del_1_proc(req->dbccl_id,
  622.     req->flags,
  623.     &reply);
  625. return (&reply);
  626. }
  628. __dbc_dup_reply *
  629. __db_dbc_dup_1(req)
  630. __dbc_dup_msg *req;
  631. {
  632. static __dbc_dup_reply reply; /* must be static */
  634. __dbc_dup_1_proc(req->dbccl_id,
  635.     req->flags,
  636.     &reply);
  638. return (&reply);
  639. }
  641. __dbc_get_reply *
  642. __db_dbc_get_1(req)
  643. __dbc_get_msg *req;
  644. {
  645. static __dbc_get_reply reply; /* must be static */
  646. static int __dbc_get_free = 0; /* must be static */
  648. if (__dbc_get_free)
  649. xdr_free((xdrproc_t)xdr___dbc_get_reply, (void *)&reply);
  650. __dbc_get_free = 0;
  652. /* Reinitialize allocated fields */
  653. reply.keydata.keydata_val = NULL;
  654. reply.datadata.datadata_val = NULL;
  656. __dbc_get_1_proc(req->dbccl_id,
  657.     req->keydlen,
  658.     req->keydoff,
  659.     req->keyflags,
  660.     req->keydata.keydata_val,
  661.     req->keydata.keydata_len,
  662.     req->datadlen,
  663.     req->datadoff,
  664.     req->dataflags,
  665.     req->datadata.datadata_val,
  666.     req->datadata.datadata_len,
  667.     req->flags,
  668.     &reply,
  669.     &__dbc_get_free);
  670. return (&reply);
  671. }
  673. __dbc_put_reply *
  674. __db_dbc_put_1(req)
  675. __dbc_put_msg *req;
  676. {
  677. static __dbc_put_reply reply; /* must be static */
  678. static int __dbc_put_free = 0; /* must be static */
  680. if (__dbc_put_free)
  681. xdr_free((xdrproc_t)xdr___dbc_put_reply, (void *)&reply);
  682. __dbc_put_free = 0;
  684. /* Reinitialize allocated fields */
  685. reply.keydata.keydata_val = NULL;
  687. __dbc_put_1_proc(req->dbccl_id,
  688.     req->keydlen,
  689.     req->keydoff,
  690.     req->keyflags,
  691.     req->keydata.keydata_val,
  692.     req->keydata.keydata_len,
  693.     req->datadlen,
  694.     req->datadoff,
  695.     req->dataflags,
  696.     req->datadata.datadata_val,
  697.     req->datadata.datadata_len,
  698.     req->flags,
  699.     &reply,
  700.     &__dbc_put_free);
  701. return (&reply);
  702. }