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

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

MySQL数据库

开发平台：

Visual C++

env_method.c：源码内容
  1. /*-
  2.  * See the file LICENSE for redistribution information.
  3.  *
  4.  * Copyright (c) 1999-2002
  5.  * Sleepycat Software.  All rights reserved.
  6.  */
  8. #include "db_config.h"
  10. #ifndef lint
  11. static const char revid[] = "$Id: env_method.c,v 11.87 2002/08/29 14:22:21 margo Exp $";
  12. #endif /* not lint */
  14. #ifndef NO_SYSTEM_INCLUDES
  15. #include <sys/types.h>
  17. #ifdef HAVE_RPC
  18. #include <rpc/rpc.h>
  19. #endif
  21. #include <string.h>
  22. #endif
  24. /*
  25.  * This is the file that initializes the global array.  Do it this way because
  26.  * people keep changing one without changing the other.  Having declaration and
  27.  * initialization in one file will hopefully fix that.
  28.  */
  29. #define DB_INITIALIZE_DB_GLOBALS 1
  31. #include "db_int.h"
  32. #include "dbinc/crypto.h"
  33. #include "dbinc/hmac.h"
  34. #include "dbinc/db_shash.h"
  35. #include "dbinc/db_page.h"
  36. #include "dbinc/db_am.h"
  37. #include "dbinc/lock.h"
  38. #include "dbinc/log.h"
  39. #include "dbinc/mp.h"
  40. #include "dbinc/rep.h"
  41. #include "dbinc/txn.h"
  43. #ifdef HAVE_RPC
  44. #include "dbinc_auto/db_server.h"
  45. #include "dbinc_auto/rpc_client_ext.h"
  46. #endif
  48. static void __dbenv_err __P((const DB_ENV *, int, const char *, ...));
  49. static void __dbenv_errx __P((const DB_ENV *, const char *, ...));
  50. static int  __dbenv_init __P((DB_ENV *));
  51. static int  __dbenv_set_alloc __P((DB_ENV *, void *(*)(size_t),
  52.     void *(*)(void *, size_t), void (*)(void *)));
  53. static int  __dbenv_set_app_dispatch __P((DB_ENV *,
  54.     int (*)(DB_ENV *, DBT *, DB_LSN *, db_recops)));
  55. static int  __dbenv_set_data_dir __P((DB_ENV *, const char *));
  56. static int  __dbenv_set_encrypt __P((DB_ENV *, const char *, u_int32_t));
  57. static void __dbenv_set_errcall __P((DB_ENV *, void (*)(const char *, char *)));
  58. static void __dbenv_set_errfile __P((DB_ENV *, FILE *));
  59. static void __dbenv_set_errpfx __P((DB_ENV *, const char *));
  60. static int  __dbenv_set_feedback __P((DB_ENV *, void (*)(DB_ENV *, int, int)));
  61. static int  __dbenv_set_flags __P((DB_ENV *, u_int32_t, int));
  62. static void __dbenv_set_noticecall __P((DB_ENV *, void (*)(DB_ENV *, db_notices)));
  63. static int  __dbenv_set_paniccall __P((DB_ENV *, void (*)(DB_ENV *, int)));
  64. static int  __dbenv_set_rpc_server_noclnt
  65.     __P((DB_ENV *, void *, const char *, long, long, u_int32_t));
  66. static int  __dbenv_set_shm_key __P((DB_ENV *, long));
  67. static int  __dbenv_set_tas_spins __P((DB_ENV *, u_int32_t));
  68. static int  __dbenv_set_tmp_dir __P((DB_ENV *, const char *));
  69. static int  __dbenv_set_verbose __P((DB_ENV *, u_int32_t, int));
  71. /*
  72.  * db_env_create --
  73.  * DB_ENV constructor.
  74.  *
  75.  * EXTERN: int db_env_create __P((DB_ENV **, u_int32_t));
  76.  */
  77. int
  78. db_env_create(dbenvpp, flags)
  79. DB_ENV **dbenvpp;
  80. u_int32_t flags;
  81. {
  82. DB_ENV *dbenv;
  83. int ret;
  85. /*
  86.  * !!!
  87.  * Our caller has not yet had the opportunity to reset the panic
  88.  * state or turn off mutex locking, and so we can neither check
  89.  * the panic state or acquire a mutex in the DB_ENV create path.
  90.  *
  91.  * !!!
  92.  * We can't call the flags-checking routines, we don't have an
  93.  * environment yet.
  94.  */
  95. if (flags != 0 && flags != DB_CLIENT)
  96. return (EINVAL);
  98. if ((ret = __os_calloc(NULL, 1, sizeof(*dbenv), &dbenv)) != 0)
  99. return (ret);
  101. #ifdef HAVE_RPC
  102. if (LF_ISSET(DB_CLIENT))
  103. F_SET(dbenv, DB_ENV_RPCCLIENT);
  104. #endif
  105. ret = __dbenv_init(dbenv);
  107. if (ret != 0) {
  108. __os_free(NULL, dbenv);
  109. return (ret);
  110. }
  112. *dbenvpp = dbenv;
  113. return (0);
  114. }
  116. /*
  117.  * __dbenv_init --
  118.  * Initialize a DB_ENV structure.
  119.  */
  120. static int
  121. __dbenv_init(dbenv)
  122. DB_ENV *dbenv;
  123. {
  124. /*
  125.  * !!!
  126.  * Our caller has not yet had the opportunity to reset the panic
  127.  * state or turn off mutex locking, and so we can neither check
  128.  * the panic state or acquire a mutex in the DB_ENV create path.
  129.  *
  130.  * Set up methods that are the same in both normal and RPC
  131.  */
  132. dbenv->err = __dbenv_err;
  133. dbenv->errx = __dbenv_errx;
  134. dbenv->set_errcall = __dbenv_set_errcall;
  135. dbenv->set_errfile = __dbenv_set_errfile;
  136. dbenv->set_errpfx = __dbenv_set_errpfx;
  138. #ifdef HAVE_RPC
  139. if (F_ISSET(dbenv, DB_ENV_RPCCLIENT)) {
  140. dbenv->close = __dbcl_env_close;
  141. dbenv->dbremove = __dbcl_env_dbremove;
  142. dbenv->dbrename = __dbcl_env_dbrename;
  143. dbenv->open = __dbcl_env_open_wrap;
  144. dbenv->remove = __dbcl_env_remove;
  145. dbenv->set_alloc = __dbcl_env_alloc;
  146. dbenv->set_app_dispatch = __dbcl_set_app_dispatch;
  147. dbenv->set_data_dir = __dbcl_set_data_dir;
  148. dbenv->set_encrypt = __dbcl_env_encrypt;
  149. dbenv->set_feedback = __dbcl_env_set_feedback;
  150. dbenv->set_flags = __dbcl_env_flags;
  151. dbenv->set_noticecall = __dbcl_env_noticecall;
  152. dbenv->set_paniccall = __dbcl_env_paniccall;
  153. dbenv->set_rpc_server = __dbcl_envrpcserver;
  154. dbenv->set_shm_key = __dbcl_set_shm_key;
  155. dbenv->set_tas_spins = __dbcl_set_tas_spins;
  156. dbenv->set_timeout = __dbcl_set_timeout;
  157. dbenv->set_tmp_dir = __dbcl_set_tmp_dir;
  158. dbenv->set_verbose = __dbcl_set_verbose;
  159. } else {
  160. #endif
  161. dbenv->close = __dbenv_close;
  162. dbenv->dbremove = __dbenv_dbremove;
  163. dbenv->dbrename = __dbenv_dbrename;
  164. dbenv->open = __dbenv_open;
  165. dbenv->remove = __dbenv_remove;
  166. dbenv->set_alloc = __dbenv_set_alloc;
  167. dbenv->set_app_dispatch = __dbenv_set_app_dispatch;
  168. dbenv->set_data_dir = __dbenv_set_data_dir;
  169. dbenv->set_encrypt = __dbenv_set_encrypt;
  170. dbenv->set_feedback = __dbenv_set_feedback;
  171. dbenv->set_flags = __dbenv_set_flags;
  172. dbenv->set_noticecall = __dbenv_set_noticecall;
  173. dbenv->set_paniccall = __dbenv_set_paniccall;
  174. dbenv->set_rpc_server = __dbenv_set_rpc_server_noclnt;
  175. dbenv->set_shm_key = __dbenv_set_shm_key;
  176. dbenv->set_tas_spins = __dbenv_set_tas_spins;
  177. dbenv->set_tmp_dir = __dbenv_set_tmp_dir;
  178. dbenv->set_verbose = __dbenv_set_verbose;
  179. #ifdef HAVE_RPC
  180. }
  181. #endif
  182. dbenv->shm_key = INVALID_REGION_SEGID;
  183. dbenv->db_ref = 0;
  185. __log_dbenv_create(dbenv); /* Subsystem specific. */
  186. __lock_dbenv_create(dbenv);
  187. __memp_dbenv_create(dbenv);
  188. __rep_dbenv_create(dbenv);
  189. __txn_dbenv_create(dbenv);
  191. return (0);
  192. }
  194. /*
  195.  * __dbenv_err --
  196.  * Error message, including the standard error string.
  197.  */
  198. static void
  199. #ifdef __STDC__
  200. __dbenv_err(const DB_ENV *dbenv, int error, const char *fmt, ...)
  201. #else
  202. __dbenv_err(dbenv, error, fmt, va_alist)
  203. const DB_ENV *dbenv;
  204. int error;
  205. const char *fmt;
  206. va_dcl
  207. #endif
  208. {
  209. DB_REAL_ERR(dbenv, error, 1, 1, fmt);
  210. }
  212. /*
  213.  * __dbenv_errx --
  214.  * Error message.
  215.  */
  216. static void
  217. #ifdef __STDC__
  218. __dbenv_errx(const DB_ENV *dbenv, const char *fmt, ...)
  219. #else
  220. __dbenv_errx(dbenv, fmt, va_alist)
  221. const DB_ENV *dbenv;
  222. const char *fmt;
  223. va_dcl
  224. #endif
  225. {
  226. DB_REAL_ERR(dbenv, 0, 0, 1, fmt);
  227. }
  229. static int
  230. __dbenv_set_alloc(dbenv, mal_func, real_func, free_func)
  231. DB_ENV *dbenv;
  232. void *(*mal_func) __P((size_t));
  233. void *(*real_func) __P((void *, size_t));
  234. void (*free_func) __P((void *));
  235. {
  236. ENV_ILLEGAL_AFTER_OPEN(dbenv, "set_alloc");
  238. dbenv->db_malloc = mal_func;
  239. dbenv->db_realloc = real_func;
  240. dbenv->db_free = free_func;
  241. return (0);
  242. }
  244. /*
  245.  * __dbenv_set_app_dispatch --
  246.  * Set the transaction abort recover function.
  247.  */
  248. static int
  249. __dbenv_set_app_dispatch(dbenv, app_dispatch)
  250. DB_ENV *dbenv;
  251. int (*app_dispatch) __P((DB_ENV *, DBT *, DB_LSN *, db_recops));
  252. {
  253. ENV_ILLEGAL_AFTER_OPEN(dbenv, "set_app_dispatch");
  255. dbenv->app_dispatch = app_dispatch;
  256. return (0);
  257. }
  259. static int
  260. __dbenv_set_encrypt(dbenv, passwd, flags)
  261. DB_ENV *dbenv;
  262. const char *passwd;
  263. u_int32_t flags;
  264. {
  265. #ifdef HAVE_CRYPTO
  266. DB_CIPHER *db_cipher;
  267. int ret;
  269. ENV_ILLEGAL_AFTER_OPEN(dbenv, "set_encrypt");
  270. #define OK_CRYPTO_FLAGS (DB_ENCRYPT_AES)
  272. if (flags != 0 && LF_ISSET(~OK_CRYPTO_FLAGS))
  273. return (__db_ferr(dbenv, "DB_ENV->set_encrypt", 0));
  275. if (passwd == NULL || strlen(passwd) == 0) {
  276. __db_err(dbenv, "Empty password specified to set_encrypt");
  277. return (EINVAL);
  278. }
  279. if (!CRYPTO_ON(dbenv)) {
  280. if ((ret = __os_calloc(dbenv, 1, sizeof(DB_CIPHER), &db_cipher))
  281.     != 0)
  282. goto err;
  283. dbenv->crypto_handle = db_cipher;
  284. } else
  285. db_cipher = (DB_CIPHER *)dbenv->crypto_handle;
  287. if (dbenv->passwd != NULL)
  288. __os_free(dbenv, dbenv->passwd);
  289. if ((ret = __os_strdup(dbenv, passwd, &dbenv->passwd)) != 0) {
  290. __os_free(dbenv, db_cipher);
  291. goto err;
  292. }
  293. /*
  294.  * We're going to need this often enough to keep around
  295.  */
  296. dbenv->passwd_len = strlen(dbenv->passwd) + 1;
  297. /*
  298.  * The MAC key is for checksumming, and is separate from
  299.  * the algorithm.  So initialize it here, even if they
  300.  * are using CIPHER_ANY.
  301.  */
  302. __db_derive_mac((u_int8_t *)dbenv->passwd,
  303.     dbenv->passwd_len, db_cipher->mac_key);
  304. switch (flags) {
  305. case 0:
  306. F_SET(db_cipher, CIPHER_ANY);
  307. break;
  308. case DB_ENCRYPT_AES:
  309. if ((ret = __crypto_algsetup(dbenv, db_cipher, CIPHER_AES, 0))
  310.     != 0)
  311. goto err1;
  312. break;
  313. }
  314. return (0);
  316. err1:
  317. __os_free(dbenv, dbenv->passwd);
  318. __os_free(dbenv, db_cipher);
  319. dbenv->crypto_handle = NULL;
  320. err:
  321. return (ret);
  322. #else
  323. COMPQUIET(dbenv, NULL);
  324. COMPQUIET(passwd, NULL);
  325. COMPQUIET(flags, 0);
  327. return (__db_eopnotsup(dbenv));
  328. #endif
  329. }
  331. static int
  332. __dbenv_set_flags(dbenv, flags, onoff)
  333. DB_ENV *dbenv;
  334. u_int32_t flags;
  335. int onoff;
  336. {
  337. #define OK_FLAGS
  338. (DB_AUTO_COMMIT | DB_CDB_ALLDB | DB_DIRECT_DB | DB_DIRECT_LOG |
  339.     DB_NOLOCKING | DB_NOMMAP | DB_NOPANIC | DB_OVERWRITE |
  340.     DB_PANIC_ENVIRONMENT | DB_REGION_INIT | DB_TXN_NOSYNC |
  341.     DB_TXN_WRITE_NOSYNC | DB_YIELDCPU)
  343. if (LF_ISSET(~OK_FLAGS))
  344. return (__db_ferr(dbenv, "DB_ENV->set_flags", 0));
  345. if (onoff && LF_ISSET(DB_TXN_WRITE_NOSYNC) && LF_ISSET(DB_TXN_NOSYNC))
  346. return (__db_ferr(dbenv, "DB_ENV->set_flags", 1));
  348. if (LF_ISSET(DB_AUTO_COMMIT)) {
  349. if (onoff)
  350. F_SET(dbenv, DB_ENV_AUTO_COMMIT);
  351. else
  352. F_CLR(dbenv, DB_ENV_AUTO_COMMIT);
  353. }
  354. if (LF_ISSET(DB_CDB_ALLDB)) {
  355. ENV_ILLEGAL_AFTER_OPEN(dbenv, "set_flags: DB_CDB_ALLDB");
  356. if (onoff)
  357. F_SET(dbenv, DB_ENV_CDB_ALLDB);
  358. else
  359. F_CLR(dbenv, DB_ENV_CDB_ALLDB);
  360. }
  361. if (LF_ISSET(DB_DIRECT_DB)) {
  362. if (onoff)
  363. F_SET(dbenv, DB_ENV_DIRECT_DB);
  364. else
  365. F_CLR(dbenv, DB_ENV_DIRECT_DB);
  366. }
  367. if (LF_ISSET(DB_DIRECT_LOG)) {
  368. if (onoff)
  369. F_SET(dbenv, DB_ENV_DIRECT_LOG);
  370. else
  371. F_CLR(dbenv, DB_ENV_DIRECT_LOG);
  372. }
  373. if (LF_ISSET(DB_NOLOCKING)) {
  374. if (onoff)
  375. F_SET(dbenv, DB_ENV_NOLOCKING);
  376. else
  377. F_CLR(dbenv, DB_ENV_NOLOCKING);
  378. }
  379. if (LF_ISSET(DB_NOMMAP)) {
  380. if (onoff)
  381. F_SET(dbenv, DB_ENV_NOMMAP);
  382. else
  383. F_CLR(dbenv, DB_ENV_NOMMAP);
  384. }
  385. if (LF_ISSET(DB_NOPANIC)) {
  386. if (onoff)
  387. F_SET(dbenv, DB_ENV_NOPANIC);
  388. else
  389. F_CLR(dbenv, DB_ENV_NOPANIC);
  390. }
  391. if (LF_ISSET(DB_OVERWRITE)) {
  392. if (onoff)
  393. F_SET(dbenv, DB_ENV_OVERWRITE);
  394. else
  395. F_CLR(dbenv, DB_ENV_OVERWRITE);
  396. }
  397. if (LF_ISSET(DB_PANIC_ENVIRONMENT)) {
  398. ENV_ILLEGAL_BEFORE_OPEN(dbenv,
  399.     "set_flags: DB_PANIC_ENVIRONMENT");
  400. PANIC_SET(dbenv, onoff);
  401. }
  402. if (LF_ISSET(DB_REGION_INIT)) {
  403. ENV_ILLEGAL_AFTER_OPEN(dbenv, "set_flags: DB_REGION_INIT");
  404. if (onoff)
  405. F_SET(dbenv, DB_ENV_REGION_INIT);
  406. else
  407. F_CLR(dbenv, DB_ENV_REGION_INIT);
  408. }
  409. if (LF_ISSET(DB_TXN_NOSYNC)) {
  410. if (onoff)
  411. F_SET(dbenv, DB_ENV_TXN_NOSYNC);
  412. else
  413. F_CLR(dbenv, DB_ENV_TXN_NOSYNC);
  414. }
  415. if (LF_ISSET(DB_TXN_WRITE_NOSYNC)) {
  416. if (onoff)
  417. F_SET(dbenv, DB_ENV_TXN_WRITE_NOSYNC);
  418. else
  419. F_CLR(dbenv, DB_ENV_TXN_WRITE_NOSYNC);
  420. }
  421. if (LF_ISSET(DB_YIELDCPU)) {
  422. if (onoff)
  423. F_SET(dbenv, DB_ENV_YIELDCPU);
  424. else
  425. F_CLR(dbenv, DB_ENV_YIELDCPU);
  426. }
  427. return (0);
  428. }
  430. static int
  431. __dbenv_set_data_dir(dbenv, dir)
  432. DB_ENV *dbenv;
  433. const char *dir;
  434. {
  435. int ret;
  437. #define DATA_INIT_CNT 20 /* Start with 20 data slots. */
  438. if (dbenv->db_data_dir == NULL) {
  439. if ((ret = __os_calloc(dbenv, DATA_INIT_CNT,
  440.     sizeof(char **), &dbenv->db_data_dir)) != 0)
  441. return (ret);
  442. dbenv->data_cnt = DATA_INIT_CNT;
  443. } else if (dbenv->data_next == dbenv->data_cnt - 1) {
  444. dbenv->data_cnt *= 2;
  445. if ((ret = __os_realloc(dbenv,
  446.     dbenv->data_cnt * sizeof(char **),
  447.     &dbenv->db_data_dir)) != 0)
  448. return (ret);
  449. }
  450. return (__os_strdup(dbenv,
  451.     dir, &dbenv->db_data_dir[dbenv->data_next++]));
  452. }
  454. static void
  455. __dbenv_set_errcall(dbenv, errcall)
  456. DB_ENV *dbenv;
  457. void (*errcall) __P((const char *, char *));
  458. {
  459. dbenv->db_errcall = errcall;
  460. }
  462. static void
  463. __dbenv_set_errfile(dbenv, errfile)
  464. DB_ENV *dbenv;
  465. FILE *errfile;
  466. {
  467. dbenv->db_errfile = errfile;
  468. }
  470. static void
  471. __dbenv_set_errpfx(dbenv, errpfx)
  472. DB_ENV *dbenv;
  473. const char *errpfx;
  474. {
  475. dbenv->db_errpfx = errpfx;
  476. }
  478. static int
  479. __dbenv_set_feedback(dbenv, feedback)
  480. DB_ENV *dbenv;
  481. void (*feedback) __P((DB_ENV *, int, int));
  482. {
  483. dbenv->db_feedback = feedback;
  484. return (0);
  485. }
  487. static void
  488. __dbenv_set_noticecall(dbenv, noticecall)
  489. DB_ENV *dbenv;
  490. void (*noticecall) __P((DB_ENV *, db_notices));
  491. {
  492. dbenv->db_noticecall = noticecall;
  493. }
  495. static int
  496. __dbenv_set_paniccall(dbenv, paniccall)
  497. DB_ENV *dbenv;
  498. void (*paniccall) __P((DB_ENV *, int));
  499. {
  500. dbenv->db_paniccall = paniccall;
  501. return (0);
  502. }
  504. static int
  505. __dbenv_set_shm_key(dbenv, shm_key)
  506. DB_ENV *dbenv;
  507. long shm_key; /* !!!: really a key_t. */
  508. {
  509. ENV_ILLEGAL_AFTER_OPEN(dbenv, "set_shm_key");
  511. dbenv->shm_key = shm_key;
  512. return (0);
  513. }
  515. static int
  516. __dbenv_set_tas_spins(dbenv, tas_spins)
  517. DB_ENV *dbenv;
  518. u_int32_t tas_spins;
  519. {
  520. dbenv->tas_spins = tas_spins;
  521. return (0);
  522. }
  524. static int
  525. __dbenv_set_tmp_dir(dbenv, dir)
  526. DB_ENV *dbenv;
  527. const char *dir;
  528. {
  529. if (dbenv->db_tmp_dir != NULL)
  530. __os_free(dbenv, dbenv->db_tmp_dir);
  531. return (__os_strdup(dbenv, dir, &dbenv->db_tmp_dir));
  532. }
  534. static int
  535. __dbenv_set_verbose(dbenv, which, onoff)
  536. DB_ENV *dbenv;
  537. u_int32_t which;
  538. int onoff;
  539. {
  540. switch (which) {
  541. case DB_VERB_CHKPOINT:
  542. case DB_VERB_DEADLOCK:
  543. case DB_VERB_RECOVERY:
  544. case DB_VERB_REPLICATION:
  545. case DB_VERB_WAITSFOR:
  546. if (onoff)
  547. FLD_SET(dbenv->verbose, which);
  548. else
  549. FLD_CLR(dbenv->verbose, which);
  550. break;
  551. default:
  552. return (EINVAL);
  553. }
  554. return (0);
  555. }
  557. /*
  558.  * __db_mi_env --
  559.  * Method illegally called with public environment.
  560.  *
  561.  * PUBLIC: int __db_mi_env __P((DB_ENV *, const char *));
  562.  */
  563. int
  564. __db_mi_env(dbenv, name)
  565. DB_ENV *dbenv;
  566. const char *name;
  567. {
  568. __db_err(dbenv, "%s: method not permitted in shared environment", name);
  569. return (EINVAL);
  570. }
  572. /*
  573.  * __db_mi_open --
  574.  * Method illegally called after open.
  575.  *
  576.  * PUBLIC: int __db_mi_open __P((DB_ENV *, const char *, int));
  577.  */
  578. int
  579. __db_mi_open(dbenv, name, after)
  580. DB_ENV *dbenv;
  581. const char *name;
  582. int after;
  583. {
  584. __db_err(dbenv, "%s: method not permitted %s open",
  585.     name, after ? "after" : "before");
  586. return (EINVAL);
  587. }
  589. /*
  590.  * __db_env_config --
  591.  * Method or function called without required configuration.
  592.  *
  593.  * PUBLIC: int __db_env_config __P((DB_ENV *, char *, u_int32_t));
  594.  */
  595. int
  596. __db_env_config(dbenv, i, flags)
  597. DB_ENV *dbenv;
  598. char *i;
  599. u_int32_t flags;
  600. {
  601. char *sub;
  603. switch (flags) {
  604. case DB_INIT_LOCK:
  605. sub = "locking";
  606. break;
  607. case DB_INIT_LOG:
  608. sub = "logging";
  609. break;
  610. case DB_INIT_MPOOL:
  611. sub = "memory pool";
  612. break;
  613. case DB_INIT_TXN:
  614. sub = "transaction";
  615. break;
  616. default:
  617. sub = "<unspecified>";
  618. break;
  619. }
  620. __db_err(dbenv,
  621.     "%s interface requires an environment configured for the %s subsystem",
  622.     i, sub);
  623. return (EINVAL);
  624. }
  626. static int
  627. __dbenv_set_rpc_server_noclnt(dbenv, cl, host, tsec, ssec, flags)
  628. DB_ENV *dbenv;
  629. void *cl;
  630. const char *host;
  631. long tsec, ssec;
  632. u_int32_t flags;
  633. {
  634. COMPQUIET(host, NULL);
  635. COMPQUIET(cl, NULL);
  636. COMPQUIET(tsec, 0);
  637. COMPQUIET(ssec, 0);
  638. COMPQUIET(flags, 0);
  640. __db_err(dbenv,
  641.     "set_rpc_server method not permitted in non-RPC environment");
  642. return (__db_eopnotsup(dbenv));
  643. }