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

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

MySQL数据库

开发平台：

Visual C++

db_server_proc.c：源码内容
  1. /*-
  2.  * See the file LICENSE for redistribution information.
  3.  *
  4.  * Copyright (c) 2000-2002
  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.92 2002/07/29 15:21:20 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 "dbinc_auto/db_server.h"
  24. #include "db_int.h"
  25. #include "dbinc/db_server_int.h"
  26. #include "dbinc_auto/rpc_server_ext.h"
  28. /* BEGIN __env_cachesize_proc */
  29. /*
  30.  * PUBLIC: void __env_cachesize_proc __P((long, u_int32_t, u_int32_t,
  31.  * PUBLIC:      u_int32_t, __env_cachesize_reply *));
  32.  */
  33. void
  34. __env_cachesize_proc(dbenvcl_id, gbytes, bytes,
  35. ncache, replyp)
  36. long dbenvcl_id;
  37. u_int32_t gbytes;
  38. u_int32_t bytes;
  39. u_int32_t ncache;
  40. __env_cachesize_reply *replyp;
  41. /* END __env_cachesize_proc */
  42. {
  43. DB_ENV *dbenv;
  44. ct_entry *dbenv_ctp;
  45. int ret;
  47. ACTIVATE_CTP(dbenv_ctp, dbenvcl_id, CT_ENV);
  48. dbenv = (DB_ENV *)dbenv_ctp->ct_anyp;
  50. ret = dbenv->set_cachesize(dbenv, gbytes, bytes, ncache);
  52. replyp->status = ret;
  53. return;
  54. }
  56. /* BEGIN __env_close_proc */
  57. /*
  58.  * PUBLIC: void __env_close_proc __P((long, u_int32_t, __env_close_reply *));
  59.  */
  60. void
  61. __env_close_proc(dbenvcl_id, flags, replyp)
  62. long dbenvcl_id;
  63. u_int32_t flags;
  64. __env_close_reply *replyp;
  65. /* END __env_close_proc */
  66. {
  67. ct_entry *dbenv_ctp;
  69. ACTIVATE_CTP(dbenv_ctp, dbenvcl_id, CT_ENV);
  70. replyp->status = __dbenv_close_int(dbenvcl_id, flags, 0);
  71. return;
  72. }
  74. /* BEGIN __env_create_proc */
  75. /*
  76.  * PUBLIC: void __env_create_proc __P((u_int32_t, __env_create_reply *));
  77.  */
  78. void
  79. __env_create_proc(timeout, replyp)
  80. u_int32_t timeout;
  81. __env_create_reply *replyp;
  82. /* END __env_create_proc */
  83. {
  84. DB_ENV *dbenv;
  85. ct_entry *ctp;
  86. int ret;
  88. ctp = new_ct_ent(&replyp->status);
  89. if (ctp == NULL)
  90. return;
  91. if ((ret = db_env_create(&dbenv, 0)) == 0) {
  92. ctp->ct_envp = dbenv;
  93. ctp->ct_type = CT_ENV;
  94. ctp->ct_parent = NULL;
  95. ctp->ct_envparent = ctp;
  96. __dbsrv_settimeout(ctp, timeout);
  97. __dbsrv_active(ctp);
  98. replyp->envcl_id = ctp->ct_id;
  99. } else
  100. __dbclear_ctp(ctp);
  102. replyp->status = ret;
  103. return;
  104. }
  106. /* BEGIN __env_dbremove_proc */
  107. /*
  108.  * PUBLIC: void __env_dbremove_proc __P((long, long, char *, char *, u_int32_t,
  109.  * PUBLIC:      __env_dbremove_reply *));
  110.  */
  111. void
  112. __env_dbremove_proc(dbenvcl_id, txnpcl_id, name,
  113. subdb, flags, replyp)
  114. long dbenvcl_id;
  115. long txnpcl_id;
  116. char *name;
  117. char *subdb;
  118. u_int32_t flags;
  119. __env_dbremove_reply *replyp;
  120. /* END __env_dbremove_proc */
  121. {
  122. int ret;
  123. DB_ENV * dbenv;
  124. ct_entry *dbenv_ctp;
  125. DB_TXN * txnp;
  126. ct_entry *txnp_ctp;
  128. ACTIVATE_CTP(dbenv_ctp, dbenvcl_id, CT_ENV);
  129. dbenv = (DB_ENV *)dbenv_ctp->ct_anyp;
  131. if (txnpcl_id != 0) {
  132. ACTIVATE_CTP(txnp_ctp, txnpcl_id, CT_TXN);
  133. txnp = (DB_TXN *)txnp_ctp->ct_anyp;
  134. } else
  135. txnp = NULL;
  137. ret = dbenv->dbremove(dbenv, txnp, name, subdb, flags);
  139. replyp->status = ret;
  140. return;
  141. }
  143. /* BEGIN __env_dbrename_proc */
  144. /*
  145.  * PUBLIC: void __env_dbrename_proc __P((long, long, char *, char *, char *,
  146.  * PUBLIC:      u_int32_t, __env_dbrename_reply *));
  147.  */
  148. void
  149. __env_dbrename_proc(dbenvcl_id, txnpcl_id, name,
  150. subdb, newname, flags, replyp)
  151. long dbenvcl_id;
  152. long txnpcl_id;
  153. char *name;
  154. char *subdb;
  155. char *newname;
  156. u_int32_t flags;
  157. __env_dbrename_reply *replyp;
  158. /* END __env_dbrename_proc */
  159. {
  160. int ret;
  161. DB_ENV * dbenv;
  162. ct_entry *dbenv_ctp;
  163. DB_TXN * txnp;
  164. ct_entry *txnp_ctp;
  166. ACTIVATE_CTP(dbenv_ctp, dbenvcl_id, CT_ENV);
  167. dbenv = (DB_ENV *)dbenv_ctp->ct_anyp;
  169. if (txnpcl_id != 0) {
  170. ACTIVATE_CTP(txnp_ctp, txnpcl_id, CT_TXN);
  171. txnp = (DB_TXN *)txnp_ctp->ct_anyp;
  172. } else
  173. txnp = NULL;
  175. ret = dbenv->dbrename(dbenv, txnp, name, subdb, newname, flags);
  177. replyp->status = ret;
  178. return;
  179. }
  181. /* BEGIN __env_encrypt_proc */
  182. /*
  183.  * PUBLIC: void __env_encrypt_proc __P((long, char *, u_int32_t,
  184.  * PUBLIC:      __env_encrypt_reply *));
  185.  */
  186. void
  187. __env_encrypt_proc(dbenvcl_id, passwd, flags, replyp)
  188. long dbenvcl_id;
  189. char *passwd;
  190. u_int32_t flags;
  191. __env_encrypt_reply *replyp;
  192. /* END __env_encrypt_proc */
  193. {
  194. int ret;
  195. DB_ENV * dbenv;
  196. ct_entry *dbenv_ctp;
  198. ACTIVATE_CTP(dbenv_ctp, dbenvcl_id, CT_ENV);
  199. dbenv = (DB_ENV *)dbenv_ctp->ct_anyp;
  201. ret = dbenv->set_encrypt(dbenv, passwd, flags);
  203. replyp->status = ret;
  204. return;
  205. }
  207. /* BEGIN __env_flags_proc */
  208. /*
  209.  * PUBLIC: void __env_flags_proc __P((long, u_int32_t, u_int32_t,
  210.  * PUBLIC:      __env_flags_reply *));
  211.  */
  212. void
  213. __env_flags_proc(dbenvcl_id, flags, onoff, replyp)
  214. long dbenvcl_id;
  215. u_int32_t flags;
  216. u_int32_t onoff;
  217. __env_flags_reply *replyp;
  218. /* END __env_flags_proc */
  219. {
  220. DB_ENV *dbenv;
  221. ct_entry *dbenv_ctp;
  222. int ret;
  224. ACTIVATE_CTP(dbenv_ctp, dbenvcl_id, CT_ENV);
  225. dbenv = (DB_ENV *)dbenv_ctp->ct_anyp;
  227. ret = dbenv->set_flags(dbenv, flags, onoff);
  228. if (onoff)
  229. dbenv_ctp->ct_envdp.onflags = flags;
  230. else
  231. dbenv_ctp->ct_envdp.offflags = flags;
  233. replyp->status = ret;
  234. return;
  235. }
  236. /* BEGIN __env_open_proc */
  237. /*
  238.  * PUBLIC: void __env_open_proc __P((long, char *, u_int32_t, u_int32_t,
  239.  * PUBLIC:      __env_open_reply *));
  240.  */
  241. void
  242. __env_open_proc(dbenvcl_id, home, flags,
  243. mode, replyp)
  244. long dbenvcl_id;
  245. char *home;
  246. u_int32_t flags;
  247. u_int32_t mode;
  248. __env_open_reply *replyp;
  249. /* END __env_open_proc */
  250. {
  251. DB_ENV *dbenv;
  252. ct_entry *dbenv_ctp, *new_ctp;
  253. u_int32_t newflags, shareflags;
  254. int ret;
  255. home_entry *fullhome;
  257. ACTIVATE_CTP(dbenv_ctp, dbenvcl_id, CT_ENV);
  258. dbenv = (DB_ENV *)dbenv_ctp->ct_anyp;
  259. fullhome = get_home(home);
  260. if (fullhome == NULL) {
  261. ret = DB_NOSERVER_HOME;
  262. goto out;
  263. }
  265. /*
  266.  * If they are using locking do deadlock detection for them,
  267.  * internally.
  268.  */
  269. if ((flags & DB_INIT_LOCK) &&
  270.     (ret = dbenv->set_lk_detect(dbenv, DB_LOCK_DEFAULT)) != 0)
  271. goto out;
  273. if (__dbsrv_verbose) {
  274. dbenv->set_errfile(dbenv, stderr);
  275. dbenv->set_errpfx(dbenv, fullhome->home);
  276. }
  278. /*
  279.  * Mask off flags we ignore
  280.  */
  281. newflags = (flags & ~DB_SERVER_FLAGMASK);
  282. shareflags = (newflags & DB_SERVER_ENVFLAGS);
  283. /*
  284.  * Check now whether we can share a handle for this env.
  285.  */
  286. replyp->envcl_id = dbenvcl_id;
  287. if ((new_ctp = __dbsrv_shareenv(dbenv_ctp, fullhome, shareflags))
  288.     != NULL) {
  289. /*
  290.  * We can share, clean up old  ID, set new one.
  291.  */
  292. if (__dbsrv_verbose)
  293. printf("Sharing env ID %ldn", new_ctp->ct_id);
  294. replyp->envcl_id = new_ctp->ct_id;
  295. ret = __dbenv_close_int(dbenvcl_id, 0, 0);
  296. } else {
  297. ret = dbenv->open(dbenv, fullhome->home, newflags, mode);
  298. dbenv_ctp->ct_envdp.home = fullhome;
  299. dbenv_ctp->ct_envdp.envflags = shareflags;
  300. }
  301. out: replyp->status = ret;
  302. return;
  303. }
  305. /* BEGIN __env_remove_proc */
  306. /*
  307.  * PUBLIC: void __env_remove_proc __P((long, char *, u_int32_t,
  308.  * PUBLIC:      __env_remove_reply *));
  309.  */
  310. void
  311. __env_remove_proc(dbenvcl_id, home, flags, replyp)
  312. long dbenvcl_id;
  313. char *home;
  314. u_int32_t flags;
  315. __env_remove_reply *replyp;
  316. /* END __env_remove_proc */
  317. {
  318. DB_ENV *dbenv;
  319. ct_entry *dbenv_ctp;
  320. int ret;
  321. home_entry *fullhome;
  323. ACTIVATE_CTP(dbenv_ctp, dbenvcl_id, CT_ENV);
  324. dbenv = (DB_ENV *)dbenv_ctp->ct_anyp;
  326. fullhome = get_home(home);
  327. if (fullhome == NULL) {
  328. replyp->status = DB_NOSERVER_HOME;
  329. return;
  330. }
  332. ret = dbenv->remove(dbenv, fullhome->home, flags);
  333. __dbdel_ctp(dbenv_ctp);
  334. replyp->status = ret;
  335. return;
  336. }
  338. /* BEGIN __txn_abort_proc */
  339. /*
  340.  * PUBLIC: void __txn_abort_proc __P((long, __txn_abort_reply *));
  341.  */
  342. void
  343. __txn_abort_proc(txnpcl_id, replyp)
  344. long txnpcl_id;
  345. __txn_abort_reply *replyp;
  346. /* END __txn_abort_proc */
  347. {
  348. DB_TXN *txnp;
  349. ct_entry *txnp_ctp;
  350. int ret;
  352. ACTIVATE_CTP(txnp_ctp, txnpcl_id, CT_TXN);
  353. txnp = (DB_TXN *)txnp_ctp->ct_anyp;
  355. ret = txnp->abort(txnp);
  356. __dbdel_ctp(txnp_ctp);
  357. replyp->status = ret;
  358. return;
  359. }
  361. /* BEGIN __txn_begin_proc */
  362. /*
  363.  * PUBLIC: void __txn_begin_proc __P((long, long, u_int32_t,
  364.  * PUBLIC:      __txn_begin_reply *));
  365.  */
  366. void
  367. __txn_begin_proc(dbenvcl_id, parentcl_id,
  368. flags, replyp)
  369. long dbenvcl_id;
  370. long parentcl_id;
  371. u_int32_t flags;
  372. __txn_begin_reply *replyp;
  373. /* END __txn_begin_proc */
  374. {
  375. DB_ENV *dbenv;
  376. DB_TXN *parent, *txnp;
  377. ct_entry *ctp, *dbenv_ctp, *parent_ctp;
  378. int ret;
  380. ACTIVATE_CTP(dbenv_ctp, dbenvcl_id, CT_ENV);
  381. dbenv = (DB_ENV *)dbenv_ctp->ct_anyp;
  382. parent_ctp = NULL;
  384. ctp = new_ct_ent(&replyp->status);
  385. if (ctp == NULL)
  386. return;
  388. if (parentcl_id != 0) {
  389. ACTIVATE_CTP(parent_ctp, parentcl_id, CT_TXN);
  390. parent = (DB_TXN *)parent_ctp->ct_anyp;
  391. ctp->ct_activep = parent_ctp->ct_activep;
  392. } else
  393. parent = NULL;
  395. ret = dbenv->txn_begin(dbenv, parent, &txnp, flags);
  396. if (ret == 0) {
  397. ctp->ct_txnp = txnp;
  398. ctp->ct_type = CT_TXN;
  399. ctp->ct_parent = parent_ctp;
  400. ctp->ct_envparent = dbenv_ctp;
  401. replyp->txnidcl_id = ctp->ct_id;
  402. __dbsrv_settimeout(ctp, dbenv_ctp->ct_timeout);
  403. __dbsrv_active(ctp);
  404. } else
  405. __dbclear_ctp(ctp);
  407. replyp->status = ret;
  408. return;
  409. }
  411. /* BEGIN __txn_commit_proc */
  412. /*
  413.  * PUBLIC: void __txn_commit_proc __P((long, u_int32_t,
  414.  * PUBLIC:      __txn_commit_reply *));
  415.  */
  416. void
  417. __txn_commit_proc(txnpcl_id, flags, replyp)
  418. long txnpcl_id;
  419. u_int32_t flags;
  420. __txn_commit_reply *replyp;
  421. /* END __txn_commit_proc */
  422. {
  423. DB_TXN *txnp;
  424. ct_entry *txnp_ctp;
  425. int ret;
  427. ACTIVATE_CTP(txnp_ctp, txnpcl_id, CT_TXN);
  428. txnp = (DB_TXN *)txnp_ctp->ct_anyp;
  430. ret = txnp->commit(txnp, flags);
  431. __dbdel_ctp(txnp_ctp);
  433. replyp->status = ret;
  434. return;
  435. }
  437. /* BEGIN __txn_discard_proc */
  438. /*
  439.  * PUBLIC: void __txn_discard_proc __P((long, u_int32_t,
  440.  * PUBLIC:      __txn_discard_reply *));
  441.  */
  442. void
  443. __txn_discard_proc(txnpcl_id, flags, replyp)
  444. long txnpcl_id;
  445. u_int32_t flags;
  446. __txn_discard_reply *replyp;
  447. /* END __txn_discard_proc */
  448. {
  449. DB_TXN *txnp;
  450. ct_entry *txnp_ctp;
  451. int ret;
  453. ACTIVATE_CTP(txnp_ctp, txnpcl_id, CT_TXN);
  454. txnp = (DB_TXN *)txnp_ctp->ct_anyp;
  456. ret = txnp->discard(txnp, flags);
  457. __dbdel_ctp(txnp_ctp);
  459. replyp->status = ret;
  460. return;
  461. }
  463. /* BEGIN __txn_prepare_proc */
  464. /*
  465.  * PUBLIC: void __txn_prepare_proc __P((long, u_int8_t *,
  466.  * PUBLIC:      __txn_prepare_reply *));
  467.  */
  468. void
  469. __txn_prepare_proc(txnpcl_id, gid, replyp)
  470. long txnpcl_id;
  471. u_int8_t *gid;
  472. __txn_prepare_reply *replyp;
  473. /* END __txn_prepare_proc */
  474. {
  475. DB_TXN *txnp;
  476. ct_entry *txnp_ctp;
  477. int ret;
  479. ACTIVATE_CTP(txnp_ctp, txnpcl_id, CT_TXN);
  480. txnp = (DB_TXN *)txnp_ctp->ct_anyp;
  482. ret = txnp->prepare(txnp, gid);
  483. replyp->status = ret;
  484. return;
  485. }
  487. /* BEGIN __txn_recover_proc */
  488. /*
  489.  * PUBLIC: void __txn_recover_proc __P((long, u_int32_t, u_int32_t,
  490.  * PUBLIC:      __txn_recover_reply *, int *));
  491.  */
  492. void
  493. __txn_recover_proc(dbenvcl_id, count,
  494. flags, replyp, freep)
  495. long dbenvcl_id;
  496. u_int32_t count;
  497. u_int32_t flags;
  498. __txn_recover_reply *replyp;
  499. int * freep;
  500. /* END __txn_recover_proc */
  501. {
  502. DB_ENV *dbenv;
  503. DB_PREPLIST *dbprep, *p;
  504. ct_entry *dbenv_ctp, *ctp;
  505. long erri, i, retcount;
  506. u_int32_t *txnidp;
  507. int ret;
  508. u_int8_t *gid;
  510. ACTIVATE_CTP(dbenv_ctp, dbenvcl_id, CT_ENV);
  511. dbenv = (DB_ENV *)dbenv_ctp->ct_anyp;
  512. dbprep = NULL;
  513. *freep = 0;
  515. if ((ret =
  516.     __os_malloc(dbenv, count * sizeof(DB_PREPLIST), &dbprep)) != 0)
  517. goto out;
  518. if ((ret =
  519.     dbenv->txn_recover(dbenv, dbprep, count, &retcount, flags)) != 0)
  520. goto out;
  521. /*
  522.  * If there is nothing, success, but it's easy.
  523.  */
  524. replyp->retcount = retcount;
  525. if (retcount == 0) {
  526. replyp->txn.txn_val = NULL;
  527. replyp->txn.txn_len = 0;
  528. replyp->gid.gid_val = NULL;
  529. replyp->gid.gid_len = 0;
  530. }
  532. /*
  533.  * We have our txn list.  Now we need to allocate the space for
  534.  * the txn ID array and the GID array and set them up.
  535.  */
  536. if ((ret = __os_calloc(dbenv, retcount, sizeof(u_int32_t),
  537.     &replyp->txn.txn_val)) != 0)
  538. goto out;
  539. replyp->txn.txn_len = retcount * sizeof(u_int32_t);
  540. if ((ret = __os_calloc(dbenv, retcount, DB_XIDDATASIZE,
  541.     &replyp->gid.gid_val)) != 0) {
  542. __os_free(dbenv, replyp->txn.txn_val);
  543. goto out;
  544. }
  545. replyp->gid.gid_len = retcount * DB_XIDDATASIZE;
  547. /*
  548.  * Now walk through our results, creating parallel arrays
  549.  * to send back.  For each entry we need to create a new
  550.  * txn ctp and then fill in the array info.
  551.  */
  552. i = 0;
  553. p = dbprep;
  554. gid = replyp->gid.gid_val;
  555. txnidp = replyp->txn.txn_val;
  556. while (i++ < retcount) {
  557. ctp = new_ct_ent(&ret);
  558. if (ret != 0) {
  559. i--;
  560. goto out2;
  561. }
  562. ctp->ct_txnp = p->txn;
  563. ctp->ct_type = CT_TXN;
  564. ctp->ct_parent = NULL;
  565. ctp->ct_envparent = dbenv_ctp;
  566. __dbsrv_settimeout(ctp, dbenv_ctp->ct_timeout);
  567. __dbsrv_active(ctp);
  569. *txnidp = ctp->ct_id;
  570. memcpy(gid, p->gid, DB_XIDDATASIZE);
  572. p++;
  573. txnidp++;
  574. gid += DB_XIDDATASIZE;
  575. }
  576. /*
  577.  * If we get here, we have success and we have to set freep
  578.  * so it'll get properly freed next time.
  579.  */
  580. *freep = 1;
  581. out:
  582. if (dbprep != NULL)
  583. __os_free(dbenv, dbprep);
  584. replyp->status = ret;
  585. return;
  586. out2:
  587. /*
  588.  * We had an error in the middle of creating our new txn
  589.  * ct entries.  We have to unwind all that we have done.  Ugh.
  590.  */
  591. for (txnidp = replyp->txn.txn_val, erri = 0;
  592.     erri < i; erri++, txnidp++) {
  593. ctp = get_tableent(*txnidp);
  594. __dbclear_ctp(ctp);
  595. }
  596. __os_free(dbenv, replyp->txn.txn_val);
  597. __os_free(dbenv, replyp->gid.gid_val);
  598. __os_free(dbenv, dbprep);
  599. replyp->status = ret;
  600. return;
  601. }
  603. /* BEGIN __db_bt_maxkey_proc */
  604. /*
  605.  * PUBLIC: void __db_bt_maxkey_proc __P((long, u_int32_t,
  606.  * PUBLIC:      __db_bt_maxkey_reply *));
  607.  */
  608. void
  609. __db_bt_maxkey_proc(dbpcl_id, maxkey, replyp)
  610. long dbpcl_id;
  611. u_int32_t maxkey;
  612. __db_bt_maxkey_reply *replyp;
  613. /* END __db_bt_maxkey_proc */
  614. {
  615. DB *dbp;
  616. ct_entry *dbp_ctp;
  617. int ret;
  619. ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
  620. dbp = (DB *)dbp_ctp->ct_anyp;
  622. ret = dbp->set_bt_maxkey(dbp, maxkey);
  624. replyp->status = ret;
  625. return;
  626. }
  628. /* BEGIN __db_associate_proc */
  629. /*
  630.  * PUBLIC: void __db_associate_proc __P((long, long, long, u_int32_t,
  631.  * PUBLIC:      __db_associate_reply *));
  632.  */
  633. void
  634. __db_associate_proc(dbpcl_id, txnpcl_id, sdbpcl_id,
  635. flags, replyp)
  636. long dbpcl_id;
  637. long txnpcl_id;
  638. long sdbpcl_id;
  639. u_int32_t flags;
  640. __db_associate_reply *replyp;
  641. /* END __db_associate_proc */
  642. {
  643. DB *dbp, *sdbp;
  644. DB_TXN *txnp;
  645. ct_entry *dbp_ctp, *sdbp_ctp, *txnp_ctp;
  646. int ret;
  648. ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
  649. dbp = (DB *)dbp_ctp->ct_anyp;
  650. ACTIVATE_CTP(sdbp_ctp, sdbpcl_id, CT_DB);
  651. sdbp = (DB *)sdbp_ctp->ct_anyp;
  652. if (txnpcl_id != 0) {
  653. ACTIVATE_CTP(txnp_ctp, txnpcl_id, CT_TXN);
  654. txnp = (DB_TXN *)txnp_ctp->ct_anyp;
  655. } else
  656. txnp = NULL;
  659. /*
  660.  * We do not support DB_CREATE for associate.   Users
  661.  * can only access secondary indices on a read-only basis,
  662.  * so whatever they are looking for needs to be there already.
  663.  */
  664. if (flags != 0)
  665. ret = EINVAL;
  666. else
  667. ret = dbp->associate(dbp, txnp, sdbp, NULL, flags);
  669. replyp->status = ret;
  670. return;
  671. }
  673. /* BEGIN __db_bt_minkey_proc */
  674. /*
  675.  * PUBLIC: void __db_bt_minkey_proc __P((long, u_int32_t,
  676.  * PUBLIC:      __db_bt_minkey_reply *));
  677.  */
  678. void
  679. __db_bt_minkey_proc(dbpcl_id, minkey, replyp)
  680. long dbpcl_id;
  681. u_int32_t minkey;
  682. __db_bt_minkey_reply *replyp;
  683. /* END __db_bt_minkey_proc */
  684. {
  685. DB *dbp;
  686. ct_entry *dbp_ctp;
  687. int ret;
  689. ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
  690. dbp = (DB *)dbp_ctp->ct_anyp;
  692. ret = dbp->set_bt_minkey(dbp, minkey);
  694. replyp->status = ret;
  695. return;
  696. }
  698. /* BEGIN __db_close_proc */
  699. /*
  700.  * PUBLIC: void __db_close_proc __P((long, u_int32_t, __db_close_reply *));
  701.  */
  702. void
  703. __db_close_proc(dbpcl_id, flags, replyp)
  704. long dbpcl_id;
  705. u_int32_t flags;
  706. __db_close_reply *replyp;
  707. /* END __db_close_proc */
  708. {
  709. ct_entry *dbp_ctp;
  711. ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
  712. replyp->status = __db_close_int(dbpcl_id, flags);
  713. return;
  714. }
  716. /* BEGIN __db_create_proc */
  717. /*
  718.  * PUBLIC: void __db_create_proc __P((long, u_int32_t, __db_create_reply *));
  719.  */
  720. void
  721. __db_create_proc(dbenvcl_id, flags, replyp)
  722. long dbenvcl_id;
  723. u_int32_t flags;
  724. __db_create_reply *replyp;
  725. /* END __db_create_proc */
  726. {
  727. DB *dbp;
  728. DB_ENV *dbenv;
  729. ct_entry *dbenv_ctp, *dbp_ctp;
  730. int ret;
  732. ACTIVATE_CTP(dbenv_ctp, dbenvcl_id, CT_ENV);
  733. dbenv = (DB_ENV *)dbenv_ctp->ct_anyp;
  735. dbp_ctp = new_ct_ent(&replyp->status);
  736. if (dbp_ctp == NULL)
  737. return ;
  738. /*
  739.  * We actually require env's for databases.  The client should
  740.  * have caught it, but just in case.
  741.  */
  742. DB_ASSERT(dbenv != NULL);
  743. if ((ret = db_create(&dbp, dbenv, flags)) == 0) {
  744. dbp_ctp->ct_dbp = dbp;
  745. dbp_ctp->ct_type = CT_DB;
  746. dbp_ctp->ct_parent = dbenv_ctp;
  747. dbp_ctp->ct_envparent = dbenv_ctp;
  748. replyp->dbcl_id = dbp_ctp->ct_id;
  749. } else
  750. __dbclear_ctp(dbp_ctp);
  751. replyp->status = ret;
  752. return;
  753. }
  755. /* BEGIN __db_del_proc */
  756. /*
  757.  * PUBLIC: void __db_del_proc __P((long, long, u_int32_t, u_int32_t, u_int32_t,
  758.  * PUBLIC:      u_int32_t, void *, u_int32_t, u_int32_t, __db_del_reply *));
  759.  */
  760. void
  761. __db_del_proc(dbpcl_id, txnpcl_id, keydlen,
  762. keydoff, keyulen, keyflags, keydata,
  763. keysize, flags, replyp)
  764. long dbpcl_id;
  765. long txnpcl_id;
  766. u_int32_t keydlen;
  767. u_int32_t keydoff;
  768. u_int32_t keyulen;
  769. u_int32_t keyflags;
  770. void *keydata;
  771. u_int32_t keysize;
  772. u_int32_t flags;
  773. __db_del_reply *replyp;
  774. /* END __db_del_proc */
  775. {
  776. DB *dbp;
  777. DBT key;
  778. DB_TXN *txnp;
  779. ct_entry *dbp_ctp, *txnp_ctp;
  780. int ret;
  782. ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
  783. dbp = (DB *)dbp_ctp->ct_anyp;
  784. if (txnpcl_id != 0) {
  785. ACTIVATE_CTP(txnp_ctp, txnpcl_id, CT_TXN);
  786. txnp = (DB_TXN *)txnp_ctp->ct_anyp;
  787. } else
  788. txnp = NULL;
  790. memset(&key, 0, sizeof(key));
  792. /* Set up key DBT */
  793. key.dlen = keydlen;
  794. key.ulen = keyulen;
  795. key.doff = keydoff;
  796. key.flags = keyflags;
  797. key.size = keysize;
  798. key.data = keydata;
  800. ret = dbp->del(dbp, txnp, &key, flags);
  802. replyp->status = ret;
  803. return;
  804. }
  806. /* BEGIN __db_encrypt_proc */
  807. /*
  808.  * PUBLIC: void __db_encrypt_proc __P((long, char *, u_int32_t,
  809.  * PUBLIC:      __db_encrypt_reply *));
  810.  */
  811. void
  812. __db_encrypt_proc(dbpcl_id, passwd, flags, replyp)
  813. long dbpcl_id;
  814. char *passwd;
  815. u_int32_t flags;
  816. __db_encrypt_reply *replyp;
  817. /* END __db_encrypt_proc */
  818. {
  819. int ret;
  820. DB * dbp;
  821. ct_entry *dbp_ctp;
  823. ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
  824. dbp = (DB *)dbp_ctp->ct_anyp;
  826. ret = dbp->set_encrypt(dbp, passwd, flags);
  827. replyp->status = ret;
  828. return;
  829. }
  831. /* BEGIN __db_extentsize_proc */
  832. /*
  833.  * PUBLIC: void __db_extentsize_proc __P((long, u_int32_t,
  834.  * PUBLIC:      __db_extentsize_reply *));
  835.  */
  836. void
  837. __db_extentsize_proc(dbpcl_id, extentsize, replyp)
  838. long dbpcl_id;
  839. u_int32_t extentsize;
  840. __db_extentsize_reply *replyp;
  841. /* END __db_extentsize_proc */
  842. {
  843. DB *dbp;
  844. ct_entry *dbp_ctp;
  845. int ret;
  847. ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
  848. dbp = (DB *)dbp_ctp->ct_anyp;
  850. ret = dbp->set_q_extentsize(dbp, extentsize);
  852. replyp->status = ret;
  853. return;
  854. }
  856. /* BEGIN __db_flags_proc */
  857. /*
  858.  * PUBLIC: void __db_flags_proc __P((long, u_int32_t, __db_flags_reply *));
  859.  */
  860. void
  861. __db_flags_proc(dbpcl_id, flags, replyp)
  862. long dbpcl_id;
  863. u_int32_t flags;
  864. __db_flags_reply *replyp;
  865. /* END __db_flags_proc */
  866. {
  867. DB *dbp;
  868. ct_entry *dbp_ctp;
  869. int ret;
  871. ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
  872. dbp = (DB *)dbp_ctp->ct_anyp;
  874. ret = dbp->set_flags(dbp, flags);
  875. dbp_ctp->ct_dbdp.setflags |= flags;
  877. replyp->status = ret;
  878. return;
  879. }
  881. /* BEGIN __db_get_proc */
  882. /*
  883.  * PUBLIC: void __db_get_proc __P((long, long, u_int32_t, u_int32_t, u_int32_t,
  884.  * PUBLIC:      u_int32_t, void *, u_int32_t, u_int32_t, u_int32_t, u_int32_t, u_int32_t, void *,
  885.  * PUBLIC:      u_int32_t, u_int32_t, __db_get_reply *, int *));
  886.  */
  887. void
  888. __db_get_proc(dbpcl_id, txnpcl_id, keydlen,
  889. keydoff, keyulen, keyflags, keydata,
  890. keysize, datadlen, datadoff, dataulen,
  891. dataflags, datadata, datasize, flags, replyp, freep)
  892. long dbpcl_id;
  893. long txnpcl_id;
  894. u_int32_t keydlen;
  895. u_int32_t keydoff;
  896. u_int32_t keyulen;
  897. u_int32_t keyflags;
  898. void *keydata;
  899. u_int32_t keysize;
  900. u_int32_t datadlen;
  901. u_int32_t datadoff;
  902. u_int32_t dataulen;
  903. u_int32_t dataflags;
  904. void *datadata;
  905. u_int32_t datasize;
  906. u_int32_t flags;
  907. __db_get_reply *replyp;
  908. int * freep;
  909. /* END __db_get_proc */
  910. {
  911. DB *dbp;
  912. DBT key, data;
  913. DB_TXN *txnp;
  914. ct_entry *dbp_ctp, *txnp_ctp;
  915. int key_alloc, bulk_alloc, ret;
  917. ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
  918. dbp = (DB *)dbp_ctp->ct_anyp;
  919. if (txnpcl_id != 0) {
  920. ACTIVATE_CTP(txnp_ctp, txnpcl_id, CT_TXN);
  921. txnp = (DB_TXN *)txnp_ctp->ct_anyp;
  922. } else
  923. txnp = NULL;
  925. *freep = 0;
  926. bulk_alloc = 0;
  927. memset(&key, 0, sizeof(key));
  928. memset(&data, 0, sizeof(data));
  930. /* Set up key and data DBT */
  931. key.dlen = keydlen;
  932. key.doff = keydoff;
  933. /*
  934.  * Ignore memory related flags on server.
  935.  */
  936. key.flags = DB_DBT_MALLOC;
  937. if (keyflags & DB_DBT_PARTIAL)
  938. key.flags |= DB_DBT_PARTIAL;
  939. key.size = keysize;
  940. key.ulen = keyulen;
  941. key.data = keydata;
  943. data.dlen = datadlen;
  944. data.doff = datadoff;
  945. data.ulen = dataulen;
  946. /*
  947.  * Ignore memory related flags on server.
  948.  */
  949. data.size = datasize;
  950. data.data = datadata;
  951. if (flags & DB_MULTIPLE) {
  952. if (data.data == 0) {
  953. ret = __os_umalloc(dbp->dbenv,
  954.     data.ulen, &data.data);
  955. if (ret != 0)
  956. goto err;
  957. bulk_alloc = 1;
  958. }
  959. data.flags |= DB_DBT_USERMEM;
  960. } else
  961. data.flags |= DB_DBT_MALLOC;
  962. if (dataflags & DB_DBT_PARTIAL)
  963. data.flags |= DB_DBT_PARTIAL;
  965. /* Got all our stuff, now do the get */
  966. ret = dbp->get(dbp, txnp, &key, &data, flags);
  967. /*
  968.  * Otherwise just status.
  969.  */
  970. if (ret == 0) {
  971. /*
  972.  * XXX
  973.  * We need to xdr_free whatever we are returning, next time.
  974.  * However, DB does not allocate a new key if one was given
  975.  * and we'd be free'ing up space allocated in the request.
  976.  * So, allocate a new key/data pointer if it is the same one
  977.  * as in the request.
  978.  */
  979. *freep = 1;
  980. /*
  981.  * Key
  982.  */
  983. key_alloc = 0;
  984. if (key.data == keydata) {
  985. ret = __os_umalloc(dbp->dbenv,
  986.     key.size, &replyp->keydata.keydata_val);
  987. if (ret != 0) {
  988. __os_ufree(dbp->dbenv, key.data);
  989. __os_ufree(dbp->dbenv, data.data);
  990. goto err;
  991. }
  992. key_alloc = 1;
  993. memcpy(replyp->keydata.keydata_val, key.data, key.size);
  994. } else
  995. replyp->keydata.keydata_val = key.data;
  997. replyp->keydata.keydata_len = key.size;
  999. /*
  1000.  * Data
  1001.  */
  1002. if (data.data == datadata) {
  1003. ret = __os_umalloc(dbp->dbenv,
  1004.      data.size, &replyp->datadata.datadata_val);
  1005. if (ret != 0) {
  1006. __os_ufree(dbp->dbenv, key.data);
  1007. __os_ufree(dbp->dbenv, data.data);
  1008. if (key_alloc)
  1009. __os_ufree(dbp->dbenv,
  1010.     replyp->keydata.keydata_val);
  1011. goto err;
  1012. }
  1013. memcpy(replyp->datadata.datadata_val, data.data,
  1014.     data.size);
  1015. } else
  1016. replyp->datadata.datadata_val = data.data;
  1017. replyp->datadata.datadata_len = data.size;
  1018. } else {
  1019. err: replyp->keydata.keydata_val = NULL;
  1020. replyp->keydata.keydata_len = 0;
  1021. replyp->datadata.datadata_val = NULL;
  1022. replyp->datadata.datadata_len = 0;
  1023. *freep = 0;
  1024. if (bulk_alloc)
  1025. __os_ufree(dbp->dbenv, data.data);
  1026. }
  1027. replyp->status = ret;
  1028. return;
  1029. }
  1031. /* BEGIN __db_h_ffactor_proc */
  1032. /*
  1033.  * PUBLIC: void __db_h_ffactor_proc __P((long, u_int32_t,
  1034.  * PUBLIC:      __db_h_ffactor_reply *));
  1035.  */
  1036. void
  1037. __db_h_ffactor_proc(dbpcl_id, ffactor, replyp)
  1038. long dbpcl_id;
  1039. u_int32_t ffactor;
  1040. __db_h_ffactor_reply *replyp;
  1041. /* END __db_h_ffactor_proc */
  1042. {
  1043. DB *dbp;
  1044. ct_entry *dbp_ctp;
  1045. int ret;
  1047. ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
  1048. dbp = (DB *)dbp_ctp->ct_anyp;
  1050. ret = dbp->set_h_ffactor(dbp, ffactor);
  1052. replyp->status = ret;
  1053. return;
  1054. }
  1056. /* BEGIN __db_h_nelem_proc */
  1057. /*
  1058.  * PUBLIC: void __db_h_nelem_proc __P((long, u_int32_t,
  1059.  * PUBLIC:      __db_h_nelem_reply *));
  1060.  */
  1061. void
  1062. __db_h_nelem_proc(dbpcl_id, nelem, replyp)
  1063. long dbpcl_id;
  1064. u_int32_t nelem;
  1065. __db_h_nelem_reply *replyp;
  1066. /* END __db_h_nelem_proc */
  1067. {
  1068. DB *dbp;
  1069. ct_entry *dbp_ctp;
  1070. int ret;
  1072. ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
  1073. dbp = (DB *)dbp_ctp->ct_anyp;
  1075. ret = dbp->set_h_nelem(dbp, nelem);
  1077. replyp->status = ret;
  1078. return;
  1079. }
  1081. /* BEGIN __db_key_range_proc */
  1082. /*
  1083.  * PUBLIC: void __db_key_range_proc __P((long, long, u_int32_t, u_int32_t,
  1084.  * PUBLIC:      u_int32_t, u_int32_t, void *, u_int32_t, u_int32_t, __db_key_range_reply *));
  1085.  */
  1086. void
  1087. __db_key_range_proc(dbpcl_id, txnpcl_id, keydlen,
  1088. keydoff, keyulen, keyflags, keydata,
  1089. keysize, flags, replyp)
  1090. long dbpcl_id;
  1091. long txnpcl_id;
  1092. u_int32_t keydlen;
  1093. u_int32_t keydoff;
  1094. u_int32_t keyulen;
  1095. u_int32_t keyflags;
  1096. void *keydata;
  1097. u_int32_t keysize;
  1098. u_int32_t flags;
  1099. __db_key_range_reply *replyp;
  1100. /* END __db_key_range_proc */
  1101. {
  1102. DB *dbp;
  1103. DBT key;
  1104. DB_KEY_RANGE range;
  1105. DB_TXN *txnp;
  1106. ct_entry *dbp_ctp, *txnp_ctp;
  1107. int ret;
  1109. ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
  1110. dbp = (DB *)dbp_ctp->ct_anyp;
  1111. if (txnpcl_id != 0) {
  1112. ACTIVATE_CTP(txnp_ctp, txnpcl_id, CT_TXN);
  1113. txnp = (DB_TXN *)txnp_ctp->ct_anyp;
  1114. } else
  1115. txnp = NULL;
  1117. memset(&key, 0, sizeof(key));
  1118. /* Set up key and data DBT */
  1119. key.dlen = keydlen;
  1120. key.ulen = keyulen;
  1121. key.doff = keydoff;
  1122. key.size = keysize;
  1123. key.data = keydata;
  1124. key.flags = keyflags;
  1126. ret = dbp->key_range(dbp, txnp, &key, &range, flags);
  1128. replyp->status = ret;
  1129. replyp->less = range.less;
  1130. replyp->equal = range.equal;
  1131. replyp->greater = range.greater;
  1132. return;
  1133. }
  1135. /* BEGIN __db_lorder_proc */
  1136. /*
  1137.  * PUBLIC: void __db_lorder_proc __P((long, u_int32_t, __db_lorder_reply *));
  1138.  */
  1139. void
  1140. __db_lorder_proc(dbpcl_id, lorder, replyp)
  1141. long dbpcl_id;
  1142. u_int32_t lorder;
  1143. __db_lorder_reply *replyp;
  1144. /* END __db_lorder_proc */
  1145. {
  1146. DB *dbp;
  1147. ct_entry *dbp_ctp;
  1148. int ret;
  1150. ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
  1151. dbp = (DB *)dbp_ctp->ct_anyp;
  1153. ret = dbp->set_lorder(dbp, lorder);
  1155. replyp->status = ret;
  1156. return;
  1157. }
  1159. /* BEGIN __db_open_proc */
  1160. /*
  1161.  * PUBLIC: void __db_open_proc __P((long, long, char *, char *, u_int32_t,
  1162.  * PUBLIC:      u_int32_t, u_int32_t, __db_open_reply *));
  1163.  */
  1164. void
  1165. __db_open_proc(dbpcl_id, txnpcl_id, name,
  1166. subdb, type, flags, mode, replyp)
  1167. long dbpcl_id;
  1168. long txnpcl_id;
  1169. char *name;
  1170. char *subdb;
  1171. u_int32_t type;
  1172. u_int32_t flags;
  1173. u_int32_t mode;
  1174. __db_open_reply *replyp;
  1175. /* END __db_open_proc */
  1176. {
  1177. DB *dbp;
  1178. DB_TXN *txnp;
  1179. DBTYPE dbtype;
  1180. ct_entry *dbp_ctp, *new_ctp, *txnp_ctp;
  1181. int isswapped, ret;
  1183. ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
  1184. dbp = (DB *)dbp_ctp->ct_anyp;
  1186. if (txnpcl_id != 0) {
  1187. ACTIVATE_CTP(txnp_ctp, txnpcl_id, CT_TXN);
  1188. txnp = (DB_TXN *)txnp_ctp->ct_anyp;
  1189. } else
  1190. txnp = NULL;
  1192. replyp->dbcl_id = dbpcl_id;
  1193. if ((new_ctp = __dbsrv_sharedb(dbp_ctp, name, subdb, type, flags))
  1194.     != NULL) {
  1195. /*
  1196.  * We can share, clean up old ID, set new one.
  1197.  */
  1198. if (__dbsrv_verbose)
  1199. printf("Sharing db ID %ldn", new_ctp->ct_id);
  1200. replyp->dbcl_id = new_ctp->ct_id;
  1201. ret = __db_close_int(dbpcl_id, 0);
  1202. goto out;
  1203. }
  1204. ret = dbp->open(dbp, txnp, name, subdb, (DBTYPE)type, flags, mode);
  1205. if (ret == 0) {
  1206. (void)dbp->get_type(dbp, &dbtype);
  1207. replyp->type = dbtype;
  1208. /* XXX
  1209.  * Tcl needs to peek at dbp->flags for DB_AM_DUP.  Send
  1210.  * this dbp's flags back.
  1211.  */
  1212. replyp->dbflags = (int) dbp->flags;
  1213. /*
  1214.  * We need to determine the byte order of the database
  1215.  * and send it back to the client.  Determine it by
  1216.  * the server's native order and the swapped value of
  1217.  * the DB itself.
  1218.  */
  1219. (void)dbp->get_byteswapped(dbp, &isswapped);
  1220. if (__db_byteorder(NULL, 1234) == 0) {
  1221. if (isswapped == 0)
  1222. replyp->lorder = 1234;
  1223. else
  1224. replyp->lorder = 4321;
  1225. } else {
  1226. if (isswapped == 0)
  1227. replyp->lorder = 4321;
  1228. else
  1229. replyp->lorder = 1234;
  1230. }
  1231. dbp_ctp->ct_dbdp.type = dbtype;
  1232. dbp_ctp->ct_dbdp.dbflags = LF_ISSET(DB_SERVER_DBFLAGS);
  1233. if (name == NULL)
  1234. dbp_ctp->ct_dbdp.db = NULL;
  1235. else if ((ret = __os_strdup(dbp->dbenv, name,
  1236.     &dbp_ctp->ct_dbdp.db)) != 0)
  1237. goto out;
  1238. if (subdb == NULL)
  1239. dbp_ctp->ct_dbdp.subdb = NULL;
  1240. else if ((ret = __os_strdup(dbp->dbenv, subdb,
  1241.     &dbp_ctp->ct_dbdp.subdb)) != 0)
  1242. goto out;
  1243. }
  1244. out:
  1245. replyp->status = ret;
  1246. return;
  1247. }
  1249. /* BEGIN __db_pagesize_proc */
  1250. /*
  1251.  * PUBLIC: void __db_pagesize_proc __P((long, u_int32_t,
  1252.  * PUBLIC:      __db_pagesize_reply *));
  1253.  */
  1254. void
  1255. __db_pagesize_proc(dbpcl_id, pagesize, replyp)
  1256. long dbpcl_id;
  1257. u_int32_t pagesize;
  1258. __db_pagesize_reply *replyp;
  1259. /* END __db_pagesize_proc */
  1260. {
  1261. DB *dbp;
  1262. ct_entry *dbp_ctp;
  1263. int ret;
  1265. ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
  1266. dbp = (DB *)dbp_ctp->ct_anyp;
  1268. ret = dbp->set_pagesize(dbp, pagesize);
  1270. replyp->status = ret;
  1271. return;
  1272. }
  1274. /* BEGIN __db_pget_proc */
  1275. /*
  1276.  * PUBLIC: void __db_pget_proc __P((long, long, u_int32_t, u_int32_t,
  1277.  * PUBLIC:      u_int32_t, u_int32_t, void *, u_int32_t, u_int32_t, u_int32_t, u_int32_t,
  1278.  * PUBLIC:      u_int32_t, void *, u_int32_t, u_int32_t, u_int32_t, u_int32_t, u_int32_t, void *,
  1279.  * PUBLIC:      u_int32_t, u_int32_t, __db_pget_reply *, int *));
  1280.  */
  1281. void
  1282. __db_pget_proc(dbpcl_id, txnpcl_id, skeydlen,
  1283. skeydoff, skeyulen, skeyflags, skeydata,
  1284. skeysize, pkeydlen, pkeydoff, pkeyulen,
  1285. pkeyflags, pkeydata, pkeysize, datadlen,
  1286. datadoff, dataulen, dataflags, datadata,
  1287. datasize, flags, replyp, freep)
  1288. long dbpcl_id;
  1289. long txnpcl_id;
  1290. u_int32_t skeydlen;
  1291. u_int32_t skeydoff;
  1292. u_int32_t skeyulen;
  1293. u_int32_t skeyflags;
  1294. void *skeydata;
  1295. u_int32_t skeysize;
  1296. u_int32_t pkeydlen;
  1297. u_int32_t pkeydoff;
  1298. u_int32_t pkeyulen;
  1299. u_int32_t pkeyflags;
  1300. void *pkeydata;
  1301. u_int32_t pkeysize;
  1302. u_int32_t datadlen;
  1303. u_int32_t datadoff;
  1304. u_int32_t dataulen;
  1305. u_int32_t dataflags;
  1306. void *datadata;
  1307. u_int32_t datasize;
  1308. u_int32_t flags;
  1309. __db_pget_reply *replyp;
  1310. int * freep;
  1311. /* END __db_pget_proc */
  1312. {
  1313. DB *dbp;
  1314. DBT skey, pkey, data;
  1315. DB_TXN *txnp;
  1316. ct_entry *dbp_ctp, *txnp_ctp;
  1317. int key_alloc, ret;
  1319. ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
  1320. dbp = (DB *)dbp_ctp->ct_anyp;
  1321. if (txnpcl_id != 0) {
  1322. ACTIVATE_CTP(txnp_ctp, txnpcl_id, CT_TXN);
  1323. txnp = (DB_TXN *)txnp_ctp->ct_anyp;
  1324. } else
  1325. txnp = NULL;
  1327. *freep = 0;
  1328. memset(&skey, 0, sizeof(skey));
  1329. memset(&pkey, 0, sizeof(pkey));
  1330. memset(&data, 0, sizeof(data));
  1332. /*
  1333.  * Ignore memory related flags on server.
  1334.  */
  1335. /* Set up key and data DBT */
  1336. skey.flags = DB_DBT_MALLOC;
  1337. skey.dlen = skeydlen;
  1338. skey.ulen = skeyulen;
  1339. skey.doff = skeydoff;
  1340. if (skeyflags & DB_DBT_PARTIAL)
  1341. skey.flags |= DB_DBT_PARTIAL;
  1342. skey.size = skeysize;
  1343. skey.data = skeydata;
  1345. pkey.flags = DB_DBT_MALLOC;
  1346. pkey.dlen = pkeydlen;
  1347. pkey.ulen = pkeyulen;
  1348. pkey.doff = pkeydoff;
  1349. if (pkeyflags & DB_DBT_PARTIAL)
  1350. pkey.flags |= DB_DBT_PARTIAL;
  1351. pkey.size = pkeysize;
  1352. pkey.data = pkeydata;
  1354. data.flags = DB_DBT_MALLOC;
  1355. data.dlen = datadlen;
  1356. data.ulen = dataulen;
  1357. data.doff = datadoff;
  1358. if (dataflags & DB_DBT_PARTIAL)
  1359. data.flags |= DB_DBT_PARTIAL;
  1360. data.size = datasize;
  1361. data.data = datadata;
  1363. /* Got all our stuff, now do the get */
  1364. ret = dbp->pget(dbp, txnp, &skey, &pkey, &data, flags);
  1365. /*
  1366.  * Otherwise just status.
  1367.  */
  1368. if (ret == 0) {
  1369. /*
  1370.  * XXX
  1371.  * We need to xdr_free whatever we are returning, next time.
  1372.  * However, DB does not allocate a new key if one was given
  1373.  * and we'd be free'ing up space allocated in the request.
  1374.  * So, allocate a new key/data pointer if it is the same one
  1375.  * as in the request.
  1376.  */
  1377. *freep = 1;
  1378. /*
  1379.  * Key
  1380.  */
  1381. key_alloc = 0;
  1382. if (skey.data == skeydata) {
  1383. ret = __os_umalloc(dbp->dbenv,
  1384.     skey.size, &replyp->skeydata.skeydata_val);
  1385. if (ret != 0) {
  1386. __os_ufree(dbp->dbenv, skey.data);
  1387. __os_ufree(dbp->dbenv, pkey.data);
  1388. __os_ufree(dbp->dbenv, data.data);
  1389. goto err;
  1390. }
  1391. key_alloc = 1;
  1392. memcpy(replyp->skeydata.skeydata_val, skey.data,
  1393.     skey.size);
  1394. } else
  1395. replyp->skeydata.skeydata_val = skey.data;
  1397. replyp->skeydata.skeydata_len = skey.size;
  1399. /*
  1400.  * Primary key
  1401.  */
  1402. if (pkey.data == pkeydata) {
  1403. ret = __os_umalloc(dbp->dbenv,
  1404.      pkey.size, &replyp->pkeydata.pkeydata_val);
  1405. if (ret != 0) {
  1406. __os_ufree(dbp->dbenv, skey.data);
  1407. __os_ufree(dbp->dbenv, pkey.data);
  1408. __os_ufree(dbp->dbenv, data.data);
  1409. if (key_alloc)
  1410. __os_ufree(dbp->dbenv,
  1411.     replyp->skeydata.skeydata_val);
  1412. goto err;
  1413. }
  1414. /*
  1415.  * We can set it to 2, because they cannot send the
  1416.  * pkey over without sending the skey over too.
  1417.  * So if they did send a pkey, they must have sent
  1418.  * the skey as well.
  1419.  */
  1420. key_alloc = 2;
  1421. memcpy(replyp->pkeydata.pkeydata_val, pkey.data,
  1422.     pkey.size);
  1423. } else
  1424. replyp->pkeydata.pkeydata_val = pkey.data;
  1425. replyp->pkeydata.pkeydata_len = pkey.size;
  1427. /*
  1428.  * Data
  1429.  */
  1430. if (data.data == datadata) {
  1431. ret = __os_umalloc(dbp->dbenv,
  1432.      data.size, &replyp->datadata.datadata_val);
  1433. if (ret != 0) {
  1434. __os_ufree(dbp->dbenv, skey.data);
  1435. __os_ufree(dbp->dbenv, pkey.data);
  1436. __os_ufree(dbp->dbenv, data.data);
  1437. /*
  1438.  * If key_alloc is 1, just skey needs to be
  1439.  * freed, if key_alloc is 2, both skey and pkey
  1440.  * need to be freed.
  1441.  */
  1442. if (key_alloc--)
  1443. __os_ufree(dbp->dbenv,
  1444.     replyp->skeydata.skeydata_val);
  1445. if (key_alloc)
  1446. __os_ufree(dbp->dbenv,
  1447.     replyp->pkeydata.pkeydata_val);
  1448. goto err;
  1449. }
  1450. memcpy(replyp->datadata.datadata_val, data.data,
  1451.     data.size);
  1452. } else
  1453. replyp->datadata.datadata_val = data.data;
  1454. replyp->datadata.datadata_len = data.size;
  1455. } else {
  1456. err: replyp->skeydata.skeydata_val = NULL;
  1457. replyp->skeydata.skeydata_len = 0;
  1458. replyp->pkeydata.pkeydata_val = NULL;
  1459. replyp->pkeydata.pkeydata_len = 0;
  1460. replyp->datadata.datadata_val = NULL;
  1461. replyp->datadata.datadata_len = 0;
  1462. *freep = 0;
  1463. }
  1464. replyp->status = ret;
  1465. return;
  1466. }
  1468. /* BEGIN __db_put_proc */
  1469. /*
  1470.  * PUBLIC: void __db_put_proc __P((long, long, u_int32_t, u_int32_t, u_int32_t,
  1471.  * PUBLIC:      u_int32_t, void *, u_int32_t, u_int32_t, u_int32_t, u_int32_t, u_int32_t, void *,
  1472.  * PUBLIC:      u_int32_t, u_int32_t, __db_put_reply *, int *));
  1473.  */
  1474. void
  1475. __db_put_proc(dbpcl_id, txnpcl_id, keydlen,
  1476. keydoff, keyulen, keyflags, keydata,
  1477. keysize, datadlen, datadoff, dataulen,
  1478. dataflags, datadata, datasize, flags, replyp, freep)
  1479. long dbpcl_id;
  1480. long txnpcl_id;
  1481. u_int32_t keydlen;
  1482. u_int32_t keydoff;
  1483. u_int32_t keyulen;
  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 dataulen;
  1490. u_int32_t dataflags;
  1491. void *datadata;
  1492. u_int32_t datasize;
  1493. u_int32_t flags;
  1494. __db_put_reply *replyp;
  1495. int * freep;
  1496. /* END __db_put_proc */
  1497. {
  1498. DB *dbp;
  1499. DBT key, data;
  1500. DB_TXN *txnp;
  1501. ct_entry *dbp_ctp, *txnp_ctp;
  1502. int ret;
  1504. ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
  1505. dbp = (DB *)dbp_ctp->ct_anyp;
  1506. if (txnpcl_id != 0) {
  1507. ACTIVATE_CTP(txnp_ctp, txnpcl_id, CT_TXN);
  1508. txnp = (DB_TXN *)txnp_ctp->ct_anyp;
  1509. } else
  1510. txnp = NULL;
  1512. *freep = 0;
  1513. memset(&key, 0, sizeof(key));
  1514. memset(&data, 0, sizeof(data));
  1516. /* Set up key and data DBT */
  1517. key.dlen = keydlen;
  1518. key.ulen = keyulen;
  1519. key.doff = keydoff;
  1520. /*
  1521.  * Ignore memory related flags on server.
  1522.  */
  1523. key.flags = DB_DBT_MALLOC;
  1524. if (keyflags & DB_DBT_PARTIAL)
  1525. key.flags |= DB_DBT_PARTIAL;
  1526. key.size = keysize;
  1527. key.data = keydata;
  1529. data.dlen = datadlen;
  1530. data.ulen = dataulen;
  1531. data.doff = datadoff;
  1532. data.flags = dataflags;
  1533. data.size = datasize;
  1534. data.data = datadata;
  1536. /* Got all our stuff, now do the put */
  1537. ret = dbp->put(dbp, txnp, &key, &data, flags);
  1538. /*
  1539.  * If the client did a DB_APPEND, set up key in reply.
  1540.  * Otherwise just status.
  1541.  */
  1542. if (ret == 0 && (flags == DB_APPEND)) {
  1543. /*
  1544.  * XXX
  1545.  * We need to xdr_free whatever we are returning, next time.
  1546.  * However, DB does not allocate a new key if one was given
  1547.  * and we'd be free'ing up space allocated in the request.
  1548.  * So, allocate a new key/data pointer if it is the same one
  1549.  * as in the request.
  1550.  */
  1551. *freep = 1;
  1552. /*
  1553.  * Key
  1554.  */
  1555. if (key.data == keydata) {
  1556. ret = __os_umalloc(dbp->dbenv,
  1557.     key.size, &replyp->keydata.keydata_val);
  1558. if (ret != 0) {
  1559. __os_ufree(dbp->dbenv, key.data);
  1560. goto err;
  1561. }
  1562. memcpy(replyp->keydata.keydata_val, key.data, key.size);
  1563. } else
  1564. replyp->keydata.keydata_val = key.data;
  1566. replyp->keydata.keydata_len = key.size;
  1567. } else {
  1568. err: replyp->keydata.keydata_val = NULL;
  1569. replyp->keydata.keydata_len = 0;
  1570. *freep = 0;
  1571. }
  1572. replyp->status = ret;
  1573. return;
  1574. }
  1576. /* BEGIN __db_re_delim_proc */
  1577. /*
  1578.  * PUBLIC: void __db_re_delim_proc __P((long, u_int32_t,
  1579.  * PUBLIC:      __db_re_delim_reply *));
  1580.  */
  1581. void
  1582. __db_re_delim_proc(dbpcl_id, delim, replyp)
  1583. long dbpcl_id;
  1584. u_int32_t delim;
  1585. __db_re_delim_reply *replyp;
  1586. /* END __db_re_delim_proc */
  1587. {
  1588. DB *dbp;
  1589. ct_entry *dbp_ctp;
  1590. int ret;
  1592. ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
  1593. dbp = (DB *)dbp_ctp->ct_anyp;
  1595. ret = dbp->set_re_delim(dbp, delim);
  1597. replyp->status = ret;
  1598. return;
  1599. }
  1601. /* BEGIN __db_re_len_proc */
  1602. /*
  1603.  * PUBLIC: void __db_re_len_proc __P((long, u_int32_t, __db_re_len_reply *));
  1604.  */
  1605. void
  1606. __db_re_len_proc(dbpcl_id, len, replyp)
  1607. long dbpcl_id;
  1608. u_int32_t len;
  1609. __db_re_len_reply *replyp;
  1610. /* END __db_re_len_proc */
  1611. {
  1612. DB *dbp;
  1613. ct_entry *dbp_ctp;
  1614. int ret;
  1616. ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
  1617. dbp = (DB *)dbp_ctp->ct_anyp;
  1619. ret = dbp->set_re_len(dbp, len);
  1621. replyp->status = ret;
  1622. return;
  1623. }
  1625. /* BEGIN __db_re_pad_proc */
  1626. /*
  1627.  * PUBLIC: void __db_re_pad_proc __P((long, u_int32_t, __db_re_pad_reply *));
  1628.  */
  1629. void
  1630. __db_re_pad_proc(dbpcl_id, pad, replyp)
  1631. long dbpcl_id;
  1632. u_int32_t pad;
  1633. __db_re_pad_reply *replyp;
  1634. /* END __db_re_pad_proc */
  1635. {
  1636. DB *dbp;
  1637. ct_entry *dbp_ctp;
  1638. int ret;
  1640. ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
  1641. dbp = (DB *)dbp_ctp->ct_anyp;
  1643. ret = dbp->set_re_pad(dbp, pad);
  1645. replyp->status = ret;
  1646. return;
  1647. }
  1649. /* BEGIN __db_remove_proc */
  1650. /*
  1651.  * PUBLIC: void __db_remove_proc __P((long, char *, char *, u_int32_t,
  1652.  * PUBLIC:      __db_remove_reply *));
  1653.  */
  1654. void
  1655. __db_remove_proc(dbpcl_id, name, subdb,
  1656. flags, replyp)
  1657. long dbpcl_id;
  1658. char *name;
  1659. char *subdb;
  1660. u_int32_t flags;
  1661. __db_remove_reply *replyp;
  1662. /* END __db_remove_proc */
  1663. {
  1664. DB *dbp;
  1665. ct_entry *dbp_ctp;
  1666. int ret;
  1668. ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
  1669. dbp = (DB *)dbp_ctp->ct_anyp;
  1671. ret = dbp->remove(dbp, name, subdb, flags);
  1672. __dbdel_ctp(dbp_ctp);
  1674. replyp->status = ret;
  1675. return;
  1676. }
  1678. /* BEGIN __db_rename_proc */
  1679. /*
  1680.  * PUBLIC: void __db_rename_proc __P((long, char *, char *, char *, u_int32_t,
  1681.  * PUBLIC:      __db_rename_reply *));
  1682.  */
  1683. void
  1684. __db_rename_proc(dbpcl_id, name, subdb,
  1685. newname, flags, replyp)
  1686. long dbpcl_id;
  1687. char *name;
  1688. char *subdb;
  1689. char *newname;
  1690. u_int32_t flags;
  1691. __db_rename_reply *replyp;
  1692. /* END __db_rename_proc */
  1693. {
  1694. DB *dbp;
  1695. ct_entry *dbp_ctp;
  1696. int ret;
  1698. ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
  1699. dbp = (DB *)dbp_ctp->ct_anyp;
  1701. ret = dbp->rename(dbp, name, subdb, newname, flags);
  1702. __dbdel_ctp(dbp_ctp);
  1704. replyp->status = ret;
  1705. return;
  1706. }
  1708. /* BEGIN __db_stat_proc */
  1709. /*
  1710.  * PUBLIC: void __db_stat_proc __P((long, u_int32_t, __db_stat_reply *,
  1711.  * PUBLIC:      int *));
  1712.  */
  1713. void
  1714. __db_stat_proc(dbpcl_id, flags, replyp, freep)
  1715. long dbpcl_id;
  1716. u_int32_t flags;
  1717. __db_stat_reply *replyp;
  1718. int * freep;
  1719. /* END __db_stat_proc */
  1720. {
  1721. DB *dbp;
  1722. DBTYPE type;
  1723. ct_entry *dbp_ctp;
  1724. u_int32_t *q, *p, *retsp;
  1725. int i, len, ret;
  1726. void *sp;
  1728. ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
  1729. dbp = (DB *)dbp_ctp->ct_anyp;
  1731. ret = dbp->stat(dbp, &sp, flags);
  1732. replyp->status = ret;
  1733. if (ret != 0)
  1734. return;
  1735. /*
  1736.  * We get here, we have success.  Allocate an array so that
  1737.  * we can use the list generator.  Generate the reply, free
  1738.  * up the space.
  1739.  */
  1740. /*
  1741.  * XXX This assumes that all elements of all stat structures
  1742.  * are u_int32_t fields.  They are, currently.
  1743.  */
  1744. (void)dbp->get_type(dbp, &type);
  1745. if (type == DB_HASH)
  1746. len = sizeof(DB_HASH_STAT);
  1747. else if (type == DB_QUEUE)
  1748. len = sizeof(DB_QUEUE_STAT);
  1749. else            /* BTREE or RECNO are same stats */
  1750. len = sizeof(DB_BTREE_STAT);
  1751. replyp->stats.stats_len = len / sizeof(u_int32_t);
  1753. if ((ret = __os_umalloc(dbp->dbenv, len * replyp->stats.stats_len,
  1754.     &retsp)) != 0)
  1755. goto out;
  1756. for (i = 0, q = retsp, p = sp; i < len;
  1757.     i++, q++, p++)
  1758. *q = *p;
  1759. replyp->stats.stats_val = retsp;
  1760. __os_ufree(dbp->dbenv, sp);
  1761. if (ret == 0)
  1762. *freep = 1;
  1763. out:
  1764. replyp->status = ret;
  1765. return;
  1766. }
  1768. /* BEGIN __db_sync_proc */
  1769. /*
  1770.  * PUBLIC: void __db_sync_proc __P((long, u_int32_t, __db_sync_reply *));
  1771.  */
  1772. void
  1773. __db_sync_proc(dbpcl_id, flags, replyp)
  1774. long dbpcl_id;
  1775. u_int32_t flags;
  1776. __db_sync_reply *replyp;
  1777. /* END __db_sync_proc */
  1778. {
  1779. DB *dbp;
  1780. ct_entry *dbp_ctp;
  1781. int ret;
  1783. ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
  1784. dbp = (DB *)dbp_ctp->ct_anyp;
  1786. ret = dbp->sync(dbp, flags);
  1788. replyp->status = ret;
  1789. return;
  1790. }
  1792. /* BEGIN __db_truncate_proc */
  1793. /*
  1794.  * PUBLIC: void __db_truncate_proc __P((long, long, u_int32_t,
  1795.  * PUBLIC:      __db_truncate_reply *));
  1796.  */
  1797. void
  1798. __db_truncate_proc(dbpcl_id, txnpcl_id,
  1799. flags, replyp)
  1800. long dbpcl_id;
  1801. long txnpcl_id;
  1802. u_int32_t flags;
  1803. __db_truncate_reply *replyp;
  1804. /* END __db_truncate_proc */
  1805. {
  1806. DB *dbp;
  1807. DB_TXN *txnp;
  1808. ct_entry *dbp_ctp, *txnp_ctp;
  1809. u_int32_t count;
  1810. int ret;
  1812. ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
  1813. dbp = (DB *)dbp_ctp->ct_anyp;
  1814. if (txnpcl_id != 0) {
  1815. ACTIVATE_CTP(txnp_ctp, txnpcl_id, CT_TXN);
  1816. txnp = (DB_TXN *)txnp_ctp->ct_anyp;
  1817. } else
  1818. txnp = NULL;
  1820. ret = dbp->truncate(dbp, txnp, &count, flags);
  1821. replyp->status = ret;
  1822. if (ret == 0)
  1823. replyp->count = count;
  1824. return;
  1825. }
  1827. /* BEGIN __db_cursor_proc */
  1828. /*
  1829.  * PUBLIC: void __db_cursor_proc __P((long, long, u_int32_t,
  1830.  * PUBLIC:      __db_cursor_reply *));
  1831.  */
  1832. void
  1833. __db_cursor_proc(dbpcl_id, txnpcl_id,
  1834. flags, replyp)
  1835. long dbpcl_id;
  1836. long txnpcl_id;
  1837. u_int32_t flags;
  1838. __db_cursor_reply *replyp;
  1839. /* END __db_cursor_proc */
  1840. {
  1841. DB *dbp;
  1842. DBC *dbc;
  1843. DB_TXN *txnp;
  1844. ct_entry *dbc_ctp, *env_ctp, *dbp_ctp, *txnp_ctp;
  1845. int ret;
  1847. ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
  1848. dbp = (DB *)dbp_ctp->ct_anyp;
  1849. dbc_ctp = new_ct_ent(&replyp->status);
  1850. if (dbc_ctp == NULL)
  1851. return;
  1853. if (txnpcl_id != 0) {
  1854. ACTIVATE_CTP(txnp_ctp, txnpcl_id, CT_TXN);
  1855. txnp = (DB_TXN *)txnp_ctp->ct_anyp;
  1856. dbc_ctp->ct_activep = txnp_ctp->ct_activep;
  1857. } else
  1858. txnp = NULL;
  1860. if ((ret = dbp->cursor(dbp, txnp, &dbc, flags)) == 0) {
  1861. dbc_ctp->ct_dbc = dbc;
  1862. dbc_ctp->ct_type = CT_CURSOR;
  1863. dbc_ctp->ct_parent = dbp_ctp;
  1864. env_ctp = dbp_ctp->ct_envparent;
  1865. dbc_ctp->ct_envparent = env_ctp;
  1866. __dbsrv_settimeout(dbc_ctp, env_ctp->ct_timeout);
  1867. __dbsrv_active(dbc_ctp);
  1868. replyp->dbcidcl_id = dbc_ctp->ct_id;
  1869. } else
  1870. __dbclear_ctp(dbc_ctp);
  1872. replyp->status = ret;
  1873. return;
  1874. }
  1876. /* BEGIN __db_join_proc */
  1877. /*
  1878.  * PUBLIC: void __db_join_proc __P((long, u_int32_t *, u_int32_t, u_int32_t,
  1879.  * PUBLIC:      __db_join_reply *));
  1880.  */
  1881. void
  1882. __db_join_proc(dbpcl_id, curs, curslen,
  1883. flags, replyp)
  1884. long dbpcl_id;
  1885. u_int32_t * curs;
  1886. u_int32_t curslen;
  1887. u_int32_t flags;
  1888. __db_join_reply *replyp;
  1889. /* END __db_join_proc */
  1890. {
  1891. DB *dbp;
  1892. DBC **jcurs, **c;
  1893. DBC *dbc;
  1894. ct_entry *dbc_ctp, *ctp, *dbp_ctp;
  1895. size_t size;
  1896. u_int32_t *cl, i;
  1897. int ret;
  1899. ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
  1900. dbp = (DB *)dbp_ctp->ct_anyp;
  1902. dbc_ctp = new_ct_ent(&replyp->status);
  1903. if (dbc_ctp == NULL)
  1904. return;
  1906. size = (curslen + 1) * sizeof(DBC *);
  1907. if ((ret = __os_calloc(dbp->dbenv,
  1908.     curslen + 1, sizeof(DBC *), &jcurs)) != 0) {
  1909. replyp->status = ret;
  1910. __dbclear_ctp(dbc_ctp);
  1911. return;
  1912. }
  1913. /*
  1914.  * If our curslist has a parent txn, we need to use it too
  1915.  * for the activity timeout.  All cursors must be part of
  1916.  * the same transaction, so just check the first.
  1917.  */
  1918. ctp = get_tableent(*curs);
  1919. DB_ASSERT(ctp->ct_type == CT_CURSOR);
  1920. /*
  1921.  * If we are using a transaction, set the join activity timer
  1922.  * to point to the parent transaction.
  1923.  */
  1924. if (ctp->ct_activep != &ctp->ct_active)
  1925. dbc_ctp->ct_activep = ctp->ct_activep;
  1926. for (i = 0, cl = curs, c = jcurs; i < curslen; i++, cl++, c++) {
  1927. ctp = get_tableent(*cl);
  1928. if (ctp == NULL) {
  1929. replyp->status = DB_NOSERVER_ID;
  1930. goto out;
  1931. }
  1932. /*
  1933.  * If we are using a txn, the join cursor points to the
  1934.  * transaction timeout.  If we are not using a transaction,
  1935.  * then all the curslist cursors must point to the join
  1936.  * cursor's timeout so that we do not timeout any of the
  1937.  * curlist cursors while the join cursor is active.
  1938.  * Change the type of the curslist ctps to CT_JOIN so that
  1939.  * we know they are part of a join list and we can distinguish
  1940.  * them and later restore them when the join cursor is closed.
  1941.  */
  1942. DB_ASSERT(ctp->ct_type == CT_CURSOR);
  1943. ctp->ct_type |= CT_JOIN;
  1944. ctp->ct_origp = ctp->ct_activep;
  1945. /*
  1946.  * Setting this to the ct_active field of the dbc_ctp is
  1947.  * really just a way to distinguish which join dbc this
  1948.  * cursor is part of.  The ct_activep of this cursor is
  1949.  * not used at all during its lifetime as part of a join
  1950.  * cursor.
  1951.  */
  1952. ctp->ct_activep = &dbc_ctp->ct_active;
  1953. *c = ctp->ct_dbc;
  1954. }
  1955. *c = NULL;
  1956. if ((ret = dbp->join(dbp, jcurs, &dbc, flags)) == 0) {
  1957. dbc_ctp->ct_dbc = dbc;
  1958. dbc_ctp->ct_type = (CT_JOINCUR | CT_CURSOR);
  1959. dbc_ctp->ct_parent = dbp_ctp;
  1960. dbc_ctp->ct_envparent = dbp_ctp->ct_envparent;
  1961. __dbsrv_settimeout(dbc_ctp, dbp_ctp->ct_envparent->ct_timeout);
  1962. __dbsrv_active(dbc_ctp);
  1963. replyp->dbcidcl_id = dbc_ctp->ct_id;
  1964. } else {
  1965. __dbclear_ctp(dbc_ctp);
  1966. /*
  1967.  * If we get an error, undo what we did above to any cursors.
  1968.  */
  1969. for (cl = curs; *cl != 0; cl++) {
  1970. ctp = get_tableent(*cl);
  1971. ctp->ct_type = CT_CURSOR;
  1972. ctp->ct_activep = ctp->ct_origp;
  1973. }
  1974. }
  1976. replyp->status = ret;
  1977. out:
  1978. __os_free(dbp->dbenv, jcurs);
  1979. return;
  1980. }
  1982. /* BEGIN __dbc_close_proc */
  1983. /*
  1984.  * PUBLIC: void __dbc_close_proc __P((long, __dbc_close_reply *));
  1985.  */
  1986. void
  1987. __dbc_close_proc(dbccl_id, replyp)
  1988. long dbccl_id;
  1989. __dbc_close_reply *replyp;
  1990. /* END __dbc_close_proc */
  1991. {
  1992. ct_entry *dbc_ctp;
  1994. ACTIVATE_CTP(dbc_ctp, dbccl_id, CT_CURSOR);
  1995. replyp->status = __dbc_close_int(dbc_ctp);
  1996. return;
  1997. }
  1999. /* BEGIN __dbc_count_proc */
  2000. /*
  2001.  * PUBLIC: void __dbc_count_proc __P((long, u_int32_t, __dbc_count_reply *));
  2002.  */
  2003. void
  2004. __dbc_count_proc(dbccl_id, flags, replyp)
  2005. long dbccl_id;
  2006. u_int32_t flags;
  2007. __dbc_count_reply *replyp;
  2008. /* END __dbc_count_proc */
  2009. {
  2010. DBC *dbc;
  2011. ct_entry *dbc_ctp;
  2012. db_recno_t num;
  2013. int ret;
  2015. ACTIVATE_CTP(dbc_ctp, dbccl_id, CT_CURSOR);
  2016. dbc = (DBC *)dbc_ctp->ct_anyp;
  2018. ret = dbc->c_count(dbc, &num, flags);
  2019. replyp->status = ret;
  2020. if (ret == 0)
  2021. replyp->dupcount = num;
  2022. return;
  2023. }
  2025. /* BEGIN __dbc_del_proc */
  2026. /*
  2027.  * PUBLIC: void __dbc_del_proc __P((long, u_int32_t, __dbc_del_reply *));
  2028.  */
  2029. void
  2030. __dbc_del_proc(dbccl_id, flags, replyp)
  2031. long dbccl_id;
  2032. u_int32_t flags;
  2033. __dbc_del_reply *replyp;
  2034. /* END __dbc_del_proc */
  2035. {
  2036. DBC *dbc;
  2037. ct_entry *dbc_ctp;
  2038. int ret;
  2040. ACTIVATE_CTP(dbc_ctp, dbccl_id, CT_CURSOR);
  2041. dbc = (DBC *)dbc_ctp->ct_anyp;
  2043. ret = dbc->c_del(dbc, flags);
  2045. replyp->status = ret;
  2046. return;
  2047. }
  2049. /* BEGIN __dbc_dup_proc */
  2050. /*
  2051.  * PUBLIC: void __dbc_dup_proc __P((long, u_int32_t, __dbc_dup_reply *));
  2052.  */
  2053. void
  2054. __dbc_dup_proc(dbccl_id, flags, replyp)
  2055. long dbccl_id;
  2056. u_int32_t flags;
  2057. __dbc_dup_reply *replyp;
  2058. /* END __dbc_dup_proc */
  2059. {
  2060. DBC *dbc, *newdbc;
  2061. ct_entry *dbc_ctp, *new_ctp;
  2062. int ret;
  2064. ACTIVATE_CTP(dbc_ctp, dbccl_id, CT_CURSOR);
  2065. dbc = (DBC *)dbc_ctp->ct_anyp;
  2067. new_ctp = new_ct_ent(&replyp->status);
  2068. if (new_ctp == NULL)
  2069. return;
  2071. if ((ret = dbc->c_dup(dbc, &newdbc, flags)) == 0) {
  2072. new_ctp->ct_dbc = newdbc;
  2073. new_ctp->ct_type = CT_CURSOR;
  2074. new_ctp->ct_parent = dbc_ctp->ct_parent;
  2075. new_ctp->ct_envparent = dbc_ctp->ct_envparent;
  2076. /*
  2077.  * If our cursor has a parent txn, we need to use it too.
  2078.  */
  2079. if (dbc_ctp->ct_activep != &dbc_ctp->ct_active)
  2080. new_ctp->ct_activep = dbc_ctp->ct_activep;
  2081. __dbsrv_settimeout(new_ctp, dbc_ctp->ct_timeout);
  2082. __dbsrv_active(new_ctp);
  2083. replyp->dbcidcl_id = new_ctp->ct_id;
  2084. } else
  2085. __dbclear_ctp(new_ctp);
  2087. replyp->status = ret;
  2088. return;
  2089. }
  2091. /* BEGIN __dbc_get_proc */
  2092. /*
  2093.  * PUBLIC: void __dbc_get_proc __P((long, u_int32_t, u_int32_t, u_int32_t,
  2094.  * PUBLIC:      u_int32_t, void *, u_int32_t, u_int32_t, u_int32_t, u_int32_t, u_int32_t, void *,
  2095.  * PUBLIC:      u_int32_t, u_int32_t, __dbc_get_reply *, int *));
  2096.  */
  2097. void
  2098. __dbc_get_proc(dbccl_id, keydlen, keydoff,
  2099. keyulen, keyflags, keydata, keysize,
  2100. datadlen, datadoff, dataulen, dataflags,
  2101. datadata, datasize, flags, replyp, freep)
  2102. long dbccl_id;
  2103. u_int32_t keydlen;
  2104. u_int32_t keydoff;
  2105. u_int32_t keyulen;
  2106. u_int32_t keyflags;
  2107. void *keydata;
  2108. u_int32_t keysize;
  2109. u_int32_t datadlen;
  2110. u_int32_t datadoff;
  2111. u_int32_t dataulen;
  2112. u_int32_t dataflags;
  2113. void *datadata;
  2114. u_int32_t datasize;
  2115. u_int32_t flags;
  2116. __dbc_get_reply *replyp;
  2117. int * freep;
  2118. /* END __dbc_get_proc */
  2119. {
  2120. DBC *dbc;
  2121. DBT key, data;
  2122. DB_ENV *dbenv;
  2123. ct_entry *dbc_ctp;
  2124. int key_alloc, bulk_alloc, ret;
  2126. ACTIVATE_CTP(dbc_ctp, dbccl_id, CT_CURSOR);
  2127. dbc = (DBC *)dbc_ctp->ct_anyp;
  2128. dbenv = dbc->dbp->dbenv;
  2130. *freep = 0;
  2131. bulk_alloc = 0;
  2132. memset(&key, 0, sizeof(key));
  2133. memset(&data, 0, sizeof(data));
  2135. /* Set up key and data DBT */
  2136. key.dlen = keydlen;
  2137. key.ulen = keyulen;
  2138. key.doff = keydoff;
  2139. /*
  2140.  * Ignore memory related flags on server.
  2141.  */
  2142. key.flags = DB_DBT_MALLOC;
  2143. if (keyflags & DB_DBT_PARTIAL)
  2144. key.flags |= DB_DBT_PARTIAL;
  2145. key.size = keysize;
  2146. key.data = keydata;
  2148. data.dlen = datadlen;
  2149. data.ulen = dataulen;
  2150. data.doff = datadoff;
  2151. data.size = datasize;
  2152. data.data = datadata;
  2153. if (flags & DB_MULTIPLE || flags & DB_MULTIPLE_KEY) {
  2154. if (data.data == 0) {
  2155. ret = __os_umalloc(dbenv, data.ulen, &data.data);
  2156. if (ret != 0)
  2157. goto err;
  2158. bulk_alloc = 1;
  2159. }
  2160. data.flags |= DB_DBT_USERMEM;
  2161. } else
  2162. data.flags |= DB_DBT_MALLOC;
  2163. if (dataflags & DB_DBT_PARTIAL)
  2164. data.flags |= DB_DBT_PARTIAL;
  2166. /* Got all our stuff, now do the get */
  2167. ret = dbc->c_get(dbc, &key, &data, flags);
  2169. /*
  2170.  * Otherwise just status.
  2171.  */
  2172. if (ret == 0) {
  2173. /*
  2174.  * XXX
  2175.  * We need to xdr_free whatever we are returning, next time.
  2176.  * However, DB does not allocate a new key if one was given
  2177.  * and we'd be free'ing up space allocated in the request.
  2178.  * So, allocate a new key/data pointer if it is the same one
  2179.  * as in the request.
  2180.  */
  2181. *freep = 1;
  2182. /*
  2183.  * Key
  2184.  */
  2185. key_alloc = 0;
  2186. if (key.data == keydata) {
  2187. ret = __os_umalloc(dbenv, key.size,
  2188.     &replyp->keydata.keydata_val);
  2189. if (ret != 0) {
  2190. __os_ufree(dbenv, key.data);
  2191. __os_ufree(dbenv, data.data);
  2192. goto err;
  2193. }
  2194. key_alloc = 1;
  2195. memcpy(replyp->keydata.keydata_val, key.data, key.size);
  2196. } else
  2197. replyp->keydata.keydata_val = key.data;
  2199. replyp->keydata.keydata_len = key.size;
  2201. /*
  2202.  * Data
  2203.  */
  2204. if (data.data == datadata) {
  2205. ret = __os_umalloc(dbenv, data.size,
  2206.     &replyp->datadata.datadata_val);
  2207. if (ret != 0) {
  2208. __os_ufree(dbenv, key.data);
  2209. __os_ufree(dbenv, data.data);
  2210. if (key_alloc)
  2211. __os_ufree(dbenv, replyp->keydata.keydata_val);
  2212. goto err;
  2213. }
  2214. memcpy(replyp->datadata.datadata_val, data.data,
  2215.     data.size);
  2216. } else
  2217. replyp->datadata.datadata_val = data.data;
  2218. replyp->datadata.datadata_len = data.size;
  2219. } else {
  2220. err: replyp->keydata.keydata_val = NULL;
  2221. replyp->keydata.keydata_len = 0;
  2222. replyp->datadata.datadata_val = NULL;
  2223. replyp->datadata.datadata_len = 0;
  2224. *freep = 0;
  2225. if (bulk_alloc)
  2226. __os_ufree(dbenv, data.data);
  2227. }
  2228. replyp->status = ret;
  2229. return;
  2230. }
  2232. /* BEGIN __dbc_pget_proc */
  2233. /*
  2234.  * PUBLIC: void __dbc_pget_proc __P((long, u_int32_t, u_int32_t, u_int32_t,
  2235.  * PUBLIC:      u_int32_t, void *, u_int32_t, u_int32_t, u_int32_t, u_int32_t, u_int32_t, void *,
  2236.  * PUBLIC:      u_int32_t, u_int32_t, u_int32_t, u_int32_t, u_int32_t, void *, u_int32_t,
  2237.  * PUBLIC:      u_int32_t, __dbc_pget_reply *, int *));
  2238.  */
  2239. void
  2240. __dbc_pget_proc(dbccl_id, skeydlen, skeydoff,
  2241. skeyulen, skeyflags, skeydata, skeysize,
  2242. pkeydlen, pkeydoff, pkeyulen, pkeyflags,
  2243. pkeydata, pkeysize, datadlen, datadoff,
  2244. dataulen, dataflags, datadata, datasize,
  2245. flags, replyp, freep)
  2246. long dbccl_id;
  2247. u_int32_t skeydlen;
  2248. u_int32_t skeydoff;
  2249. u_int32_t skeyulen;
  2250. u_int32_t skeyflags;
  2251. void *skeydata;
  2252. u_int32_t skeysize;
  2253. u_int32_t pkeydlen;
  2254. u_int32_t pkeydoff;
  2255. u_int32_t pkeyulen;
  2256. u_int32_t pkeyflags;
  2257. void *pkeydata;
  2258. u_int32_t pkeysize;
  2259. u_int32_t datadlen;
  2260. u_int32_t datadoff;
  2261. u_int32_t dataulen;
  2262. u_int32_t dataflags;
  2263. void *datadata;
  2264. u_int32_t datasize;
  2265. u_int32_t flags;
  2266. __dbc_pget_reply *replyp;
  2267. int * freep;
  2268. /* END __dbc_pget_proc */
  2269. {
  2270. DBC *dbc;
  2271. DBT skey, pkey, data;
  2272. DB_ENV *dbenv;
  2273. ct_entry *dbc_ctp;
  2274. int key_alloc, ret;
  2276. ACTIVATE_CTP(dbc_ctp, dbccl_id, CT_CURSOR);
  2277. dbc = (DBC *)dbc_ctp->ct_anyp;
  2278. dbenv = dbc->dbp->dbenv;
  2280. *freep = 0;
  2281. memset(&skey, 0, sizeof(skey));
  2282. memset(&pkey, 0, sizeof(pkey));
  2283. memset(&data, 0, sizeof(data));
  2285. /*
  2286.  * Ignore memory related flags on server.
  2287.  */
  2288. /* Set up key and data DBT */
  2289. skey.flags = DB_DBT_MALLOC;
  2290. skey.dlen = skeydlen;
  2291. skey.ulen = skeyulen;
  2292. skey.doff = skeydoff;
  2293. if (skeyflags & DB_DBT_PARTIAL)
  2294. skey.flags |= DB_DBT_PARTIAL;
  2295. skey.size = skeysize;
  2296. skey.data = skeydata;
  2298. pkey.flags = DB_DBT_MALLOC;
  2299. pkey.dlen = pkeydlen;
  2300. pkey.ulen = pkeyulen;
  2301. pkey.doff = pkeydoff;
  2302. if (pkeyflags & DB_DBT_PARTIAL)
  2303. pkey.flags |= DB_DBT_PARTIAL;
  2304. pkey.size = pkeysize;
  2305. pkey.data = pkeydata;
  2307. data.flags = DB_DBT_MALLOC;
  2308. data.dlen = datadlen;
  2309. data.ulen = dataulen;
  2310. data.doff = datadoff;
  2311. if (dataflags & DB_DBT_PARTIAL)
  2312. data.flags |= DB_DBT_PARTIAL;
  2313. data.size = datasize;
  2314. data.data = datadata;
  2316. /* Got all our stuff, now do the get */
  2317. ret = dbc->c_pget(dbc, &skey, &pkey, &data, flags);
  2318. /*
  2319.  * Otherwise just status.
  2320.  */
  2321. if (ret == 0) {
  2322. /*
  2323.  * XXX
  2324.  * We need to xdr_free whatever we are returning, next time.
  2325.  * However, DB does not allocate a new key if one was given
  2326.  * and we'd be free'ing up space allocated in the request.
  2327.  * So, allocate a new key/data pointer if it is the same one
  2328.  * as in the request.
  2329.  */
  2330. *freep = 1;
  2331. /*
  2332.  * Key
  2333.  */
  2334. key_alloc = 0;
  2335. if (skey.data == skeydata) {
  2336. ret = __os_umalloc(dbenv,
  2337.     skey.size, &replyp->skeydata.skeydata_val);
  2338. if (ret != 0) {
  2339. __os_ufree(dbenv, skey.data);
  2340. __os_ufree(dbenv, pkey.data);
  2341. __os_ufree(dbenv, data.data);
  2342. goto err;
  2343. }
  2344. key_alloc = 1;
  2345. memcpy(replyp->skeydata.skeydata_val, skey.data,
  2346.     skey.size);
  2347. } else
  2348. replyp->skeydata.skeydata_val = skey.data;
  2349. replyp->skeydata.skeydata_len = skey.size;
  2351. /*
  2352.  * Primary key
  2353.  */
  2354. if (pkey.data == pkeydata) {
  2355. ret = __os_umalloc(dbenv,
  2356.      pkey.size, &replyp->pkeydata.pkeydata_val);
  2357. if (ret != 0) {
  2358. __os_ufree(dbenv, skey.data);
  2359. __os_ufree(dbenv, pkey.data);
  2360. __os_ufree(dbenv, data.data);
  2361. if (key_alloc)
  2362. __os_ufree(dbenv,
  2363.     replyp->skeydata.skeydata_val);
  2364. goto err;
  2365. }
  2366. /*
  2367.  * We can set it to 2, because they cannot send the
  2368.  * pkey over without sending the skey over too.
  2369.  * So if they did send a pkey, they must have sent
  2370.  * the skey as well.
  2371.  */
  2372. key_alloc = 2;
  2373. memcpy(replyp->pkeydata.pkeydata_val, pkey.data,
  2374.     pkey.size);
  2375. } else
  2376. replyp->pkeydata.pkeydata_val = pkey.data;
  2377. replyp->pkeydata.pkeydata_len = pkey.size;
  2379. /*
  2380.  * Data
  2381.  */
  2382. if (data.data == datadata) {
  2383. ret = __os_umalloc(dbenv,
  2384.      data.size, &replyp->datadata.datadata_val);
  2385. if (ret != 0) {
  2386. __os_ufree(dbenv, skey.data);
  2387. __os_ufree(dbenv, pkey.data);
  2388. __os_ufree(dbenv, data.data);
  2389. /*
  2390.  * If key_alloc is 1, just skey needs to be
  2391.  * freed, if key_alloc is 2, both skey and pkey
  2392.  * need to be freed.
  2393.  */
  2394. if (key_alloc--)
  2395. __os_ufree(dbenv,
  2396.     replyp->skeydata.skeydata_val);
  2397. if (key_alloc)
  2398. __os_ufree(dbenv,
  2399.     replyp->pkeydata.pkeydata_val);
  2400. goto err;
  2401. }
  2402. memcpy(replyp->datadata.datadata_val, data.data,
  2403.     data.size);
  2404. } else
  2405. replyp->datadata.datadata_val = data.data;
  2406. replyp->datadata.datadata_len = data.size;
  2407. } else {
  2408. err: replyp->skeydata.skeydata_val = NULL;
  2409. replyp->skeydata.skeydata_len = 0;
  2410. replyp->pkeydata.pkeydata_val = NULL;
  2411. replyp->pkeydata.pkeydata_len = 0;
  2412. replyp->datadata.datadata_val = NULL;
  2413. replyp->datadata.datadata_len = 0;
  2414. *freep = 0;
  2415. }
  2416. replyp->status = ret;
  2417. return;
  2418. }
  2420. /* BEGIN __dbc_put_proc */
  2421. /*
  2422.  * PUBLIC: void __dbc_put_proc __P((long, u_int32_t, u_int32_t, u_int32_t,
  2423.  * PUBLIC:      u_int32_t, void *, u_int32_t, u_int32_t, u_int32_t, u_int32_t, u_int32_t, void *,
  2424.  * PUBLIC:      u_int32_t, u_int32_t, __dbc_put_reply *, int *));
  2425.  */
  2426. void
  2427. __dbc_put_proc(dbccl_id, keydlen, keydoff,
  2428. keyulen, keyflags, keydata, keysize,
  2429. datadlen, datadoff, dataulen, dataflags,
  2430. datadata, datasize, flags, replyp, freep)
  2431. long dbccl_id;
  2432. u_int32_t keydlen;
  2433. u_int32_t keydoff;
  2434. u_int32_t keyulen;
  2435. u_int32_t keyflags;
  2436. void *keydata;
  2437. u_int32_t keysize;
  2438. u_int32_t datadlen;
  2439. u_int32_t datadoff;
  2440. u_int32_t dataulen;
  2441. u_int32_t dataflags;
  2442. void *datadata;
  2443. u_int32_t datasize;
  2444. u_int32_t flags;
  2445. __dbc_put_reply *replyp;
  2446. int * freep;
  2447. /* END __dbc_put_proc */
  2448. {
  2449. DB *dbp;
  2450. DBC *dbc;
  2451. DBT key, data;
  2452. ct_entry *dbc_ctp;
  2453. int ret;
  2455. ACTIVATE_CTP(dbc_ctp, dbccl_id, CT_CURSOR);
  2456. dbc = (DBC *)dbc_ctp->ct_anyp;
  2457. dbp = (DB *)dbc_ctp->ct_parent->ct_anyp;
  2459. memset(&key, 0, sizeof(key));
  2460. memset(&data, 0, sizeof(data));
  2462. /* Set up key and data DBT */
  2463. key.dlen = keydlen;
  2464. key.ulen = keyulen;
  2465. key.doff = keydoff;
  2466. /*
  2467.  * Ignore memory related flags on server.
  2468.  */
  2469. key.flags = 0;
  2470. if (keyflags & DB_DBT_PARTIAL)
  2471. key.flags |= DB_DBT_PARTIAL;
  2472. key.size = keysize;
  2473. key.data = keydata;
  2475. data.dlen = datadlen;
  2476. data.ulen = dataulen;
  2477. data.doff = datadoff;
  2478. data.flags = dataflags;
  2479. data.size = datasize;
  2480. data.data = datadata;
  2482. /* Got all our stuff, now do the put */
  2483. ret = dbc->c_put(dbc, &key, &data, flags);
  2485. *freep = 0;
  2486. if (ret == 0 && (flags == DB_AFTER || flags == DB_BEFORE) &&
  2487.     dbp->type == DB_RECNO) {
  2488. /*
  2489.  * We need to xdr_free whatever we are returning, next time.
  2490.  */
  2491. replyp->keydata.keydata_val = key.data;
  2492. replyp->keydata.keydata_len = key.size;
  2493. } else {
  2494. replyp->keydata.keydata_val = NULL;
  2495. replyp->keydata.keydata_len = 0;
  2496. }
  2497. replyp->status = ret;
  2498. return;
  2499. }
  2500. #endif /* HAVE_RPC */