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

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

MySQL数据库

开发平台：

Visual C++

db_server_proc.c：源码内容
  1. /*-
  2.  * See the file LICENSE for redistribution information.
  3.  *
  4.  * Copyright (c) 2000
  5.  *      Sleepycat Software.  All rights reserved.
  6.  */
  8. #include "db_config.h"
  10. #ifdef HAVE_RPC
  11. #ifndef lint
  12. static const char revid[] = "$Id: db_server_proc.c,v 1.48 2001/01/06 16:08:01 sue Exp $";
  13. #endif /* not lint */
  15. #ifndef NO_SYSTEM_INCLUDES
  16. #include <sys/types.h>
  18. #include <rpc/rpc.h>
  20. #include <string.h>
  21. #endif
  22. #include "db_server.h"
  24. #include "db_int.h"
  25. #include "db_server_int.h"
  26. #include "rpc_server_ext.h"
  28. static int __db_stats_list __P((DB_ENV *,
  29.       __db_stat_statsreplist **, u_int32_t *, int));
  31. /* BEGIN __env_cachesize_1_proc */
  32. void
  33. __env_cachesize_1_proc(dbenvcl_id, gbytes, bytes,
  34. ncache, replyp)
  35. long dbenvcl_id;
  36. u_int32_t gbytes;
  37. u_int32_t bytes;
  38. u_int32_t ncache;
  39. __env_cachesize_reply *replyp;
  40. /* END __env_cachesize_1_proc */
  41. {
  42. int ret;
  43. DB_ENV * dbenv;
  44. ct_entry *dbenv_ctp;
  46. ACTIVATE_CTP(dbenv_ctp, dbenvcl_id, CT_ENV);
  47. dbenv = (DB_ENV *)dbenv_ctp->ct_anyp;
  49. ret = dbenv->set_cachesize(dbenv, gbytes, bytes, ncache);
  51. replyp->status = ret;
  52. return;
  53. }
  55. /* BEGIN __env_close_1_proc */
  56. void
  57. __env_close_1_proc(dbenvcl_id, flags, replyp)
  58. long dbenvcl_id;
  59. u_int32_t flags;
  60. __env_close_reply *replyp;
  61. /* END __env_close_1_proc */
  62. {
  63. replyp->status = __dbenv_close_int(dbenvcl_id, flags);
  64. return;
  65. }
  67. /* BEGIN __env_create_1_proc */
  68. void
  69. __env_create_1_proc(timeout, replyp)
  70. u_int32_t timeout;
  71. __env_create_reply *replyp;
  72. /* END __env_create_1_proc */
  73. {
  74. int ret;
  75. DB_ENV *dbenv;
  76. ct_entry *ctp;
  78. ctp = new_ct_ent(&replyp->status);
  79. if (ctp == NULL)
  80. return;
  81. if ((ret = db_env_create(&dbenv, 0)) == 0) {
  82. ctp->ct_envp = dbenv;
  83. ctp->ct_type = CT_ENV;
  84. ctp->ct_parent = NULL;
  85. ctp->ct_envparent = ctp;
  86. __dbsrv_settimeout(ctp, timeout);
  87. __dbsrv_active(ctp);
  88. replyp->envcl_id = ctp->ct_id;
  89. } else
  90. __dbclear_ctp(ctp);
  92. replyp->status = ret;
  93. return;
  94. }
  96. /* BEGIN __env_flags_1_proc */
  97. void
  98. __env_flags_1_proc(dbenvcl_id, flags, onoff, replyp)
  99. long dbenvcl_id;
  100. u_int32_t flags;
  101. u_int32_t onoff;
  102. __env_flags_reply *replyp;
  103. /* END __env_flags_1_proc */
  104. {
  105. int ret;
  106. DB_ENV * dbenv;
  107. ct_entry *dbenv_ctp;
  109. ACTIVATE_CTP(dbenv_ctp, dbenvcl_id, CT_ENV);
  110. dbenv = (DB_ENV *)dbenv_ctp->ct_anyp;
  112. ret = dbenv->set_flags(dbenv, flags, onoff);
  114. replyp->status = ret;
  115. return;
  116. }
  117. /* BEGIN __env_open_1_proc */
  118. void
  119. __env_open_1_proc(dbenvcl_id, home, flags,
  120. mode, replyp)
  121. long dbenvcl_id;
  122. char *home;
  123. u_int32_t flags;
  124. u_int32_t mode;
  125. __env_open_reply *replyp;
  126. /* END __env_open_1_proc */
  127. {
  128. int ret;
  129. DB_ENV * dbenv;
  130. ct_entry *dbenv_ctp;
  131. char *fullhome;
  133. ACTIVATE_CTP(dbenv_ctp, dbenvcl_id, CT_ENV);
  134. dbenv = (DB_ENV *)dbenv_ctp->ct_anyp;
  135. fullhome = get_home(home);
  136. if (fullhome == NULL) {
  137. replyp->status = DB_NOSERVER_HOME;
  138. return;
  139. }
  141. ret = dbenv->open(dbenv, fullhome, flags, mode);
  142. replyp->status = ret;
  143. return;
  144. }
  146. /* BEGIN __env_remove_1_proc */
  147. void
  148. __env_remove_1_proc(dbenvcl_id, home, flags, replyp)
  149. long dbenvcl_id;
  150. char *home;
  151. u_int32_t flags;
  152. __env_remove_reply *replyp;
  153. /* END __env_remove_1_proc */
  154. {
  155. int ret;
  156. DB_ENV * dbenv;
  157. ct_entry *dbenv_ctp;
  158. char *fullhome;
  160. ACTIVATE_CTP(dbenv_ctp, dbenvcl_id, CT_ENV);
  161. dbenv = (DB_ENV *)dbenv_ctp->ct_anyp;
  162. fullhome = get_home(home);
  163. if (fullhome == NULL) {
  164. replyp->status = DB_NOSERVER_HOME;
  165. return;
  166. }
  168. ret = dbenv->remove(dbenv, fullhome, flags);
  169. __dbdel_ctp(dbenv_ctp);
  170. replyp->status = ret;
  171. return;
  172. }
  174. /* BEGIN __txn_abort_1_proc */
  175. void
  176. __txn_abort_1_proc(txnpcl_id, replyp)
  177. long txnpcl_id;
  178. __txn_abort_reply *replyp;
  179. /* END __txn_abort_1_proc */
  180. {
  181. DB_TXN * txnp;
  182. ct_entry *txnp_ctp;
  183. int ret;
  185. ACTIVATE_CTP(txnp_ctp, txnpcl_id, CT_TXN);
  186. txnp = (DB_TXN *)txnp_ctp->ct_anyp;
  188. ret =  txn_abort(txnp);
  189. __dbdel_ctp(txnp_ctp);
  190. replyp->status = ret;
  191. return;
  192. }
  194. /* BEGIN __txn_begin_1_proc */
  195. void
  196. __txn_begin_1_proc(envpcl_id, parentcl_id,
  197. flags, replyp)
  198. long envpcl_id;
  199. long parentcl_id;
  200. u_int32_t flags;
  201. __txn_begin_reply *replyp;
  202. /* END __txn_begin_1_proc */
  203. {
  204. int ret;
  205. DB_ENV * envp;
  206. ct_entry *envp_ctp;
  207. DB_TXN * parent;
  208. ct_entry *parent_ctp;
  209. DB_TXN *txnp;
  210. ct_entry *ctp;
  212. ACTIVATE_CTP(envp_ctp, envpcl_id, CT_ENV);
  213. envp = (DB_ENV *)envp_ctp->ct_anyp;
  214. parent_ctp = NULL;
  216. ctp = new_ct_ent(&replyp->status);
  217. if (ctp == NULL)
  218. return;
  220. if (parentcl_id != 0) {
  221. ACTIVATE_CTP(parent_ctp, parentcl_id, CT_TXN);
  222. parent = (DB_TXN *)parent_ctp->ct_anyp;
  223. ctp->ct_activep = parent_ctp->ct_activep;
  224. } else
  225. parent = NULL;
  227. ret = txn_begin(envp, parent, &txnp, flags);
  228. if (ret == 0) {
  229. ctp->ct_txnp = txnp;
  230. ctp->ct_type = CT_TXN;
  231. ctp->ct_parent = parent_ctp;
  232. ctp->ct_envparent = envp_ctp;
  233. replyp->txnidcl_id = ctp->ct_id;
  234. __dbsrv_settimeout(ctp, envp_ctp->ct_timeout);
  235. __dbsrv_active(ctp);
  236. } else
  237. __dbclear_ctp(ctp);
  239. replyp->status = ret;
  240. return;
  241. }
  243. /* BEGIN __txn_commit_1_proc */
  244. void
  245. __txn_commit_1_proc(txnpcl_id, flags, replyp)
  246. long txnpcl_id;
  247. u_int32_t flags;
  248. __txn_commit_reply *replyp;
  249. /* END __txn_commit_1_proc */
  250. {
  251. int ret;
  252. DB_TXN * txnp;
  253. ct_entry *txnp_ctp;
  255. ACTIVATE_CTP(txnp_ctp, txnpcl_id, CT_TXN);
  256. txnp = (DB_TXN *)txnp_ctp->ct_anyp;
  258. ret = txn_commit(txnp, flags);
  259. __dbdel_ctp(txnp_ctp);
  261. replyp->status = ret;
  262. return;
  263. }
  265. /* BEGIN __db_bt_maxkey_1_proc */
  266. void
  267. __db_bt_maxkey_1_proc(dbpcl_id, maxkey, replyp)
  268. long dbpcl_id;
  269. u_int32_t maxkey;
  270. __db_bt_maxkey_reply *replyp;
  271. /* END __db_bt_maxkey_1_proc */
  272. {
  273. int ret;
  274. DB * dbp;
  275. ct_entry *dbp_ctp;
  277. ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
  278. dbp = (DB *)dbp_ctp->ct_anyp;
  280. ret = dbp->set_bt_maxkey(dbp, maxkey);
  282. replyp->status = ret;
  283. return;
  284. }
  286. /* BEGIN __db_bt_minkey_1_proc */
  287. void
  288. __db_bt_minkey_1_proc(dbpcl_id, minkey, replyp)
  289. long dbpcl_id;
  290. u_int32_t minkey;
  291. __db_bt_minkey_reply *replyp;
  292. /* END __db_bt_minkey_1_proc */
  293. {
  294. int ret;
  295. DB * dbp;
  296. ct_entry *dbp_ctp;
  298. ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
  299. dbp = (DB *)dbp_ctp->ct_anyp;
  301. ret = dbp->set_bt_minkey(dbp, minkey);
  303. replyp->status = ret;
  304. return;
  305. }
  307. /* BEGIN __db_close_1_proc */
  308. void
  309. __db_close_1_proc(dbpcl_id, flags, replyp)
  310. long dbpcl_id;
  311. u_int32_t flags;
  312. __db_close_reply *replyp;
  313. /* END __db_close_1_proc */
  314. {
  315. int ret;
  316. DB * dbp;
  317. ct_entry *dbp_ctp;
  319. ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
  320. dbp = (DB *)dbp_ctp->ct_anyp;
  322. ret = dbp->close(dbp, flags);
  323. __dbdel_ctp(dbp_ctp);
  325. replyp-> status= ret;
  326. return;
  327. }
  329. /* BEGIN __db_create_1_proc */
  330. void
  331. __db_create_1_proc(flags, envpcl_id, replyp)
  332. u_int32_t flags;
  333. long envpcl_id;
  334. __db_create_reply *replyp;
  335. /* END __db_create_1_proc */
  336. {
  337. int ret;
  338. DB_ENV * envp;
  339. DB *dbp;
  340. ct_entry *envp_ctp, *dbp_ctp;
  342. ACTIVATE_CTP(envp_ctp, envpcl_id, CT_ENV);
  343. envp = (DB_ENV *)envp_ctp->ct_anyp;
  345. dbp_ctp = new_ct_ent(&replyp->status);
  346. if (dbp_ctp == NULL)
  347. return ;
  348. /*
  349.  * We actually require env's for databases.  The client should
  350.  * have caught it, but just in case.
  351.  */
  352. DB_ASSERT(envp != NULL);
  353. if ((ret = db_create(&dbp, envp, flags)) == 0) {
  354. dbp_ctp->ct_dbp = dbp;
  355. dbp_ctp->ct_type = CT_DB;
  356. dbp_ctp->ct_parent = envp_ctp;
  357. dbp_ctp->ct_envparent = envp_ctp;
  358. replyp->dbpcl_id = dbp_ctp->ct_id;
  359. } else
  360. __dbclear_ctp(dbp_ctp);
  361. replyp->status = ret;
  362. return;
  363. }
  365. /* BEGIN __db_del_1_proc */
  366. void
  367. __db_del_1_proc(dbpcl_id, txnpcl_id, keydlen,
  368. keydoff, keyflags, keydata, keysize,
  369. flags, replyp)
  370. long dbpcl_id;
  371. long txnpcl_id;
  372. u_int32_t keydlen;
  373. u_int32_t keydoff;
  374. u_int32_t keyflags;
  375. void *keydata;
  376. u_int32_t keysize;
  377. u_int32_t flags;
  378. __db_del_reply *replyp;
  379. /* END __db_del_1_proc */
  380. {
  381. int ret;
  382. DB * dbp;
  383. ct_entry *dbp_ctp;
  384. DB_TXN * txnp;
  385. ct_entry *txnp_ctp;
  386. DBT key;
  388. ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
  389. dbp = (DB *)dbp_ctp->ct_anyp;
  390. if (txnpcl_id != 0) {
  391. ACTIVATE_CTP(txnp_ctp, txnpcl_id, CT_TXN);
  392. txnp = (DB_TXN *)txnp_ctp->ct_anyp;
  393. } else
  394. txnp = NULL;
  396. memset(&key, 0, sizeof(key));
  398. /* Set up key DBT */
  399. key.dlen = keydlen;
  400. key.doff = keydoff;
  401. key.flags = keyflags;
  402. key.size = keysize;
  403. key.data = keydata;
  405. ret = dbp->del(dbp, txnp, &key, flags);
  407. replyp->status = ret;
  408. return;
  409. }
  411. /* BEGIN __db_extentsize_1_proc */
  412. void
  413. __db_extentsize_1_proc(dbpcl_id, extentsize, replyp)
  414. long dbpcl_id;
  415. u_int32_t extentsize;
  416. __db_extentsize_reply *replyp;
  417. /* END __db_extentsize_1_proc */
  418. {
  419. int ret;
  420. DB * dbp;
  421. ct_entry *dbp_ctp;
  423. ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
  424. dbp = (DB *)dbp_ctp->ct_anyp;
  426. ret = dbp->set_q_extentsize(dbp, extentsize);
  428. replyp->status = ret;
  429. return;
  430. }
  432. /* BEGIN __db_flags_1_proc */
  433. void
  434. __db_flags_1_proc(dbpcl_id, flags, replyp)
  435. long dbpcl_id;
  436. u_int32_t flags;
  437. __db_flags_reply *replyp;
  438. /* END __db_flags_1_proc */
  439. {
  440. int ret;
  441. DB * dbp;
  442. ct_entry *dbp_ctp;
  444. ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
  445. dbp = (DB *)dbp_ctp->ct_anyp;
  447. ret = dbp->set_flags(dbp, flags);
  449. replyp->status = ret;
  450. return;
  451. }
  453. /* BEGIN __db_get_1_proc */
  454. void
  455. __db_get_1_proc(dbpcl_id, txnpcl_id, keydlen,
  456. keydoff, keyflags, keydata, keysize,
  457. datadlen, datadoff, dataflags, datadata,
  458. datasize, flags, replyp, freep)
  459. long dbpcl_id;
  460. long txnpcl_id;
  461. u_int32_t keydlen;
  462. u_int32_t keydoff;
  463. u_int32_t keyflags;
  464. void *keydata;
  465. u_int32_t keysize;
  466. u_int32_t datadlen;
  467. u_int32_t datadoff;
  468. u_int32_t dataflags;
  469. void *datadata;
  470. u_int32_t datasize;
  471. u_int32_t flags;
  472. __db_get_reply *replyp;
  473. int * freep;
  474. /* END __db_get_1_proc */
  475. {
  476. int key_alloc, ret;
  477. DB * dbp;
  478. ct_entry *dbp_ctp;
  479. DB_TXN * txnp;
  480. ct_entry *txnp_ctp;
  481. DBT key, data;
  483. ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
  484. dbp = (DB *)dbp_ctp->ct_anyp;
  485. if (txnpcl_id != 0) {
  486. ACTIVATE_CTP(txnp_ctp, txnpcl_id, CT_TXN);
  487. txnp = (DB_TXN *)txnp_ctp->ct_anyp;
  488. } else
  489. txnp = NULL;
  491. *freep = 0;
  492. memset(&key, 0, sizeof(key));
  493. memset(&data, 0, sizeof(data));
  495. /* Set up key and data DBT */
  496. key.dlen = keydlen;
  497. key.doff = keydoff;
  498. /*
  499.  * Ignore memory related flags on server.
  500.  */
  501. key.flags = DB_DBT_MALLOC;
  502. if (keyflags & DB_DBT_PARTIAL)
  503. key.flags |= DB_DBT_PARTIAL;
  504. key.size = keysize;
  505. key.data = keydata;
  507. data.dlen = datadlen;
  508. data.doff = datadoff;
  509. /*
  510.  * Ignore memory related flags on server.
  511.  */
  512. data.flags = DB_DBT_MALLOC;
  513. if (dataflags & DB_DBT_PARTIAL)
  514. data.flags |= DB_DBT_PARTIAL;
  515. data.size = datasize;
  516. data.data = datadata;
  518. /* Got all our stuff, now do the get */
  519. ret = dbp->get(dbp, txnp, &key, &data, flags);
  520. /*
  521.  * Otherwise just status.
  522.  */
  523. if (ret == 0) {
  524. /*
  525.  * XXX
  526.  * We need to xdr_free whatever we are returning, next time.
  527.  * However, DB does not allocate a new key if one was given
  528.  * and we'd be free'ing up space allocated in the request.
  529.  * So, allocate a new key/data pointer if it is the same one
  530.  * as in the request.
  531.  */
  532. *freep = 1;
  533. /*
  534.  * Key
  535.  */
  536. key_alloc = 0;
  537. if (key.data == keydata) {
  538. ret = __os_malloc(dbp->dbenv,
  539.     key.size, NULL, &replyp->keydata.keydata_val);
  540. if (ret != 0) {
  541. __os_free(key.data, key.size);
  542. __os_free(data.data, data.size);
  543. goto err;
  544. }
  545. key_alloc = 1;
  546. memcpy(replyp->keydata.keydata_val, key.data, key.size);
  547. } else
  548. replyp->keydata.keydata_val = key.data;
  550. replyp->keydata.keydata_len = key.size;
  552. /*
  553.  * Data
  554.  */
  555. if (data.data == datadata) {
  556. ret = __os_malloc(dbp->dbenv,
  557.      data.size, NULL, &replyp->datadata.datadata_val);
  558. if (ret != 0) {
  559. __os_free(key.data, key.size);
  560. __os_free(data.data, data.size);
  561. if (key_alloc)
  562. __os_free(replyp->keydata.keydata_val,
  563.     key.size);
  564. goto err;
  565. }
  566. memcpy(replyp->datadata.datadata_val, data.data,
  567.     data.size);
  568. } else
  569. replyp->datadata.datadata_val = data.data;
  570. replyp->datadata.datadata_len = data.size;
  571. } else {
  572. err: replyp->keydata.keydata_val = NULL;
  573. replyp->keydata.keydata_len = 0;
  574. replyp->datadata.datadata_val = NULL;
  575. replyp->datadata.datadata_len = 0;
  576. *freep = 0;
  577. }
  578. replyp->status = ret;
  579. return;
  580. }
  582. /* BEGIN __db_h_ffactor_1_proc */
  583. void
  584. __db_h_ffactor_1_proc(dbpcl_id, ffactor, replyp)
  585. long dbpcl_id;
  586. u_int32_t ffactor;
  587. __db_h_ffactor_reply *replyp;
  588. /* END __db_h_ffactor_1_proc */
  589. {
  590. int ret;
  591. DB * dbp;
  592. ct_entry *dbp_ctp;
  594. ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
  595. dbp = (DB *)dbp_ctp->ct_anyp;
  597. ret = dbp->set_h_ffactor(dbp, ffactor);
  599. replyp->status = ret;
  600. return;
  601. }
  603. /* BEGIN __db_h_nelem_1_proc */
  604. void
  605. __db_h_nelem_1_proc(dbpcl_id, nelem, replyp)
  606. long dbpcl_id;
  607. u_int32_t nelem;
  608. __db_h_nelem_reply *replyp;
  609. /* END __db_h_nelem_1_proc */
  610. {
  611. int ret;
  612. DB * dbp;
  613. ct_entry *dbp_ctp;
  615. ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
  616. dbp = (DB *)dbp_ctp->ct_anyp;
  618. ret = dbp->set_h_nelem(dbp, nelem);
  620. replyp->status = ret;
  621. return;
  622. }
  624. /* BEGIN __db_key_range_1_proc */
  625. void
  626. __db_key_range_1_proc(dbpcl_id, txnpcl_id, keydlen,
  627. keydoff, keyflags, keydata, keysize,
  628. flags, replyp)
  629. long dbpcl_id;
  630. long txnpcl_id;
  631. u_int32_t keydlen;
  632. u_int32_t keydoff;
  633. u_int32_t keyflags;
  634. void *keydata;
  635. u_int32_t keysize;
  636. u_int32_t flags;
  637. __db_key_range_reply *replyp;
  638. /* END __db_key_range_1_proc */
  639. {
  640. int ret;
  641. DB * dbp;
  642. ct_entry *dbp_ctp;
  643. DB_TXN * txnp;
  644. ct_entry *txnp_ctp;
  645. DBT key;
  646. DB_KEY_RANGE range;
  648. ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
  649. dbp = (DB *)dbp_ctp->ct_anyp;
  650. if (txnpcl_id != 0) {
  651. ACTIVATE_CTP(txnp_ctp, txnpcl_id, CT_TXN);
  652. txnp = (DB_TXN *)txnp_ctp->ct_anyp;
  653. } else
  654. txnp = NULL;
  656. memset(&key, 0, sizeof(key));
  657. /* Set up key and data DBT */
  658. key.dlen = keydlen;
  659. key.doff = keydoff;
  660. key.size = keysize;
  661. key.data = keydata;
  662. key.flags = keyflags;
  664. ret = dbp->key_range(dbp, txnp, &key, &range, flags);
  666. replyp->status = ret;
  667. replyp->less = range.less;
  668. replyp->equal = range.equal;
  669. replyp->greater = range.greater;
  670. return;
  671. }
  673. /* BEGIN __db_lorder_1_proc */
  674. void
  675. __db_lorder_1_proc(dbpcl_id, lorder, replyp)
  676. long dbpcl_id;
  677. u_int32_t lorder;
  678. __db_lorder_reply *replyp;
  679. /* END __db_lorder_1_proc */
  680. {
  681. int ret;
  682. DB * dbp;
  683. ct_entry *dbp_ctp;
  685. ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
  686. dbp = (DB *)dbp_ctp->ct_anyp;
  688. ret = dbp->set_lorder(dbp, lorder);
  690. replyp->status = ret;
  691. return;
  692. }
  694. /* BEGIN __dbopen_1_proc */
  695. void
  696. __db_open_1_proc(dbpcl_id, name, subdb,
  697. type, flags, mode, replyp)
  698. long dbpcl_id;
  699. char *name;
  700. char *subdb;
  701. u_int32_t type;
  702. u_int32_t flags;
  703. u_int32_t mode;
  704. __db_open_reply *replyp;
  705. /* END __db_open_1_proc */
  706. {
  707. int ret;
  708. DB * dbp;
  709. ct_entry *dbp_ctp;
  711. ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
  712. dbp = (DB *)dbp_ctp->ct_anyp;
  714. ret = dbp->open(dbp, name, subdb, (DBTYPE)type, flags, mode);
  715. if (ret == 0) {
  716. replyp->type = (int) dbp->get_type(dbp);
  717. /* XXX
  718.  * Tcl needs to peek at dbp->flags for DB_AM_DUP.  Send
  719.  * this dbp's flags back.
  720.  */
  721. replyp->dbflags = (int) dbp->flags;
  722. }
  723. replyp->status = ret;
  724. return;
  725. }
  727. /* BEGIN __db_pagesize_1_proc */
  728. void
  729. __db_pagesize_1_proc(dbpcl_id, pagesize, replyp)
  730. long dbpcl_id;
  731. u_int32_t pagesize;
  732. __db_pagesize_reply *replyp;
  733. /* END __db_pagesize_1_proc */
  734. {
  735. int ret;
  736. DB * dbp;
  737. ct_entry *dbp_ctp;
  739. ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
  740. dbp = (DB *)dbp_ctp->ct_anyp;
  742. ret = dbp->set_pagesize(dbp, pagesize);
  744. replyp->status = ret;
  745. return;
  746. }
  748. /* BEGIN __db_put_1_proc */
  749. void
  750. __db_put_1_proc(dbpcl_id, txnpcl_id, keydlen,
  751. keydoff, keyflags, keydata, keysize,
  752. datadlen, datadoff, dataflags, datadata,
  753. datasize, flags, replyp, freep)
  754. long dbpcl_id;
  755. long txnpcl_id;
  756. u_int32_t keydlen;
  757. u_int32_t keydoff;
  758. u_int32_t keyflags;
  759. void *keydata;
  760. u_int32_t keysize;
  761. u_int32_t datadlen;
  762. u_int32_t datadoff;
  763. u_int32_t dataflags;
  764. void *datadata;
  765. u_int32_t datasize;
  766. u_int32_t flags;
  767. __db_put_reply *replyp;
  768. int * freep;
  769. /* END __db_put_1_proc */
  770. {
  771. int ret;
  772. DB * dbp;
  773. ct_entry *dbp_ctp;
  774. DB_TXN * txnp;
  775. ct_entry *txnp_ctp;
  776. DBT key, data;
  778. ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
  779. dbp = (DB *)dbp_ctp->ct_anyp;
  780. if (txnpcl_id != 0) {
  781. ACTIVATE_CTP(txnp_ctp, txnpcl_id, CT_TXN);
  782. txnp = (DB_TXN *)txnp_ctp->ct_anyp;
  783. } else
  784. txnp = NULL;
  786. *freep = 0;
  787. memset(&key, 0, sizeof(key));
  788. memset(&data, 0, sizeof(data));
  790. /* Set up key and data DBT */
  791. key.dlen = keydlen;
  792. key.doff = keydoff;
  793. /*
  794.  * Ignore memory related flags on server.
  795.  */
  796. key.flags = DB_DBT_MALLOC;
  797. if (keyflags & DB_DBT_PARTIAL)
  798. key.flags |= DB_DBT_PARTIAL;
  799. key.size = keysize;
  800. key.data = keydata;
  802. data.dlen = datadlen;
  803. data.doff = datadoff;
  804. data.flags = dataflags;
  805. data.size = datasize;
  806. data.data = datadata;
  808. /* Got all our stuff, now do the put */
  809. ret = dbp->put(dbp, txnp, &key, &data, flags);
  810. /*
  811.  * If the client did a DB_APPEND, set up key in reply.
  812.  * Otherwise just status.
  813.  */
  814. if (ret == 0 && (flags == DB_APPEND)) {
  815. /*
  816.  * XXX
  817.  * We need to xdr_free whatever we are returning, next time.
  818.  * However, DB does not allocate a new key if one was given
  819.  * and we'd be free'ing up space allocated in the request.
  820.  * So, allocate a new key/data pointer if it is the same one
  821.  * as in the request.
  822.  */
  823. *freep = 1;
  824. /*
  825.  * Key
  826.  */
  827. if (key.data == keydata) {
  828. ret = __os_malloc(dbp->dbenv,
  829.     key.size, NULL, &replyp->keydata.keydata_val);
  830. if (ret != 0) {
  831. __os_free(key.data, key.size);
  832. goto err;
  833. }
  834. memcpy(replyp->keydata.keydata_val, key.data, key.size);
  835. } else
  836. replyp->keydata.keydata_val = key.data;
  838. replyp->keydata.keydata_len = key.size;
  839. } else {
  840. err: replyp->keydata.keydata_val = NULL;
  841. replyp->keydata.keydata_len = 0;
  842. *freep = 0;
  843. }
  844. replyp->status = ret;
  845. return;
  846. }
  848. /* BEGIN __db_re_delim_1_proc */
  849. void
  850. __db_re_delim_1_proc(dbpcl_id, delim, replyp)
  851. long dbpcl_id;
  852. u_int32_t delim;
  853. __db_re_delim_reply *replyp;
  854. /* END __db_re_delim_1_proc */
  855. {
  856. int ret;
  857. DB * dbp;
  858. ct_entry *dbp_ctp;
  860. ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
  861. dbp = (DB *)dbp_ctp->ct_anyp;
  863. ret = dbp->set_re_delim(dbp, delim);
  865. replyp->status = ret;
  866. return;
  867. }
  869. /* BEGIN __db_re_len_1_proc */
  870. void
  871. __db_re_len_1_proc(dbpcl_id, len, replyp)
  872. long dbpcl_id;
  873. u_int32_t len;
  874. __db_re_len_reply *replyp;
  875. /* END __db_re_len_1_proc */
  876. {
  877. int ret;
  878. DB * dbp;
  879. ct_entry *dbp_ctp;
  881. ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
  882. dbp = (DB *)dbp_ctp->ct_anyp;
  884. ret = dbp->set_re_len(dbp, len);
  886. replyp->status = ret;
  887. return;
  888. }
  890. /* BEGIN __db_re_pad_1_proc */
  891. void
  892. __db_re_pad_1_proc(dbpcl_id, pad, replyp)
  893. long dbpcl_id;
  894. u_int32_t pad;
  895. __db_re_pad_reply *replyp;
  896. /* END __db_re_pad_1_proc */
  897. {
  898. int ret;
  899. DB * dbp;
  900. ct_entry *dbp_ctp;
  902. ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
  903. dbp = (DB *)dbp_ctp->ct_anyp;
  905. ret = dbp->set_re_pad(dbp, pad);
  907. replyp->status = ret;
  908. return;
  909. }
  911. /* BEGIN __db_remove_1_proc */
  912. void
  913. __db_remove_1_proc(dbpcl_id, name, subdb,
  914. flags, replyp)
  915. long dbpcl_id;
  916. char *name;
  917. char *subdb;
  918. u_int32_t flags;
  919. __db_remove_reply *replyp;
  920. /* END __db_remove_1_proc */
  921. {
  922. int ret;
  923. DB * dbp;
  924. ct_entry *dbp_ctp;
  926. ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
  927. dbp = (DB *)dbp_ctp->ct_anyp;
  929. ret = dbp->remove(dbp, name, subdb, flags);
  930. __dbdel_ctp(dbp_ctp);
  932. replyp->status = ret;
  933. return;
  934. }
  936. /* BEGIN __db_rename_1_proc */
  937. void
  938. __db_rename_1_proc(dbpcl_id, name, subdb,
  939. newname, flags, replyp)
  940. long dbpcl_id;
  941. char *name;
  942. char *subdb;
  943. char *newname;
  944. u_int32_t flags;
  945. __db_rename_reply *replyp;
  946. /* END __db_rename_1_proc */
  947. {
  948. int ret;
  949. DB * dbp;
  950. ct_entry *dbp_ctp;
  952. ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
  953. dbp = (DB *)dbp_ctp->ct_anyp;
  955. ret = dbp->rename(dbp, name, subdb, newname, flags);
  956. __dbdel_ctp(dbp_ctp);
  958. replyp->status = ret;
  959. return;
  960. }
  962. /* BEGIN __db_stat_1_proc */
  963. void
  964. __db_stat_1_proc(dbpcl_id,
  965. flags, replyp, freep)
  966. long dbpcl_id;
  967. u_int32_t flags;
  968. __db_stat_reply *replyp;
  969. int * freep;
  970. /* END __db_stat_1_proc */
  971. {
  972. int ret;
  973. DB * dbp;
  974. ct_entry *dbp_ctp;
  975. DBTYPE type;
  976. void *sp;
  977. int len;
  979. ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
  980. dbp = (DB *)dbp_ctp->ct_anyp;
  982. ret = dbp->stat(dbp, &sp, NULL, flags);
  983. replyp->status = ret;
  984. if (ret != 0)
  985. return;
  986. /*
  987.  * We get here, we have success.  Allocate an array so that
  988.  * we can use the list generator.  Generate the reply, free
  989.  * up the space.
  990.  */
  991. /*
  992.  * XXX This assumes that all elements of all stat structures
  993.  * are u_int32_t fields.  They are, currently.
  994.  */
  995. type = dbp->get_type(dbp);
  996. if (type == DB_HASH)
  997. len = sizeof(DB_HASH_STAT) / sizeof(u_int32_t);
  998. else if (type == DB_QUEUE)
  999. len = sizeof(DB_QUEUE_STAT) / sizeof(u_int32_t);
  1000. else            /* BTREE or RECNO are same stats */
  1001. len = sizeof(DB_BTREE_STAT) / sizeof(u_int32_t);
  1002. /*
  1003.  * Set up our list of stats.
  1004.  */
  1005. ret = __db_stats_list(dbp->dbenv,
  1006.     &replyp->statslist, (u_int32_t*)sp, len);
  1008. __os_free(sp, 0);
  1009. if (ret == 0)
  1010. *freep = 1;
  1011. replyp->status = ret;
  1012. return;
  1013. }
  1015. int
  1016. __db_stats_list(dbenv, locp, pp, len)
  1017. DB_ENV *dbenv;
  1018. __db_stat_statsreplist **locp;
  1019. u_int32_t *pp;
  1020. int len;
  1021. {
  1022. u_int32_t *p, *q;
  1023. int i, ret;
  1024. __db_stat_statsreplist *nl, **nlp;
  1026. nlp = locp;
  1027. for (i = 0; i < len; i++) {
  1028. p = pp+i;
  1029. if ((ret = __os_malloc(dbenv, sizeof(*nl), NULL, nlp)) != 0)
  1030. goto out;
  1031. nl = *nlp;
  1032. nl->next = NULL;
  1033. if ((ret = __os_malloc(dbenv,
  1034.     sizeof(u_int32_t), NULL, &nl->ent.ent_val)) != 0)
  1035. goto out;
  1036. q = (u_int32_t *)nl->ent.ent_val;
  1037. *q = *p;
  1038. nl->ent.ent_len = sizeof(u_int32_t);
  1039. nlp = &nl->next;
  1040. }
  1041. return (0);
  1042. out:
  1043. __db_stats_freelist(locp);
  1044. return (ret);
  1045. }
  1047. /*
  1048.  * PUBLIC: void __db_stats_freelist __P((__db_stat_statsreplist **));
  1049.  */
  1050. void
  1051. __db_stats_freelist(locp)
  1052. __db_stat_statsreplist **locp;
  1053. {
  1054. __db_stat_statsreplist *nl, *nl1;
  1056. for (nl = *locp; nl != NULL; nl = nl1) {
  1057. nl1 = nl->next;
  1058. if (nl->ent.ent_val)
  1059. __os_free(nl->ent.ent_val, nl->ent.ent_len);
  1060. __os_free(nl, sizeof(*nl));
  1061. }
  1062. *locp = NULL;
  1063. }
  1065. /* BEGIN __db_swapped_1_proc */
  1066. void
  1067. __db_swapped_1_proc(dbpcl_id, replyp)
  1068. long dbpcl_id;
  1069. __db_swapped_reply *replyp;
  1070. /* END __db_swapped_1_proc */
  1071. {
  1072. int ret;
  1073. DB * dbp;
  1074. ct_entry *dbp_ctp;
  1076. ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
  1077. dbp = (DB *)dbp_ctp->ct_anyp;
  1079. ret = dbp->get_byteswapped(dbp);
  1081. replyp->status = ret;
  1082. return;
  1083. }
  1085. /* BEGIN __db_sync_1_proc */
  1086. void
  1087. __db_sync_1_proc(dbpcl_id, flags, replyp)
  1088. long dbpcl_id;
  1089. u_int32_t flags;
  1090. __db_sync_reply *replyp;
  1091. /* END __db_sync_1_proc */
  1092. {
  1093. int ret;
  1094. DB * dbp;
  1095. ct_entry *dbp_ctp;
  1097. ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
  1098. dbp = (DB *)dbp_ctp->ct_anyp;
  1100. ret = dbp->sync(dbp, flags);
  1102. replyp->status = ret;
  1103. return;
  1104. }
  1106. /* BEGIN __db_cursor_1_proc */
  1107. void
  1108. __db_cursor_1_proc(dbpcl_id, txnpcl_id,
  1109. flags, replyp)
  1110. long dbpcl_id;
  1111. long txnpcl_id;
  1112. u_int32_t flags;
  1113. __db_cursor_reply *replyp;
  1114. /* END __db_cursor_1_proc */
  1115. {
  1116. int ret;
  1117. DB * dbp;
  1118. ct_entry *dbp_ctp;
  1119. DB_TXN * txnp;
  1120. ct_entry *txnp_ctp;
  1121. DBC *dbc;
  1122. ct_entry *dbc_ctp, *env_ctp;
  1124. ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
  1125. dbp = (DB *)dbp_ctp->ct_anyp;
  1126. dbc_ctp = new_ct_ent(&replyp->status);
  1127. if (dbc_ctp == NULL)
  1128. return;
  1130. if (txnpcl_id != 0) {
  1131. ACTIVATE_CTP(txnp_ctp, txnpcl_id, CT_TXN);
  1132. txnp = (DB_TXN *)txnp_ctp->ct_anyp;
  1133. dbc_ctp->ct_activep = txnp_ctp->ct_activep;
  1134. } else
  1135. txnp = NULL;
  1137. if ((ret = dbp->cursor(dbp, txnp, &dbc, flags)) == 0) {
  1138. dbc_ctp->ct_dbc = dbc;
  1139. dbc_ctp->ct_type = CT_CURSOR;
  1140. dbc_ctp->ct_parent = dbp_ctp;
  1141. env_ctp = dbp_ctp->ct_envparent;
  1142. dbc_ctp->ct_envparent = env_ctp;
  1143. __dbsrv_settimeout(dbc_ctp, env_ctp->ct_timeout);
  1144. __dbsrv_active(dbc_ctp);
  1145. replyp->dbcidcl_id = dbc_ctp->ct_id;
  1146. } else
  1147. __dbclear_ctp(dbc_ctp);
  1149. replyp->status = ret;
  1150. return;
  1151. }
  1153. /* BEGIN __db_join_1_proc */
  1154. void
  1155. __db_join_1_proc(dbpcl_id, curslist,
  1156. flags, replyp)
  1157. long dbpcl_id;
  1158. u_int32_t * curslist;
  1159. u_int32_t flags;
  1160. __db_join_reply *replyp;
  1161. /* END __db_join_1_proc */
  1162. {
  1163. DB * dbp;
  1164. ct_entry *dbp_ctp;
  1165. DBC *dbc;
  1166. DBC **jcurs, **c;
  1167. ct_entry *dbc_ctp, *ctp;
  1168. size_t size;
  1169. int ret;
  1170. u_int32_t *cl;
  1172. ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
  1173. dbp = (DB *)dbp_ctp->ct_anyp;
  1175. dbc_ctp = new_ct_ent(&replyp->status);
  1176. if (dbc_ctp == NULL)
  1177. return;
  1179. for (size = sizeof(DBC *), cl = curslist; *cl != 0; size += sizeof(DBC *), cl++)
  1180. ;
  1181. if ((ret = __os_malloc(dbp->dbenv, size, NULL, &jcurs)) != 0) {
  1182. replyp->status = ret;
  1183. __dbclear_ctp(dbc_ctp);
  1184. return;
  1185. }
  1186. /*
  1187.  * If our curslist has a parent txn, we need to use it too
  1188.  * for the activity timeout.  All cursors must be part of
  1189.  * the same transaction, so just check the first.
  1190.  */
  1191. ctp = get_tableent(*curslist);
  1192. DB_ASSERT(ctp->ct_type == CT_CURSOR);
  1193. /*
  1194.  * If we are using a transaction, set the join activity timer
  1195.  * to point to the parent transaction.
  1196.  */
  1197. if (ctp->ct_activep != &ctp->ct_active)
  1198. dbc_ctp->ct_activep = ctp->ct_activep;
  1199. for (cl = curslist, c = jcurs; *cl != 0; cl++, c++) {
  1200. ctp = get_tableent(*cl);
  1201. if (ctp == NULL) {
  1202. replyp->status = DB_NOSERVER_ID;
  1203. goto out;
  1204. }
  1205. /*
  1206.  * If we are using a txn, the join cursor points to the
  1207.  * transaction timeout.  If we are not using a transaction,
  1208.  * then all the curslist cursors must point to the join
  1209.  * cursor's timeout so that we do not timeout any of the
  1210.  * curlist cursors while the join cursor is active.
  1211.  * Change the type of the curslist ctps to CT_JOIN so that
  1212.  * we know they are part of a join list and we can distinguish
  1213.  * them and later restore them when the join cursor is closed.
  1214.  */
  1215. DB_ASSERT(ctp->ct_type == CT_CURSOR);
  1216. ctp->ct_type |= CT_JOIN;
  1217. ctp->ct_origp = ctp->ct_activep;
  1218. /*
  1219.  * Setting this to the ct_active field of the dbc_ctp is
  1220.  * really just a way to distinguish which join dbc this
  1221.  * cursor is part of.  The ct_activep of this cursor is
  1222.  * not used at all during its lifetime as part of a join
  1223.  * cursor.
  1224.  */
  1225. ctp->ct_activep = &dbc_ctp->ct_active;
  1226. *c = ctp->ct_dbc;
  1227. }
  1228. *c = NULL;
  1229. if ((ret = dbp->join(dbp, jcurs, &dbc, flags)) == 0) {
  1230. dbc_ctp->ct_dbc = dbc;
  1231. dbc_ctp->ct_type = (CT_JOINCUR | CT_CURSOR);
  1232. dbc_ctp->ct_parent = dbp_ctp;
  1233. dbc_ctp->ct_envparent = dbp_ctp->ct_envparent;
  1234. __dbsrv_settimeout(dbc_ctp, dbp_ctp->ct_envparent->ct_timeout);
  1235. __dbsrv_active(dbc_ctp);
  1236. replyp->dbcidcl_id = dbc_ctp->ct_id;
  1237. } else {
  1238. __dbclear_ctp(dbc_ctp);
  1239. /*
  1240.  * If we get an error, undo what we did above to any cursors.
  1241.  */
  1242. for (cl = curslist; *cl != 0; cl++) {
  1243. ctp = get_tableent(*cl);
  1244. ctp->ct_type = CT_CURSOR;
  1245. ctp->ct_activep = ctp->ct_origp;
  1246. }
  1247. }
  1249. replyp->status = ret;
  1250. out:
  1251. __os_free(jcurs, size);
  1252. return;
  1253. }
  1255. /* BEGIN __dbc_close_1_proc */
  1256. void
  1257. __dbc_close_1_proc(dbccl_id, replyp)
  1258. long dbccl_id;
  1259. __dbc_close_reply *replyp;
  1260. /* END __dbc_close_1_proc */
  1261. {
  1262. ct_entry *dbc_ctp;
  1264. ACTIVATE_CTP(dbc_ctp, dbccl_id, CT_CURSOR);
  1265. replyp->status = __dbc_close_int(dbc_ctp);
  1266. return;
  1267. }
  1269. /* BEGIN __dbc_count_1_proc */
  1270. void
  1271. __dbc_count_1_proc(dbccl_id, flags, replyp)
  1272. long dbccl_id;
  1273. u_int32_t flags;
  1274. __dbc_count_reply *replyp;
  1275. /* END __dbc_count_1_proc */
  1276. {
  1277. int ret;
  1278. DBC * dbc;
  1279. ct_entry *dbc_ctp;
  1280. db_recno_t num;
  1282. ACTIVATE_CTP(dbc_ctp, dbccl_id, CT_CURSOR);
  1283. dbc = (DBC *)dbc_ctp->ct_anyp;
  1285. ret = dbc->c_count(dbc, &num, flags);
  1286. replyp->status = ret;
  1287. if (ret == 0)
  1288. replyp->dupcount = num;
  1289. return;
  1290. }
  1292. /* BEGIN __dbc_del_1_proc */
  1293. void
  1294. __dbc_del_1_proc(dbccl_id, flags, replyp)
  1295. long dbccl_id;
  1296. u_int32_t flags;
  1297. __dbc_del_reply *replyp;
  1298. /* END __dbc_del_1_proc */
  1299. {
  1300. int ret;
  1301. DBC * dbc;
  1302. ct_entry *dbc_ctp;
  1304. ACTIVATE_CTP(dbc_ctp, dbccl_id, CT_CURSOR);
  1305. dbc = (DBC *)dbc_ctp->ct_anyp;
  1307. ret = dbc->c_del(dbc, flags);
  1309. replyp->status = ret;
  1310. return;
  1311. }
  1313. /* BEGIN __dbc_dup_1_proc */
  1314. void
  1315. __dbc_dup_1_proc(dbccl_id, flags, replyp)
  1316. long dbccl_id;
  1317. u_int32_t flags;
  1318. __dbc_dup_reply *replyp;
  1319. /* END __dbc_dup_1_proc */
  1320. {
  1321. int ret;
  1322. DBC * dbc;
  1323. ct_entry *dbc_ctp;
  1324. DBC *newdbc;
  1325. ct_entry *new_ctp;
  1327. ACTIVATE_CTP(dbc_ctp, dbccl_id, CT_CURSOR);
  1328. dbc = (DBC *)dbc_ctp->ct_anyp;
  1330. new_ctp = new_ct_ent(&replyp->status);
  1331. if (new_ctp == NULL)
  1332. return;
  1334. if ((ret = dbc->c_dup(dbc, &newdbc, flags)) == 0) {
  1335. new_ctp->ct_dbc = newdbc;
  1336. new_ctp->ct_type = CT_CURSOR;
  1337. new_ctp->ct_parent = dbc_ctp->ct_parent;
  1338. new_ctp->ct_envparent = dbc_ctp->ct_envparent;
  1339. /*
  1340.  * If our cursor has a parent txn, we need to use it too.
  1341.  */
  1342. if (dbc_ctp->ct_activep != &dbc_ctp->ct_active)
  1343. new_ctp->ct_activep = dbc_ctp->ct_activep;
  1344. __dbsrv_settimeout(new_ctp, dbc_ctp->ct_timeout);
  1345. __dbsrv_active(new_ctp);
  1346. replyp->dbcidcl_id = new_ctp->ct_id;
  1347. } else
  1348. __dbclear_ctp(new_ctp);
  1350. replyp->status = ret;
  1351. return;
  1352. }
  1354. /* BEGIN __dbc_get_1_proc */
  1355. void
  1356. __dbc_get_1_proc(dbccl_id, keydlen, keydoff,
  1357. keyflags, keydata, keysize, datadlen,
  1358. datadoff, dataflags, datadata, datasize,
  1359. flags, replyp, freep)
  1360. long dbccl_id;
  1361. u_int32_t keydlen;
  1362. u_int32_t keydoff;
  1363. u_int32_t keyflags;
  1364. void *keydata;
  1365. u_int32_t keysize;
  1366. u_int32_t datadlen;
  1367. u_int32_t datadoff;
  1368. u_int32_t dataflags;
  1369. void *datadata;
  1370. u_int32_t datasize;
  1371. u_int32_t flags;
  1372. __dbc_get_reply *replyp;
  1373. int * freep;
  1374. /* END __dbc_get_1_proc */
  1375. {
  1376. DB_ENV *dbenv;
  1377. DBC *dbc;
  1378. DBT key, data;
  1379. ct_entry *dbc_ctp;
  1380. int key_alloc, ret;
  1382. ACTIVATE_CTP(dbc_ctp, dbccl_id, CT_CURSOR);
  1383. dbc = (DBC *)dbc_ctp->ct_anyp;
  1384. dbenv = dbc->dbp->dbenv;
  1386. *freep = 0;
  1387. memset(&key, 0, sizeof(key));
  1388. memset(&data, 0, sizeof(data));
  1390. /* Set up key and data DBT */
  1391. key.dlen = keydlen;
  1392. key.doff = keydoff;
  1393. /*
  1394.  * Ignore memory related flags on server.
  1395.  */
  1396. key.flags = DB_DBT_MALLOC;
  1397. if (keyflags & DB_DBT_PARTIAL)
  1398. key.flags |= DB_DBT_PARTIAL;
  1399. key.size = keysize;
  1400. key.data = keydata;
  1402. data.dlen = datadlen;
  1403. data.doff = datadoff;
  1404. data.flags = DB_DBT_MALLOC;
  1405. if (dataflags & DB_DBT_PARTIAL)
  1406. data.flags |= DB_DBT_PARTIAL;
  1407. data.size = datasize;
  1408. data.data = datadata;
  1410. /* Got all our stuff, now do the get */
  1411. ret = dbc->c_get(dbc, &key, &data, flags);
  1413. /*
  1414.  * Otherwise just status.
  1415.  */
  1416. if (ret == 0) {
  1417. /*
  1418.  * XXX
  1419.  * We need to xdr_free whatever we are returning, next time.
  1420.  * However, DB does not allocate a new key if one was given
  1421.  * and we'd be free'ing up space allocated in the request.
  1422.  * So, allocate a new key/data pointer if it is the same one
  1423.  * as in the request.
  1424.  */
  1425. *freep = 1;
  1426. /*
  1427.  * Key
  1428.  */
  1429. key_alloc = 0;
  1430. if (key.data == keydata) {
  1431. ret = __os_malloc(dbenv, key.size, NULL,
  1432.     &replyp->keydata.keydata_val);
  1433. if (ret != 0) {
  1434. __os_free(key.data, key.size);
  1435. __os_free(data.data, data.size);
  1436. goto err;
  1437. }
  1438. key_alloc = 1;
  1439. memcpy(replyp->keydata.keydata_val, key.data, key.size);
  1440. } else
  1441. replyp->keydata.keydata_val = key.data;
  1443. replyp->keydata.keydata_len = key.size;
  1445. /*
  1446.  * Data
  1447.  */
  1448. if (data.data == datadata) {
  1449. ret = __os_malloc(dbenv, data.size, NULL,
  1450.     &replyp->datadata.datadata_val);
  1451. if (ret != 0) {
  1452. __os_free(key.data, key.size);
  1453. __os_free(data.data, data.size);
  1454. if (key_alloc)
  1455. __os_free(replyp->keydata.keydata_val,
  1456.     key.size);
  1457. goto err;
  1458. }
  1459. memcpy(replyp->datadata.datadata_val, data.data,
  1460.     data.size);
  1461. } else
  1462. replyp->datadata.datadata_val = data.data;
  1463. replyp->datadata.datadata_len = data.size;
  1464. } else {
  1465. err: replyp->keydata.keydata_val = NULL;
  1466. replyp->keydata.keydata_len = 0;
  1467. replyp->datadata.datadata_val = NULL;
  1468. replyp->datadata.datadata_len = 0;
  1469. *freep = 0;
  1470. }
  1471. replyp->status = ret;
  1472. return;
  1473. }
  1475. /* BEGIN __dbc_put_1_proc */
  1476. void
  1477. __dbc_put_1_proc(dbccl_id, keydlen, keydoff,
  1478. keyflags, keydata, keysize, datadlen,
  1479. datadoff, dataflags, datadata, datasize,
  1480. flags, replyp, freep)
  1481. long dbccl_id;
  1482. u_int32_t keydlen;
  1483. u_int32_t keydoff;
  1484. u_int32_t keyflags;
  1485. void *keydata;
  1486. u_int32_t keysize;
  1487. u_int32_t datadlen;
  1488. u_int32_t datadoff;
  1489. u_int32_t dataflags;
  1490. void *datadata;
  1491. u_int32_t datasize;
  1492. u_int32_t flags;
  1493. __dbc_put_reply *replyp;
  1494. int * freep;
  1495. /* END __dbc_put_1_proc */
  1496. {
  1497. int ret;
  1498. DBC * dbc;
  1499. DB *dbp;
  1500. ct_entry *dbc_ctp;
  1501. DBT key, data;
  1503. ACTIVATE_CTP(dbc_ctp, dbccl_id, CT_CURSOR);
  1504. dbc = (DBC *)dbc_ctp->ct_anyp;
  1505. dbp = (DB *)dbc_ctp->ct_parent->ct_anyp;
  1507. memset(&key, 0, sizeof(key));
  1508. memset(&data, 0, sizeof(data));
  1510. /* Set up key and data DBT */
  1511. key.dlen = keydlen;
  1512. key.doff = keydoff;
  1513. /*
  1514.  * Ignore memory related flags on server.
  1515.  */
  1516. key.flags = 0;
  1517. if (keyflags & DB_DBT_PARTIAL)
  1518. key.flags |= DB_DBT_PARTIAL;
  1519. key.size = keysize;
  1520. key.data = keydata;
  1522. data.dlen = datadlen;
  1523. data.doff = datadoff;
  1524. data.flags = dataflags;
  1525. data.size = datasize;
  1526. data.data = datadata;
  1528. /* Got all our stuff, now do the put */
  1529. ret = dbc->c_put(dbc, &key, &data, flags);
  1531. *freep = 0;
  1532. if (ret == 0 && (flags == DB_AFTER || flags == DB_BEFORE) &&
  1533.     dbp->type == DB_RECNO) {
  1534. /*
  1535.  * We need to xdr_free whatever we are returning, next time.
  1536.  */
  1537. replyp->keydata.keydata_val = key.data;
  1538. replyp->keydata.keydata_len = key.size;
  1539. } else {
  1540. replyp->keydata.keydata_val = NULL;
  1541. replyp->keydata.keydata_len = 0;
  1542. }
  1543. replyp->status = ret;
  1544. return;
  1545. }
  1546. #endif /* HAVE_RPC */