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

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

MySQL数据库

开发平台：

Visual C++

env_open.c：源码内容
  1. /*-
  2.  * See the file LICENSE for redistribution information.
  3.  *
  4.  * Copyright (c) 1996, 1997, 1998, 1999, 2000
  5.  * Sleepycat Software.  All rights reserved.
  6.  */
  8. #include "db_config.h"
  10. #ifndef lint
  11. static const char revid[] = "$Id: env_open.c,v 11.34 2000/12/21 19:20:00 bostic Exp $";
  12. #endif /* not lint */
  14. #ifndef NO_SYSTEM_INCLUDES
  15. #include <sys/types.h>
  17. #include <ctype.h>
  18. #include <stdlib.h>
  19. #include <string.h>
  20. #include <unistd.h>
  21. #endif
  23. #include "db_int.h"
  24. #include "db_page.h"
  25. #include "db_shash.h"
  26. #include "btree.h"
  27. #include "hash.h"
  28. #include "qam.h"
  29. #include "lock.h"
  30. #include "log.h"
  31. #include "mp.h"
  32. #include "txn.h"
  33. #include "clib_ext.h"
  35. static int __dbenv_config __P((DB_ENV *, const char *, u_int32_t));
  36. static int __dbenv_refresh __P((DB_ENV *));
  37. static int __db_home __P((DB_ENV *, const char *, u_int32_t));
  38. static int __db_parse __P((DB_ENV *, char *));
  39. static int __db_tmp_open __P((DB_ENV *, u_int32_t, char *, DB_FH *));
  41. /*
  42.  * db_version --
  43.  * Return version information.
  44.  */
  45. char *
  46. db_version(majverp, minverp, patchp)
  47. int *majverp, *minverp, *patchp;
  48. {
  49. if (majverp != NULL)
  50. *majverp = DB_VERSION_MAJOR;
  51. if (minverp != NULL)
  52. *minverp = DB_VERSION_MINOR;
  53. if (patchp != NULL)
  54. *patchp = DB_VERSION_PATCH;
  55. return ((char *)DB_VERSION_STRING);
  56. }
  58. /*
  59.  * __dbenv_open --
  60.  * Initialize an environment.
  61.  *
  62.  * PUBLIC: int __dbenv_open __P((DB_ENV *, const char *, u_int32_t, int));
  63.  */
  64. int
  65. __dbenv_open(dbenv, db_home, flags, mode)
  66. DB_ENV *dbenv;
  67. const char *db_home;
  68. u_int32_t flags;
  69. int mode;
  70. {
  71. DB_ENV *rm_dbenv;
  72. int ret;
  73. u_int32_t init_flags;
  75. #undef OKFLAGS
  76. #define OKFLAGS
  77. DB_CREATE | DB_INIT_CDB | DB_INIT_LOCK | DB_INIT_LOG |
  78. DB_INIT_MPOOL | DB_INIT_TXN | DB_JOINENV | DB_LOCKDOWN |
  79. DB_PRIVATE | DB_RECOVER | DB_RECOVER_FATAL | DB_SYSTEM_MEM |
  80. DB_THREAD | DB_USE_ENVIRON | DB_USE_ENVIRON_ROOT
  81. #undef OKFLAGS_CDB
  82. #define OKFLAGS_CDB
  83. DB_CREATE | DB_INIT_CDB | DB_INIT_MPOOL | DB_LOCKDOWN |
  84. DB_PRIVATE | DB_SYSTEM_MEM | DB_THREAD |
  85. DB_USE_ENVIRON | DB_USE_ENVIRON_ROOT
  87. /*
  88.  * Flags saved in the init_flags field of the environment, representing
  89.  * flags to DBENV->set_flags and DBENV->open that need to be set.
  90.  */
  91. #define DB_INITENV_CDB 0x0001 /* DB_INIT_CDB */
  92. #define DB_INITENV_CDB_ALLDB 0x0002 /* DB_INIT_CDB_ALLDB */
  93. #define DB_INITENV_LOCK 0x0004 /* DB_INIT_LOCK */
  94. #define DB_INITENV_LOG 0x0008 /* DB_INIT_LOG */
  95. #define DB_INITENV_MPOOL 0x0010 /* DB_INIT_MPOOL */
  96. #define DB_INITENV_TXN 0x0020 /* DB_INIT_TXN */
  98. if ((ret = __db_fchk(dbenv, "DBENV->open", flags, OKFLAGS)) != 0)
  99. return (ret);
  100. if (LF_ISSET(DB_INIT_CDB) &&
  101.     (ret = __db_fchk(dbenv, "DBENV->open", flags, OKFLAGS_CDB)) != 0)
  102. return (ret);
  103. if ((ret = __db_fcchk(dbenv,
  104.     "DBENV->open", flags, DB_PRIVATE, DB_SYSTEM_MEM)) != 0)
  105. return (ret);
  106. if ((ret = __db_fcchk(dbenv, "DBENV->open", flags, DB_JOINENV,
  107.     DB_CREATE | DB_INIT_LOCK | DB_INIT_LOG | DB_INIT_MPOOL |
  108.     DB_INIT_TXN | DB_PRIVATE)) != 0)
  109. return (ret);
  111. /*
  112.  * If we're doing recovery, destroy the environment so that we create
  113.  * all the regions from scratch.  I'd like to reuse already created
  114.  * regions, but that's hard.  We would have to create the environment
  115.  * region from scratch, at least, as we have no way of knowing if its
  116.  * linked lists are corrupted.
  117.  *
  118.  * I suppose we could set flags while modifying those links, but that
  119.  * is going to be difficult to get right.  The major concern I have
  120.  * is if the application stomps the environment with a rogue pointer.
  121.  * We have no way of detecting that, and we could be forced into a
  122.  * situation where we start up and then crash, repeatedly.
  123.  *
  124.  * Note that we do not check any flags like DB_PRIVATE before calling
  125.  * remove.  We don't care if the current environment was private or
  126.  * not, we just want to nail any files that are left-over for whatever
  127.  * reason, from whatever session.
  128.  */
  129. if (LF_ISSET(DB_RECOVER | DB_RECOVER_FATAL)) {
  130. if ((ret = db_env_create(&rm_dbenv, 0)) != 0)
  131. return (ret);
  132. if ((ret = dbenv->remove(rm_dbenv, db_home, DB_FORCE)) != 0)
  133. return (ret);
  134. }
  136. /* Initialize the DB_ENV structure. */
  137. if ((ret = __dbenv_config(dbenv, db_home, flags)) != 0)
  138. goto err;
  140. /* Convert the DBENV->open flags to internal flags. */
  141. if (LF_ISSET(DB_CREATE))
  142. F_SET(dbenv, DB_ENV_CREATE);
  143. if (LF_ISSET(DB_LOCKDOWN))
  144. F_SET(dbenv, DB_ENV_LOCKDOWN);
  145. if (LF_ISSET(DB_PRIVATE))
  146. F_SET(dbenv, DB_ENV_PRIVATE);
  147. if (LF_ISSET(DB_SYSTEM_MEM))
  148. F_SET(dbenv, DB_ENV_SYSTEM_MEM);
  149. if (LF_ISSET(DB_THREAD))
  150. F_SET(dbenv, DB_ENV_THREAD);
  152. /* Default permissions are read-write for both owner and group. */
  153. dbenv->db_mode = mode == 0 ? __db_omode("rwrw--") : mode;
  155. /*
  156.  * Create/join the environment.  We pass in the flags that
  157.  * will be of interest to an environment joining later;  if
  158.  * we're not the ones to do the create, we
  159.  * pull out whatever has been stored, if we don't do a create.
  160.  */
  161. init_flags = 0;
  162. init_flags |= (LF_ISSET(DB_INIT_CDB) ? DB_INITENV_CDB : 0);
  163. init_flags |= (LF_ISSET(DB_INIT_LOCK) ? DB_INITENV_LOCK : 0);
  164. init_flags |= (LF_ISSET(DB_INIT_LOG) ? DB_INITENV_LOG : 0);
  165. init_flags |= (LF_ISSET(DB_INIT_MPOOL) ? DB_INITENV_MPOOL : 0);
  166. init_flags |= (LF_ISSET(DB_INIT_TXN) ? DB_INITENV_TXN : 0);
  167. init_flags |=
  168.     (F_ISSET(dbenv, DB_ENV_CDB_ALLDB) ? DB_INITENV_CDB_ALLDB : 0);
  170. if ((ret = __db_e_attach(dbenv, &init_flags)) != 0)
  171. goto err;
  173. /*
  174.  * __db_e_attach will return the saved init_flags field, which
  175.  * contains the DB_INIT_* flags used when we were created.
  176.  */
  177. if (LF_ISSET(DB_JOINENV)) {
  178. LF_CLR(DB_JOINENV);
  180. LF_SET((init_flags & DB_INITENV_CDB) ? DB_INIT_CDB : 0);
  181. LF_SET((init_flags & DB_INITENV_LOCK) ? DB_INIT_LOCK : 0);
  182. LF_SET((init_flags & DB_INITENV_LOG) ? DB_INIT_LOG : 0);
  183. LF_SET((init_flags & DB_INITENV_MPOOL) ? DB_INIT_MPOOL : 0);
  184. LF_SET((init_flags & DB_INITENV_TXN) ? DB_INIT_TXN : 0);
  186. if (LF_ISSET(DB_INITENV_CDB_ALLDB) &&
  187.     (ret = dbenv->set_flags(dbenv, DB_CDB_ALLDB, 1)) != 0)
  188. goto err;
  189. }
  191. /* Initialize for CDB product. */
  192. if (LF_ISSET(DB_INIT_CDB)) {
  193. LF_SET(DB_INIT_LOCK);
  194. F_SET(dbenv, DB_ENV_CDB);
  195. }
  197. /* Initialize the DB list, and its mutex if appropriate. */
  198. LIST_INIT(&dbenv->dblist);
  199. if (F_ISSET(dbenv, DB_ENV_THREAD)) {
  200. if ((ret = __db_mutex_alloc(dbenv,
  201.     dbenv->reginfo, (MUTEX **)&dbenv->dblist_mutexp)) != 0)
  202. return (ret);
  203. if ((ret = __db_mutex_init(dbenv,
  204.     dbenv->dblist_mutexp, 0, MUTEX_THREAD)) != 0) {
  205. __db_mutex_free(dbenv, dbenv->reginfo,
  206.     dbenv->dblist_mutexp);
  207. return (ret);
  208. }
  209. }
  211. /*
  212.  * Initialize the subsystems.  Transactions imply logging but do not
  213.  * imply locking.  While almost all applications want both locking
  214.  * and logging, it would not be unreasonable for a single threaded
  215.  * process to want transactions for atomicity guarantees, but not
  216.  * necessarily need concurrency.
  217.  */
  218. if (LF_ISSET(DB_INIT_MPOOL))
  219. if ((ret = __memp_open(dbenv)) != 0)
  220. goto err;
  221. if (LF_ISSET(DB_INIT_LOG | DB_INIT_TXN))
  222. if ((ret = __log_open(dbenv)) != 0)
  223. goto err;
  224. if (LF_ISSET(DB_INIT_LOCK))
  225. if ((ret = __lock_open(dbenv)) != 0)
  226. goto err;
  227. if (LF_ISSET(DB_INIT_TXN)) {
  228. if ((ret = __txn_open(dbenv)) != 0)
  229. goto err;
  231. /*
  232.  * If the application is running with transactions, initialize
  233.  * the function tables.
  234.  */
  235. if ((ret = __bam_init_recover(dbenv)) != 0)
  236. goto err;
  237. if ((ret = __crdel_init_recover(dbenv)) != 0)
  238. goto err;
  239. if ((ret = __db_init_recover(dbenv)) != 0)
  240. goto err;
  241. if ((ret = __ham_init_recover(dbenv)) != 0)
  242. goto err;
  243. if ((ret = __log_init_recover(dbenv)) != 0)
  244. goto err;
  245. if ((ret = __qam_init_recover(dbenv)) != 0)
  246. goto err;
  247. if ((ret = __txn_init_recover(dbenv)) != 0)
  248. goto err;
  250. /*
  251.  * If the application specified their own recovery
  252.  * initialization function, call it.
  253.  */
  254. if (dbenv->db_recovery_init != NULL &&
  255.     (ret = dbenv->db_recovery_init(dbenv)) != 0)
  256. goto err;
  258. /* Perform recovery for any previous run. */
  259. if (LF_ISSET(DB_RECOVER | DB_RECOVER_FATAL) &&
  260.     (ret = __db_apprec(dbenv,
  261.     LF_ISSET(DB_RECOVER | DB_RECOVER_FATAL))) != 0)
  262. goto err;
  263. }
  264. return (0);
  266. err: (void)__dbenv_refresh(dbenv);
  267. return (ret);
  268. }
  270. /*
  271.  * __dbenv_remove --
  272.  * Discard an environment.
  273.  *
  274.  * PUBLIC: int __dbenv_remove __P((DB_ENV *, const char *, u_int32_t));
  275.  */
  276. int
  277. __dbenv_remove(dbenv, db_home, flags)
  278. DB_ENV *dbenv;
  279. const char *db_home;
  280. u_int32_t flags;
  281. {
  282. int ret, t_ret;
  284. #undef OKFLAGS
  285. #define OKFLAGS
  286. DB_FORCE | DB_USE_ENVIRON | DB_USE_ENVIRON_ROOT
  288. /* Validate arguments. */
  289. if ((ret = __db_fchk(dbenv, "DBENV->remove", flags, OKFLAGS)) != 0)
  290. goto err;
  292. /*
  293.  * A hard-to-debug error is calling DBENV->remove after open.  That's
  294.  * not legal.  You have to close the original, already opened handle
  295.  * and then allocate a new DBENV handle to use for DBENV->remove.
  296.  */
  297. if (F_ISSET(dbenv, DB_ENV_OPEN_CALLED)) {
  298. __db_err(dbenv,
  299.     "DBENV handle opened, not usable for remove method.");
  300. return (EINVAL);
  301. }
  303. /* Initialize the DB_ENV structure. */
  304. if ((ret = __dbenv_config(dbenv, db_home, flags)) != 0)
  305. goto err;
  307. /* Remove the environment. */
  308. ret = __db_e_remove(dbenv, LF_ISSET(DB_FORCE) ? 1 : 0);
  310. /* Discard any resources we've acquired. */
  311. err: if ((t_ret = __dbenv_refresh(dbenv)) != 0 && ret == 0)
  312. ret = t_ret;
  314. memset(dbenv, CLEAR_BYTE, sizeof(DB_ENV));
  315. __os_free(dbenv, sizeof(DB_ENV));
  317. return (ret);
  318. }
  320. /*
  321.  * __dbenv_config --
  322.  * Initialize the DB_ENV structure.
  323.  */
  324. static int
  325. __dbenv_config(dbenv, db_home, flags)
  326. DB_ENV *dbenv;
  327. const char *db_home;
  328. u_int32_t flags;
  329. {
  330. FILE *fp;
  331. int ret;
  332. char *lp, buf[MAXPATHLEN * 2];
  334. /* Set the database home. */
  335. if ((ret = __db_home(dbenv, db_home, flags)) != 0)
  336. return (ret);
  338. /*
  339.  * Parse the config file.
  340.  *
  341.  * !!!
  342.  * Don't use sprintf(3)/snprintf(3) -- the former is dangerous, and
  343.  * the latter isn't standard, and we're manipulating strings handed
  344.  * us by the application.
  345.  */
  346. if (dbenv->db_home != NULL) {
  347. #define CONFIG_NAME "/DB_CONFIG"
  348. if (strlen(dbenv->db_home) +
  349.     strlen(CONFIG_NAME) + 1 > sizeof(buf)) {
  350. ret = ENAMETOOLONG;
  351. return (ret);
  352. }
  353. (void)strcpy(buf, dbenv->db_home);
  354. (void)strcat(buf, CONFIG_NAME);
  355. if ((fp = fopen(buf, "r")) != NULL) {
  356. while (fgets(buf, sizeof(buf), fp) != NULL) {
  357. if ((lp = strchr(buf, 'n')) == NULL) {
  358. __db_err(dbenv,
  359.     "%s: line too long", CONFIG_NAME);
  360. (void)fclose(fp);
  361. ret = EINVAL;
  362. return (ret);
  363. }
  364. *lp = '';
  365. if (buf[0] == '' ||
  366.     buf[0] == '#' || isspace((int)buf[0]))
  367. continue;
  369. if ((ret = __db_parse(dbenv, buf)) != 0) {
  370. (void)fclose(fp);
  371. return (ret);
  372. }
  373. }
  374. (void)fclose(fp);
  375. }
  376. }
  378. /* Set up the tmp directory path. */
  379. if (dbenv->db_tmp_dir == NULL && (ret = __os_tmpdir(dbenv, flags)) != 0)
  380. return (ret);
  382. /*
  383.  * The locking file descriptor is rarely on.  Set the fd to -1, not
  384.  * because it's ever tested, but to make sure we catch mistakes.
  385.  */
  386. if ((ret =
  387.     __os_calloc(dbenv,
  388. 1, sizeof(*dbenv->lockfhp), &dbenv->lockfhp)) != 0)
  389. return (ret);
  390. dbenv->lockfhp->fd = -1;
  392. /*
  393.  * Flag that the DB_ENV structure has been initialized.  Note, this
  394.  * must be set before calling into the subsystems as it's used during
  395.  * file naming.
  396.  */
  397. F_SET(dbenv, DB_ENV_OPEN_CALLED);
  399. return (0);
  400. }
  402. /*
  403.  * __dbenv_close --
  404.  * DB_ENV destructor.
  405.  *
  406.  * PUBLIC: int __dbenv_close __P((DB_ENV *, u_int32_t));
  407.  */
  408. int
  409. __dbenv_close(dbenv, flags)
  410. DB_ENV *dbenv;
  411. u_int32_t flags;
  412. {
  413. int ret;
  415. COMPQUIET(flags, 0);
  417. PANIC_CHECK(dbenv);
  419. ret = __dbenv_refresh(dbenv);
  421. /* Discard the structure if we allocated it. */
  422. if (!F_ISSET(dbenv, DB_ENV_USER_ALLOC)) {
  423. memset(dbenv, CLEAR_BYTE, sizeof(DB_ENV));
  424. __os_free(dbenv, sizeof(DB_ENV));
  425. }
  427. return (ret);
  428. }
  430. /*
  431.  * __dbenv_refresh --
  432.  * Refresh the DB_ENV structure, releasing any allocated resources.
  433.  */
  434. static int
  435. __dbenv_refresh(dbenv)
  436. DB_ENV *dbenv;
  437. {
  438. int ret, t_ret;
  439. char **p;
  441. ret = 0;
  443. /*
  444.  * Close subsystems, in the reverse order they were opened (txn
  445.  * must be first, it may want to discard locks and flush the log).
  446.  */
  447. if (TXN_ON(dbenv)) {
  448. if ((t_ret = __txn_close(dbenv)) != 0 && ret == 0)
  449. ret = t_ret;
  450. }
  452. if (LOCKING_ON(dbenv)) {
  453. if ((t_ret = __lock_close(dbenv)) != 0 && ret == 0)
  454. ret = t_ret;
  455. }
  456. __lock_dbenv_close(dbenv);
  458. if (LOGGING_ON(dbenv)) {
  459. if ((t_ret = __log_close(dbenv)) != 0 && ret == 0)
  460. ret = t_ret;
  461. }
  463. if (MPOOL_ON(dbenv)) {
  464. if ((t_ret = __memp_close(dbenv)) != 0 && ret == 0)
  465. ret = t_ret;
  466. }
  468. /* Discard DB list and its mutex. */
  469. LIST_INIT(&dbenv->dblist);
  470. if (dbenv->dblist_mutexp != NULL)
  471. __db_mutex_free(dbenv, dbenv->reginfo, dbenv->dblist_mutexp);
  473. /* Detach from the region. */
  474. if (dbenv->reginfo != NULL) {
  475. if ((t_ret = __db_e_detach(dbenv, 0)) != 0 && ret == 0)
  476. ret = t_ret;
  477. /*
  478.  * !!!
  479.  * Don't free dbenv->reginfo or set the reference to NULL,
  480.  * that was done by __db_e_detach().
  481.  */
  482. }
  484. /* Clean up the structure. */
  485. dbenv->db_panic = 0;
  487. if (dbenv->db_home != NULL) {
  488. __os_freestr(dbenv->db_home);
  489. dbenv->db_home = NULL;
  490. }
  491. if (dbenv->db_log_dir != NULL) {
  492. __os_freestr(dbenv->db_log_dir);
  493. dbenv->db_log_dir = NULL;
  494. }
  495. if (dbenv->db_tmp_dir != NULL) {
  496. __os_freestr(dbenv->db_tmp_dir);
  497. dbenv->db_tmp_dir = NULL;
  498. }
  499. if (dbenv->db_data_dir != NULL) {
  500. for (p = dbenv->db_data_dir; *p != NULL; ++p)
  501. __os_freestr(*p);
  502. __os_free(dbenv->db_data_dir,
  503.     dbenv->data_cnt * sizeof(char **));
  504. dbenv->db_data_dir = NULL;
  505. }
  506. dbenv->data_cnt = dbenv->data_next = 0;
  508. dbenv->db_mode = 0;
  510. if (dbenv->lockfhp != NULL) {
  511. __os_free(dbenv->lockfhp, sizeof(*dbenv->lockfhp));
  512. dbenv->lockfhp = NULL;
  513. }
  515. if (dbenv->dtab != NULL) {
  516. __os_free(dbenv->dtab,
  517.     dbenv->dtab_size * sizeof(dbenv->dtab[0]));
  518. dbenv->dtab = NULL;
  519. dbenv->dtab_size = 0;
  520. }
  522. dbenv->mp_mmapsize = 0;
  523. dbenv->links.tqe_next = NULL;
  524. dbenv->links.tqe_prev = NULL;
  525. dbenv->xa_rmid = 0;
  526. dbenv->xa_txn = 0;
  528. F_CLR(dbenv, ~(DB_ENV_STANDALONE | DB_ENV_USER_ALLOC));
  530. return (ret);
  531. }
  533. #define DB_ADDSTR(add) {
  534. if ((add) != NULL) {
  535. /* If leading slash, start over. */
  536. if (__os_abspath(add)) {
  537. p = str;
  538. slash = 0;
  539. }
  540. /* Append to the current string. */
  541. len = strlen(add);
  542. if (slash)
  543. *p++ = PATH_SEPARATOR[0];
  544. memcpy(p, add, len);
  545. p += len;
  546. slash = strchr(PATH_SEPARATOR, p[-1]) == NULL;
  547. }
  548. }
  550. /*
  551.  * __db_appname --
  552.  * Given an optional DB environment, directory and file name and type
  553.  * of call, build a path based on the DBENV->open rules, and return
  554.  * it in allocated space.
  555.  *
  556.  * PUBLIC: int __db_appname __P((DB_ENV *, APPNAME,
  557.  * PUBLIC:    const char *, const char *, u_int32_t, DB_FH *, char **));
  558.  */
  559. int
  560. __db_appname(dbenv, appname, dir, file, tmp_oflags, fhp, namep)
  561. DB_ENV *dbenv;
  562. APPNAME appname;
  563. const char *dir, *file;
  564. u_int32_t tmp_oflags;
  565. DB_FH *fhp;
  566. char **namep;
  567. {
  568. DB_ENV etmp;
  569. size_t len, str_len;
  570. int data_entry, ret, slash, tmp_create, tmp_free;
  571. const char *a, *b, *c;
  572. char *p, *str;
  574. a = b = c = NULL;
  575. data_entry = -1;
  576. tmp_create = tmp_free = 0;
  578. /*
  579.  * We don't return a name when creating temporary files, just a
  580.  * file handle.  Default to an error now.
  581.  */
  582. if (fhp != NULL)
  583. F_CLR(fhp, DB_FH_VALID);
  584. if (namep != NULL)
  585. *namep = NULL;
  587. /*
  588.  * Absolute path names are never modified.  If the file is an absolute
  589.  * path, we're done.  If the directory is, simply append the file and
  590.  * return.
  591.  */
  592. if (file != NULL && __os_abspath(file))
  593. return (__os_strdup(dbenv, file, namep));
  594. if (dir != NULL && __os_abspath(dir)) {
  595. a = dir;
  596. goto done;
  597. }
  599. /*
  600.  * DB_ENV  DIR    APPNAME    RESULT
  601.  * -------------------------------------------
  602.  * null    null    none    <tmp>/file
  603.  * null    set    none    DIR/file
  604.  * set    null    none    DB_HOME/file
  605.  * set    set    none    DB_HOME/DIR/file
  606.  *
  607.  * DB_ENV  FILE    APPNAME    RESULT
  608.  * -------------------------------------------
  609.  * null    null    DB_APP_DATA    <tmp>/<create>
  610.  * null    set    DB_APP_DATA    ./file
  611.  * set    null    DB_APP_DATA    <tmp>/<create>
  612.  * set    set    DB_APP_DATA    DB_HOME/DB_DATA_DIR/file
  613.  *
  614.  * DB_ENV  DIR    APPNAME    RESULT
  615.  * -------------------------------------------
  616.  * null    null    DB_APP_LOG    <tmp>/file
  617.  * null    set    DB_APP_LOG    DIR/file
  618.  * set    null    DB_APP_LOG    DB_HOME/DB_LOG_DIR/file
  619.  * set    set    DB_APP_LOG    DB_HOME/DB_LOG_DIR/DIR/file
  620.  *
  621.  * DB_ENV    APPNAME    RESULT
  622.  * -------------------------------------------
  623.  * null    DB_APP_TMP*    <tmp>/<create>
  624.  * set    DB_APP_TMP*    DB_HOME/DB_TMP_DIR/<create>
  625.  */
  626. retry: switch (appname) {
  627. case DB_APP_NONE:
  628. if (dbenv == NULL || !F_ISSET(dbenv, DB_ENV_OPEN_CALLED)) {
  629. if (dir == NULL)
  630. goto tmp;
  631. a = dir;
  632. } else {
  633. a = dbenv->db_home;
  634. b = dir;
  635. }
  636. break;
  637. case DB_APP_DATA:
  638. if (dir != NULL) {
  639. __db_err(dbenv,
  640.     "DB_APP_DATA: illegal directory specification");
  641. return (EINVAL);
  642. }
  644. if (file == NULL) {
  645. tmp_create = 1;
  646. goto tmp;
  647. }
  648. if (dbenv != NULL && F_ISSET(dbenv, DB_ENV_OPEN_CALLED)) {
  649. a = dbenv->db_home;
  650. if (dbenv->db_data_dir != NULL &&
  651.     (b = dbenv->db_data_dir[++data_entry]) == NULL) {
  652. data_entry = -1;
  653. b = dbenv->db_data_dir[0];
  654. }
  655. }
  656. break;
  657. case DB_APP_LOG:
  658. if (dbenv == NULL || !F_ISSET(dbenv, DB_ENV_OPEN_CALLED)) {
  659. if (dir == NULL)
  660. goto tmp;
  661. a = dir;
  662. } else {
  663. a = dbenv->db_home;
  664. b = dbenv->db_log_dir;
  665. c = dir;
  666. }
  667. break;
  668. case DB_APP_TMP:
  669. if (dir != NULL || file != NULL) {
  670. __db_err(dbenv,
  671.     "DB_APP_TMP: illegal directory or file specification");
  672. return (EINVAL);
  673. }
  675. tmp_create = 1;
  676. if (dbenv == NULL || !F_ISSET(dbenv, DB_ENV_OPEN_CALLED))
  677. goto tmp;
  678. else {
  679. a = dbenv->db_home;
  680. b = dbenv->db_tmp_dir;
  681. }
  682. break;
  683. }
  685. /* Reference a file from the appropriate temporary directory. */
  686. if (0) {
  687. tmp: if (dbenv == NULL || !F_ISSET(dbenv, DB_ENV_OPEN_CALLED)) {
  688. memset(&etmp, 0, sizeof(etmp));
  689. if ((ret = __os_tmpdir(&etmp, DB_USE_ENVIRON)) != 0)
  690. return (ret);
  691. tmp_free = 1;
  692. a = etmp.db_tmp_dir;
  693. } else
  694. a = dbenv->db_tmp_dir;
  695. }
  697. done: len =
  698.     (a == NULL ? 0 : strlen(a) + 1) +
  699.     (b == NULL ? 0 : strlen(b) + 1) +
  700.     (c == NULL ? 0 : strlen(c) + 1) +
  701.     (file == NULL ? 0 : strlen(file) + 1);
  703. /*
  704.  * Allocate space to hold the current path information, as well as any
  705.  * temporary space that we're going to need to create a temporary file
  706.  * name.
  707.  */
  708. #define DB_TRAIL "BDBXXXXXX"
  709. str_len = len + sizeof(DB_TRAIL) + 10;
  710. if ((ret = __os_malloc(dbenv, str_len, NULL, &str)) != 0) {
  711. if (tmp_free)
  712. __os_freestr(etmp.db_tmp_dir);
  713. return (ret);
  714. }
  716. slash = 0;
  717. p = str;
  718. DB_ADDSTR(a);
  719. DB_ADDSTR(b);
  720. DB_ADDSTR(file);
  721. *p = '';
  723. /* Discard any space allocated to find the temp directory. */
  724. if (tmp_free) {
  725. __os_freestr(etmp.db_tmp_dir);
  726. tmp_free = 0;
  727. }
  729. /*
  730.  * If we're opening a data file, see if it exists.  If it does,
  731.  * return it, otherwise, try and find another one to open.
  732.  */
  733. if (data_entry != -1 && __os_exists(str, NULL) != 0) {
  734. __os_free(str, str_len);
  735. a = b = c = NULL;
  736. goto retry;
  737. }
  739. /* Create the file if so requested. */
  740. if (tmp_create &&
  741.     (ret = __db_tmp_open(dbenv, tmp_oflags, str, fhp)) != 0) {
  742. __os_free(str, str_len);
  743. return (ret);
  744. }
  746. if (namep == NULL)
  747. __os_free(str, str_len);
  748. else
  749. *namep = str;
  750. return (0);
  751. }
  753. /*
  754.  * __db_home --
  755.  * Find the database home.
  756.  */
  757. static int
  758. __db_home(dbenv, db_home, flags)
  759. DB_ENV *dbenv;
  760. const char *db_home;
  761. u_int32_t flags;
  762. {
  763. const char *p;
  765. /*
  766.  * Use db_home by default, this allows utilities to reasonably
  767.  * override the environment either explicitly or by using a -h
  768.  * option.  Otherwise, use the environment if it's permitted
  769.  * and initialized.
  770.  */
  771. if ((p = db_home) == NULL &&
  772.     (LF_ISSET(DB_USE_ENVIRON) ||
  773.     (LF_ISSET(DB_USE_ENVIRON_ROOT) && __os_isroot())) &&
  774.     (p = getenv("DB_HOME")) != NULL && p[0] == '') {
  775. __db_err(dbenv, "illegal DB_HOME environment variable");
  776. return (EINVAL);
  777. }
  779. return (p == NULL ? 0 : __os_strdup(dbenv, p, &dbenv->db_home));
  780. }
  782. /*
  783.  * __db_parse --
  784.  * Parse a single NAME VALUE pair.
  785.  */
  786. static int
  787. __db_parse(dbenv, s)
  788. DB_ENV *dbenv;
  789. char *s;
  790. {
  791. u_long v1, v2, v3;
  792. u_int32_t flags;
  793. char *name, *p, *value, v4;
  795. /*
  796.  * !!!
  797.  * The value of 40 is hard-coded into format arguments to sscanf
  798.  * below, it can't be changed here without changing it there, too.
  799.  */
  800. char arg[40];
  802. /*
  803.  * Name/value pairs are parsed as two white-space separated strings.
  804.  * Leading and trailing white-space is trimmed from the value, but
  805.  * it may contain embedded white-space.  Note: we use the isspace(3)
  806.  * macro because it's more portable, but that means that you can use
  807.  * characters like form-feed to separate the strings.
  808.  */
  809. name = s;
  810. for (p = name; *p != '' && !isspace((int)*p); ++p)
  811. ;
  812. if (*p == '' || p == name)
  813. goto illegal;
  814. *p = '';
  815. for (++p; isspace((int)*p); ++p)
  816. ;
  817. if (*p == '')
  818. goto illegal;
  819. value = p;
  820. for (++p; *p != ''; ++p)
  821. ;
  822. for (--p; isspace((int)*p); --p)
  823. ;
  824. ++p;
  825. if (p == value) {
  826. illegal: __db_err(dbenv, "mis-formatted name-value pair: %s", s);
  827. return (EINVAL);
  828. }
  829. *p = '';
  831. if (!strcasecmp(name, "set_cachesize")) {
  832. if (sscanf(value, "%lu %lu %lu %c", &v1, &v2, &v3, &v4) != 3)
  833. goto badarg;
  834. return (dbenv->set_cachesize(dbenv, v1, v2, v3));
  835. }
  837. if (!strcasecmp(name, "set_data_dir") ||
  838.     !strcasecmp(name, "db_data_dir")) /* Compatibility. */
  839. return (dbenv->set_data_dir(dbenv, value));
  841. if (!strcasecmp(name, "set_flags")) {
  842. if (sscanf(value, "%40s %c", arg, &v4) != 1)
  843. goto badarg;
  845. if (!strcasecmp(value, "db_cdb_alldb"))
  846. return (dbenv->set_flags(dbenv, DB_CDB_ALLDB, 1));
  847. if (!strcasecmp(value, "db_nommap"))
  848. return (dbenv->set_flags(dbenv, DB_NOMMAP, 1));
  849. if (!strcasecmp(value, "db_txn_nosync"))
  850. return (dbenv->set_flags(dbenv, DB_TXN_NOSYNC, 1));
  851. goto badarg;
  852. }
  854. if (!strcasecmp(name, "set_lg_bsize")) {
  855. if (sscanf(value, "%lu %c", &v1, &v4) != 1)
  856. goto badarg;
  857. return (dbenv->set_lg_bsize(dbenv, v1));
  858. }
  860. if (!strcasecmp(name, "set_lg_max")) {
  861. if (sscanf(value, "%lu %c", &v1, &v4) != 1)
  862. goto badarg;
  863. return (dbenv->set_lg_max(dbenv, v1));
  864. }
  866. if (!strcasecmp(name, "set_lg_dir") ||
  867.     !strcasecmp(name, "db_log_dir")) /* Compatibility. */
  868. return (dbenv->set_lg_dir(dbenv, value));
  870. if (!strcasecmp(name, "set_lk_detect")) {
  871. if (sscanf(value, "%40s %c", arg, &v4) != 1)
  872. goto badarg;
  873. if (!strcasecmp(value, "db_lock_default"))
  874. flags = DB_LOCK_DEFAULT;
  875. else if (!strcasecmp(value, "db_lock_oldest"))
  876. flags = DB_LOCK_OLDEST;
  877. else if (!strcasecmp(value, "db_lock_random"))
  878. flags = DB_LOCK_RANDOM;
  879. else if (!strcasecmp(value, "db_lock_youngest"))
  880. flags = DB_LOCK_YOUNGEST;
  881. else
  882. goto badarg;
  883. return (dbenv->set_lk_detect(dbenv, flags));
  884. }
  886. if (!strcasecmp(name, "set_lk_max")) {
  887. if (sscanf(value, "%lu %c", &v1, &v4) != 1)
  888. goto badarg;
  889. return (dbenv->set_lk_max(dbenv, v1));
  890. }
  892. if (!strcasecmp(name, "set_lk_max_locks")) {
  893. if (sscanf(value, "%lu %c", &v1, &v4) != 1)
  894. goto badarg;
  895. return (dbenv->set_lk_max_locks(dbenv, v1));
  896. }
  898. if (!strcasecmp(name, "set_lk_max_lockers")) {
  899. if (sscanf(value, "%lu %c", &v1, &v4) != 1)
  900. goto badarg;
  901. return (dbenv->set_lk_max_lockers(dbenv, v1));
  902. }
  904. if (!strcasecmp(name, "set_lk_max_objects")) {
  905. if (sscanf(value, "%lu %c", &v1, &v4) != 1)
  906. goto badarg;
  907. return (dbenv->set_lk_max_objects(dbenv, v1));
  908. }
  910. if (!strcasecmp(name, "set_mp_mmapsize")) {
  911. if (sscanf(value, "%lu %c", &v1, &v4) != 1)
  912. goto badarg;
  913. return (dbenv->set_mp_mmapsize(dbenv, v1));
  914. }
  916. if (!strcasecmp(name, "set_region_init")) {
  917. if (sscanf(value, "%lu %c", &v1, &v4) != 1 || v1 != 1)
  918. goto badarg;
  919. return (db_env_set_region_init(v1));
  920. }
  922. if (!strcasecmp(name, "set_shm_key")) {
  923. if (sscanf(value, "%lu %c", &v1, &v4) != 1)
  924. goto badarg;
  925. return (dbenv->set_shm_key(dbenv, (long)v1));
  926. }
  928. if (!strcasecmp(name, "set_tas_spins")) {
  929. if (sscanf(value, "%lu %c", &v1, &v4) != 1)
  930. goto badarg;
  931. return (db_env_set_tas_spins(v1));
  932. }
  934. if (!strcasecmp(name, "set_tmp_dir") ||
  935.     !strcasecmp(name, "db_tmp_dir")) /* Compatibility.*/
  936. return (dbenv->set_tmp_dir(dbenv, value));
  938. if (!strcasecmp(name, "set_tx_max")) {
  939. if (sscanf(value, "%lu %c", &v1, &v4) != 1)
  940. goto badarg;
  941. return (dbenv->set_tx_max(dbenv, v1));
  942. }
  944. if (!strcasecmp(name, "set_verbose")) {
  945. if (sscanf(value, "%40s %c", arg, &v4) != 1)
  946. goto badarg;
  948. if (!strcasecmp(value, "db_verb_chkpoint"))
  949. flags = DB_VERB_CHKPOINT;
  950. else if (!strcasecmp(value, "db_verb_deadlock"))
  951. flags = DB_VERB_DEADLOCK;
  952. else if (!strcasecmp(value, "db_verb_recovery"))
  953. flags = DB_VERB_RECOVERY;
  954. else if (!strcasecmp(value, "db_verb_waitsfor"))
  955. flags = DB_VERB_WAITSFOR;
  956. else
  957. goto badarg;
  958. return (dbenv->set_verbose(dbenv, flags, 1));
  959. }
  961. __db_err(dbenv, "unrecognized name-value pair: %s", s);
  962. return (EINVAL);
  964. badarg: __db_err(dbenv, "incorrect arguments for name-value pair: %s", s);
  965. return (EINVAL);
  966. }
  968. /*
  969.  * __db_tmp_open --
  970.  * Create a temporary file.
  971.  */
  972. static int
  973. __db_tmp_open(dbenv, tmp_oflags, path, fhp)
  974. DB_ENV *dbenv;
  975. u_int32_t tmp_oflags;
  976. char *path;
  977. DB_FH *fhp;
  978. {
  979. u_long pid;
  980. int mode, isdir, ret;
  981. const char *p;
  982. char *trv;
  984. /*
  985.  * Check the target directory; if you have six X's and it doesn't
  986.  * exist, this runs for a *very* long time.
  987.  */
  988. if ((ret = __os_exists(path, &isdir)) != 0) {
  989. __db_err(dbenv, "%s: %s", path, db_strerror(ret));
  990. return (ret);
  991. }
  992. if (!isdir) {
  993. __db_err(dbenv, "%s: %s", path, db_strerror(EINVAL));
  994. return (EINVAL);
  995. }
  997. /* Build the path. */
  998. for (trv = path; *trv != ''; ++trv)
  999. ;
  1000. *trv = PATH_SEPARATOR[0];
  1001. for (p = DB_TRAIL; (*++trv = *p) != ''; ++p)
  1002. ;
  1004. /*
  1005.  * Replace the X's with the process ID.  Pid should be a pid_t,
  1006.  * but we use unsigned long for portability.
  1007.  */
  1008. for (pid = getpid(); *--trv == 'X'; pid /= 10)
  1009. switch (pid % 10) {
  1010. case 0: *trv = '0'; break;
  1011. case 1: *trv = '1'; break;
  1012. case 2: *trv = '2'; break;
  1013. case 3: *trv = '3'; break;
  1014. case 4: *trv = '4'; break;
  1015. case 5: *trv = '5'; break;
  1016. case 6: *trv = '6'; break;
  1017. case 7: *trv = '7'; break;
  1018. case 8: *trv = '8'; break;
  1019. case 9: *trv = '9'; break;
  1020. }
  1021. ++trv;
  1023. /* Set up open flags and mode. */
  1024. mode = __db_omode("rw----");
  1026. /* Loop, trying to open a file. */
  1027. for (;;) {
  1028. if ((ret = __os_open(dbenv, path,
  1029.     tmp_oflags | DB_OSO_CREATE | DB_OSO_EXCL, mode, fhp)) == 0)
  1030. return (0);
  1032. /*
  1033.  * !!!:
  1034.  * If we don't get an EEXIST error, then there's something
  1035.  * seriously wrong.  Unfortunately, if the implementation
  1036.  * doesn't return EEXIST for O_CREAT and O_EXCL regardless
  1037.  * of other possible errors, we've lost.
  1038.  */
  1039. if (ret != EEXIST) {
  1040. __db_err(dbenv,
  1041.     "tmp_open: %s: %s", path, db_strerror(ret));
  1042. return (ret);
  1043. }
  1045. /*
  1046.  * Tricky little algorithm for backward compatibility.
  1047.  * Assumes sequential ordering of lower-case characters.
  1048.  */
  1049. for (;;) {
  1050. if (*trv == '')
  1051. return (EINVAL);
  1052. if (*trv == 'z')
  1053. *trv++ = 'a';
  1054. else {
  1055. if (isdigit((int)*trv))
  1056. *trv = 'a';
  1057. else
  1058. ++*trv;
  1059. break;
  1060. }
  1061. }
  1062. }
  1063. /* NOTREACHED */
  1064. }