зеркало из https://github.com/mozilla/gecko-dev.git
796 строки
18 KiB
C
796 строки
18 KiB
C
/*-
|
|
* See the file LICENSE for redistribution information.
|
|
*
|
|
* Copyright (c) 1996, 1997, 1998
|
|
* Sleepycat Software. All rights reserved.
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#ifndef lint
|
|
static const char sccsid[] = "@(#)db_appinit.c 10.52 (Sleepycat) 6/2/98";
|
|
#endif /* not lint */
|
|
|
|
#ifndef NO_SYSTEM_INCLUDES
|
|
#include <sys/types.h>
|
|
|
|
#include <ctype.h>
|
|
#include <errno.h>
|
|
#include <signal.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
#endif
|
|
|
|
#include "db_int.h"
|
|
#include "shqueue.h"
|
|
#include "db_page.h"
|
|
#include "btree.h"
|
|
#include "hash.h"
|
|
#include "log.h"
|
|
#include "txn.h"
|
|
#include "clib_ext.h"
|
|
#include "common_ext.h"
|
|
|
|
static int __db_home __P((DB_ENV *, const char *, u_int32_t));
|
|
static int __db_parse __P((DB_ENV *, char *));
|
|
static int __db_tmp_dir __P((DB_ENV *, u_int32_t));
|
|
static int __db_tmp_open __P((DB_ENV *, u_int32_t, char *, int *));
|
|
|
|
/*
|
|
* db_version --
|
|
* Return version information.
|
|
*/
|
|
char *
|
|
db_version(majverp, minverp, patchp)
|
|
int *majverp, *minverp, *patchp;
|
|
{
|
|
if (majverp != NULL)
|
|
*majverp = DB_VERSION_MAJOR;
|
|
if (minverp != NULL)
|
|
*minverp = DB_VERSION_MINOR;
|
|
if (patchp != NULL)
|
|
*patchp = DB_VERSION_PATCH;
|
|
return ((char *)DB_VERSION_STRING);
|
|
}
|
|
|
|
/*
|
|
* db_appinit --
|
|
* Initialize the application environment.
|
|
*/
|
|
int
|
|
db_appinit(db_home, db_config, dbenv, flags)
|
|
const char *db_home;
|
|
char * const *db_config;
|
|
DB_ENV *dbenv;
|
|
u_int32_t flags;
|
|
{
|
|
FILE *fp;
|
|
int mode, ret;
|
|
char * const *p;
|
|
char *lp, buf[MAXPATHLEN * 2];
|
|
|
|
/* Validate arguments. */
|
|
if (dbenv == NULL)
|
|
return (EINVAL);
|
|
|
|
|
|
#ifdef HAVE_SPINLOCKS
|
|
#define OKFLAGS \
|
|
(DB_CREATE | DB_NOMMAP | DB_THREAD | DB_INIT_LOCK | DB_INIT_LOG | \
|
|
DB_INIT_MPOOL | DB_INIT_TXN | DB_MPOOL_PRIVATE | DB_RECOVER | \
|
|
DB_RECOVER_FATAL | DB_TXN_NOSYNC | DB_USE_ENVIRON | DB_USE_ENVIRON_ROOT)
|
|
#else
|
|
#define OKFLAGS \
|
|
(DB_CREATE | DB_NOMMAP | DB_INIT_LOCK | DB_INIT_LOG | \
|
|
DB_INIT_MPOOL | DB_INIT_TXN | DB_MPOOL_PRIVATE | DB_RECOVER | \
|
|
DB_RECOVER_FATAL | DB_TXN_NOSYNC | DB_USE_ENVIRON | DB_USE_ENVIRON_ROOT)
|
|
#endif
|
|
if ((ret = __db_fchk(dbenv, "db_appinit", flags, OKFLAGS)) != 0)
|
|
return (ret);
|
|
|
|
/* Transactions imply logging. */
|
|
if (LF_ISSET(DB_INIT_TXN))
|
|
LF_SET(DB_INIT_LOG);
|
|
|
|
/* Convert the db_appinit(3) flags. */
|
|
if (LF_ISSET(DB_THREAD))
|
|
F_SET(dbenv, DB_ENV_THREAD);
|
|
|
|
fp = NULL;
|
|
|
|
/* Set the database home. */
|
|
if ((ret = __db_home(dbenv, db_home, flags)) != 0)
|
|
goto err;
|
|
|
|
/* Parse the config array. */
|
|
for (p = db_config; p != NULL && *p != NULL; ++p)
|
|
if ((ret = __db_parse(dbenv, *p)) != 0)
|
|
goto err;
|
|
|
|
/*
|
|
* Parse the config file.
|
|
*
|
|
* XXX
|
|
* Don't use sprintf(3)/snprintf(3) -- the former is dangerous, and
|
|
* the latter isn't standard, and we're manipulating strings handed
|
|
* us by the application.
|
|
*/
|
|
if (dbenv->db_home != NULL) {
|
|
#define CONFIG_NAME "/DB_CONFIG"
|
|
if (strlen(dbenv->db_home) +
|
|
strlen(CONFIG_NAME) + 1 > sizeof(buf)) {
|
|
ret = ENAMETOOLONG;
|
|
goto err;
|
|
}
|
|
(void)strcpy(buf, dbenv->db_home);
|
|
(void)strcat(buf, CONFIG_NAME);
|
|
if ((fp = fopen(buf, "r")) != NULL) {
|
|
while (fgets(buf, sizeof(buf), fp) != NULL) {
|
|
if ((lp = strchr(buf, '\n')) != NULL)
|
|
*lp = '\0';
|
|
if ((ret = __db_parse(dbenv, buf)) != 0)
|
|
goto err;
|
|
}
|
|
(void)fclose(fp);
|
|
fp = NULL;
|
|
}
|
|
}
|
|
|
|
/* Set up the tmp directory path. */
|
|
if (dbenv->db_tmp_dir == NULL &&
|
|
(ret = __db_tmp_dir(dbenv, flags)) != 0)
|
|
goto err;
|
|
|
|
/* Indicate that the path names have been set. */
|
|
F_SET(dbenv, DB_ENV_APPINIT);
|
|
|
|
/*
|
|
* If we are doing recovery, remove all the old shared memory
|
|
* regions.
|
|
*/
|
|
if (LF_ISSET(DB_RECOVER | DB_RECOVER_FATAL)) {
|
|
if ((ret = log_unlink(NULL, 1, dbenv)) != 0)
|
|
goto err;
|
|
if ((ret = memp_unlink(NULL, 1, dbenv)) != 0)
|
|
goto err;
|
|
if ((ret = lock_unlink(NULL, 1, dbenv)) != 0)
|
|
goto err;
|
|
if ((ret = txn_unlink(NULL, 1, dbenv)) != 0)
|
|
goto err;
|
|
}
|
|
|
|
/*
|
|
* Create the new shared regions.
|
|
*
|
|
* Default permissions are read-write for both owner and group.
|
|
*/
|
|
mode = __db_omode("rwrw--");
|
|
if (LF_ISSET(DB_INIT_LOCK) && (ret = lock_open(NULL,
|
|
LF_ISSET(DB_CREATE | DB_THREAD),
|
|
mode, dbenv, &dbenv->lk_info)) != 0)
|
|
goto err;
|
|
if (LF_ISSET(DB_INIT_LOG) && (ret = log_open(NULL,
|
|
LF_ISSET(DB_CREATE | DB_THREAD),
|
|
mode, dbenv, &dbenv->lg_info)) != 0)
|
|
goto err;
|
|
if (LF_ISSET(DB_INIT_MPOOL) && (ret = memp_open(NULL,
|
|
LF_ISSET(DB_CREATE | DB_MPOOL_PRIVATE | DB_NOMMAP | DB_THREAD),
|
|
mode, dbenv, &dbenv->mp_info)) != 0)
|
|
goto err;
|
|
if (LF_ISSET(DB_INIT_TXN) && (ret = txn_open(NULL,
|
|
LF_ISSET(DB_CREATE | DB_THREAD | DB_TXN_NOSYNC),
|
|
mode, dbenv, &dbenv->tx_info)) != 0)
|
|
goto err;
|
|
|
|
/*
|
|
* If the application is running with transactions, initialize the
|
|
* function tables. Once that's done, do recovery for any previous
|
|
* run.
|
|
*/
|
|
if (LF_ISSET(DB_INIT_TXN)) {
|
|
if ((ret = __bam_init_recover(dbenv)) != 0)
|
|
goto err;
|
|
if ((ret = __db_init_recover(dbenv)) != 0)
|
|
goto err;
|
|
if ((ret = __ham_init_recover(dbenv)) != 0)
|
|
goto err;
|
|
if ((ret = __log_init_recover(dbenv)) != 0)
|
|
goto err;
|
|
if ((ret = __txn_init_recover(dbenv)) != 0)
|
|
goto err;
|
|
|
|
if (LF_ISSET(DB_RECOVER | DB_RECOVER_FATAL) &&
|
|
(ret = __db_apprec(dbenv,
|
|
LF_ISSET(DB_RECOVER | DB_RECOVER_FATAL))) != 0)
|
|
goto err;
|
|
}
|
|
|
|
return (ret);
|
|
|
|
err: if (fp != NULL)
|
|
(void)fclose(fp);
|
|
|
|
(void)db_appexit(dbenv);
|
|
return (ret);
|
|
}
|
|
|
|
/*
|
|
* db_appexit --
|
|
* Close down the default application environment.
|
|
*/
|
|
int
|
|
db_appexit(dbenv)
|
|
DB_ENV *dbenv;
|
|
{
|
|
int ret, t_ret;
|
|
char **p;
|
|
|
|
ret = 0;
|
|
|
|
/* Close subsystems. */
|
|
if (dbenv->tx_info && (t_ret = txn_close(dbenv->tx_info)) != 0)
|
|
if (ret == 0)
|
|
ret = t_ret;
|
|
if (dbenv->mp_info && (t_ret = memp_close(dbenv->mp_info)) != 0)
|
|
if (ret == 0)
|
|
ret = t_ret;
|
|
if (dbenv->lg_info && (t_ret = log_close(dbenv->lg_info)) != 0)
|
|
if (ret == 0)
|
|
ret = t_ret;
|
|
if (dbenv->lk_info && (t_ret = lock_close(dbenv->lk_info)) != 0)
|
|
if (ret == 0)
|
|
ret = t_ret;
|
|
|
|
/* Free allocated memory. */
|
|
if (dbenv->db_home != NULL)
|
|
FREES(dbenv->db_home);
|
|
if ((p = dbenv->db_data_dir) != NULL) {
|
|
for (; *p != NULL; ++p)
|
|
FREES(*p);
|
|
FREE(dbenv->db_data_dir, dbenv->data_cnt * sizeof(char **));
|
|
}
|
|
if (dbenv->db_log_dir != NULL)
|
|
FREES(dbenv->db_log_dir);
|
|
if (dbenv->db_tmp_dir != NULL)
|
|
FREES(dbenv->db_tmp_dir);
|
|
|
|
return (ret);
|
|
}
|
|
|
|
#define DB_ADDSTR(str) { \
|
|
if ((str) != NULL) { \
|
|
/* If leading slash, start over. */ \
|
|
if (__db_abspath(str)) { \
|
|
p = start; \
|
|
slash = 0; \
|
|
} \
|
|
/* Append to the current string. */ \
|
|
len = strlen(str); \
|
|
if (slash) \
|
|
*p++ = PATH_SEPARATOR[0]; \
|
|
memcpy(p, str, len); \
|
|
p += len; \
|
|
slash = strchr(PATH_SEPARATOR, p[-1]) == NULL; \
|
|
} \
|
|
}
|
|
|
|
/*
|
|
* __db_appname --
|
|
* Given an optional DB environment, directory and file name and type
|
|
* of call, build a path based on the db_appinit(3) rules, and return
|
|
* it in allocated space.
|
|
*
|
|
* PUBLIC: int __db_appname __P((DB_ENV *,
|
|
* PUBLIC: APPNAME, const char *, const char *, u_int32_t, int *, char **));
|
|
*/
|
|
int
|
|
__db_appname(dbenv, appname, dir, file, tmp_oflags, fdp, namep)
|
|
DB_ENV *dbenv;
|
|
APPNAME appname;
|
|
const char *dir, *file;
|
|
u_int32_t tmp_oflags;
|
|
int *fdp;
|
|
char **namep;
|
|
{
|
|
DB_ENV etmp;
|
|
size_t len;
|
|
int data_entry, ret, slash, tmp_create, tmp_free;
|
|
const char *a, *b, *c;
|
|
char *p, *start;
|
|
|
|
a = b = c = NULL;
|
|
data_entry = -1;
|
|
tmp_create = tmp_free = 0;
|
|
|
|
/*
|
|
* We don't return a name when creating temporary files, just an fd.
|
|
* Default to error now.
|
|
*/
|
|
if (fdp != NULL)
|
|
*fdp = -1;
|
|
if (namep != NULL)
|
|
*namep = NULL;
|
|
|
|
/*
|
|
* Absolute path names are never modified. If the file is an absolute
|
|
* path, we're done. If the directory is, simply append the file and
|
|
* return.
|
|
*/
|
|
if (file != NULL && __db_abspath(file))
|
|
return ((*namep =
|
|
(char *)__db_strdup(file)) == NULL ? ENOMEM : 0);
|
|
if (dir != NULL && __db_abspath(dir)) {
|
|
a = dir;
|
|
goto done;
|
|
}
|
|
|
|
/*
|
|
* DB_ENV DIR APPNAME RESULT
|
|
* -------------------------------------------
|
|
* null null none <tmp>/file
|
|
* null set none DIR/file
|
|
* set null none DB_HOME/file
|
|
* set set none DB_HOME/DIR/file
|
|
*
|
|
* DB_ENV FILE APPNAME RESULT
|
|
* -------------------------------------------
|
|
* null null DB_APP_DATA <tmp>/<create>
|
|
* null set DB_APP_DATA ./file
|
|
* set null DB_APP_DATA <tmp>/<create>
|
|
* set set DB_APP_DATA DB_HOME/DB_DATA_DIR/file
|
|
*
|
|
* DB_ENV DIR APPNAME RESULT
|
|
* -------------------------------------------
|
|
* null null DB_APP_LOG <tmp>/file
|
|
* null set DB_APP_LOG DIR/file
|
|
* set null DB_APP_LOG DB_HOME/DB_LOG_DIR/file
|
|
* set set DB_APP_LOG DB_HOME/DB_LOG_DIR/DIR/file
|
|
*
|
|
* DB_ENV APPNAME RESULT
|
|
* -------------------------------------------
|
|
* null DB_APP_TMP* <tmp>/<create>
|
|
* set DB_APP_TMP* DB_HOME/DB_TMP_DIR/<create>
|
|
*/
|
|
retry: switch (appname) {
|
|
case DB_APP_NONE:
|
|
if (dbenv == NULL || !F_ISSET(dbenv, DB_ENV_APPINIT)) {
|
|
if (dir == NULL)
|
|
goto tmp;
|
|
a = dir;
|
|
} else {
|
|
a = dbenv->db_home;
|
|
b = dir;
|
|
}
|
|
break;
|
|
case DB_APP_DATA:
|
|
if (dir != NULL) {
|
|
__db_err(dbenv,
|
|
"DB_APP_DATA: illegal directory specification");
|
|
return (EINVAL);
|
|
}
|
|
|
|
if (file == NULL) {
|
|
tmp_create = 1;
|
|
goto tmp;
|
|
}
|
|
if (dbenv == NULL || !F_ISSET(dbenv, DB_ENV_APPINIT))
|
|
a = PATH_DOT;
|
|
else {
|
|
a = dbenv->db_home;
|
|
if (dbenv->db_data_dir != NULL &&
|
|
(b = dbenv->db_data_dir[++data_entry]) == NULL) {
|
|
data_entry = -1;
|
|
b = dbenv->db_data_dir[0];
|
|
}
|
|
}
|
|
break;
|
|
case DB_APP_LOG:
|
|
if (dbenv == NULL || !F_ISSET(dbenv, DB_ENV_APPINIT)) {
|
|
if (dir == NULL)
|
|
goto tmp;
|
|
a = dir;
|
|
} else {
|
|
a = dbenv->db_home;
|
|
b = dbenv->db_log_dir;
|
|
c = dir;
|
|
}
|
|
break;
|
|
case DB_APP_TMP:
|
|
if (dir != NULL || file != NULL) {
|
|
__db_err(dbenv,
|
|
"DB_APP_TMP: illegal directory or file specification");
|
|
return (EINVAL);
|
|
}
|
|
|
|
tmp_create = 1;
|
|
if (dbenv == NULL || !F_ISSET(dbenv, DB_ENV_APPINIT))
|
|
goto tmp;
|
|
else {
|
|
a = dbenv->db_home;
|
|
b = dbenv->db_tmp_dir;
|
|
}
|
|
break;
|
|
}
|
|
|
|
/* Reference a file from the appropriate temporary directory. */
|
|
if (0) {
|
|
tmp: if (dbenv == NULL || !F_ISSET(dbenv, DB_ENV_APPINIT)) {
|
|
memset(&etmp, 0, sizeof(etmp));
|
|
if ((ret = __db_tmp_dir(&etmp, DB_USE_ENVIRON)) != 0)
|
|
return (ret);
|
|
tmp_free = 1;
|
|
a = etmp.db_tmp_dir;
|
|
} else
|
|
a = dbenv->db_tmp_dir;
|
|
}
|
|
|
|
done: len =
|
|
(a == NULL ? 0 : strlen(a) + 1) +
|
|
(b == NULL ? 0 : strlen(b) + 1) +
|
|
(c == NULL ? 0 : strlen(c) + 1) +
|
|
(file == NULL ? 0 : strlen(file) + 1);
|
|
|
|
/*
|
|
* Allocate space to hold the current path information, as well as any
|
|
* temporary space that we're going to need to create a temporary file
|
|
* name.
|
|
*/
|
|
#define DB_TRAIL "XXXXXX"
|
|
if ((start =
|
|
(char *)__db_malloc(len + sizeof(DB_TRAIL) + 10)) == NULL) {
|
|
__db_err(dbenv, "%s", strerror(ENOMEM));
|
|
if (tmp_free)
|
|
FREES(etmp.db_tmp_dir);
|
|
return (ENOMEM);
|
|
}
|
|
|
|
slash = 0;
|
|
p = start;
|
|
DB_ADDSTR(a);
|
|
DB_ADDSTR(b);
|
|
DB_ADDSTR(file);
|
|
*p = '\0';
|
|
|
|
/*
|
|
* If we're opening a data file, see if it exists. If it does,
|
|
* return it, otherwise, try and find another one to open.
|
|
*/
|
|
if (data_entry != -1 && __db_exists(start, NULL) != 0) {
|
|
FREES(start);
|
|
a = b = c = NULL;
|
|
goto retry;
|
|
}
|
|
|
|
/* Discard any space allocated to find the temp directory. */
|
|
if (tmp_free)
|
|
FREES(etmp.db_tmp_dir);
|
|
|
|
/* Create the file if so requested. */
|
|
if (tmp_create &&
|
|
(ret = __db_tmp_open(dbenv, tmp_oflags, start, fdp)) != 0) {
|
|
FREES(start);
|
|
return (ret);
|
|
}
|
|
|
|
if (namep != NULL)
|
|
*namep = start;
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* __db_home --
|
|
* Find the database home.
|
|
*/
|
|
static int
|
|
__db_home(dbenv, db_home, flags)
|
|
DB_ENV *dbenv;
|
|
const char *db_home;
|
|
u_int32_t flags;
|
|
{
|
|
const char *p;
|
|
|
|
p = db_home;
|
|
|
|
/* Use the environment if it's permitted and initialized. */
|
|
#ifdef HAVE_GETUID
|
|
if (LF_ISSET(DB_USE_ENVIRON) ||
|
|
(LF_ISSET(DB_USE_ENVIRON_ROOT) && getuid() == 0)) {
|
|
#else
|
|
if (LF_ISSET(DB_USE_ENVIRON)) {
|
|
#endif
|
|
if ((p = getenv("DB_HOME")) == NULL)
|
|
p = db_home;
|
|
else if (p[0] == '\0') {
|
|
__db_err(dbenv,
|
|
"illegal DB_HOME environment variable");
|
|
return (EINVAL);
|
|
}
|
|
}
|
|
|
|
if (p == NULL)
|
|
return (0);
|
|
|
|
if ((dbenv->db_home = (char *)__db_strdup(p)) == NULL) {
|
|
__db_err(dbenv, "%s", strerror(ENOMEM));
|
|
return (ENOMEM);
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* __db_parse --
|
|
* Parse a single NAME VALUE pair.
|
|
*/
|
|
static int
|
|
__db_parse(dbenv, s)
|
|
DB_ENV *dbenv;
|
|
char *s;
|
|
{
|
|
int ret;
|
|
char *local_s, *name, *value, **p, *tp;
|
|
|
|
ret = 0;
|
|
|
|
/*
|
|
* We need to strdup the argument in case the caller passed us
|
|
* static data.
|
|
*/
|
|
if ((local_s = (char *)__db_strdup(s)) == NULL)
|
|
return (ENOMEM);
|
|
|
|
tp = local_s;
|
|
while ((name = strsep(&tp, " \t")) != NULL && *name == '\0')
|
|
;
|
|
if (name == NULL)
|
|
goto illegal;
|
|
while ((value = strsep(&tp, " \t")) != NULL && *value == '\0')
|
|
;
|
|
if (value == NULL) {
|
|
illegal: ret = EINVAL;
|
|
__db_err(dbenv, "illegal name-value pair: %s", s);
|
|
goto err;
|
|
}
|
|
|
|
#define DATA_INIT_CNT 20 /* Start with 20 data slots. */
|
|
if (!strcmp(name, "DB_DATA_DIR")) {
|
|
if (dbenv->db_data_dir == NULL) {
|
|
if ((dbenv->db_data_dir =
|
|
(char **)__db_calloc(DATA_INIT_CNT,
|
|
sizeof(char **))) == NULL)
|
|
goto nomem;
|
|
dbenv->data_cnt = DATA_INIT_CNT;
|
|
} else if (dbenv->data_next == dbenv->data_cnt - 1) {
|
|
dbenv->data_cnt *= 2;
|
|
if ((dbenv->db_data_dir =
|
|
(char **)__db_realloc(dbenv->db_data_dir,
|
|
dbenv->data_cnt * sizeof(char **))) == NULL)
|
|
goto nomem;
|
|
}
|
|
p = &dbenv->db_data_dir[dbenv->data_next++];
|
|
} else if (!strcmp(name, "DB_LOG_DIR")) {
|
|
if (dbenv->db_log_dir != NULL)
|
|
FREES(dbenv->db_log_dir);
|
|
p = &dbenv->db_log_dir;
|
|
} else if (!strcmp(name, "DB_TMP_DIR")) {
|
|
if (dbenv->db_tmp_dir != NULL)
|
|
FREES(dbenv->db_tmp_dir);
|
|
p = &dbenv->db_tmp_dir;
|
|
} else
|
|
goto err;
|
|
|
|
if ((*p = (char *)__db_strdup(value)) == NULL) {
|
|
nomem: ret = ENOMEM;
|
|
__db_err(dbenv, "%s", strerror(ENOMEM));
|
|
}
|
|
|
|
err: FREES(local_s);
|
|
return (ret);
|
|
}
|
|
|
|
#ifdef macintosh
|
|
#include <TFileSpec.h>
|
|
|
|
static char *sTempFolder;
|
|
#endif
|
|
|
|
/*
|
|
* tmp --
|
|
* Set the temporary directory path.
|
|
*/
|
|
static int
|
|
__db_tmp_dir(dbenv, flags)
|
|
DB_ENV *dbenv;
|
|
u_int32_t flags;
|
|
{
|
|
static const char * list[] = { /* Ordered: see db_appinit(3). */
|
|
"/var/tmp",
|
|
"/usr/tmp",
|
|
"/temp", /* WIN32. */
|
|
"/tmp",
|
|
"C:/temp", /* WIN32. */
|
|
"C:/tmp", /* WIN32. */
|
|
NULL
|
|
};
|
|
const char **lp, *p;
|
|
|
|
/* Use the environment if it's permitted and initialized. */
|
|
p = NULL;
|
|
#ifdef HAVE_GETEUID
|
|
if (LF_ISSET(DB_USE_ENVIRON) ||
|
|
(LF_ISSET(DB_USE_ENVIRON_ROOT) && getuid() == 0)) {
|
|
#else
|
|
if (LF_ISSET(DB_USE_ENVIRON)) {
|
|
#endif
|
|
if ((p = getenv("TMPDIR")) != NULL && p[0] == '\0') {
|
|
__db_err(dbenv, "illegal TMPDIR environment variable");
|
|
return (EINVAL);
|
|
}
|
|
/* WIN32 */
|
|
if (p == NULL && (p = getenv("TEMP")) != NULL && p[0] == '\0') {
|
|
__db_err(dbenv, "illegal TEMP environment variable");
|
|
return (EINVAL);
|
|
}
|
|
/* WIN32 */
|
|
if (p == NULL && (p = getenv("TMP")) != NULL && p[0] == '\0') {
|
|
__db_err(dbenv, "illegal TMP environment variable");
|
|
return (EINVAL);
|
|
}
|
|
/* Macintosh */
|
|
if (p == NULL &&
|
|
(p = getenv("TempFolder")) != NULL && p[0] == '\0') {
|
|
__db_err(dbenv,
|
|
"illegal TempFolder environment variable");
|
|
return (EINVAL);
|
|
}
|
|
}
|
|
|
|
#ifdef macintosh
|
|
/* Get the path to the temporary folder. */
|
|
if (p == NULL) {
|
|
FSSpec spec;
|
|
|
|
if (!Special2FSSpec(kTemporaryFolderType,
|
|
kOnSystemDisk, 0, &spec)) {
|
|
p = FSp2FullPath(&spec);
|
|
sTempFolder = __db_malloc(strlen(p) + 1);
|
|
strcpy(sTempFolder, p);
|
|
p = sTempFolder;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/* Step through the list looking for a possibility. */
|
|
if (p == NULL)
|
|
for (lp = list; *lp != NULL; ++lp)
|
|
if (__db_exists(p = *lp, NULL) == 0)
|
|
break;
|
|
|
|
if (p == NULL)
|
|
return (0);
|
|
|
|
if ((dbenv->db_tmp_dir = (char *)__db_strdup(p)) == NULL) {
|
|
__db_err(dbenv, "%s", strerror(ENOMEM));
|
|
return (ENOMEM);
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* __db_tmp_open --
|
|
* Create a temporary file.
|
|
*/
|
|
static int
|
|
__db_tmp_open(dbenv, flags, path, fdp)
|
|
DB_ENV *dbenv;
|
|
u_int32_t flags;
|
|
char *path;
|
|
int *fdp;
|
|
{
|
|
#ifdef HAVE_SIGFILLSET
|
|
sigset_t set, oset;
|
|
#endif
|
|
u_long pid;
|
|
int mode, isdir, ret;
|
|
char *p, *trv;
|
|
|
|
/*
|
|
* Check the target directory; if you have six X's and it doesn't
|
|
* exist, this runs for a *very* long time.
|
|
*/
|
|
if ((ret = __db_exists(path, &isdir)) != 0) {
|
|
__db_err(dbenv, "%s: %s", path, strerror(ret));
|
|
return (ret);
|
|
}
|
|
if (!isdir) {
|
|
__db_err(dbenv, "%s: %s", path, strerror(EINVAL));
|
|
return (EINVAL);
|
|
}
|
|
|
|
/* Build the path. */
|
|
for (trv = path; *trv != '\0'; ++trv)
|
|
;
|
|
*trv = PATH_SEPARATOR[0];
|
|
for (p = DB_TRAIL; (*++trv = *p) != '\0'; ++p)
|
|
;
|
|
|
|
/*
|
|
* Replace the X's with the process ID. Pid should be a pid_t,
|
|
* but we use unsigned long for portability.
|
|
*/
|
|
for (pid = getpid(); *--trv == 'X'; pid /= 10)
|
|
switch (pid % 10) {
|
|
case 0: *trv = '0'; break;
|
|
case 1: *trv = '1'; break;
|
|
case 2: *trv = '2'; break;
|
|
case 3: *trv = '3'; break;
|
|
case 4: *trv = '4'; break;
|
|
case 5: *trv = '5'; break;
|
|
case 6: *trv = '6'; break;
|
|
case 7: *trv = '7'; break;
|
|
case 8: *trv = '8'; break;
|
|
case 9: *trv = '9'; break;
|
|
}
|
|
++trv;
|
|
|
|
/* Set up open flags and mode. */
|
|
LF_SET(DB_CREATE | DB_EXCL);
|
|
mode = __db_omode("rw----");
|
|
|
|
/*
|
|
* Try to open a file. We block every signal we can get our hands
|
|
* on so that, if we're interrupted at the wrong time, the temporary
|
|
* file isn't left around -- of course, if we drop core in-between
|
|
* the calls we'll hang forever, but that's probably okay. ;-}
|
|
*/
|
|
#ifdef HAVE_SIGFILLSET
|
|
if (LF_ISSET(DB_TEMPORARY))
|
|
(void)sigfillset(&set);
|
|
#endif
|
|
for (;;) {
|
|
#ifdef HAVE_SIGFILLSET
|
|
if (LF_ISSET(DB_TEMPORARY))
|
|
(void)sigprocmask(SIG_BLOCK, &set, &oset);
|
|
#endif
|
|
ret = __db_open(path, flags, flags, mode, fdp);
|
|
#ifdef HAVE_SIGFILLSET
|
|
if (LF_ISSET(DB_TEMPORARY))
|
|
(void)sigprocmask(SIG_SETMASK, &oset, NULL);
|
|
#endif
|
|
if (ret == 0)
|
|
return (0);
|
|
|
|
/*
|
|
* XXX:
|
|
* If we don't get an EEXIST error, then there's something
|
|
* seriously wrong. Unfortunately, if the implementation
|
|
* doesn't return EEXIST for O_CREAT and O_EXCL regardless
|
|
* of other possible errors, we've lost.
|
|
*/
|
|
if (ret != EEXIST) {
|
|
__db_err(dbenv,
|
|
"tmp_open: %s: %s", path, strerror(ret));
|
|
return (ret);
|
|
}
|
|
|
|
/*
|
|
* Tricky little algorithm for backward compatibility.
|
|
* Assumes the ASCII ordering of lower-case characters.
|
|
*/
|
|
for (;;) {
|
|
if (*trv == '\0')
|
|
return (EINVAL);
|
|
if (*trv == 'z')
|
|
*trv++ = 'a';
|
|
else {
|
|
if (isdigit(*trv))
|
|
*trv = 'a';
|
|
else
|
|
++*trv;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
/* NOTREACHED */
|
|
}
|