END_TEST
START_TEST (trace_get_level_test) {
int min_level, max_level, res;
const char *channel;
channel = "foo";
min_level = 1;
max_level = 2;
res = pr_trace_get_level(NULL);
fail_unless(res < 0, "Failed to handle null channel");
fail_unless(errno == EINVAL, "Failed to set errno to EINVAL, got %d (%s)",
errno, strerror(errno));
res = pr_trace_get_level("bar");
fail_unless(res < 0, "Failed to handle unset channels/levels");
fail_unless(errno == EPERM, "Failed to set errno to EPERM, got %d (%s)",
errno, strerror(errno));
res = pr_trace_set_levels(channel, min_level, max_level);
fail_unless(res == 0, "Failed to set '%s:%d-%d': %s", channel, min_level,
max_level, strerror(errno));
res = pr_trace_get_level("bar");
fail_unless(res < 0, "Failed to handle unknown channel");
fail_unless(errno == ENOENT, "Failed to set errno to ENOENT, got %d (%s)",
errno, strerror(errno));
res = pr_trace_get_level(channel);
fail_unless(res == max_level, "Failed to get level %d for channel '%s': %s",
max_level, channel, strerror(errno));
}
static int regexp_exec_pcre(pr_regex_t *pre, const char *str,
size_t nmatches, regmatch_t *matches, int flags, unsigned long match_limit,
unsigned long match_limit_recursion) {
if (pre->pcre != NULL) {
int res;
size_t str_len;
str_len = strlen(str);
/* Use the default match limits, if set and if the caller did not
* explicitly provide limits.
*/
if (match_limit == 0) {
match_limit = pcre_match_limit;
}
if (match_limit_recursion == 0) {
match_limit_recursion = pcre_match_limit_recursion;
}
if (match_limit > 0) {
if (pre->pcre_extra == NULL) {
pre->pcre_extra = pcalloc(pre->regex_pool, sizeof(pcre_extra));
}
pre->pcre_extra->flags |= PCRE_EXTRA_MATCH_LIMIT;
pre->pcre_extra->match_limit = match_limit;
}
if (match_limit_recursion > 0) {
if (pre->pcre_extra == NULL) {
pre->pcre_extra = pcalloc(pre->regex_pool, sizeof(pcre_extra));
}
pre->pcre_extra->flags |= PCRE_EXTRA_MATCH_LIMIT_RECURSION;
pre->pcre_extra->match_limit_recursion = match_limit_recursion;
}
pr_trace_msg(trace_channel, 9,
"executing PCRE regex '%s' against subject '%s'",
pr_regexp_get_pattern(pre), str);
res = pcre_exec(pre->pcre, pre->pcre_extra, str, str_len, 0, flags,
NULL, 0);
if (res < 0) {
if (pr_trace_get_level(trace_channel) >= 9) {
const char *reason = "unknown";
switch (res) {
case PCRE_ERROR_NOMATCH:
reason = "subject did not match pattern";
break;
case PCRE_ERROR_NULL:
reason = "null regex or subject";
break;
case PCRE_ERROR_BADOPTION:
reason = "unsupported options bit";
break;
case PCRE_ERROR_BADMAGIC:
reason = "bad magic number in regex";
break;
case PCRE_ERROR_UNKNOWN_OPCODE:
case PCRE_ERROR_INTERNAL:
reason = "internal PCRE error or corrupted regex";
break;
case PCRE_ERROR_NOMEMORY:
reason = "not enough memory for backreferences";
break;
case PCRE_ERROR_MATCHLIMIT:
reason = "match limit reached/exceeded";
break;
case PCRE_ERROR_RECURSIONLIMIT:
reason = "match limit recursion reached/exceeded";
break;
case PCRE_ERROR_BADUTF8:
reason = "invalid UTF8 subject used";
break;
case PCRE_ERROR_PARTIAL:
reason = "subject matched only partially; PCRE_PARTIAL flag not used";
break;
}
pr_trace_msg(trace_channel, 9,
"PCRE regex '%s' failed to match subject '%s': %s",
pr_regexp_get_pattern(pre), str, reason);
} else {
pr_trace_msg(trace_channel, 9,
"PCRE regex '%s' successfully match subject '%s'",
pr_regexp_get_pattern(pre), str);
}
}
return res;
}
errno = EINVAL;
return -1;
}
int proxy_db_open(pool *p, const char *table_path, const char *schema_name) {
int res;
pool *tmp_pool;
const char *stmt;
if (p == NULL ||
table_path == NULL) {
errno = EINVAL;
return -1;
}
/* If we already have a database handle open, then attach the given
* path to our handle. Otherwise, open/create the database file first.
*/
if (proxy_dbh == NULL) {
res = sqlite3_open(table_path, &proxy_dbh);
if (res != SQLITE_OK) {
pr_log_debug(DEBUG0, MOD_PROXY_VERSION
": error opening SQLite database '%s': %s", table_path,
sqlite3_errmsg(proxy_dbh));
errno = EPERM;
return -1;
}
/* Tell SQLite to only use in-memory journals. This is necessary for
* working properly when a chroot is used. Note that the MEMORY journal
* mode of SQLite is supported only for SQLite-3.6.5 and later.
*/
res = sqlite3_exec(proxy_dbh, "PRAGMA journal_mode = MEMORY;", NULL, NULL,
NULL);
if (res != SQLITE_OK) {
pr_trace_msg(trace_channel, 2,
"error setting MEMORY journal mode on SQLite database '%s': %s",
table_path, sqlite3_errmsg(proxy_dbh));
}
if (pr_trace_get_level(trace_channel) >= PROXY_DB_SQLITE_TRACE_LEVEL) {
sqlite3_trace(proxy_dbh, db_trace, NULL);
}
prepared_stmts = pr_table_nalloc(db_pool, 0, 4);
}
tmp_pool = make_sub_pool(p);
stmt = pstrcat(tmp_pool, "ATTACH DATABASE '", table_path, "' AS ",
schema_name, ";", NULL);
res = sqlite3_exec(proxy_dbh, stmt, NULL, NULL, NULL);
if (res != SQLITE_OK) {
pr_trace_msg(trace_channel, 2,
"error attaching database '%s' (as '%s') to existing SQLite handle "
"using '%s': %s", table_path, schema_name, stmt,
sqlite3_errmsg(proxy_dbh));
destroy_pool(tmp_pool);
errno = EPERM;
return -1;
}
destroy_pool(tmp_pool);
return 0;
}
