EXPORTED void sync_log_init(void)
{
const char *conf;
int i;
/* sync_log_init() may be called more than once */
if (channels) strarray_free(channels);
conf = config_getstring(IMAPOPT_SYNC_LOG_CHANNELS);
if (!conf) conf = "\"\"";
channels = strarray_split(conf, " ", 0);
/*
* The sysadmin can specify "" in the value of sync_log_channels to
* mean the default channel name - this will be useful for sysadmins
* who want to start using a sync log channel for squatter but who
* have been using the default sync log channel for sync_client.
*/
i = strarray_find(channels, "\"\"", 0);
if (i >= 0)
strarray_set(channels, i, NULL);
strarray_free(unsuppressable);
unsuppressable = NULL;
conf = config_getstring(IMAPOPT_SYNC_LOG_UNSUPPRESSABLE_CHANNELS);
if (conf)
unsuppressable = strarray_split(conf, " ", 0);
}
char *find_free_server(void)
{
const char *servers = config_getstring(IMAPOPT_SERVERLIST);
char *server = NULL;
if (servers) {
if (!server_parts) {
server_parts = xzmalloc(sizeof(partlist_t));
partlist_initialize(
server_parts,
proxy_part_filldata,
NULL,
servers,
NULL,
partlist_getmode(config_getstring(IMAPOPT_SERVERLIST_SELECT_MODE)),
config_getint(IMAPOPT_SERVERLIST_SELECT_SOFT_USAGE_LIMIT),
config_getint(IMAPOPT_SERVERLIST_SELECT_USAGE_REINIT)
);
}
server = (char *)partlist_select_value(server_parts);
}
return server;
}
static int
wallet_load_keys(struct wallet *wallet,
char **errStr,
struct config *cfg,
enum wallet_state *wallet_state)
{
char *saltStr;
int64 count;
int n;
int i;
n = config_getint64(cfg, 0, "numKeys");
saltStr = config_getstring(cfg, NULL, "encryption.salt");
count = config_getint64(cfg, CRYPT_NUM_ITERATIONS_OLD,
"encryption.numIterations");
if (saltStr == NULL) {
*wallet_state = WALLET_PLAIN;
} else {
*wallet_state = WALLET_ENCRYPTED_LOCKED;
}
wallet_crypt_init(wallet, saltStr, count);
free(saltStr);
Log(LGPFX" %s wallet: %u key%s in file '%s'.\n",
*wallet_state == WALLET_PLAIN ? "plain" : "encrypted",
n, n > 1 ? "s" : "", wallet->filename);
for (i = 0; i < n; i++) {
time_t birth = config_getint64(cfg, 0, "key%u.birth", i);
char *desc = config_getstring(cfg, NULL, "key%u.desc", i);
char *priv = config_getstring(cfg, NULL, "key%u.privkey", i);
char *pub = config_getstring(cfg, NULL, "key%u.pubkey", i);
bool spendable = config_getbool(cfg, TRUE, "key%u.spendable", i);
bool s;
s = wallet_alloc_key(wallet, priv, pub, desc, birth, spendable);
free(pub);
free(priv);
free(desc);
if (s == 0) {
Log(LGPFX" failed to load pub_key #%u\n", i);
*errStr = "failed to alloc key";
goto exit;
}
}
if (wallet->pass && *wallet_state == WALLET_ENCRYPTED_LOCKED) {
*wallet_state = WALLET_ENCRYPTED_UNLOCKED;
}
return 0;
exit:
return 1;
}
static void myinit(void)
{
int r = pr_Initialize (1L, AFSCONF_CLIENTNAME, config_getstring(IMAPOPT_AFSPTS_MYCELL));
if (r) {
syslog(LOG_DEBUG, "pr_Initialize failed: %d", r);
fatal("pr_initialize failed", EC_TEMPFAIL);
}
localrealms = config_getstring(IMAPOPT_AFSPTS_LOCALREALMS);
return;
}
int tls_enabled(void)
{
const char *val;
val = config_getstring(IMAPOPT_TLS_CERT_FILE);
if (!val || !strcasecmp(val, "disabled")) return 0;
val = config_getstring(IMAPOPT_TLS_KEY_FILE);
if (!val || !strcasecmp(val, "disabled")) return 0;
return 1;
}
EXPORTED const char *config_backupstagingpath(void)
{
static const char *staging_path = NULL;
if (staging_path) return staging_path;
staging_path = config_getstring(IMAPOPT_BACKUP_STAGING_PATH);
if (!staging_path)
staging_path = strconcat(config_getstring(IMAPOPT_TEMP_PATH),
"/backup", NULL);
return staging_path;
}
EXPORTED int tls_enabled(void)
{
const char *val;
val = config_getstring(IMAPOPT_TLS_SERVER_CERT);
if (!val || !strcasecmp(val, "disabled")) return 0;
val = config_getstring(IMAPOPT_TLS_SERVER_KEY);
if (!val || !strcasecmp(val, "disabled")) return 0;
if (config_getswitch(IMAPOPT_CHATTY))
syslog(LOG_INFO, "TLS is available.");
return 1;
}
static void
txdb_export_tx_cb(const void *key,
size_t keyLen,
void *cbData,
void *keyData)
{
struct bitcui_tx **txiPtr = (struct bitcui_tx **)cbData;
struct tx_entry *txe = (struct tx_entry *)keyData;
struct bitcui_tx *txi = *txiPtr;
char hashStr[80];
if (txe->relevant == 0) {
return;
}
/*
* We need to weed out transactions that made it in an orphan block but were
* not integrated later on in the main chain.
*/
txi->src = NULL;
txi->dst = NULL;
txi->desc = NULL;
ASSERT(keyLen == sizeof(uint256));
memcpy(&txi->txHash, key, keyLen);
txi->value = txdb_get_tx_credit(&txe->tx);
txi->value -= txdb_get_tx_debit(&txe->tx);
txi->blockHeight = -1;
if (!uint256_iszero(&txe->blkHash)) {
txi->blockHeight = blockstore_get_block_height(btc->blockStore,
&txe->blkHash);
}
uint256_snprintf_reverse(hashStr, sizeof hashStr, (uint256*)key);
txi->desc = config_getstring(btc->txLabelsCfg, NULL, "tx.%s.label", hashStr) ;
/*
* This is a workaround for a bug caused by truncated hashStr.
*/
if (txi->desc == NULL) {
hashStr[63] = '\0';
txi->desc = config_getstring(btc->txLabelsCfg, NULL, "tx.%s.label", hashStr) ;
}
txi->timestamp = txe->timestamp;
*txiPtr += 1;
}
int masterconf_init(const char *ident, const char *alt_config)
{
char *buf;
const char *prefix;
/* Open the log file with the appropriate facility so we
* correctly log any config errors */
openlog(ident, LOG_PID, SYSLOG_FACILITY);
config_ident = ident;
config_read(alt_config, 0);
prefix = config_getstring(IMAPOPT_SYSLOG_PREFIX);
if(prefix) {
int size = strlen(prefix) + 1 + strlen(ident) + 1;
buf = xmalloc(size);
strlcpy(buf, prefix, size);
strlcat(buf, "/", size);
strlcat(buf, ident, size);
/* Reopen the log with the new prefix */
closelog();
openlog(buf, LOG_PID, SYSLOG_FACILITY);
/* don't free the openlog() string! */
}
/* drop debug messages locally */
if (!config_debug)
setlogmask(~LOG_MASK(LOG_DEBUG));
return 0;
}
EXPORTED void quotadb_open(const char *fname)
{
int ret;
char *tofree = NULL;
int flags = CYRUSDB_CREATE;
if (!fname)
fname = config_getstring(IMAPOPT_QUOTA_DB_PATH);
/* create db file name */
if (!fname) {
tofree = strconcat(config_dir, FNAME_QUOTADB, (char *)NULL);
fname = tofree;
}
if (config_getswitch(IMAPOPT_IMPROVED_MBOXLIST_SORT))
flags |= CYRUSDB_MBOXSORT;
ret = cyrusdb_open(QDB, fname, flags, &qdb);
if (ret != 0) {
syslog(LOG_ERR, "DBERROR: opening %s: %s", fname,
cyrusdb_strerror(ret));
/* Exiting TEMPFAIL because Sendmail thinks this
EC_OSFILE == permanent failure. */
fatal("can't read quotas file", EC_TEMPFAIL);
}
free(tofree);
quota_dbopen = 1;
}
static Xapian::Stopper *get_stopper()
{
Xapian::Stopper *stopper = NULL;
const char *swpath = config_getstring(IMAPOPT_SEARCH_STOPWORD_PATH);
if (swpath) {
// Set path to stopword file
struct buf buf = BUF_INITIALIZER;
buf_setcstr(&buf, swpath);
// XXX doesn't play nice with WIN32 paths
buf_appendcstr(&buf, "/english.list");
// Open the stopword file
errno = 0;
std::ifstream inFile (buf_cstring(&buf));
if (inFile.fail()) {
syslog(LOG_ERR, "Xapian: could not open stopword file %s: %s",
buf_cstring(&buf), errno ? strerror(errno) : "unknown error");
exit(1);
}
// Create the Xapian stopper
stopper = new Xapian::SimpleStopper(
std::istream_iterator<std::string>(inFile),
std::istream_iterator<std::string>());
// Clean up
buf_free(&buf);
}
return stopper;
}
/*
* Open the user deny database. If 'create' is true and the database
* does not exist, create it. Returns 0 on success or an IMAP error
* code.
*/
EXPORTED int denydb_open(int create)
{
const char *fname;
int ret;
char *tofree = NULL;
fname = config_getstring(IMAPOPT_USERDENY_DB_PATH);
/* create db file name */
if (!fname) {
tofree = strconcat(config_dir, FNAME_USERDENYDB, (char *)NULL);
fname = tofree;
}
ret = cyrusdb_open(DENYDB, fname, (create ? CYRUSDB_CREATE : 0), &denydb);
if (ret == CYRUSDB_NOTFOUND) {
/* ignore non-existent DB, report all other errors */
ret = ENOENT;
}
else if (ret != CYRUSDB_OK) {
syslog(LOG_WARNING, "DENYDB_ERROR: opening %s: %s", fname,
cyrusdb_strerror(ret));
ret = IMAP_IOERROR;
}
free(tofree);
return ret;
}
EXPORTED int jmapauth_open(struct db **dbptr, int db_flags, const char *fname)
{
int r = 0;
char *tofree = NULL;
assert(dbptr);
if (!fname) {
fname = config_getstring(IMAPOPT_JMAPAUTH_DB_PATH);
}
/* create db file name */
if (!fname) {
tofree = strconcat(config_dir, FNAME_JMAPAUTH, (char*)NULL);
fname = tofree;
}
/* open the database */
r = cyrusdb_open(DB, fname, db_flags, dbptr);
if (r) {
if (r != CYRUSDB_NOTFOUND) {
syslog(LOG_ERR, "JMAP auth: cannot open db %s: %s",
fname, cyrusdb_strerror(r));
}
return r;
}
free(tofree);
return r;
}
void denydb_open(const char *fname)
{
int ret;
char *tofree = NULL;
if (!fname)
fname = config_getstring(IMAPOPT_USERDENY_DB_PATH);
/* create db file name */
if (!fname) {
tofree =strconcat(config_dir, FNAME_USERDENYDB, (char *)NULL);
fname = tofree;
}
ret = (DENYDB->open)(fname, 0, &denydb);
if (ret == CYRUSDB_OK) {
deny_dbopen = 1;
} else if (errno != ENOENT) {
/* ignore non-existent DB, report all other errors */
syslog(LOG_WARNING, "DENYDB_ERROR: opening %s: %s", fname,
cyrusdb_strerror(ret));
}
free(tofree);
}
EXPORTED pid_t open_sendmail(const char *argv[], FILE **sm)
{
int fds[2];
FILE *ret;
pid_t p;
if (pipe(fds)) {
printf("451 lmtpd: didn't start pipe()?!?\r\n");
fatal("couldn't start pipe()", EC_OSERR);
}
if ((p = fork()) == 0) {
/* i'm the child! run sendmail! */
close(fds[1]);
/* make the pipe be stdin */
dup2(fds[0], 0);
execv(config_getstring(IMAPOPT_SENDMAIL), (char **) argv);
/* if we're here we suck */
printf("451 lmtpd: didn't exec() sendmail?!?\r\n");
exit(EXIT_FAILURE);
}
if (p < 0) {
/* failure */
*sm = NULL;
return p;
}
/* parent */
close(fds[0]);
ret = fdopen(fds[1], "w");
*sm = ret;
return p;
}
void statuscache_open(const char *fname)
{
int ret;
char *tofree = NULL;
if (!fname)
fname = config_getstring(IMAPOPT_STATUSCACHE_DB_PATH);
/* create db file name */
if (!fname) {
tofree = strconcat(config_dir, FNAME_STATUSCACHEDB, (char *)NULL);
fname = tofree;
}
ret = cyrusdb_open(DB, fname, CYRUSDB_CREATE, &statuscachedb);
if (ret != 0) {
syslog(LOG_ERR, "DBERROR: opening %s: %s", fname,
cyrusdb_strerror(ret));
syslog(LOG_ERR, "statuscache in degraded mode");
return;
}
free(tofree);
statuscache_dbopen = 1;
}
/* must be called after cyrus_init */
EXPORTED int duplicate_init(const char *fname)
{
int r = 0;
char *tofree = NULL;
if (!fname)
fname = config_getstring(IMAPOPT_DUPLICATE_DB_PATH);
/* create db file name */
if (!fname) {
tofree = strconcat(config_dir, FNAME_DELIVERDB, (char *)NULL);
fname = tofree;
}
r = cyrusdb_open(DB, fname, CYRUSDB_CREATE, &dupdb);
if (r != 0) {
syslog(LOG_ERR, "DBERROR: opening %s: %s", fname,
cyrusdb_strerror(r));
goto out;
}
duplicate_dbopen = 1;
out:
free(tofree);
return r;
}
/* must be called after cyrus_init */
static int newsrc_init(const char *fname, int myflags __attribute__((unused)))
{
char buf[1024];
int r = 0;
if (r != 0)
syslog(LOG_ERR, "DBERROR: init %s: %s", buf,
cyrusdb_strerror(r));
else {
char *tofree = NULL;
if (!fname)
fname = config_getstring(IMAPOPT_NEWSRC_DB_PATH);
/* create db file name */
if (!fname) {
tofree = strconcat(config_dir, FNAME_NEWSRCDB, (char *)NULL);
fname = tofree;
}
r = cyrusdb_open(DB, fname, CYRUSDB_CREATE, &newsrc_db);
if (r != 0)
syslog(LOG_ERR, "DBERROR: opening %s: %s", fname,
cyrusdb_strerror(r));
else
newsrc_dbopen = 1;
free(tofree);
}
return r;
}
EXPORTED int smtpclient_open(smtpclient_t **smp)
{
int r = 0;
const char *backend = config_getstring(IMAPOPT_SMTP_BACKEND);
if (!strcmp(backend, "sendmail")) {
r = smtpclient_open_sendmail(smp);
}
else if (!strcmp(backend, "host")) {
r = smtpclient_open_host(config_getstring(IMAPOPT_SMTP_HOST), smp);
}
else {
syslog(LOG_ERR, "smtpclient_open: unknown backend: %s", backend);
r = IMAP_INTERNAL;
}
return r;
}
static char *blockstore_get_filename(struct config *config) {
char bsPath[PATH_MAX];
char *dir;
dir = bitc_get_directory();
snprintf(bsPath, sizeof bsPath, "%s/headers.dat", dir);
free(dir);
return config_getstring(config, bsPath, "headers.filename");
}
char *statuscache_filename(void)
{
const char *fname = config_getstring(IMAPOPT_STATUSCACHE_DB_PATH);
if (fname)
return xstrdup(fname);
/* create db file name */
return strconcat(config_dir, FNAME_STATUSCACHEDB, (char *)NULL);
}
static void partlist_local_init(void)
{
if (partlist_local) {
/* already done */
return;
}
partlist_local = xzmalloc(sizeof(partlist_t));
partlist_initialize(
partlist_local,
NULL,
"partition-",
NULL,
config_getstring(IMAPOPT_PARTITION_SELECT_EXCLUDE),
partlist_getmode(config_getstring(IMAPOPT_PARTITION_SELECT_MODE)),
config_getint(IMAPOPT_PARTITION_SELECT_SOFT_USAGE_LIMIT),
config_getint(IMAPOPT_PARTITION_SELECT_USAGE_REINIT)
);
}
static char *
txdb_get_db_path(struct config *config)
{
char txdbPath[PATH_MAX];
char *dir;
dir = bitc_get_directory();
snprintf(txdbPath, sizeof txdbPath, "%s/txdb", dir);
free(dir);
return config_getstring(config, txdbPath, "txdb.path");
}
char *
wallet_get_filename(void)
{
char str[256];
char *dir;
dir = bitc_get_directory();
snprintf(str, sizeof str, "%s/wallet.cfg", dir);
free(dir);
return config_getstring(btc->config, str, "wallet.filename");
}
static const char *get_config(const char *channel, const char *val)
{
const char *response = NULL;
if (channel) {
char name[MAX_MAILBOX_NAME]; /* crazy long, but hey */
snprintf(name, MAX_MAILBOX_NAME, "%s_%s", channel, val);
response = config_getoverflowstring(name, NULL);
}
if (!response) {
/* get the core value */
if (!strcmp(val, "sync_host"))
response = config_getstring(IMAPOPT_SYNC_HOST);
else if (!strcmp(val, "sync_authname"))
response = config_getstring(IMAPOPT_SYNC_AUTHNAME);
else if (!strcmp(val, "sync_password"))
response = config_getstring(IMAPOPT_SYNC_PASSWORD);
else if (!strcmp(val, "sync_realm"))
response = config_getstring(IMAPOPT_SYNC_REALM);
else if (!strcmp(val, "sync_port"))
response = config_getstring(IMAPOPT_SYNC_PORT);
else if (!strcmp(val, "sync_shutdown_file"))
response = config_getstring(IMAPOPT_SYNC_SHUTDOWN_FILE);
else
fatal("unknown config variable requested", EC_SOFTWARE);
}
return response;
}
EXPORTED int backupdb_open(struct db **backup_dbp, struct txn **tidp)
{
char *fname = xstrdupnull(config_getstring(IMAPOPT_BACKUP_DB_PATH));
int flags = CYRUSDB_CREATE;
if (!fname)
fname = strconcat(config_dir, FNAME_BACKUPDB, NULL);
int r = cyrusdb_lockopen(config_backup_db, fname, flags, backup_dbp, tidp);
free(fname);
return r;
}
EXPORTED int is_system_user(const char *userid)
{
static strarray_t *admins = NULL;
if (!admins) admins = strarray_split(config_getstring(IMAPOPT_ADMINS), NULL, STRARRAY_TRIM);
if (!strcmp(userid, "anyone")) return 1;
if (!strcmp(userid, "anonymous")) return 1;
if (strarray_find(admins, userid, 0) >= 0)
return 1;
return 0;
}
EXPORTED const char *user_sieve_path(const char *user)
{
static char sieve_path[2048];
char hash, *domain;
if (config_virtdomains && (domain = strchr(user, '@'))) {
char d = (char) dir_hash_c(domain+1, config_fulldirhash);
*domain = '\0'; /* split user@domain */
hash = (char) dir_hash_c(user, config_fulldirhash);
snprintf(sieve_path, sizeof(sieve_path), "%s%s%c/%s/%c/%s",
config_getstring(IMAPOPT_SIEVEDIR),
FNAME_DOMAINDIR, d, domain+1, hash, user);
*domain = '@'; /* reassemble user@domain */
}
else {
hash = (char) dir_hash_c(user, config_fulldirhash);
snprintf(sieve_path, sizeof(sieve_path), "%s/%c/%s",
config_getstring(IMAPOPT_SIEVEDIR), hash, user);
}
return sieve_path;
}
EXPORTED int idle_make_server_address(struct sockaddr_un *mysun)
{
const char *idle_sock;
memset(mysun, 0, sizeof(*mysun));
mysun->sun_family = AF_UNIX;
idle_sock = config_getstring(IMAPOPT_IDLESOCKET);
if (idle_sock) {
strlcpy(mysun->sun_path, idle_sock, sizeof(mysun->sun_path));
}
else {
/* TODO: detect overflow and fail */
strlcpy(mysun->sun_path, config_dir, sizeof(mysun->sun_path));
strlcat(mysun->sun_path, FNAME_IDLE_SOCK, sizeof(mysun->sun_path));
}
return 1;
}
int actions_init(void)
{
int sieve_usehomedir = 0;
sieve_usehomedir = config_getswitch(IMAPOPT_SIEVEUSEHOMEDIR);
if (!sieve_usehomedir) {
sieve_dir = (char *) config_getstring(IMAPOPT_SIEVEDIR);
} else {
/* can't use home directories with timsieved */
syslog(LOG_ERR, "can't use home directories");
return TIMSIEVE_FAIL;
}
return TIMSIEVE_OK;
}
